How to use

thru

function

in

Collection

// Helper to get tokens
const getTokens = (home, tokens = []) => _(utils.sortTokens(utils.getTerminusTokens(home), tokens))
 .map(token => ({name: token.email, value: token.token}))
 .thru(tokens => tokens.concat([{name: 'add or refresh a token', value: 'more'}]))
 .value()

/*
 * Helper to get appMount
 */
const getAppMount = (app, base, files) => {
 if (_.has(app, 'source.root')) return path.join(base, app.source.root);
 return _(files)
  .filter(file => file.name === app.name)
  .thru(file => file[0].dir)
  .value();
}

_(files)
 .flatMap(file => traverseUp(path.resolve(startFrom, file)))
 .sortBy().reverse()
 .filter(file => fs.existsSync(file) && path.isAbsolute(file))
 .thru(files => _.isEmpty(files) ? [] : [_.first(files)])
 .flatMap(dirFile => _.map(files, file => path.join(path.dirname(dirFile), file)))
 .filter(file => fs.existsSync(file))
 .value()

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

_(apps)
 .map(app => app.relationships || [])
 .flatten()
 .thru(relationships => relationships[0])
 .map((relationship, alias) => ({
  alias,
  service: relationship.split(':')[0],
  endpoint: relationship.split(':')[1],
  creds: _.get(open, alias, {}),
 }))
 .groupBy('service')
 .value()

constructor(id, options = {}, factory) {
   options = _.merge({}, config, options);
   // Get route for this service
   const primaryRoute = _(_.get(options, '_app.platformsh.routes', []))
    .map((config, url) => _.merge({}, config, {url}))
    .filter(route => route.type === 'upstream')
    .filter(route => route.upstream.split(':')[0] === options.name)
    .orderBy('primary', ['desc'])
    .thru(routes => routes[0].url)
    .value();
   // Build the php
   const php = {
    image: `docker.registry.platform.sh/php-${options.version}`,
    volumes: options.volumes,
    ports: ['80'],
    environment: {
     DRUSH_OPTIONS_URI: primaryRoute,
    },
   };

   // Add in the php service and push downstream
   super(id, options, {services: _.set({}, options.name, php)});
  }

_(data)
    .map((value, index) => new Table(value, opts))
    .map(table => table.toString())
    .thru(data => data.join(os.EOL))
    .value()

_(_.merge(_.get(data, 'Config.ExposedPorts', []), {'443/tcp': {}}))
 .map((value, port) => ({
  port: _.head(port.split('/')),
  protocol: (_.includes(secured, port.split('/')[0])) ? 'https' : 'http'}
 ))
 .filter(exposed => _.includes(scan, exposed.port))
 .flatMap(ports => _.map(_.get(data, `NetworkSettings.Ports.${ports.port}/tcp`, []), i => _.merge({}, ports, i)))
 .filter(ports => _.includes([bindAddress, '0.0.0.0'], ports.HostIp))
 .map(ports => url.format({
  protocol: ports.protocol,
  hostname: 'localhost',
  port: _.includes(scan, ports.port) ? ports.HostPort : '',
 }))
 .thru(urls => ({service: data.Config.Labels['com.docker.compose.service'], urls}))
 .value()

_(excludes)
 .thru(excludes => toObject(getNamedVolumeNames(excludes)))
 .value()

_(files)
 .filter(file => fs.existsSync(file))
 .map(file => yaml.safeLoad(fs.readFileSync(file)))
 .thru(data => _.merge({}, ...data))
 .thru(data => {
  // Set the php version
  // @TODO: what is the best version here?
  data.php = _.toString(_.get(data, 'php_version', '5.6'));
  // Set the webroot
  data.webroot = (_.get(data, 'web_docroot', false)) ? 'web' : '.';
  // Set the drush version
  data.drush = _.toString(_.get(data, 'drush_version', '8'));
  // if drush version is less than 8, use 8 anyway
  if (data.drush < 8) data.drush = 8;
  // return
  return data;
 })
 .value()

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

_(keys)
 .map(service => data)
 .map((service, index) => _.set({}, keys[index], service))
 .thru(services => _.reduce(services, (sum, service) => _.merge(sum, service), {}))
 .value()

// Helper to get tokens
const getTokens = (home, tokens = []) => _(utils.sortTokens(utils.getPlatformshTokens(home), tokens))
 .map(token => ({name: token.email, value: token.token}))
 .thru(tokens => tokens.concat([{name: 'add or refresh a token', value: 'more'}]))
 .value()