activeldap 0.9.0

data/lib/active_ldap/association/children.rb

@@ -0,0 +1,21 @@
+require 'active_ldap/association/collection'
+
+module ActiveLdap
+  module Association
+    class Children < Collection
+      private
+      def insert_entry(entry)
+        entry.dn = [entry.id, @owner.dn].join(",")
+        entry.save
+      end
+
+      def find_target
+        @owner.find(:all, :base => @owner.dn, :scope => :one)
+      end
+
+      def delete_entries(entries)
+        entries.each(&:destroy)
+      end
+    end
+  end
+end

data/lib/active_ldap/association/collection.rb

@@ -0,0 +1,83 @@
+require 'active_ldap/association/proxy'
+
+module ActiveLdap
+  module Association
+    class Collection < Proxy
+      include Enumerable
+
+      def to_ary
+        load_target
+        @target.to_ary
+      end
+
+      def reset
+        @target = []
+        @loaded = false
+      end
+
+      def <<(*entries)
+        add_entries(*entries)
+      end
+      alias_method(:push, :<<)
+      alias_method(:concat, :<<)
+
+      def each(&block)
+        to_ary.each(&block)
+      end
+
+      def delete(*entries)
+        entries = flatten_deeper(entries).reject do |entry|
+          @target.delete(entry) if entry.new_entry?
+          entry.new_entry?
+        end
+        return if entries.empty?
+
+        delete_entries(entries)
+        entries.each do |entry|
+          @target.delete(entry)
+        end
+      end
+
+      def replace(others)
+        load_target
+        deleted_entries = @target - others
+        added_entries = others - @target
+
+        delete(deleted_entries)
+        concat(added_entries)
+      end
+
+      def exists?
+        load_target
+        not @target.empty?
+      end
+
+      private
+      def flatten_deeper(array)
+        array.collect do |element|
+          element.respond_to?(:flatten) ? element.flatten : element
+        end.flatten
+      end
+
+      def insert_entry(entry)
+        entry[@options[:foreign_key_name]] = @owner[@options[:local_key_name]]
+        entry.save
+      end
+
+      def add_entries(*entries)
+        result = true
+        load_target
+
+        flatten_deeper(entries).each do |entry|
+          unless @owner.new_entry?
+            infect_connection(entry)
+            result &&= insert_entry(entry)
+          end
+          @target << entry
+        end
+
+        result && self
+      end
+    end
+  end
+end

data/lib/active_ldap/association/has_many.rb

@@ -0,0 +1,31 @@
+require 'active_ldap/association/collection'
+require 'active_ldap/association/has_many_utils'
+
+module ActiveLdap
+  module Association
+    class HasMany < Collection
+      include HasManyUtils
+
+      private
+      def insert_entry(entry)
+        entry[primary_key] = @owner[@options[:foreign_key_name]]
+        entry.save
+      end
+
+      def find_target
+        collect_targets(:foreign_key_name)
+      end
+
+      def delete_entries(entries)
+        key = primary_key
+        components = @owner[@options[:foreign_key_name], true].reject do |value|
+          value.nil?
+        end
+        filter = [:and,
+                  [:and, {key => components}],
+                  [:or, {foreign_class.dn_attribute => entries.collect(&:id)}]]
+        foreign_class.update_all({key => []}, filter)
+      end
+    end
+  end
+end

data/lib/active_ldap/association/has_many_utils.rb

@@ -0,0 +1,35 @@
+module ActiveLdap
+  module Association
+    module HasManyUtils
+      private
+      def collect_targets(requested_target_key, need_requested_targets=false)
+        foreign_base_key = primary_key
+        return [] if foreign_base_key.nil?
+
+        requested_targets = @owner[@options[requested_target_key], true]
+
+        components = requested_targets.reject(&:nil?)
+        unless foreign_base_key == "dn"
+          components = components.collect do |value|
+            [foreign_base_key, value]
+          end
+        end
+
+        if components.empty?
+          targets = []
+        elsif foreign_base_key == "dn"
+          targets = foreign_class.find(components, find_options)
+        else
+          options = find_options(:filter => [:or, *components])
+          targets = foreign_class.find(:all, options)
+        end
+
+        if need_requested_targets
+          [targets, requested_targets]
+        else
+          targets
+        end
+      end
+    end
+  end
+end

