How to use

transform

function

in

LoDashStatic

_.transform(
  fs.readdirSync(__dirname),
  (result, filename) => {
   const filepath = `${__dirname}/${filename}`;
   if (path.extname(filename) === '.js' && filename !== 'index.js') {
    const jsname = path.basename(filename, '.js');
    result[jsname] = require(filepath)(funcs);
   }
  },
  {}
 )

function load(config, metadata) {
 var
  defaults = {},
  base_url = getVaultURL(config) + '/' + API_PREFIX,
  partial;

 if (config.has('timeout')) {
  defaults.timeout = config.get('timeout');
 }

 defaults = _.assign(defaults, getSSLOptions(config));
 defaults = _.assign(defaults, getProxy(config));

 partial = _.partial(Endpoint.create, base_url, defaults);
 return _.transform(metadata, partial, {});
}

function help() {
 var data = _.transform(CMD_MAP, (result, value, key) => {
  result[key] = value[0];
 });
 console.log(columnify(data, {
  columns: ['COMMAND', 'DESCRIPTION'],
  minWidth: 20,
 }));

 console.log('\n' + EXTRA_HELP_INFO);
}

/**
 * Creates an object of base name and compiled template pairs that match `pattern`.
 *
 * @memberOf file
 * @param {string} pattern The glob pattern to be match.
 * @returns {Object} Returns the object of compiled templates.
 */
function globTemplate(pattern) {
 return _.transform(glob.sync(pattern), (result, filePath) => {
  const key = path.basename(filePath, path.extname(filePath));
  result[key] = _.template(fs.readFileSync(filePath, 'utf8'));
 }, {});
}

/**
 * Generates an "operationId" attribute based on path and method names.
 *
 * @private
 * @param  {String} method_name HTTP method name.
 * @param  {String} path_name   Path name.
 * @return {String}
 */
const generateOperationId = (method_name, path_name) => {
 if (path_name === '/') return method_name;

 // clean url path for requests ending with '/'
 let clean_path = path_name;
 if (clean_path.indexOf('/', clean_path.length - 1) !== -1) {
  clean_path = clean_path.substring(0, clean_path.length - 1);
 }

 let segments = clean_path.split('/').slice(1);
 segments = _.transform(segments, (result, segment) => {
  if (segment[0] === '{' && segment[segment.length - 1] === '}') {
   segment = `by-${_.capitalize(segment.substring(1, segment.length - 1))}}`;
  }
  result.push(segment);
 });

 return _.camelCase(`${method_name.toLowerCase()}-${segments.join('-')}`);
}

console.log(`[${name}] Executing...`);
const result = await new Benchmark().config(config).tasks(tasks).execute();
return _.transform(
 result,
 (memo, { name, mean }, index) => {

const assets = _.transform(files, (result, file) => {

/**
 * Deep diff between two object, using lodash
 * @param  {Object} object Object compared
 * @param  {Object} base   Object to compare with
 * @return {Object}        Return a new object who represent the diff
 */
function difference(object, base) {
  function changes(object, base) {
    return _.transform(object, function(result, value, key) {
      if (!_.isEqual(value, base[key])) {
        result[key] = (_.isObject(value) && _.isObject(base[key])) ? changes(value, base[key]) : value;
      }
    });
  }
  return changes(object, base);
}

/*----------------------------------------------------------------------------*/

/**
 * Creates a hash object. If a `properties` object is provided, its own
 * enumerable properties are assigned to the created hash.
 *
 * @memberOf util
 * @param {Object} [properties] The properties to assign to the hash.
 * @returns {Object} Returns the new hash object.
 */
function Hash(properties) {
 return _.transform(properties, (result, value, key) => {
  result[key] = (_.isPlainObject(value) && !(value instanceof Hash))
   ? new Hash(value)
   : value;
 }, this);
}

_.transform(data, (form, value, field) => {
  form.append(field, value);
 }, new FormData())