Calculate property name from tag name, e.g. a:schemeClr -> schemeClr.
342167
def _prop_name(self):
        
        if ':' in self._nsptagname:
            start = self._nsptagname.index(':') + 1
        else:
            start = 0
        return self._nsptagname[start:]
738120
def decode_name(s):
    """"""
    # Some names contain XML-like entity codes
    return re.sub(r'&#(\d+);', lambda x: chr(int(x.group(1))), s)
850033
private NameInfo getNameInfoForName(String name, SymbolType type) {
    Map<String, NameInfo> map = type == PROPERTY ? propertyNameInfo : varNameInfo;
    if (map.containsKey(name)) {
      return map.get(name);
    } else {
      NameInfo nameInfo = new NameInfo(name);
      map.put(name, nameInfo);
      symbolGraph.createNode(nameInfo);
      return nameInfo;
    }
  }
460066
def get_property_values(self, property_name):
        '''
        
        '''
        property_values = set()
        for signature_value in self.values():
            if signature_value.get(property_name):
                property_values.add(signature_value[property_name])
        return property_values
277479
def getParamsByName(elem, name):
	
	name = StripParamName(name)
	return elem.getElements(lambda e: (e.tagName == ligolw.Param.tagName) and (e.Name == name))
1233031
function selectorTagNameSpy(results, tagName) {
        var context = phantomas.getDOMPath(this);

        // querying by BODY and body is the same (issue #419)
        tagName = tagName.toLowerCase();

        phantomas.incrMetric('DOMqueriesByTagName');
        phantomas.addOffender('DOMqueriesByTagName', {tag: tagName, node: phantomas.getDOMPath(this)});
        querySpy('tag name', tagName, 'getElementsByTagName', context, (results.length === 0));
    }
311432
@Override
	public String getProperty(String tag, String def) {
		String rv;
		rv = super.getProperty(tag, null);
		if(rv==null && getter!=null) {
			rv = getter.get(tag, null, true);
		}
		return rv==null?def:rv;
	}
1278967
def get_tag(self, name):
        """"""
        res = self.get_request('/tag/' + name)
        return Tag(cloud_manager=self, **res['tag'])
82873
def tag(self, name, attrs=None, selfclosing=None):
        """"""
        if self.disable_tags > 0:
            return

        if name in self.linkable_tags and attrs and len(attrs) > 0:
            for attrib in attrs:
                if attrib[0] in self.linkable_attrs:
                    attrib[1] = INTERNAL_LINK.sub('{\g<1>}', attrib[1])

        super().tag(name, attrs, selfclosing)
663790
def call(self, tag_name: str, *args, **kwargs):
        """"""
        if hasattr(self, tag_name):
            getattr(self, tag_name)(*args, **kwargs)
340656
private void checkTagName(String name) {
        if (standardTags.contains(name)) {
            overridenStandardTags.add(name);
        } else {
            if (name.indexOf('.') == -1) {
                potentiallyConflictingTags.add(name);
            }
            unseenCustomTags.add(name);
        }
    }
452443
def get_property_func(key):
    
    def get_it(obj):
        try:
            return getattr(obj, key)
        except AttributeError:
            return obj.tags.get(key)
    return get_it
413068
def _text_of_element(self, property_name):
        
        element = getattr(self, property_name)
        if element is None:
            return ''
        if element.text is None:
            return ''
        return element.text
721127
def configured_name_key(name)
      is_property_tag = MetaTags.config.property_tags.any? do |tag_name|
        name.to_s.match(/^#{Regexp.escape(tag_name.to_s)}\b/)
      end
      is_property_tag ? :property : :name
    end
1303200
def tag_details(tag, nodenames):
    
    details = {}

    details['type'] = tag.name
    details['ordinal'] = tag_ordinal(tag)

    # Ordinal value
    if tag_details_sibling_ordinal(tag):
        details['sibling_ordinal'] = tag_details_sibling_ordinal(tag)

    # Asset name
    if tag_details_asset(tag):
        details['asset'] = tag_details_asset(tag)

    object_id_tag = first(raw_parser.object_id(tag, pub_id_type= "doi"))
    if object_id_tag:
        details['component_doi'] = extract_component_doi(tag, nodenames)

    return details
709600
def _validate_property_names(class_name, properties):
    """"""
    for property_name in properties:
        if not property_name or property_name.startswith(ILLEGAL_PROPERTY_NAME_PREFIXES):
            raise IllegalSchemaStateError(u'Class "{}" has a property with an illegal name: '
                                          u'{}'.format(class_name, property_name))
722944
function getPropertyName(node) {
			if (node.computed) {
				switch (node.property.type) {
					case "Literal":
						return String(node.property.value);
					case "TemplateLiteral":
						if (node.property.expressions.length === 0) {
							return node.property.quasis[0].value.cooked;
						}
						// fallthrough
					default:
						return false;
				}
			}
			return node.property.name;
		}