onReceiveCategories(categories) {
this.categories = _.sortBy(categories, 'position');
this.emitChange();
}
export const sortBySeverity = (issues: Array<*>) => sortBy(issues, issue => SEVERITIES.indexOf(issue.severity));
Site.index(function(records){
var sites = _.sortBy(records, 'priority');
res.render('home/index', {title: 'Andrew Moore: a Portfolio', user:user, sites:sites});
});
}), (error, result) => {
expenses = _.sortBy(result, 'date')
cb(error, result)
})
mapAndFlattenFilters(filters).then(function (results) {
// used to display the current filters in the state
$scope.filters = _.sortBy(results, function (filter) {
return !filter.meta.pinned;
});
})
}, function(err, cells) {
// transformar la hoja Excel en charlas
var talks = [];
_.forEach(cells.cells, function(row) {
//console.log(row);
var track = getValue(row['16']);
if (track) {
var title = getValue(row['1']);
talks.push({
'id': title.toLowerCase().trim().replace(/[^ a-zA-Z0-9\-_]+/g, '').replace(/ +/g, '-'),
'slides': getValue(row['2']),
'video': getValue(row['3']),
'interview': getValue(row['4']),
'author': getValue(row['5']),
'language': getValue(row['6']),
'tags': getSplittedValue(row['7']),
'languages': getSplittedValue(row['8']),
'slotType': getValue(row['9']),
'description': getValue(row['10']).replace(/(\n *)+/g, '</p><p>'),
'avatar': getValue(row['11']),
'level': getValue(row['12']),
'bio': getValue(row['13']).replace(/(\n *)+/g, '</p><p>'),
'title': title,
//'avatar2': getValue(row['19']), demasiado lío
'date': getValue(row['15']),
'track': track,
'time': getValue(row['17']),
})
}
});
// sort the talks for the list view
talks = _.sortBy(talks, function(talk) {
return talk.date + '-' + talk.time + '-' + talk.track;
})
_.each(talks, function(talk) {
if (talk.avatar) {
var name = talk.id;
if (name.length > FILENAME_MAX_SIZE) {
name.substring(0, FILENAME_MAX_SIZE);
}
downloader.download({
file: {
url: talk.avatar,
name: name
},
originalFilename: 'src/img/talks/orig/' + name + '{{extension}}',
processedFilename: 'src/img/talks/processed/' + name + '.png',
vectorToPng: 'inkscape --export-png="{{originalFilename}}" --export-height=' + AVATAR_SIZE + ' --export-width=' + AVATAR_SIZE + ' "{{processedFilename}}"',
toPng: 'convert "{{originalFilename}}" -geometry ' + AVATAR_SIZE + 'x' + AVATAR_SIZE + ' "{{processedFilename}}"'
});
talk.avatar = '/img/talks/processed/' + name + '.png';
}
})
var agendaHtml = _.template(
'<ul class="row unstyled small-block-grid-1 medium-block-grid-2">' +
'<% _.forEach(talks, function(talk) { %>' +
'<li>' +
'<article class="talk">' +
'<% if (talk.avatar) { %>' +
'<img class="th toright" src="{{talk.avatar}}">' +
'<% } %>' +
'<h1>{{talk.title}}</h1>' +
'<p>{{talk.description}}' +
'<br><small>' +
'Author: {{talk.author}}' +
'<br>Tags:' +
'<% _.forEach(talk.tags, function(tag) { %>' +
' <span class="radius label">{{tag}}</span>' +
'<% }); %>' +
'<br>Programming languages:' +
'<% _.forEach(talk.languages, function(lang) { %>' +
' <span class="secondary round label">{{lang}}</span>' +
'<% }); %>' +
'<br>Date: {{talk.date}} at {{talk.time}}' +
'<br>Track: {{talk.track}}' +
'<br>Level: {{talk.level}}' +
'</small>' +
'</p>' +
'</article>' +
'</li>' +
'<% }); %>' +
'</ul>', {
talks: _.chain(talks).filter(function(talk) {
return talk.date == '2014-11-21';
}).sortBy('title').value()
}
);
// save the HTML with agenda of talks
console.log("Writing list of talks to src/_includes/talks.html")
fs.writeFile(
'src/_includes/talks.html',
agendaHtml
);
// save the json with the array of talks
console.log("Writing list of talks to src/js/talks/data.js")
fs.writeFile(
'src/js/talks/data.js',
'(function() { \'use strict\'; module.exports = ' + JSON.stringify(talks) + ';})()'
);
fs.writeFile(
'src/talks.json',
JSON.stringify(talks)
);
});
docs.forEach(function(doc) {
var additionalVariables = [];
var dependencies = {
coreSpies: {},
spies: [],
variables: []
};
if (typeof doc.requires !== 'undefined') {
doc.requires.forEach(function(dependency) {
var chainedMethods = {};
var dependencyObject;
var match;
var methods = [];
var methodName;
var methodSpies = [];
var regularExpression;
regularExpression = new RegExp(
(isInternalService(dependency) ? '\\' : '') + dependency + _methodRegularExpression,
'g'
);
while (match = regularExpression.exec(doc.fileInfo.content)) {
methodName = match[1];
methods.push(methodName);
if (match[2]) {
if (typeof chainedMethods[methodName] === 'undefined') {
chainedMethods[methodName] = [];
}
chainedMethods[methodName].push(match[2]);
}
}
for (methodName in chainedMethods) {
dependencyObject = createDependencyObject(
dependency + methodName.charAt(0).toUpperCase() + methodName.slice(1),
chainedMethods[methodName]
);
dependencyObject.methodName = methodName;
methodSpies.push(dependencyObject);
additionalVariables.push(dependencyObject.variable);
}
dependencyObject = createDependencyObject(
dependency,
methods,
methodSpies
);
if (dependency === '$scope') {
dependencies.coreSpies[dependency] = dependencyObject;
}
dependencies.spies.push(dependencyObject);
});
}
if (doc.docType === 'componentController' && typeof dependencies.coreSpies.$scope === 'undefined') {
dependencies.spies.push(
createDependencyObject('$scope')
);
}
dependencies.spies = _.sortBy(dependencies.spies, 'name');
pushVariables(dependencies, _.map(dependencies.spies, 'variable'));
pushVariables(dependencies, additionalVariables.sort());
log.debug('Compiled ' + dependencies.spies.length + ' dependencies');
doc.dependencies = dependencies;
});
grunt.task.registerMultiTask('index', c.getHelp('index'), function () {
var self = this;
var options = self.options({
js: [],
css: [],
include: []
});
if (self.files.length == 0) {
grunt.fail.warn("No source or destination set.");
return;
}
var src = self.files[0].src;
if (_.isArray(src) && src.length != 1) {
grunt.fail.warn('Only one template source supported.');
return;
}
src = _.isArray(src) ? src[0] : src;
if (!grunt.file.exists(src)) {
grunt.fail.warn('Template not found: ' + src);
}
var dest = self.files[0].dest;
if (_.isArray(dest) && dest.length != 1) {
grunt.fail.warn('Only one destination file supported.');
return;
}
dest = _.isArray(dest) ? dest[0] : dest;
options.include = c.toArray(options.include);
var includes = _.flatten(_.map(options.include, function (include) {
var files = grunt.file.expandMapping(include.src, '', include);
return _.map(files, function (file) {
return (c.toString(include.prefix) || '') + file.dest;
});
}));
// order by directory depth
includes = _.map(_.sortBy(_.map(includes, function (include) {
var str = include.replace(/\\/, '/');
return {
path: str,
depth: str.split('/').length
}
}), 'depth'), 'path');
grunt.file.copy(src, dest, {
process: function (contents) {
return grunt.template.process(contents, {
data: _.extend({
scripts: _.map(options.js.concat(includes), process),
styles: _.map(options.css, process),
version: version(options)
}, options.data || {})
});
}
});
});
results.forEach(result => {
// File with `CssSyntaxError` have not `_postcssResult`
if (!result._postcssResult) {
return
}
const unused = { source: result.source, ranges: [] }
const rangeData = _.cloneDeep(result._postcssResult.stylelint.disabledRanges)
if (!rangeData) {
return
}
result.warnings.forEach(warning => {
const rule = warning.rule
const ruleRanges = rangeData[rule]
if (ruleRanges) {
// Back to front so we get the *last* range that applies to the warning
for (const range of ruleRanges.reverse()) {
if (isWarningInRange(warning, range)) {
range.used = true
return
}
}
}
for (const range of rangeData.all.reverse()) {
if (isWarningInRange(warning, range)) {
range.used = true
return
}
}
})
Object.keys(rangeData).forEach(rule => {
rangeData[rule].forEach(range => {
// Is an equivalent range already marked as unused?
const alreadyMarkedUnused = unused.ranges.find(unusedRange => {
return unusedRange.start === range.start && unusedRange.end === range.end
})
// If this range is unused and no equivalent is marked,
// mark this range as unused
if (!range.used && !alreadyMarkedUnused) {
unused.ranges.push(range)
}
// If this range is used but an equivalent has been marked as unused,
// remove that equivalent. This can happen because of the duplication
// of ranges in rule-specific range sets and the "all" range set
if (range.used && alreadyMarkedUnused) {
_.remove(unused.ranges, alreadyMarkedUnused)
}
})
})
unused.ranges = _.sortBy(unused.ranges, [ "start", "end" ])
report.push(unused)
})
var _ = require('lodash');
//console.log(_.toPairs([1, 2, 3, 4]));
var entries = require('./reading.json');
//_.sortBy(_.toPairs(_.countBy(entries.map((e) => e.tags).join(' ').split(' '))), (v) => v[1])
sorti = _.sortBy(_.toPairs(_.countBy(entries.map((e) => e.tags).join(' ').split(' '))), (v) => v[1]);
//console.log(sorti);
//affiche tous les tags avec leurs chiffres sans les redis
/*sorti.forEach(function(element, i){
var woreplace = [_.replace(element[0], "redis-" , "") , element[1]];
console.log (woreplace);
});*/
//le plus intéressant pour le moment? sans les redis et sans les tags seul pour le menu:
var language = ["java", "pyton", "php", "c#", "c++"];
var lang;
// && _.filter(element[0], _.matches({language})) == element
sorti.forEach(function(element, i){
if( _.isEqual(element[1] , 1) == false)
{
var woreplace = [_.replace(element[0], "redis-" , "") , element[1]];
//console.log (woreplace);
/*woreplace.forEach(function(element, i)
{
if (_.filter(element, _.matches({language})) == element && element == woreplace[0])
{
lang += woreplace[0];
console.log(lang);
}
})*/
exports.exec = function(settings, registry) {
'use strict';
exports.outlineTemplate = moboUtil.loadTemplate(exports, 'outline.wikitext', settings);
if (!exports.outlineTemplate) {
log('[E] No outline.wikitext template found. Please update your mobo_templates!');
log('[i] To automatically update your templates, run mobo --update ');
return '';
}
//////////////////////////////////////////
// Statistics //
//////////////////////////////////////////
var statistics = '';
for (var statName in registry.statistics.outputStats) {
statistics += '* ' + statName + ': ' + registry.statistics.outputStats[statName] + '\n';
}
//////////////////////////////////////////
// Tree Outline //
//////////////////////////////////////////
var tree = '';
// Iterate Forms alphabetically
var sortedFormKeys = _.sortBy(_.keys(registry.expandedForm), function(a) { return a; });
for (var i = 0; i < sortedFormKeys.length; i++) {
var formName = sortedFormKeys[i];
var form = registry.expandedForm[formName];
if (!form.$abstract) {
// Print form info
tree += '\n===[[Form:' + formName + '|' + formName + ']] <span class="text-muted"> - ' + form.title + '</span>===\n';
// Iterate models
for (var modelName in form.properties) {
var model = form.properties[modelName];
if (!model.$abstract && model.properties) {
// Print model info
var modelStats = ' <span class="text-muted"> - ' + model.title + '</span>';
if (settings.uploadOutlineCountRefs) {
var modelReferences = model.$referenceCounter || 1;
modelStats += ' <span class="label label-warning">' + modelReferences + '</span>';
}
tree += '* [[Template:' + modelName + '|' + modelName + ']]' + modelStats + '\n';
// Iterate fields
for (var fieldName in model.properties) {
// TODO: Analyzing fields could happen on a global level, saved then as metadata
var field = model.properties[fieldName];
var inspect = field.items || field;
if (!field.$abstract) {
// Print field info
var fieldStats = ' <span class="text-muted"> - ' + field.title + '</span>';
if (settings.uploadOutlineCountRefs) {
fieldStats += ' <span class="label label-default">' + (field.$referenceCounter || 1) + '</span>';
}
if (field.items) {
fieldStats += ' <span class="label label-warning">multiple</span>';
}
fieldStats += ' <span class="label label-danger">' + inspect.type + '</span>';
if (inspect.format) {
fieldStats += ' <span class="label label-primary">' + inspect.format + '</span>';
}
if (inspect.form) {
for (var k = 0; k < inspect.form.length; k++) {
fieldStats += ' <span class="label label-info">' + inspect.form[k] + '</span>';
}
}
tree += '** [[Property:' + fieldName + '|' + fieldName + ']]' + fieldStats + '\n';
}
}
}
}
}
}
return exports.outlineTemplate({
statistics: statistics,
tree: tree
});
};
async.parallel(asyncProfileSearchTasks, function(){
var sortedGroups = _.sortBy(uploadGroups, function(group) { return group.userid === userId; });
return cb(null, sortedGroups);
});
Party.prototype.repr = function() {
return _.sortBy(this._party, function(player) { return !player.active })
.map(function (player) { return player.repr(); });
};
name:"Lin Yuan 3",
age:27
};
var objary=[aobj,bobj,cobj];
var ary1=[2,3,4,5,2,3,1,5,'asdasd','asd12dsd','lin'];
var ary2 = [2,3,'lin'];
var ary3=_.difference(ary1,ary2);
var users = [
"asdasd","asdasd","asdasd","asdasd","asdasd1","asdasd2"
];
var result =_.sortBy(_.countBy(users));
// console.log(result);
// console.log(_.findLastKey(result));
var allTypesArray = ["4", "4", "2", "2", "2", "6", "2", "6", "6"];
var map = allTypesArray.reduce(function (p, c) {
p[c] = (p[c] || 0) + 1;
return p;
}, {});
var newTypesArray = Object.keys(map).sort(function (a, b) {
return map[a] < map[b];
});
var aryPairs = _.toPairs(map);
console.log(_.sortBy(aryPairs,function(pair){return -pair[1] }));
Scythe.prototype.sortDirectories = function (dirs) {
return _.sortBy(dirs, function (dir) {
dir = dir.split(path.sep);
return - dir.length;
});
};
render() {
const { profiles } = this.props;
const options = [
{ label: translate('none'), value: '' },
...sortBy(profiles, 'name').map(profile => ({
label: profile.isBuiltIn
? `${profile.name} (${translate('quality_profiles.built_in')})`
: profile.name,
value: profile.key
}))
];
const submitDisabled =
this.state.loading ||
this.state.selected == null ||
this.state.selected === this.props.profile.parentKey;
return (
<Modal
isOpen={true}
contentLabel={translate('quality_profiles.change_parent')}
className="modal"
overlayClassName="modal-overlay"
onRequestClose={this.props.onClose}>
<form id="change-profile-parent-form" onSubmit={this.handleFormSubmit}>
<div className="modal-head">
<h2>
{translate('quality_profiles.change_parent')}
</h2>
</div>
<div className="modal-body">
<div className="modal-field">
<label htmlFor="change-profile-parent">
{translate('quality_profiles.parent')}: <em className="mandatory">*</em>
</label>
<Select
clearable={false}
id="change-profile-parent"
name="parentKey"
onChange={this.handleSelectChange}
options={options}
value={
this.state.selected != null
? this.state.selected
: this.props.profile.parentKey || ''
}
/>
</div>
</div>
<div className="modal-foot">
{this.state.loading && <i className="spinner spacer-right" />}
<button disabled={submitDisabled} id="change-profile-parent-submit">
{translate('change_verb')}
</button>
<a href="#" id="change-profile-parent-cancel" onClick={this.handleCancelClick}>
{translate('cancel')}
</a>
</div>
</form>
</Modal>
);
}
const sortItems = () => {
this.items =
this.isAscending
? _.sortBy(this.items, 'title')
: _.sortBy(this.items, 'title').reverse();
};
// massage items into an object by Shop
const subTotalsByShop = this.getSubtotalByShop();
const shippingByShop = this.getShippingTotalByShop();
const { shipping } = this;
const itemsByShop = this.items.reduce((shopItems, item) => {
if (!shopItems[item.shopId]) {
shopItems[item.shopId] = [item];
} else {
shopItems[item.shopId].push(item);
}
return shopItems;
}, {});
const shopObjects = Object.keys(itemsByShop).map((shop) => ({
[shop]: {
name: Shops.findOne(shop).name,
subTotal: subTotalsByShop[shop],
taxes: itemsByShop[shop].reduce((sum, item) => (sum + (item.tax || 0)), 0),
items: itemsByShop[shop],
quantityTotal: itemsByShop[shop].reduce((sum, item) => sum + item.quantity, 0),
shipping: shippingByShop[shop],
shippingMethod: shipping[0].shipmentMethod
}
}));
// TODO we just assume now that every shop uses the same carrier, thus the hard-coded zero index
// because shipping records are not stored by shop
const sortedShopObjects = _.sortBy(shopObjects, (shopObject) => shopObject.name);
return sortedShopObjects;
}
};
AggConfigs.prototype.getRequestAggs = function () {
return _.sortBy(this, function (agg) {
return agg.schema.group === 'metrics' ? 1 : 0;
});
};
.map(function(list, type) {
return [type, _.sortBy(list, 'score')];
})
_orderedMetricIds(graphFilters: object): Array<Object> {
this.dependencies = e.graph.dependencyTree(this._graph(), graphFilters)
const inOrder = _.sortBy(this.dependencies, function(n){return n[1]}).map(e => e[0])
return inOrder
}
$scope.hakemustyypit = function (hakemuskausi) {
return _.sortBy(hakemuskausi.hakemukset, hakemus => _.findIndex(sortOrder, hakemus.hakemustyyppitunnus));
};
}), (error, result) => {
expenses = _.sortBy(result, 'date')
next()
})
var extractDates = function(tickets) {
var datesInStorage = _.map(_.uniqBy(tickets, 'date0'), function(json) {
return moment(json.date0, 'DD.MM.YYYY').toDate();
});
return _.sortBy(datesInStorage);
};
define(function (require) {
var _ = require('lodash');
var Registry = require('utils/registry/registry');
// this is generally a data-structure that Registry is good for managing
var users = [
{ name: 'John', id: 69, username: '******', group: 'admins' },
{ name: 'Anon', id: 0, username: '******', group: 'secret' },
{ name: 'Fern', id: 42, username: '******', group: 'editor' },
{ name: 'Mary', id: 55, username: '******', group: 'editor' }
];
// this is how we used to accomplish this, before Registry
users.byName = _.indexBy(users, 'name');
users.byUsername = _.indexBy(users, 'username');
users.byGroup = _.groupBy(users, 'group');
users.inIdOrder = _.sortBy(users, 'id');
// then things started becoming unruly... so Registry!
describe('Registry', function () {
describe('Basics', function () {
var reg;
beforeEach(function () {
reg = new Registry();
});
it('Extends Array', function () {
expect(reg).to.be.a(Array);
});
it('fails basic lodash check', function () {
expect(_.isArray(reg)).to.be(false);
});
it('clones to an object', function () {
expect(_.isPlainObject(_.clone(reg))).to.be(true);
expect(_.isArray(_.clone(reg))).to.be(false);
});
});
describe('Indexing', function () {
it('provides the initial set', function () {
var reg = new Registry({
initialSet: [1, 2, 3]
});
expect(reg).to.have.length(3);
reg.forEach(function (v, i) {
expect(v).to.eql(i + 1);
});
});
it('indexes the initial set', function () {
var reg = new Registry({
index: ['username'],
initialSet: users
});
expect(reg).to.have.property('byUsername');
expect(reg.byUsername).to.eql(users.byUsername);
});
it('updates indices after values are added', function () {
// split up the user list, and add it in chunks
var firstUser = users.slice(0, 1).pop();
var otherUsers = users.slice(1);
// start off with all but the first
var reg = new Registry({
group: ['group'],
order: ['id'],
initialSet: otherUsers
});
// add the first
reg.push(firstUser);
// end up with the same structure that is in the users fixture
expect(reg.byGroup).to.eql(users.byGroup);
expect(reg.inIdOrder).to.eql(users.inIdOrder);
});
it('updates indices after values are removed', function () {
// start off with all
var reg = new Registry({
group: ['group'],
order: ['id'],
initialSet: users
});
// remove the last
reg.pop();
var expectedCount = users.length - 1;
// indexed lists should be updated
expect(reg).to.have.length(expectedCount);
var sumOfGroups = _.reduce(reg.byGroup, function (note, group) {
return note + group.length;
}, 0);
expect(sumOfGroups).to.eql(expectedCount);
});
it('updates indices after values are re-ordered', function () {
var rawUsers = users.slice(0);
// collect and shuffle the ids available
var ids = [];
_.times(rawUsers.length, function (i) { ids.push(i); });
ids = _.shuffle(ids);
// move something here
var toI = ids.shift();
// from here
var fromI = ids.shift();
// do the move
var move = function (arr) { arr.splice(toI, 0, arr.splice(fromI, 1)[0]); };
var reg = new Registry({
index: ['username'],
initialSet: rawUsers
});
var index = reg.byUsername;
move(reg);
expect(reg.byUsername).to.eql(index);
expect(reg.byUsername).to.not.be(index);
});
});
require('./inflector')();
require('./path_getter')();
});
});
list: function(q){
return _.sortBy(q ? _.filter(todos, q) : todos, function(t){
return t.createAt;
});
},
self.sortHits = function (hits) {
self.isAscending = !self.isAscending;
self.hits = self.isAscending ? _.sortBy(hits, 'title') : _.sortBy(hits, 'title').reverse();
};
http.createServer(function(request, response) {
response.on('error', function(err) {
console.error(err);
});
response.writeHead(200, {'Content-Type': 'text/html'});
// NOTE TO SELF:
// terrible solution
var html = `<meta http-equiv="refresh" content="${REFRESH_INTERVAL}; URL=http://localhost:${PORT}">`;
// NOTE TO SELF:
// alphabetical order should be replaced in the future
_.forEach(_.sortBy(displayObject, ['alias']), healthObject => {
var style = '',
fontColor = '',
backgroundColor = '',
borderColor = '';
if (/^[12]..$/.test(healthObject.HTTPStatusCode) && healthObject.isConsistent) {
// 1xx Informational
// 2xx Success
fontColor = '3c763d';
backgroundColor = 'dff0d8';
borderColor = 'd0e9c6';
} else if (/^.$/.test(healthObject.HTTPStatusCode) && healthObject.isConsistent) {
// 3xx Redirection
fontColor = '8a6d3b';
backgroundColor = 'fcf8e3';
borderColor = 'faf2cc';
} else {
fontColor = 'a94442';
backgroundColor = 'f2dede';
borderColor = 'ebcccc';
}
style = `padding: 5px; margin-bottom: .5rem; color: #${fontColor}; background-color: #${backgroundColor}; border: 1px solid #${borderColor}; border-radius: .25rem; font-size: 14px; font-family: 'Helvetica';`;
html += `<div class="health-data" style="${style}">`;
html += `Endpoint <strong><span>${healthObject.alias}</span></strong><br>`;
html += `<div style="margin-top: 4px; margin-bottom: 4px;">`;
if (/^[12]..$/.test(healthObject.HTTPStatusCode) && healthObject.isConsistent) {
html += `Available & Consistent<br>`;
} else {
if (!/^[12]..$/.test(healthObject.HTTPStatusCode)) {
html += `HTTP status code was <span>${healthObject.HTTPStatusCode}</span><br>`;
}
if (!healthObject.isConsistent) {
html += `Response data structure was <span>inconsistent</span><br>`;
}
}
html += `</div>`;
html += `<span style="font-size: 12px;">${util.elapsedTime(healthObject.timestamp)}</span>`;
html += `</div>`;
});
response.write(html);
response.end();
}).listen(PORT);
})).then(({projects}) => {
return _.reverse(_.sortBy(projects, 'updatedAt')).map(x => new Project(x));
});
function orderByPosition(books){
return _.sortBy(books, 'order');
}