ruby-activeldap 0.8.2 → 0.8.3

data/lib/active_ldap/ldap_error.rb

@@ -1,74 +0,0 @@
-module ActiveLdap
-  class LdapError < Error
-    class << self
-      def define(code, name, target)
-        klass_name = name.downcase.camelize
-        target.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-          class #{klass_name} < #{self}
-            CODE = #{code}
-            def code
-              CODE
-            end
-          end
-EOC
-        target.const_get(klass_name)
-      end
-    end
-
-    ERRORS = {}
-    {
-      0x00 => "SUCCESS",
-      0x01 => "OPERATIONS_ERROR",
-      0x02 => "PROTOCOL_ERROR",
-      0x03 => "TIMELIMIT_EXCEEDED",
-      0x04 => "SIZELIMIT_EXCEEDED",
-      0x05 => "COMPARE_FALSE",
-      0x06 => "COMPARE_TRUE",
-      0x07 => "AUTH_METHOD_NOT_SUPPORTED",
-      0x08 => "STRONG_AUTH_REQUIRED",
-      0x09 => "PARTIAL_RESULTS", # LDAPv2+ (not LDAPv3)
-
-      0x0a => "REFERRAL",
-      0x0b => "ADMINLIMIT_EXCEEDED",
-      0x0c => "UNAVAILABLE_CRITICAL_EXTENSION",
-      0x0d => "CONFIDENTIALITY_REQUIRED",
-      0x0e => "LDAP_SASL_BIND_IN_PROGRESS",
-
-      0x10 => "NO_SUCH_ATTRIBUTE",
-      0x11 => "UNDEFINED_TYPE",
-      0x12 => "INAPPROPRIATE_MATCHING",
-      0x13 => "CONSTRAINT_VIOLATION",
-      0x14 => "TYPE_OR_VALUE_EXISTS",
-      0x15 => "INVALID_SYNTAX",
-
-      0x20 => "NO_SUCH_OBJECT",
-      0x21 => "ALIAS_PROBLEM",
-      0x22 => "INVALID_DN_SYNTAX",
-      0x23 => "IS_LEAF",
-      0x24 => "ALIAS_DEREF_PROBLEM",
-
-      0x2F => "PROXY_AUTHZ_FAILURE",
-      0x30 => "INAPPROPRIATE_AUTH",
-      0x31 => "INVALID_CREDENTIALS",
-      0x32 => "INSUFFICIENT_ACCESS",
-
-      0x33 => "BUSY",
-      0x34 => "UNAVAILABLE",
-      0x35 => "UNWILLING_TO_PERFORM",
-      0x36 => "LOOP_DETECT",
-
-      0x40 => "NAMING_VIOLATION",
-      0x41 => "OBJECT_CLASS_VIOLATION",
-      0x42 => "NOT_ALLOWED_ON_NONLEAF",
-      0x43 => "NOT_ALLOWED_ON_RDN",
-      0x44 => "ALREADY_EXISTS",
-      0x45 => "NO_OBJECT_CLASS_MODS",
-      0x46 => "RESULTS_TOO_LARGE",
-      0x47 => "AFFECTS_MULTIPLE_DSAS",
-
-      0x50 => "OTHER",
-    }.each do |code, name|
-      ERRORS[code] = LdapError.define(code, name, self)
-    end
-  end
-end

data/lib/active_ldap/object_class.rb

@@ -1,74 +0,0 @@
-module ActiveLdap
-  module ObjectClass
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-    end
-
-    def add_class(*target_classes)
-      replace_class((classes + target_classes.flatten).uniq)
-    end
-
-    def ensure_recommended_classes
-      add_class(self.class.recommended_classes)
-    end
-
-    def remove_class(*target_classes)
-      replace_class((classes - target_classes.flatten).uniq)
-    end
-
-    def replace_class(*target_classes)
-      new_classes = target_classes.flatten.uniq
-      assert_object_classes(new_classes)
-      if new_classes.sort != classes.sort
-        set_attribute('objectClass', new_classes)
-      end
-    end
-
-    def classes
-      (get_attribute('objectClass', true) || []).dup
-    end
-
-    private
-    def assert_object_classes(new_classes)
-      assert_valid_object_class_value_type(new_classes)
-      assert_valid_object_class_value(new_classes)
-      assert_have_all_required_classes(new_classes)
-    end
-
-    def assert_valid_object_class_value_type(new_classes)
-      invalid_classes = new_classes.reject do |new_class|
-        new_class.is_a?(String)
-      end
-      unless invalid_classes.empty?
-        message = "Value in objectClass array is not a String"
-        invalid_classes_info = invalid_classes.collect do |invalid_class|
-          "#{invalid_class.class}:#{invalid_class.inspect}"
-        end.join(", ")
-        raise TypeError,  "#{message}: #{invalid_classes_info}"
-      end
-    end
-
-    def assert_valid_object_class_value(new_classes)
-      invalid_classes = new_classes.reject do |new_class|
-        schema.exist_name?("objectClasses", new_class)
-      end
-      unless invalid_classes.empty?
-        message = "unknown objectClass in LDAP server"
-        message = "#{message}: #{invalid_classes.join(', ')}"
-        raise ObjectClassError, message
-      end
-    end
-
-    def assert_have_all_required_classes(new_classes)
-      required_classes = self.class.required_classes - new_classes
-      unless required_classes.empty?
-        raise RequiredObjectClassMissed,
-                "Can't remove required objectClass: " +
-                 required_classes.join(", ")
-      end
-    end
-  end
-end