data/lib/active_ldap/association/has_many_wrap.rb

@@ -0,0 +1,46 @@
+require 'active_ldap/association/collection'
+require 'active_ldap/association/has_many_utils'
+
+module ActiveLdap
+  module Association
+    class HasManyWrap < Collection
+      include HasManyUtils
+
+      private
+      def insert_entry(entry)
+        old_value = @owner[@options[:wrap], true]
+        new_value = (old_value + entry[primary_key, true]).uniq.sort
+        if old_value != new_value
+          @owner[@options[:wrap]] = new_value
+          @owner.save
+        end
+      end
+
+      def delete_entries(entries)
+        old_value = @owner[@options[:wrap], true]
+        new_value = old_value - entries.collect {|entry| entry[primary_key]}
+        new_value = new_value.uniq.sort
+        if old_value != new_value
+          @owner[@options[:wrap]] = new_value
+          @owner.save
+        end
+      end
+
+      def find_target
+        targets, requested_targets = collect_targets(:wrap, true)
+        return [] if targets.nil?
+
+        found_targets = {}
+        foreign_base_key = primary_key
+        targets.each do |target|
+          found_targets[target.send(foreign_base_key)] ||= target
+        end
+
+        klass = foreign_class
+        requested_targets.collect do |name|
+          found_targets[name] || klass.new(name)
+        end
+      end
+    end
+  end
+end

data/lib/active_ldap/association/proxy.rb

@@ -0,0 +1,102 @@
+module ActiveLdap
+  module Association
+    class Proxy
+      alias_method :proxy_respond_to?, :respond_to?
+      alias_method :proxy_extend, :extend
+
+      def initialize(owner, options)
+        @owner = owner
+        @options = options
+        extend(options[:extend]) if options[:extend]
+        reset
+      end
+
+      def respond_to?(symbol, include_priv=false)
+        proxy_respond_to?(symbol, include_priv) or
+          (load_target && @target.respond_to?(symbol, include_priv))
+      end
+
+      def ===(other)
+        load_target and other === @target
+      end
+
+      def reset
+        @target = nil
+        @loaded = false
+      end
+
+      def reload
+        reset
+        load_target
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded
+        @loaded = true
+      end
+
+      def target
+        @target
+      end
+
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      def exists?
+        load_target
+        not @target.nil?
+      end
+
+      private
+      def method_missing(method, *args, &block)
+        load_target
+        @target.send(method, *args, &block)
+      end
+
+      def foreign_class
+        klass = @owner.class.associated_class(@options[:association_id])
+        klass = @owner.class.module_eval(klass) if klass.is_a?(String)
+        klass
+      end
+
+      def have_foreign_key?
+        false
+      end
+
+      def primary_key
+        @options[:primary_key_name] || foreign_class.dn_attribute
+      end
+
+      def load_target
+        if !@owner.new_entry? or have_foreign_key?
+          begin
+            @target = find_target unless loaded?
+          rescue EntryNotFound
+            reset
+          end
+        end
+
+        loaded if target
+        target
+      end
+
+      def find_options(options={})
+        if @owner.connection != @owner.class.connection
+          {:connection => @owner.connection}.merge(options)
+        else
+          options
+        end
+      end
+
+      def infect_connection(target)
+        conn = @owner.instance_variable_get("@connection")
+        target.connection = conn if conn
+      end
+    end
+  end
+end

data/lib/active_ldap/associations.rb

