put name back together after parts have been normalized
775365
function combinePluginParts(loader, argumentName, pluginName, defaultExtension) {
    if (defaultExtension && argumentName.substr(argumentName.length - 3, 3) == '.js')
      argumentName = argumentName.substr(0, argumentName.length - 3);

    if (loader.pluginFirst) {
      return pluginName + '!' + argumentName;
    }
    else {
      return argumentName + '!' + pluginName;
    }
  }
579917
protected function normalizeNames()
	{
        if (! $this->validFile($this->imagePath())) {
			$this->image = $this->default();
		}

		if ($this->hasOptions()) {
			$this->createThumbnail();
		}
	}
654960
def _clean_rec_name(rec):
    
    out_id = []
    for char in list(rec.id):
        if char in ALLOWED_CONTIG_NAME_CHARS:
            out_id.append(char)
        else:
            out_id.append("_")
    rec.id = "".join(out_id)
    rec.description = ""
    return rec
1049366
def set_default_names(data):
    """"""
    if all(name is not None for name in data.index.names):
        return data

    data = data.copy()
    if data.index.nlevels > 1:
        names = [name if name is not None else 'level_{}'.format(i)
                 for i, name in enumerate(data.index.names)]
        data.index.names = names
    else:
        data.index.name = data.index.name or 'index'
    return data
665217
def tidy(fnames):
    
    for fname in fnames:
        try:
            node = nrml.read(fname)
        except ValueError as err:
            print(err)
            return
        with open(fname + '.bak', 'wb') as f:
            f.write(open(fname, 'rb').read())
        with open(fname, 'wb') as f:
            # make sure the xmlns i.e. the NRML version is unchanged
            nrml.write(node.nodes, f, writers.FIVEDIGITS, xmlns=node['xmlns'])
        print('Reformatted %s, original left in %s.bak' % (fname, fname))
1328916
def _makeUniqueFilename(taken_names, name):
    
    if name in taken_names:
        # try to form up new name
        basename, ext = os.path.splitext(name)
        num = 1
        name = "%s-%d%s" % (basename, num, ext)
        while name in taken_names:
            num += 1
            name = "%s-%d%s" % (basename, num, ext)
    # finally, enter name into set
    taken_names.add(name)
    return name
737503
def normalize(location_name, preserve_commas=False):
    """"""
    def replace(match):
        if preserve_commas and ',' in match.group(0):
            return ','
        return ' '
    return NORMALIZATION_RE.sub(replace, location_name).strip().lower()
998924
def normalize(self, text, **kwargs):
        """"""
        identifiers = []
        for ident in super(IdentifierType, self).normalize(text, **kwargs):
            identifiers.append(normalize(ident))
        return identifiers
366215
def normalize_eols(text, eol='\n'):
    """"""
    for eol_char, _ in EOL_CHARS:
        if eol_char != eol:
            text = text.replace(eol_char, eol)
    return text
1293516
def _replaceRenamedPairMembers(kerning, leftRename, rightRename):
    
    renamedKerning = {}
    for (left, right), value in kerning.items():
        left = leftRename.get(left, left)
        right = rightRename.get(right, right)
        renamedKerning[left, right] = value
    return renamedKerning
986230
def normalizeFilename(filename):
    
    result = os.path.expanduser(filename)
    result = os.path.abspath(result)
    return result
249914
def normalize_dependency_group_name(name)
      segments = name.to_s.dup.downcase.split(/_/)
      [segments.shift, *segments.map{ |word| word.capitalize }].join('').to_sym
    end
1243959
def convert_to_humanized_name(name, suffix)
      name.gsub(/\.#{::Regexp.quote(suffix)}$/i, '').tr('_', ' ').strip
    end
1121377
def _normalize(self, name):
        
        name = re.sub(
            r'^(Senator|Representative|Sen\.?|Rep\.?|'
            'Hon\.?|Right Hon\.?|Mr\.?|Mrs\.?|Ms\.?|L\'hon\.?|'
            'Assembly(member|man|woman)) ',
            '',
            name)
        return name.strip().lower().replace('.', '')
789569
def nicename(name):
    '''
    '''
    name = to_string(name)
    return capfirst(' '.join(name.replace('-', ' ').replace('_', ' ').split()))
1209137
def normalize_partial_name(decl):
    
    if decl.cache.normalized_partial_name is None:
        decl.cache.normalized_partial_name = normalize(decl.partial_name)
    return decl.cache.normalized_partial_name
227324
def normalize_pipeline_name(name=''):
    """"""
    normalized_name = name
    for bad in '\\/?%#':
        normalized_name = normalized_name.replace(bad, '_')
    return normalized_name