data/lib/active_ldap/schema.rb

@@ -1,299 +0,0 @@
-module ActiveLdap
-  class Schema
-    def initialize(entries)
-      @entries = default_entries.merge(entries || {})
-      @schema_info = {}
-      @class_attributes_info = {}
-      @cache = {}
-    end
-
-    def names(group)
-      alias_map(group).keys
-    end
-
-    def exist_name?(group, name)
-      alias_map(group).has_key?(normalize_schema_name(name))
-    end
-
-    # attribute
-    #
-    # This is just like LDAP::Schema#attribute except that it allows
-    # look up in any of the given keys.
-    # e.g.
-    #  attribute('attributeTypes', 'cn', 'DESC')
-    #  attribute('ldapSyntaxes', '1.3.6.1.4.1.1466.115.121.1.5', 'DESC')
-    def attribute(group, id_or_name, attribute_name)
-      return [] if attribute_name.empty?
-      attribute_name = normalize_attribute_name(attribute_name)
-      value = attributes(group, id_or_name)[attribute_name]
-      value ? value.dup : []
-    end
-    alias_method :[], :attribute
-    alias_method :attr, :attribute
-
-    NUMERIC_OID_RE = "\\d[\\d\\.]+"
-    DESCRIPTION_RE = "[a-zA-Z][a-zA-Z\\d\\-]*"
-    OID_RE = "(?:#{NUMERIC_OID_RE}|#{DESCRIPTION_RE}-oid)"
-    def attributes(group, id_or_name)
-      return {} if group.empty? or id_or_name.empty?
-
-      unless @entries.has_key?(group)
-        raise ArgumentError, "Unknown schema group: #{group}"
-      end
-
-      # Initialize anything that is required
-      info, ids, aliases = ensure_schema_info(group)
-      id, name = determine_id_or_name(id_or_name, aliases)
-
-      # Check already parsed options first
-      return ids[id] if ids.has_key?(id)
-
-      schemata = @entries[group] || []
-      while schema = schemata.shift
-        next unless /\A\s*\(\s*(#{OID_RE})\s*(.*)\s*\)\s*\z/ =~ schema
-        schema_id = $1
-        rest = $2
-        next if ids.has_key?(schema_id)
-
-        attributes = {}
-        ids[schema_id] = attributes
-
-        parse_attributes(rest, attributes)
-        (attributes["NAME"] || []).each do |v|
-          normalized_name = normalize_schema_name(v)
-          aliases[normalized_name] = schema_id
-          id = schema_id if id.nil? and name == normalized_name
-        end
-
-        break if id == schema_id
-      end
-
-      ids[id || aliases[name]] || {}
-    end
-
-    # attribute_aliases
-    #
-    # Returns all names from the LDAP schema for the
-    # attribute given.
-    def attribute_aliases(name)
-      cache([:attribute_aliases, name]) do
-        attribute_type(name, 'NAME')
-      end
-    end
-
-    # read_only?
-    #
-    # Returns true if an attribute is read-only
-    # NO-USER-MODIFICATION
-    def read_only?(name)
-      cache([:read_only?, name]) do
-        attribute_type(name, 'NO-USER-MODIFICATION')[0] == 'TRUE'
-      end
-    end
-
-    # single_value?
-    #
-    # Returns true if an attribute can only have one
-    # value defined
-    # SINGLE-VALUE
-    def single_value?(name)
-      cache([:single_value?, name]) do
-        attribute_type(name, 'SINGLE-VALUE')[0] == 'TRUE'
-      end
-    end
-
-    # binary?
-    #
-    # Returns true if the given attribute's syntax
-    # is X-NOT-HUMAN-READABLE or X-BINARY-TRANSFER-REQUIRED
-    def binary?(name)
-      cache([:binary?, name]) do
-        # Get syntax OID
-        syntax = attribute_type(name, 'SYNTAX')[0]
-        !syntax.nil? and
-          (ldap_syntax(syntax, 'X-NOT-HUMAN-READABLE') == ["TRUE"] or
-           ldap_syntax(syntax, 'X-BINARY-TRANSFER-REQUIRED') == ["TRUE"])
-      end
-    end
-
-    # binary_required?
-    #
-    # Returns true if the value MUST be transferred in binary
-    def binary_required?(name)
-      cache([:binary_required?, name]) do
-        # Get syntax OID
-        syntax = attribute_type(name, 'SYNTAX')[0]
-        !syntax.nil? and
-          ldap_syntax(syntax, 'X-BINARY-TRANSFER-REQUIRED') == ["TRUE"]
-      end
-    end
-
-    # class_attributes
-    #
-    # Returns an Array of all the valid attributes (but not with full aliases)
-    # for the given objectClass
-    def class_attributes(objc)
-      cache([:class_attributes, objc]) do
-        # First get all the current level attributes
-        must = object_class(objc, 'MUST')
-        may = object_class(objc, 'MAY')
-
-        # Now add all attributes from the parent object (SUPerclasses)
-        # Hopefully an iterative approach will be pretty speedy
-        # 1. build complete list of SUPs
-        # 2. Add attributes from each
-        sups = object_class(objc, 'SUP')
-        loop do
-          start_size = sups.size
-          new_sups = []
-          sups.each do |sup|
-            new_sups.concat(object_class(sup, 'SUP'))
-          end
-
-          sups.concat(new_sups)
-          sups.uniq!
-          break if sups.size == start_size
-        end
-        sups.each do |sup|
-          must.concat(object_class(sup, 'MUST'))
-          may.concat(object_class(sup, 'MAY'))
-        end
-
-        # Clean out the dupes.
-        must.uniq!
-        may.uniq!
-        if objc == "inetOrgPerson"
-          may.collect! do |name|
-            if name == "x500uniqueIdentifier"
-              "x500UniqueIdentifier"
-            else
-              name
-            end
-          end
-        end
-
-        {:must => must, :may => may}
-      end
-    end
-
-    private
-    def cache(key)
-      (@cache[key] ||= [yield])[0]
-    end
-
-    def ensure_schema_info(group)
-      @schema_info[group] ||= {:ids => {}, :aliases => {}}
-      info = @schema_info[group]
-      [info, info[:ids], info[:aliases]]
-    end
-
-    def determine_id_or_name(id_or_name, aliases)
-      if /\A[\d\.]+\z/ =~ id_or_name
-        id = id_or_name
-        name = nil
-      else
-        name = normalize_schema_name(id_or_name)
-        id = aliases[name]
-      end
-      [id, name]
-    end
-
-    # from RFC 2252
-    attribute_type_description_reserved_names =
-      ["NAME", "DESC", "OBSOLETE", "SUP", "EQUALITY", "ORDERING", "SUBSTR",
-       "SYNTAX", "SINGLE-VALUE", "COLLECTIVE", "NO-USER-MODIFICATION", "USAGE"]
-    syntax_description_reserved_names = ["DESC"]
-    object_class_description_reserved_names =
-      ["NAME", "DESC", "OBSOLETE", "SUP", "ABSTRACT", "STRUCTURAL",
-       "AUXILIARY", "MUST", "MAY"]
-    matching_rule_description_reserved_names =
-      ["NAME", "DESC", "OBSOLETE", "SYNTAX"]
-    matching_rule_use_description_reserved_names =
-      ["NAME", "DESC", "OBSOLETE", "APPLIES"]
-    private_experiment_reserved_names = ["X-[A-Z\\-_]+"]
-    reserved_names =
-      (attribute_type_description_reserved_names +
-       syntax_description_reserved_names +
-       object_class_description_reserved_names +
-       matching_rule_description_reserved_names +
-       matching_rule_use_description_reserved_names +
-       private_experiment_reserved_names).uniq
-    RESERVED_NAMES_RE = /(?:#{reserved_names.join('|')})/
-
-    def parse_attributes(str, attributes)
-      str.scan(/([A-Z\-_]+)\s+
-                (?:\(\s*([\w\-]+(?:\s+\$\s+[\w\-]+)+)\s*\)|
-                   \(\s*([^\)]*)\s*\)|
-                   '([^\']*)'|
-                   ((?!#{RESERVED_NAMES_RE})[a-zA-Z][a-zA-Z\d\-;]*)|
-                   (\d[\d\.\{\}]+)|
-                   ()
-                )/x
-               ) do |name, multi_amp, multi, string, literal, syntax, no_value|
-        case
-        when multi_amp
-          values = multi_amp.rstrip.split(/\s*\$\s*/)
-        when multi
-          values = multi.scan(/\s*'([^\']*)'\s*/).collect {|value| value[0]}
-        when string
-          values = [string]
-        when literal
-          values = [literal]
-        when syntax
-          values = [syntax]
-        when no_value
-          values = ["TRUE"]
-        end
-        attributes[normalize_attribute_name(name)] = values
-      end
-    end
-
-    def attribute_type(name, attribute_name)
-      cache([:attribute_type, name, attribute_name]) do
-        attribute("attributeTypes", name, attribute_name)
-      end
-    end
-
-    def ldap_syntax(name, attribute_name)
-      return [] unless @entries.has_key?("ldapSyntaxes")
-      cache([:ldap_syntax, name, attribute_name]) do
-        attribute("ldapSyntaxes", name, attribute_name)
-      end
-    end
-
-    def object_class(name, attribute_name)
-      cache([:object_class, name, attribute_name]) do
-        attribute("objectClasses", name, attribute_name)
-      end
-    end
-
-    def alias_map(group)
-      ensure_parse(group)
-      return {} if @schema_info[group].nil?
-      @schema_info[group][:aliases] || {}
-    end
-
-    def ensure_parse(group)
-      return if @entries[group].nil?
-      unless @entries[group].empty?
-        attribute(group, 'nonexistent', 'nonexistent')
-      end
-    end
-
-    def normalize_schema_name(name)
-      name.downcase.sub(/;.*$/, '')
-    end
-
-    def normalize_attribute_name(name)
-      name.upcase.gsub(/_/, "-")
-    end
-
-    def default_entries
-      {
-        "objectClasses" => [],
-        "attributeTypes" => [],
-        "ldapSyntaxes" => [],
-      }
-    end
-  end # Schema
-end

data/lib/active_ldap/timeout.rb

@@ -1,75 +0,0 @@
-require 'timeout'
-
-module Timeout
-
-  # A forking timeout implementation that relies on
-  # signals to interrupt blocking I/O instead of passing
-  # that code to run in a separate process.
-  #
-  # A process is fork()ed, sleeps for _sec_,
-  # then sends a ALRM signal to the Process.ppid
-  # process. ALRM is used to avoid conflicts with sleep()
-  #
-  # This overwrites any signal
-  def Timeout.alarm(sec, exception=Timeout::Error, &block)
-    return block.call if sec == nil or sec.zero?
- 
-  
-    # Trap an alarm in case it comes before we're ready
-    orig_alrm = trap(:ALRM, 'IGNORE')
-
-    # Setup a fallback in case of a race condition of an
-    # alarm before we set the other trap
-    trap(:ALRM) do 
-      # Don't leave zombies
-      Process.wait2()
-      # Restore the original handler
-      trap('ALRM', orig_alrm)
-      # Now raise an exception!
-      raise exception, 'execution expired'
-    end
-
-    # Spawn the sleeper
-    pid = Process.fork {
-      begin
-        # Sleep x seconds then send SIGALRM 
-        sleep(sec)
-        # Send alarm!
-        Process.kill(:ALRM, Process.ppid)
-      end
-      exit! 0
-    }
-
-    # Setup the real handler
-    trap(:ALRM) do
-      # Make sure we clean up any zombies
-      Process.waitpid(pid)
-      # Restore the original handler
-      trap(:ALRM, orig_alrm)
-      # Now raise an exception!
-      raise exception, 'execution expired'
-    end
-
-    begin
-      # Run the code!
-      return block.call
-    ensure
-      # Restore old alarm handler since we're done
-      trap(:ALRM, orig_alrm)
-      # Make sure the process is dead
-      # This may be run twice (trap occurs during execution) so ignore ESRCH
-      Process.kill(:TERM, pid) rescue Errno::ESRCH
-      # Don't leave zombies
-      Process.waitpid(pid) rescue Errno::ECHILD
-    end
-  end
-end # Timeout
-
-if __FILE__ == $0
-  require 'time'
-  Timeout.alarm(2) do 
-    loop do 
-      p Time.now
-    end
-  end
-end