How to use

compact

function

in

LoDashStatic

/**
   * Merge `mixins` property in schema
   *
   * @static
   * @param {Object} src Source schema property
   * @param {Object} target Target schema property
   *
   * @returns {Object} Merged schema
   */
  static mergeSchemaUniqArray(src, target) {
    return _.uniqWith(_.compact(flatten([src, target])), _.isEqual);
  }

/**
   * Merge `started`, `stopped`, `created` event handler properties in schema
   *
   * @static
   * @param {Object} src Source schema property
   * @param {Object} target Target schema property
   *
   * @returns {Object} Merged schema
   */
  static mergeSchemaLifecycleHandlers(src, target) {
    return _.compact(flatten([target, src]));
  }

/*
 * Parse docker-compose options
 */
const parseOptions = (opts = {}) => {
 const flags = _.map(composeFlags, (value, key) => _.get(opts, key, false) ? value : '');
 const environment = _.flatMap(opts.environment, (value, key) => ['--env', `${key}=${value}`]);
 const user = (_.has(opts, 'user')) ? ['--user', opts.user] : [];
 const workdir = (_.has(opts, 'workdir')) ? ['--workdir', opts.workdir] : [];
 const entrypoint = _.map(opts.entrypoint, entrypoint => ['--entrypoint', entrypoint]);
 return _.compact(_.flatten([flags, environment, user, workdir, entrypoint]));
}

_(cmd)
 // Put into an object so we can handle "multi-service" tooling
 .map(cmd => parseCommand(cmd, service))
 // Handle dynamic services
 .map(config => handleDynamic(config, options, answers))
 // Add in any argv extras if they've been passed in
 .map(config => handleOpts(config, handlePassthruOpts(options, answers)))
 // Wrap the command in /bin/sh if that makes sense
 .map(config => _.merge({}, config, {command: escape(config.command, true, config.args)}))
 // Add any args to the command and compact to remove undefined
 .map(config => _.merge({}, config, {command: _.compact(config.command.concat(config.args))}))
 // Put into an object
 .value()

/*
 * Helper to standardize construction of docker commands
 */
const buildCmd = (run, name, compose, {services, cmd}, opts = {}) => {
 if (!name) throw new Error('Need to give this composition a project name!');
 // @TODO: we need to strip out opts.user on start/stop because we often get it as part of run
 const project = ['--project-name', name];
 const files = _.flatten(_.map(compose, unit => ['--file', unit]));
 const options = parseOptions(opts);
 const argz = _.flatten(_.compact([services, cmd]));
 return _.flatten([project, files, run, options, argz]);
}

/**
   * Initialize Tracer.
   */
  init() {
    if (this.opts.enabled) {

      this.defaultTags = isFunction(this.opts.defaultTags) ? this.opts.defaultTags.call(this, this) : this.opts.defaultTags;

      // Create Exporter instances
      if (this.opts.exporter) {
        const exporters = Array.isArray(this.opts.exporter) ? this.opts.exporter : [this.opts.exporter];

        this.exporter = _.compact(exporters).map(r => {
          const exporter = Exporters.resolve(r);
          exporter.init(this);
          return exporter;
        });

        const exporterNames = this.exporter.map(exporter => this.broker.getConstructorName(exporter));
        this.logger.info(`Tracing exporter${exporterNames.length > 1 ? "s": ""}: ${exporterNames.join(", ")}`);
      }

    }
  }

/**
   * Sanitize hooks. If the hook is a string, convert it to Service method calling.
   *
   * @param {Function|String|Array<any>} hooks
   * @param {Service?} service
   * @returns
   */
  function sanitizeHooks(hooks, service) {
    if (isString(hooks))
      return service && isFunction(service[hooks]) ? service[hooks] : null;

    if (Array.isArray(hooks)) {
      return _.compact(hooks.map(h => {
        if (isString(h))
          return service && isFunction(service[h]) ? service[h] : null;

        return h;
      }));
    }

    return hooks;
  }

