Transforms the special attribute with the given name.
431289
function transformSpecialAttribute(name, attribute) {
        if (t.isJSXExpressionContainer(attribute.value)) {
            let value = attribute.value.expression;
            switch (name) {
                case "ui5ControlData":
                    renderer.renderControlData(value);
                    break;
                case "ui5ElementData":
                    renderer.renderElementData(value);
                    break;
                case "ui5AccessibilityData":
                    renderer.handleAccessibilityData(value);
                    break;
                default:
                    error(attribute, "Unknown special attribute: '" + name + "'.");
            }
        } else {
            error(attribute, "Only expressions supported in special attributes.");
        }
    }
585124
private String replaceNonAlpha(String name) {
        String modifiedName = null;
        if (p != null)
            modifiedName = p.matcher(name).replaceAll("_");
        return modifiedName;
    }
861125
def rename(self, name):
        """"""
        self.ec2.create_tags(Resources = [self.instance_id],
                             Tags      = [{'Key':   'Name',
                                           'Value':  name}])
        self.refresh_info()
1003337
function transformAttrs (data, tag) {
  let { attrs, directives } = data
  if (!attrs) {
    attrs = data.attrs = {}
  }
  attrs['weex-type'] = tag
  if (tag === 'image' || tag === 'gif') {
    const { src, resize } = attrs
    if (src) {
      attrs['data-img-src'] = src
    }
    if (resize) {
      if (!directives) {
        directives = data.directives = []
      }
      directives.push({
        name: 'weex-resize',
        value: attrs.resize
      })
    }
  }
}
625403
function transform(el, context) {
    ebayUIAttributeTransformer(el, context);

    const builder = context.builder;
    const iconAttribute = el.getAttribute('icon');
    const iconName = iconAttribute && iconAttribute.value.value;
    if (iconName) {
        const iconTag = context.createNodeForEl('ebay-icon', [
            {
                name: 'name',
                value: builder.literal(iconName)
            },
            {
                name: 'type',
                value: builder.literal('inline')
            }
        ]);
        const menuIconTag = context.createNodeForEl('ebay-infotip:icon');
        menuIconTag.appendChild(iconTag);
        el.prependChild(menuIconTag);
    }
}
1094680
def set_special(index, color, iterm_name="h", alpha=100):
    """"""
    if OS == "Darwin" and iterm_name:
        return "\033]P%s%s\033\\" % (iterm_name, color.strip("#"))

    if index in [11, 708] and alpha != "100":
        return "\033]%s;[%s]%s\033\\" % (index, alpha, color)

    return "\033]%s;%s\033\\" % (index, color)
721227
def _convert_to_standard_attr(attr):
    '''
    
    '''
    ret_attr = ATTR_MAP.get(attr, None)
    if ret_attr is None:
        # All others convert to lowercase
        return attr.lower()
    return ret_attr
684688
def name_replace(self, to_replace, replacement):
        """"""
        self.name = self.name.replace(to_replace, replacement)
1112297
def normalizeToName(val):
    
    if val not in tagsAndNameSet:
        raise KeyError("{} is not a tag or name string".format(val))
    else:
        try:
            return tagToFullDict[val]
        except KeyError:
            return val
455887
function normalizeAttributeKey(key) {
  const hyphenIndex = key.indexOf('-');

  if (hyphenIndex !== -1 && key.match(HTML_CUSTOM_ATTR_R) === null) {
    key = key.replace(CAPTURE_LETTER_AFTER_HYPHEN, function(_, letter) {
      return letter.toUpperCase();
    });
  }

  return key;
}
735418
function transformFeature (feature, fields) {
  const attributes = {}

  // first transform each of the features to the converted field name and transformed value
  if (feature.attributes && Object.keys(feature.attributes)) {
    _.each(Object.keys(feature.attributes), (name) => {
      let attr = {}
      attr[name] = feature.attributes[name]
      try {
        attributes[fields[name].outName] = convertAttribute(attr, fields[name])
      } catch (e) {
        console.error('Field was missing from attribute')
      }
    })
  }

  return {
    type: 'Feature',
    properties: attributes,
    geometry: parseGeometry(feature.geometry)
  }
}
689052
def rename(self, old_name, new_name):
        """"""
        try:
            self.api.rename(mkey(old_name), mkey(new_name))
        except ResponseError, exc:
            if "no such key" in exc.args:
                raise KeyError(old_name)
            raise
474260
def normalize(name):
    """"""

    # Name should not contain some specials chars (issue #1068)
    ret = name.replace(':', '')
    ret = ret.replace('%', '')
    ret = ret.replace(' ', '_')

    return ret
1113192
def normalize_name(name):
    
    if not name or not isinstance(name, basestring):
        raise ValueError('Can only normalize non-empty string names. Unexpected '+ repr(name))

    if len(name) > 1:
        name = name.lower()
    if name != '_' and '_' in name:
        name = name.replace('_', ' ')

    return canonical_names.get(name, name)
505254
private function applyExtraAttributes()
    {
        // Convert distinguished name string into an array
        if ($this->hasAttribute('distinguishedname')) {
            $dn = $this->getAttribute('distinguishedname');

            $this->setAttribute('dn', $dn);

            $this->setAttribute('dn_array', $this->connection->explodeDn($dn, true));
        }

        // Convert the object category string into an array
        if ($this->hasAttribute('objectcategory')) {
            $oc = $this->getAttribute('objectcategory');

            $this->setAttribute('oc', $oc);

            $this->setAttribute('oc_array', $this->connection->explodeDn($oc, true));
        }
    }
601742
def add_special(self, name):
        """"""
        self.undeclared.discard(name)
        self.declared.add(name)
601158
def _normalize_name(name):
    # type: (str) -> str
    
    name = name.lower().replace('_', '-')
    if name.startswith('--'):
        name = name[2:]  # only prefer long opts
    return name