Determine if an attribute is present.

 @example Is the attribute present?
   person.attribute_present?("title")

 @param [ String, Symbol ] name The name of the attribute.

 @return [ true, false ] True if present, false if not.

 @since 1.0.0
334973
def attribute_present?(name)
      attribute = read_raw_attribute(name)
      !attribute.blank? || attribute == false
    rescue ActiveModel::MissingAttributeError
      false
    end
1245938
def is_active(self, name):
        
        if name in self._plugins.keys():
            return self._plugins["name"].active
        return None
111901
function hasAttribute (element, attrName) {
  if (typeof element.hasAttribute === 'function') {
    return element.hasAttribute(attrName)
  }
  return element.getAttribute(attrName) !== null
}
1225502
def validate(self, name, value):
        
        validator = self.attribute_validators.get(name, None)
        if validator:
            return True if validator(value) else False
        return True
223129
def any_present?(*keys)
      keys.each do |key|
        return true if self.send(key).present?
      end
      return false
    end
101587
public boolean contains(Attribute attr) throws NamingException {
    if (attr == null) {
      return false; // protect
    }

    Attribute recAttr = getAttributes().get(attr.getID());

    if (recAttr == null) {
      return false;
    }

    NamingEnumeration ne = attr.getAll();

    while (ne.hasMore()) {
      if (!recAttr.contains(ne.next())) {
        return false;
      }
    }

    return true;
  }
729374
def check_available!(name, endpoint)
      check_name_available!(name) unless name.nil?
      check_endpoint_available!(endpoint) unless endpoint.nil?
    end
580442
def hasProp(self, name):
        
        ret = libxml2mod.xmlHasProp(self._o, name)
        if ret is None:return None
        __tmp = xmlAttr(_obj=ret)
        return __tmp
858334
def validates_attached_presence(name, options = {})

      message = options[:message] || "must be attached"

      validates_presence_of :"#{name}_identifier", message: message,
        if: options[:if], unless: options[:unless]

    end
935365
def has_guise?(value)
      value = value.to_s.classify

      unless guise_options.values.include?(value)
        raise ArgumentError, "no such guise #{value}"
      end

      association(guise_options.association_name).reader.any? do |record|
        !record.marked_for_destruction? &&
          record[guise_options.attribute] == value
      end
    end
294353
def attribute(name, options = {})
        return unless
          @_object &&
          attribute_present?(name) &&
          resolve_condition(options)

        attribute = data_object_attribute(name)
        name = create_key(options[:as] || name)
        @_result[name] = attribute
      end
208965
def read_attribute(name)
      name = name.to_s

      if respond_to?(name)
        attribute(name)
      else
        raise ::ActiveRemote::UnknownAttributeError, "unknown attribute: #{name}"
      end
    end
709796
def named(name)
      resource = all.detect { |resource| resource.name == name }
      if resource.nil?
        raise UnknownResource, "Resource named #{name} doesn't exist"
      else
        resource
      end
    end
959410
def _name_exists(self, name):
        
        for i in range(self.count()):
            if self.tabText(i) == name:
                return True
        return False
309983
private boolean isEmptyAttribute(Attribute a) {
		try {
			return (a == null || a.size() == 0 || a.get() == null);
		}
		catch (NamingException e) {
			return true;
		}
	}
1280589
def has_role? role_name
      raise ArgumentError, '#has_role? should take a single role String or Symbol as the argument' if !role_name || role_name.kind_of?(Array)
      has_roles? role_name
    end
1111816
def hasAttribute(self, attr: str) -> bool:
        """"""
        if attr == 'class':
            return bool(self.classList)
        return attr in self.attributes