How to use

filter

function

in

Collection

_(services)
 // Break apart platform type into typ and version
 .map(service => _.merge({}, service, getPlatformServiceType(service)))
 // Filter out services that are not supported yet
 .filter(service => getLandoServiceType(service.type) !== false)
 // Merge in other needed lando things
 .map(service => _.merge({}, getLandoService(service), {runConfig: _.find(runConfig, {service: service.name})}))
 // Finally map to an object
 .map(service => ([service.name, service]))
 .fromPairs()
 .value()

exports.makeExecutable(_(fs.readdirSync(dest))
   .filter(file => path.extname(file) === '.sh')
   .value()
  , dest);

_(loadCacheFile(config.toolingRouter))
   .map(route => _.merge({}, route, {
    closeness: _.indexOf(pathsToRoot(), route.route),
   }))
   .filter(route => route.closeness !== -1)
   .orderBy('closeness')
   .thru(routes => routes[0])
   .value()

_(fs.readdirSync(baseDir, {withFileTypes: true}))
  .filter(dirent => dirent.isDirectory())
  .map(dirent => dirent.name)
  .concat('.')
  .map(directory => path.resolve(baseDir, directory, '.platform.app.yaml'))
  .filter(file => fs.existsSync(file))
  .map(file => ({data: yamlPlatform.load(fs.readFileSync(file)), file}))
  .map(data => ({name: data.data.name, file: data.file, dir: path.dirname(data.file)}))
  .value()

/*
 * Helper to get passthru options
 */
const handlePassthruOpts = (options = {}, answers = {}) => _(options)
 .map((value, key) => _.merge({}, {name: key}, value))
 .filter(value => value.passthrough === true && !_.isNil(answers[value.name]))
 .map(value => `--${value.name}=${answers[value.name]}`)
 .value()

_(files)
 .map(file => (path.isAbsolute(file) ? file : path.join(base, file)))
 .filter(file => fs.existsSync(file))
 .value()

_(services)
 .map(service => getServiceToolingByType(service))
 .filter(tools => !_.isEmpty(tools))
 .map(tools => _.map(tools, (config, name) => ([name, config])))
 .flatten()
 .fromPairs()
 .value()

_(apps)
 .filter(app => app.closeness !== -1)
 .orderBy('closeness')
 .thru(apps => apps[0])
 .value()

_(services)
 // Filter out non psh containers
 .filter(service => !_.isEmpty(service.platformsh))
 // Filter out psh services
 .filter(service => service.platformsh.application)
 .value()

_(config.LANDO_METRICS_PLUGINS)
 .map(plugin => _.merge({}, plugin, {path: path.resolve(__dirname, 'plugins', `${plugin.name}.js`)}))
 .filter(plugin => fs.existsSync(plugin.path))
 .map(plugin => _.merge({}, plugin, {Reporter: require(plugin.path)}))
 .value()

_(services)
 // Filter out services that are not supported yet
 .filter(service => getLandoServiceType(service.type) !== false)
 // Merge in other needed lando things
 .map(service => _.merge({}, getLandoService(service)))
 // Finally map to an object
 .map(service => ([service.name, service])).fromPairs()
 .value()

_(parsedServices)
  .map(service => getServiceToolingByType(service, app))
  .flatten()
  .filter(service => service.name)
  .map(service => ([service.name, _.omit(service, 'name')]))
  .fromPairs()
  .value()

_(services)
 // Filter out non psh containers
 .filter(service => !_.isEmpty(service.platformsh))
 // Filter out psh application containers
 .filter(service => !service.platformsh.application)
 .value()

exports.makeExecutable(_(fs.readdirSync(dest))
   .filter(file => path.extname(file) === '.sh')
   .value()
  , dest);

_(config.LANDO_METRICS_PLUGINS)
 .map(plugin => _.merge({}, plugin, {path: path.resolve(__dirname, 'plugins', `${plugin.name}.js`)}))
 .filter(plugin => fs.existsSync(plugin.path))
 .map(plugin => _.merge({}, plugin, {Reporter: require(plugin.path)}))
 .value()