How to use

snakeCase

function

in

LoDashStatic

get(name) {
    name = _.upperFirst(_.camelCase(name));
    if(this.models[name]) return this.models[name];

    try {
      this.models[name] = require(`models/${_.snakeCase(name)}`);
    } catch(e) {
      throw e;
    }

    return this.models[name];
  }

const generateSafeParamIds = (path) => {
 const params = _.get(path, 'node.params', []);
 const paramIds = params.map((param) => {
  if (t.isIdentifier(param)) {
   return param.name;
  }
  if (t.isObjectPattern(param)) {
   return path.scope.generateUidIdentifier('obj').name;
  }
  if (t.isAssignmentPattern(param)) {
   return _.get(param, 'left.name', 'unhandled_assignment_pattern_default');
  }
  return _.snakeCase(`unhandled.${param.type}`);
 });
 return paramIds;
}

_.map(
           _.sortBy(
            [
             collection.attributes[
              details.via
             ],
             details
            ],
            'collection'
           ),
           table => {
            return _.snakeCase(
             pluralize.plural(table.collection) +
              ' ' +
              pluralize.plural(table.via)
            );
           }
          ).join('__')

const userPluginsPath = `${this.akyuu.projectRoot}/plugins/${_.snakeCase(key)}`;
if(fs.existsSync(`${userPluginsPath}.js`) || fs.existsSync(path.join(userPluginsPath, "index.js"))) {
  plug = require(userPluginsPath).create(this.akyuu, config);
    const builtInPath = `../built_in_plugin/${_.snakeCase(key)}`;
    if(fs.existsSync(path.join(__dirname, `${builtInPath}.js`))) {
      plug = require(builtInPath).create(this.akyuu, config);

lines
    .map((line, index) => {
     if (['{', '}'].includes(line)) {
      return '';
     }

     const split = Object.keys(fields)[index - 1].split('(');
     const attribute = _.trim(split[0]);
     const info = _.get(description[attribute], 'description');
     const deprecated = _.get(description[attribute], 'deprecated');

     // Snakecase an attribute when we find a dash.
     if (attribute.indexOf('-') !== -1) {
      line = `  ${_.snakeCase(attribute)}(${_.trim(split[1])}`;
     }

     if (info) {
      line = `  """\n    ${info}\n  """\n${line}`;
     }

     if (deprecated) {
      line = `${line} @deprecated(reason: "${deprecated}")`;
     }

     return line;
    })
    .join('\n')

line = `  ${_.snakeCase(attribute)}: ${_.trim(split[1])}`;