@@ -0,0 +1,172 @@
+require 'active_ldap/association/belongs_to'
+require 'active_ldap/association/belongs_to_many'
+require 'active_ldap/association/has_many'
+require 'active_ldap/association/has_many_wrap'
+
+module ActiveLdap
+  # Associations
+  #
+  # Associations provides the class methods needed for
+  # the extension classes to create methods using
+  # belongs_to and has_many
+  module Associations
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.class_inheritable_array(:associations)
+      base.associations = []
+    end
+
+    module ClassMethods
+      def set_associated_class(name, klass)
+        @associated_classes ||= {}
+        @associated_classes[name.to_s] = klass
+      end
+
+      def associated_class(name)
+        @associated_classes[name.to_s]
+      end
+
+      # belongs_to
+      #
+      # This defines a method for an extension class map its DN key
+      # attribute value on to multiple items which reference it by
+      # |:foreign_key| in the other LDAP entry covered by class |:class_name|.
+      #
+      # Example:
+      #  belongs_to :groups, :class_name => "Group",
+      #             :many => "memberUid" # Group#memberUid
+      #             # :foreign_key => "uid" # User#uid
+      #             # dn attribute value is used by default
+      #  belongs_to :primary_group, :class_name => "Group",
+      #             :foreign_key => "gidNumber", # User#gidNumber
+      #             :primary_key => "gidNumber"  # Group#gidNumber
+      #
+      def belongs_to(association_id, options={})
+        validate_belongs_to_options(options)
+        klass = options[:class] || Inflector.classify(association_id)
+        foreign_key = options[:foreign_key]
+        primary_key = options[:primary_key]
+        many = options[:many]
+        set_associated_class(association_id, klass)
+
+        opts = {
+          :association_id => association_id,
+          :foreign_key_name => foreign_key,
+          :primary_key_name => primary_key,
+          :many => many,
+          :extend => options[:extend],
+        }
+        if opts[:many]
+          association_class = Association::BelongsToMany
+          opts[:foreign_key_name] ||= dn_attribute
+        else
+          association_class = Association::BelongsTo
+          opts[:foreign_key_name] ||= "#{association_id}_id"
+
+          before_save(<<-EOC)
+            if defined?(@#{association_id})
+              association = @#{association_id}
+              if association and association.updated?
+                self[association.__send__(:primary_key)] =
+                  association[#{opts[:foreign_key_name].dump}]
+              end
+            end
+          EOC
+        end
+
+        association_accessor(association_id) do |target|
+          association_class.new(target, opts)
+        end
+      end
+
+
+      # has_many
+      #
+      # This defines a method for an extension class expand an 
+      # existing multi-element attribute into ActiveLdap objects.
+      # This discards any calls which result in entries that
+      # don't exist in LDAP!
+      #
+      # Example:
+      #   has_many :primary_members, :class_name => "User",
+      #            :primary_key => "gidNumber", # User#gidNumber
+      #            :foreign_key => "gidNumber"  # Group#gidNumber
+      #   has_many :members, :class_name => "User",
+      #            :wrap => "memberUid" # Group#memberUid
+      def has_many(association_id, options = {})
+        validate_has_many_options(options)
+        klass = options[:class] || Inflector.classify(association_id)
+        foreign_key = options[:foreign_key] || association_id.to_s + "_id"
+        primary_key = options[:primary_key]
+        set_associated_class(association_id, klass)
+
+        opts = {
+          :association_id => association_id,
+          :foreign_key_name => foreign_key,
+          :primary_key_name => primary_key,
+          :wrap => options[:wrap],
+          :extend => options[:extend],
+        }
+        if opts[:wrap]
+          association_class = Association::HasManyWrap
+        else
+          association_class = Association::HasMany
+        end
+
+        association_accessor(association_id) do |target|
+          association_class.new(target, opts)
+        end
+      end
+
+      private
+      def association_accessor(name, &make_association)
+        define_method("__make_#{name}") do
+          make_association.call(self)
+        end
+        associations << name
+        association_reader(name, &make_association)
+        association_writer(name, &make_association)
+      end
+
+      def association_reader(name, &make_association)
+        class_eval(<<-EOM, __FILE__, __LINE__ + 1)
+          def #{name}
+            @#{name} ||= __make_#{name}
+          end
+        EOM
+      end
+
+      def association_writer(name, &make_association)
+        class_eval(<<-EOM, __FILE__, __LINE__ + 1)
+          def #{name}=(new_value)
+            association = defined?(@#{name}) ? @#{name} : nil
+            association ||= __make_#{name}
+            association.replace(new_value)
+            @#{name} = new_value.nil? ? nil : association
+            @#{name}
+          end
+        EOM
+      end
+
+      VALID_BELONGS_TO_OPTIONS = [:class, :foreign_key, :primary_key, :many,
+                                  :extend]
+      def validate_belongs_to_options(options)
+        options.assert_valid_keys(VALID_BELONGS_TO_OPTIONS)
+      end
+
+      VALID_HAS_MANY_OPTIONS = [:class, :foreign_key, :primary_key, :wrap,
+                                :extend]
+      def validate_has_many_options(options)
+        options.assert_valid_keys(VALID_HAS_MANY_OPTIONS)
+      end
+    end
+
+    def clear_association_cache
+      return if new_record?
+      (self.class.associations || []).each do |association|
+        instance_variable_set("@#{association}", nil)
+      end
+    end
+  end
+end

data/lib/active_ldap/attributes.rb

@@ -0,0 +1,211 @@
+module ActiveLdap
+  module Attributes
+    def self.included(base)
+      base.class_eval do
+        extend(ClassMethods)
+        extend(Normalize)
+        include(Normalize)
+      end
+    end
+
+    module ClassMethods
+      def attr_protected(*attributes)
+        targets = attributes.collect {|attr| attr.to_s} - protected_attributes
+        instance_variable_set("@attr_protected", targets)
+      end
+
+      def protected_attributes
+        ancestors[0..(ancestors.index(Base))].inject([]) do |result, ancestor|
+          result + ancestor.instance_eval {@attr_protected ||= []}
+        end
+      end
+    end
+
+    module Normalize
+      def normalize_attribute_name(name)
+        name.to_s.downcase
+      end
+
+      # Enforce typing:
+      # Hashes are for subtypes
+      # Arrays are for multiple entries
+      def normalize_attribute(name, value)
+        if name.nil?
+          raise RuntimeError, _('The first argument, name, must not be nil. ' \
+                                'Please report this as a bug!')
+        end
+
+        name = normalize_attribute_name(name)
+        rubyish_class_name = Inflector.underscore(value.class.name)
+        handler = "normalize_attribute_value_of_#{rubyish_class_name}"
+        if respond_to?(handler, true)
+          [name, send(handler, name, value)]
+        else
+          [name, [schema.attribute(name).normalize_value(value)]]
+        end
+      end
+
+      def unnormalize_attributes(attributes)
+        result = {}
+        attributes.each do |name, values|
+          unnormalize_attribute(name, values, result)
+        end
+        result
+      end
+
+      def unnormalize_attribute(name, values, result={})
+        if values.empty?
+          result[name] = []
+        else
+          values.each do |value|
+            if value.is_a?(Hash)
+              suffix, real_value = extract_attribute_options(value)
+              new_name = name + suffix
+              result[new_name] ||= []
+              result[new_name].concat(real_value)
+            else
+              result[name] ||= []
+              result[name] << value.dup
+            end
+          end
+        end
+        result
+      end
+
+      private
+      def normalize_attribute_value_of_array(name, value)
+	attribute = schema.attribute(name)
+        if value.size > 1 and attribute.single_value?
+          format = _("Attribute %s can only have a single value")
+          message = format % self.class.human_attribute_name(attribute)
+          raise TypeError, message
+        end
+        if value.empty?
+          if schema.attribute(name).binary_required?
+            [{'binary' => value}]
+          else
+            value
+          end
+        else
+          value.collect do |entry|
+            normalize_attribute(name, entry)[1][0]
+          end
+        end
+      end
+
+      def normalize_attribute_value_of_hash(name, value)
+        if value.keys.size > 1
+          format = _("Hashes must have one key-value pair only: %s")
+          raise TypeError, format % value.inspect
+        end
+        unless value.keys[0].match(/^(lang-[a-z][a-z]*)|(binary)$/)
+          logger.warn do
+            format = _("unknown option did not match lang-* or binary: %s")
+            format % value.keys[0]
+          end
+        end
+        # Contents MUST be a String or an Array
+        if !value.has_key?('binary') and schema.attribute(name).binary_required?
+          suffix, real_value = extract_attribute_options(value)
+          name, values =
+            normalize_attribute_options("#{name}#{suffix};binary", real_value)
+          values
+        else
+          [value]
+        end
+      end
+
+      def normalize_attribute_value_of_nil_class(name, value)
+        if schema.attribute(name).binary_required?
+          [{'binary' => []}]
+        else
+          []
+        end
+      end
+
+      def normalize_attribute_value_of_string(name, value)
+        if schema.attribute(name).binary_required?
+          [{'binary' => [value]}]
+        else
+          [value]
+        end
+      end
+
+      def normalize_attribute_value_of_date(name, value)
+        new_value = sprintf('%.04d%.02d%.02d%.02d%.02d%.02d%s',
+                            value.year, value.month, value.mday, 0, 0, 0,
+                            '+0000')
+        normalize_attribute_value_of_string(name, new_value)
+      end
+
+      def normalize_attribute_value_of_time(name, value)
+        new_value = sprintf('%.04d%.02d%.02d%.02d%.02d%.02d%s',
+                            0, 0, 0, value.hour, value.min, value.sec,
+                            value.zone)
+        normalize_attribute_value_of_string(name, new_value)
+      end
+
+      def normalize_attribute_value_of_date_time(name, value)
+        new_value = sprintf('%.04d%.02d%.02d%.02d%.02d%.02d%s',
+                            value.year, value.month, value.mday, value.hour,
+                            value.min, value.sec, value.zone)
+        normalize_attribute_value_of_string(name, new_value)
+      end
+
+      # normalize_attribute_options
+      #
+      # Makes the Hashized value from the full attribute name
+      # e.g. userCertificate;binary => "some_bin"
+      #      becomes userCertificate => {"binary" => "some_bin"}
+      def normalize_attribute_options(attr, value)
+        return [attr, value] unless attr.match(/;/)
+
+        ret_attr, *options = attr.split(/;/)
+        [ret_attr,
+         [options.reverse.inject(value) {|result, option| {option => result}}]]
+      end
+
+      # extract_attribute_options
+      #
+      # Extracts all of the subtypes from a given set of nested hashes
+      # and returns the attribute suffix and the final true value
+      def extract_attribute_options(value)
+        options = ''
+        ret_val = value
+        if value.class == Hash
+          options = ';' + value.keys[0]
+          ret_val = value[value.keys[0]]
+          if ret_val.class == Hash
+            sub_options, ret_val = extract_attribute_options(ret_val)
+            options += sub_options
+          end
+        end
+        ret_val = [ret_val] unless ret_val.class == Array
+        [options, ret_val]
+      end
+    end
+
+    private
+    def remove_attributes_protected_from_mass_assignment(targets)
+      needless_attributes = {}
+      (attributes_protected_by_default +
+       (self.class.protected_attributes || [])).each do |name|
+        needless_attributes[to_real_attribute_name(name)] = true
+      end
+
+      targets.collect do |key, value|
+        [to_real_attribute_name(key) || key, value]
+      end.reject do |key, value|
+        needless_attributes[key]
+      end
+    end
+
+    def attributes_protected_by_default
+      [dn_attribute, 'objectClass']
+    end
+
+    def normalize_attribute_name(name)
+      self.class.normalize_attribute_name(name)
+    end
+  end
+end