NSLigatureAttributeName

 :ligature
   = 0, :off, :none
   = 1, :on, :default
195384
def ligature_attribute(styles={})
      return nil if styles.nil?
      value = styles[:ligature]
      return 0 if [0, :off, :none].include?(value)
      return 1 if [1, :on, :default].include?(value)
      nil
    end
629839
@Nullable
    private static TemplateSignature parseSignatureAttribute(Signature signatureAttribute) {

        Matcher m = TEMPLATED_SIGNATURE.matcher(signatureAttribute.getSignature());
        if (!m.matches()) {
            return null;
        }

        TemplateSignature ts = new TemplateSignature();
        ts.signature = m.group(2);

        m = TEMPLATE.matcher(m.group(1));
        List<TemplateItem> templates = new ArrayList<>(4);
        while (m.find()) {
            templates.add(new TemplateItem(m.group(1), m.group(2)));
        }
        ts.templateParameters = templates.toArray(new TemplateItem[0]);

        return ts;
    }
1274633
public static String unsign(@NotNull String val, @NotNull Mac mac) {
        int idx = val.lastIndexOf('.');

        if (idx == -1) {
            return null;
        }

        String str = val.substring(0, idx);
        if (val.equals(sign(str, mac))) {
            return str;
        }
        return null;
    }
985403
private static void setAttributes(FunctionLib extFL, FunctionLib newFL) {
	newFL.setDescription(extFL.getDescription());
	newFL.setDisplayName(extFL.getDisplayName());
	newFL.setShortName(extFL.getShortName());
	newFL.setUri(extFL.getUri());
	newFL.setVersion(extFL.getVersion());
    }
1125074
private Token attributesBlock() {
        Matcher matcher = scanner.getMatcherForPattern("^&attributes\\b");
        if (matcher.find(0) && matcher.group(0) != null) {
            this.scanner.consume(11);
            CharacterParser.Match match = this.bracketExpression();
            this.scanner.consume(match.getEnd()+1);
            return new AttributesBlock(match.getSrc(),lineno);
        }
        return null;
    }
160879
function createMarkupForCustomAttribute(name, value) {
    if (!isAttributeNameSafe(name) || value == null) {
      return '';
    }
    return name + '=' + quoteAttributeValueForBrowser(value);
  }
1129088
function(name, value) {

		var result = '';

		if (value === true) {

			result = ' ' + name + '="' + name + '"';

		} else if (value != null && value !== false) {

			result = ' ' + name + '="' + this.escapeAttributeValue(value + '') + '"';

		}

		return result;

	}
1295299
def MoveToAttributeNo(self, no):
        
        ret = libxml2mod.xmlTextReaderMoveToAttributeNo(self._o, no)
        return ret
1340963
public Attribute removeAttributeByLocalName(CharSequence name) {
		for (Iterator<Attribute> it = event.attributes.iterator(); it.hasNext(); ) {
			Attribute attr = it.next();
			if (attr.localName.equals(name)) {
				it.remove();
				return attr;
			}
		}
		return null;
	}
43020
def attribute_prefix=(attribute_prefix)
      if attribute_prefix.nil?
        fail ArgumentError, "attribute_prefix cannot be nil"
      end

      if attribute_prefix.to_s.length < 1
        fail ArgumentError, "invalid value for 'attribute_prefix', the character length must be great than or equal to 1."
      end

      @attribute_prefix = attribute_prefix
    end
1094921
def font_attribute(styles={})
      return nil if styles.nil?
      value = styles[:font]
      return nil unless value && value.is_a?(UIFont)
      value
    end
246949
public UnprotectedStringBuffer getAttributeValueByFullName(CharSequence name) {
		for (Attribute attr : event.attributes)
			if (attr.text.equals(name))
				return attr.value;
		return null;
	}
874949
function(attr) {
                var names = [],
                    last = 0;
                // Goes through attr string and places the characters found between the periods and single escaped periods into the
                // `names` array.  Double escaped periods are ignored.
                attr.replace(escapeReg, function(first, second, index) {

                    if (!second) {
                        names.push(
                            attr
                            .slice(last, index)

                            .replace(escapeDotReg, '.'));
                        last = index + first.length;
                    }
                });

                names.push(
                    attr
                    .slice(last)

                    .replace(escapeDotReg, '.'));
                return names;
            }
1092470
function setElAttributes(el, attributes) {
  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
    var attrValue = attributes[attrName];

    if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
      el.removeAttribute(attrName);
    } else {
      el.setAttribute(attrName, attrValue === true ? '' : attrValue);
    }
  });
}
1292379
private void addFmtAttribute(Text attribute) throws IllegalArgumentException {
    	if (!attribute.startsWith(SessionDescription.FMTP)) {
    		throw new IllegalArgumentException("Not a valid FMT attribute"+attribute);
    	}
    	
    	Iterator<Text> it = attribute.split(':').iterator();
    	Text token = it.next();
        
    	token = it.next();
        token.trim();

        //payload and format descriptor
        it = token.split(' ').iterator();

        //payload
        token = it.next();
        token.trim();

        int payload = token.toInteger();

        //format descriptor
        token = it.next();
        token.trim();

        RTPFormat fmt = getFormat(payload);
        if (fmt != null) {
            //TODO : replace string with text
            fmt.getFormat().setOptions(token);
        }
    }
546035
public static void validateAttributeName(String name) {
    checkForKeyword(name);

    validateName(name);

    if (!name.matches("[a-zA-Z0-9_#]+(-[a-z]{2,3})??$")) {
      throw new MolgenisDataException(
          "Invalid characters in: ["
              + name
              + "] Only letters (a-z, A-Z), digits (0-9), underscores (_) and hashes (#) are allowed.");
    }
  }
291318
function setAttr(node, name, val, asProp, initial) {
	var el = node.el;

	if (node.ns != null)
		{ el.setAttribute(name, val); }
	else if (name === "class")
		{ el.className = val; }
	else if (name === "id" || typeof val === "boolean" || asProp)
		{ el[name] = val; }
	else if (name[0] === ".")
		{ el[name.substr(1)] = val; }
	else
		{ el.setAttribute(name, val); }
}