/**
   * Merge `events` property in schema
   *
   * @static
   * @param {Object} src Source schema property
   * @param {Object} target Target schema property
   *
   * @returns {Object} Merged schema
   */
  static mergeSchemaEvents(src, target) {
    Object.keys(src).forEach(k => {
      const modEvent = wrapToHander(src[k]);
      const resEvent = wrapToHander(target[k]);

      let handler = _.compact(flatten([resEvent ? resEvent.handler : null, modEvent ? modEvent.handler : null]));
      if (handler.length == 1) handler = handler[0];

      target[k] = _.defaultsDeep(modEvent, resEvent);
      target[k].handler = handler;
    });

    return target;
  }

/**
   * Initialize queues for REQUEST & EVENT packets.
   *
   * @memberof AmqpTransporter
   */
  makeBalancedSubscriptions() {
    if (!this.hasBuiltInBalancer) return this.broker.Promise.resolve();

    return this.unsubscribeFromBalancedCommands().then(() => {
      const services = this.broker.getLocalNodeInfo().services;
      return this.broker.Promise.all(services.map(service => {
        const p = [];

        // Service actions queues
        if (service.actions && typeof(service.actions) == "object") {
          p.push(Object.keys(service.actions).map(action => this.subscribeBalancedRequest(action)));
        }

        // Load-balanced/grouped events queues
        if (service.events && typeof(service.events) == "object") {
          p.push(Object.keys(service.events).map(event => {
            const group = service.events[event].group || service.name;
            this.subscribeBalancedEvent(event, group);
          }));
        }

        return this.broker.Promise.all(_.compact(flatten(p, true)));
      }));
    });
  }

const reporters = Array.isArray(this.opts.reporter) ? this.opts.reporter : [this.opts.reporter];
this.reporter = _.compact(reporters).map(r => {
  const reporter = Reporters.resolve(r);
  reporter.init(this);

/*
  * Get list of sites
  */
 getSites() {
  // Call to get user sites
  const pantheonUserSites = () => {
   const getSites = ['users', _.get(this.session, 'user_id'), 'memberships', 'sites'];
   return pantheonRequest(this.request, this.log, 'get', getSites, {params: {limit: MAX_SITES}})
   .then(sites => _.map(sites, (site, id) => _.merge(site, site.site)));
  };
  // Call to get org sites
  const pantheonOrgSites = () => {
   const getOrgs = ['users', _.get(this.session, 'user_id'), 'memberships', 'organizations'];
   return pantheonRequest(this.request, this.log, 'get', getOrgs)
   .map(org => {
    if (org.role !== 'unprivileged') {
     const getOrgsSites = ['organizations', org.id, 'memberships', 'sites'];
     return pantheonRequest(this.request, this.log, 'get', getOrgsSites, {params: {limit: MAX_SITES}})
     .map(site => _.merge(site, site.site));
    }
   })
   .then(sites => _.flatten(sites));
  };
  // Run both requests
  return Promise.all([pantheonUserSites(), pantheonOrgSites()])
  // Combine, cache and all the things
  .then(sites => _.compact(_.sortBy(_.uniqBy(_.flatten(sites), 'name'), 'name')))
  // Filter out any BAAAAD BIZZZNIZZZ
  .filter(site => !site.frozen);
 }

/**
   * Merge `hooks` property in schema
   *
   * @static
   * @param {Object} src Source schema property
   * @param {Object} target Target schema property
   *
   * @returns {Object} Merged schema
   */
  static mergeSchemaHooks(src, target) {
    Object.keys(src).forEach(k => {
      if (target[k] == null)
        target[k] = {};

      Object.keys(src[k]).forEach(k2 => {
        const modHook = wrapToArray(src[k][k2]);
        const resHook = wrapToArray(target[k][k2]);

        target[k][k2] = _.compact(flatten(k == "before" ? [resHook, modHook] : [modHook, resHook]));
      });
    });

    return target;
  }

 volumes: utils.getNamedVolumes(excludes),
 services: toObject(app.services, {
  volumes: _.compact(serviceExcludes.concat(serviceIncludes)),
 }),
}));
app.add(new app.ComposeService('excludes', {}, {
 services: toObject(app.services, {
  volumes: _.compact(serviceExcludes),
 }),
}));

  const resHook = wrapToArray(targetAction.hooks[k]);
  srcAction.hooks[k] = _.compact(flatten(k == "before" ? [resHook, modHook] : [modHook, resHook]));
});

// Helper to get popuylation command
const getPopCommand = (excludes = []) => _.compact(_.flatten([['/helpers/mounter.sh'], excludes]))