How to use

filter

function

in

CollectionChain

Promise
 .all([
  queryCollaborators({ repositoryOwner, repositoryName }),
  queryCommits({ repositoryOwner, repositoryName, since })
 ])
 .then(results => {
  const collaborators = _.keyBy(results[0], 'login')

  return _.chain(results[1])
   .map('author.user')
   .reject(_.isEmpty)
   .groupBy('login')
   .map(group => _.defaults({ commits: _.size(group) }, _.head(group)))
   .filter(user => _.isEmpty(collaborators[user.login]))
   .value()
 })
 .then(res => formatOutput(res))
 .catch(err => console.log(err))

_.chain(os.networkInterfaces())
  .values()
  .flatten()
  .filter(function(val) {
   return (val.family == 'IPv4' && val.internal == false)
  })
  .map('address')
  .first()
  .value()

_.chain(db)
  .filter(a => _.includes(_.lowerCase(a.name), _.lowerCase(criteria.name)))
  .filter(a => a.age > criteria.age.min && a.age < criteria.age.max)
  .filter(a => a.yearsActive > criteria.yearsActive.min && a.yearsActive < criteria.yearsActive.max)
  .sortBy(a => a[sortProperty])
  .value()

function excludeInterface(name, content) {
 var without = _.curry(function (name, content) {
  return !_.includes(content, name);
 });

 return _.chain(content)
  .split('\n\n')
  .filter(without(name))
  .join('\n\n').trim();
}

_.chain(suffix)
  .map(function (s) {
   var suffix = s
   var result = ''
   var limit = word.length-suffix.length
   if (word.lastIndexOf(suffix) == limit)
    result = word.substring(0, limit)
   return result
  })
  .filter(function (c) { return c !== '' })
  .filter(function (c) { return Word.prototype.isBasicWord(c) })
  .value()

_.chain(sentences)
  .map(function (sentence) {
   var res = {}
   res['text'] = sentence
   res['s_id'] = count
   res['words'] = tokenizer.tokenize(sentence)
   res['words'] = _.chain(res['words'])
    .filter(function (word) { return !Helper.isStopWord(Processor.prototype.LANG, word)})
    .filter(function (word) { return !Helper.isPunctuation(word)})
    .map(function (word) { return s(word).toLowerCase().value() })
    .value()
   res['words'] = _.uniq(res['words'])
   count += 1
   return res
  })
  .value()

_.chain(fs.readdirSync(absPath))
  .filter(file => file.match(/\.svg$/))
  .map(file => {
   const fileParts = file.split('.');
   const name = fileParts.length < 2 ? file : _.initial(fileParts).join('.');
   const shortname = name
    .toLowerCase()
    .replace(/[!|’|.| |-]/g, '')
    .replace(/[+]/, 'plus');

   return {
    shortname,
    name,
    url: 'http://instantlogosearch.com',
    path: path.join('instantlogos', 'logos', file)
   };
  })
  .value()

const restOfUsers =  _.chain(clients)
  .keys()
  .filter(c => c !== userId)
  .value();
client.emit('sign-in-done', {

//
 // ---- ACL
 //

 _trimActions(actions) {
  return _.chain(actions)
   .map(_.lowerCase)
   .map(act => ACTION_ALIASES[act] || act)
   .filter(act => _.includes(ALLOWED_ACTIONS, act))
   .uniq()
   .value();
 }

_.chain(events)
    .map('guard')
    .filter()
    .uniq()
    .map(id => ({
      id,
      asleep: false,
      minutesAsleep: 0,
      byMinute: _.range(60)
        .map(() => 0)
    }))
    .keyBy('id')
    .value()

_.chain(confix)
  .map(function (p) {
   var confix = p[0]
   var starts = p[1]
   var dissolve = p[2]
   var end = p[3]
   var result = []
   if (word.indexOf(confix) == 0) {
    result = starts.map(function (start) {
     var sub = word.substring(confix.length)
     sub = (dissolve) ? start+sub : sub
     if ((sub.indexOf(start) == 0) || (start == '*')) {
      var limit = sub.length-end.length
      if (sub.lastIndexOf(end) == limit)
       sub = sub.substring(0, limit)
      return sub
     }
     else
      return ''
    })
   }
   return result
  })
  .flatten()
  .filter(function (c) { return c !== '' })
  .filter(function (c) { return Word.prototype.isBasicWord(c) })
  .value()

_.chain(prefix)
  .map(function (p) {
   var prefix = p[0]
   var starts = p[1]
   var dissolve = p[2]
   var result = []
   if (word.indexOf(prefix) == 0) {
    result = starts.map(function (start) {
     var sub = word.substring(prefix.length)
     sub = (dissolve) ? start+sub : sub
     if ((sub.indexOf(start) == 0) || (start == '*'))
      return sub
     else
      return ''
    })
   }
   return result
  })
  .flatten()
  .filter(function (c) { return c !== '' })
  .filter(function (c) { return Word.prototype.isBasicWord(c) })
  .value()

Promise
 .all([
  queryCollaborators({ repositoryOwner, repositoryName }),
  queryCommits({ repositoryOwner, repositoryName, since })
 ])
 .then(results => {
  const collaborators = _.keyBy(results[0], 'login')

  return _.chain(results[1])
   .map('author.user')
   .reject(_.isEmpty)
   .groupBy('login')
   .map(group => _.defaults({ commits: _.size(group) }, _.head(group)))
   .filter(user => _.isEmpty(collaborators[user.login]))
   .value()
 })
 .then(res => formatOutput(res))
 .catch(err => console.log(err))

_.chain(events)
    .map('guard')
    .filter()
    .uniq()
    .map(id => ({
      id,
      asleep: false,
      minutesAsleep: 0,
      byMinute: _.range(60)
        .map(() => 0)
    }))
    .keyBy('id')
    .value()