ActiveLdap::Operations::Common

# File lib/active_ldap/operations.rb, line 112
def count(options={})
  search(options).size
end

# File lib/active_ldap/operations.rb, line 88
def exist?(dn, options={})
  attr, value, prefix = split_search_value(dn)

  options_for_leaf = {
    :attribute => attr,
    :value => value,
    :prefix => prefix,
    :limit => 1,
  }

  attribute = attr || ensure_search_attribute
  options_for_non_leaf = {
    :attribute => attr,
    :value => value,
    :prefix => ["#{attribute}=#{value}", prefix].compact.join(","),
    :limit => 1,
    :scope => :base,
  }

  !search(options_for_leaf.merge(options)).empty? or
    !search(options_for_non_leaf.merge(options)).empty?
end

# File lib/active_ldap/operations.rb, line 29
def search(options={}, &block)
  validate_search_options(options)
  attr = options[:attribute]
  value = options[:value] || '*'
  filter = options[:filter]
  prefix = options[:prefix]
  classes = options[:classes]
  requested_attributes = options[:attributes]

  value = value.first if value.is_a?(Array) and value.first.size == 1

  _attr = nil
  _prefix = nil
  if attr.nil? or attr == dn_attribute
    _attr, value, _prefix = split_search_value(value)
  end
  attr ||= _attr || ensure_search_attribute
  prefix ||= _prefix
  filter ||= [attr, value]
  filter = [:and, filter, *object_class_filters(classes)]
  _base = options[:base] ? [options[:base]] : [prefix, base]
  _base = prepare_search_base(_base)
  if options.has_key?(:ldap_scope)
    message = _(":ldap_scope search option is deprecated. "                        "Use :scope instead.")
    ActiveSupport::Deprecation.warn(message)
    options[:scope] ||= options[:ldap_scope]
  end
  search_options = {
    :base => _base,
    :scope => options[:scope] || scope,
    :filter => filter,
    :limit => options[:limit],
    :attributes => requested_attributes,
    :sort_by => options[:sort_by] || sort_by,
    :order => options[:order] || order,
  }
  options[:connection] ||= connection
  values = []
  requested_all_attributes_p =
    (requested_attributes.nil? or requested_attributes.include?('*'))
  options[:connection].search(search_options) do |dn, attrs|
    attributes = {}
    attrs.each do |key, _value|
      if requested_all_attributes_p or requested_attributes.include?(key)
        normalized_attribute, normalized_value =
          normalize_attribute_options(key, _value)
        attributes[normalized_attribute] ||= []
        attributes[normalized_attribute].concat(normalized_value)
      else
        next
      end
    end
    values << [dn, attributes]
  end
  values = values.collect {|_value| yield(_value)} if block_given?
  values
end