/*
Return an array of name variations that ember uses
169555
function(name) {
    var variations = [];
    // var lastSegment = name.split('/').slice(-1)[0] || name;
    var dashedFullPath = name.split('/').join('-');
    variations.push(stringUtils.camelize(name));
    variations.push(stringUtils.dasherize(name));
    variations.push(stringUtils.dasherize(name).split('-').join(' '));
    variations.push(stringUtils.classify(dashedFullPath));

    // console.log('variations:',variations);

    return variations;
  }
458664
function (name) {
        return Array.isArray(name) ? (name.map(this.valueOf.bind(this))) : this.hash[name];
    }
1152363
function getNames(input) {
    let names = [];
    let split = input.split(/([\uD800-\uDBFF][\uDC00-\uDFFF])/);

    for (let i = 0; i < split.length; i++) {
        let char = split[i];
        if (char !== '') {
            let currentName = autocomplete.name(char).name;
            names.push(currentName);
        }
    }

    return names;
}
837488
protected function variantFilenames()
    {
        $names = [];

        foreach ($this->variants() as $variant) {
            $names[ $variant ] = $this->variantFilename($variant);
        }

        return $names;
    }
779750
function getResourceNames() {
        var resourceNames = {};
        var resourcesDir = this.injector.rootDir + '/' + this.injector.servicesDir + '/resources';

        if (!fs.existsSync(path.normalize(resourcesDir))) {
            return resourceNames;
        }

        var names = fs.readdirSync(path.normalize(resourcesDir));
        _.each(names, function (name) {
            if (name.substring(name.length - 3) !== '.js') {  // only dirs, not js files
                resourceNames[utils.getPascalCase(name)] = utils.getCamelCase(name);
            }
        });

        return resourceNames;
    }
1354934
function (fullName, options) {
      _emberMetalDebug.assert('fullName must be a proper full name', this.registry.validateFullName(fullName));
      return factoryFor(this, this.registry.normalize(fullName), options);
    }
1100888
function (methodName) {
            var names = [], params = this.getParameters(methodName);

            params.forEach(function (param) {
                names.push(param.name);
            });

            return names;
        }
2268
function getScheduledName(arr) {
    var name = arr.slice(0).shift()
    return [`${app}-production-${name}`, `${app}-staging-${name}`]
  }
336069
function variants(name, initial) {
  const map = initial ? initStars : bubbleStars;
  if (map[name]) return map[name];

  const parts = name.split('.');
  const result = [];
  let base = false;

  // initial events the implicit namespace of 'this'
  if (initial) {
    parts.unshift('this');
    base = true;
  }

  // use max - 1 bits as a bitmap to pick a part or a *
  // need to skip the full star case if the namespace is synthetic
  const max = Math.pow(2, parts.length) - (initial ? 1 : 0);
  for (let i = 0; i < max; i++) {
    const join = [];
    for (let j = 0; j < parts.length; j++) {
      join.push(1 & (i >> j) ? '*' : parts[j]);
    }
    result.unshift(join.join('.'));
  }

  if (base) {
    // include non-this-namespaced versions
    if (parts.length > 2) {
      result.push.apply(result, variants(name, false));
    } else {
      result.push('*');
      result.push(name);
    }
  }

  map[name] = result;
  return result;
}
230621
function getNames (resourceType) {
  const aliases = [resourceType];
  if (resourceAliases[resourceType]) {
    return aliases.concat(resourceAliases[resourceType]);
  }
  return alias(resourceType);
}
402640
private JSONArray getAlternativeNames(Collection<List<?>> alternativeNames) {

        if (alternativeNames == null || alternativeNames.size() == 0) {
            return null;
        }

        JSONArray altNames = new JSONArray();
        for (List<?> altName : alternativeNames) {
            //int altNameType = (Integer) altName.get(0);  // XXX For now we're going to ignore the type
            //                                             // We might want to do something special later.
            String altNameValue = altName.get(1).toString();
            altNames.put(altNameValue);
        }

        return altNames;
    }
424038
function getTemplates(app) {
	var results = [];

	if (extensions && extensions.hasOwnProperty('templates')
		&& extensions.templates.hasOwnProperty(app)
	) {
		var sourceArray = extensions.templates[app];

		for (index = 0; index < sourceArray.length; ++index) {
		    results.push(app + '.' + sourceArray[index]);
		}
	}

	return results;
}
620757
function getRichItemNames(textStyleModel) {
    // Use object to remove duplicated names.
    var richItemNameMap;
    while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {
        var rich = (textStyleModel.option || EMPTY_OBJ).rich;
        if (rich) {
            richItemNameMap = richItemNameMap || {};
            for (var name in rich) {
                if (rich.hasOwnProperty(name)) {
                    richItemNameMap[name] = 1;
                }
            }
        }
        textStyleModel = textStyleModel.parentModel;
    }
    return richItemNameMap;
}
771602
function(name) {
    var nameList = name.split('.');

    return nameList
      .map(function(item, i, list) {
        return list.slice(0, i+1).join('.');
      })
      .filter(function(item) {
        return item !== null;
      });
  }
8187
function getRouteNamespaces(spec) {
    let names = new Map();
    for (let id of spec.routeIDs) {
        let [namespace, explicit] = Namespace.forRoute(spec.route(id));
        namespace.log.push(`Route ${id} maps to ${namespace.fullName} (explicit = ${explicit})`);
        names.set(id, [namespace, explicit]);
    }
    return names;
}
366824
function getModifierClassNames(props) {
  return modifierKeys.reduce((result, key) => {
    if (props[key]) {
      return result.concat(styles[`${key}-${props[key]}`]);
    }
    return result;
  }, []);
}
223200
def get_template_names(self):
        """"""
        request = self.request
        querystring_key = request.REQUEST.get('querystring_key', PAGE_LABEL)
        if request.is_ajax() and querystring_key == self.key:
            return [self.page_template]
        return super(
            AjaxMultipleObjectTemplateResponseMixin, self).get_template_names()