powerhome-activeldap 3.2.3

data/lib/active_ldap/association/belongs_to_many.rb

@@ -0,0 +1,58 @@
+require 'active_ldap/association/collection'
+
+module ActiveLdap
+  module Association
+    class BelongsToMany < Collection
+      private
+      def insert_entry(entry)
+        _foreign_class = foreign_class
+        entry = _foreign_class.find(entry) unless entry.is_a?(_foreign_class)
+        old_value = entry[@options[:many], true]
+        primary_key_name = @options[:primary_key_name]
+        if primary_key_name == "dn"
+          old_value = dn_values_to_string_values(old_value)
+        end
+        current_value = @owner[primary_key_name, true]
+        current_value = dn_values_to_string_values(current_value)
+        new_value = old_value + current_value
+        new_value = new_value.uniq.sort
+        if old_value != new_value
+          entry[@options[:many]] = new_value
+          entry.save
+        end
+      end
+
+      def delete_entries(entries)
+          _foreign_class = foreign_class
+        entries.each do |entry|
+          entry = _foreign_class.find(entry) unless entry.is_a?(_foreign_class)
+          old_value = entry[@options[:many], true]
+          primary_key_name = @options[:primary_key_name]
+          if primary_key_name == "dn"
+            old_value = dn_values_to_string_values(old_value)
+          end
+          current_value = @owner[primary_key_name, true]
+          current_value = dn_values_to_string_values(current_value)
+          new_value = old_value - current_value
+          new_value = new_value.uniq.sort
+          if old_value != new_value
+            entry[@options[:many]] = new_value
+            entry.save
+          end
+        end
+      end
+
+      def find_target
+        values = @owner[@options[:primary_key_name], true].compact
+        return [] if values.empty?
+
+        key = @options[:many]
+        components = values.collect do |value|
+          [key, value]
+        end
+        options = find_options(:filter => [:or, *components])
+        foreign_class.find(:all, options)
+      end
+    end
+  end
+end

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.to_s].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,105 @@
+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
+
+        entry = @target.first
+        if entry.nil?
+          deleted_entries = []
+          added_entries = others
+        else
+          base_class = entry.class
+          others = others.collect do |other|
+            other = base_class.find(other) unless other.is_a?(base_class)
+            other
+          end
+          deleted_entries = @target - others
+          added_entries = others - @target
+        end
+
+        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
+
+      def dn_values_to_string_values(values)
+        values.collect do |value|
+          if value.is_a?(DN)
+            value.to_s
+          else
+            value
+          end
+        end
+      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[foreign_key] = @owner[primary_key]
+        entry.save
+      end
+
+      def find_target
+        collect_targets(primary_key)
+      end
+
+      def delete_entries(entries)
+        _foreign_key = foreign_key
+        components = @owner[primary_key, true].reject do |value|
+          value.nil?
+        end
+        filter = [:and,
+                  [:and, {_foreign_key => components}],
+                  [:or, {foreign_class.dn_attribute => entries.collect(&:id)}]]
+        foreign_class.update_all({_foreign_key => []}, filter)
+      end
+    end
+  end
+end

data/lib/active_ldap/association/has_many_utils.rb

@@ -0,0 +1,44 @@
+module ActiveLdap
+  module Association
+    module HasManyUtils
+      private
+      def collect_targets(requested_target_key, need_requested_targets=false)
+        _foreign_key = foreign_key
+        return [] if _foreign_key.nil?
+
+        requested_targets = @owner[requested_target_key, true]
+        requested_targets = requested_targets.reject(&:nil?)
+        if requested_targets.empty?
+          targets = []
+        elsif _foreign_key == "dn"
+          requested_targets = requested_targets.collect do |target|
+            if target.is_a?(DN)
+              target
+            else
+              DN.parse(target)
+            end
+          end
+          targets = []
+          requested_targets.each do |target|
+            begin
+              targets << foreign_class.find(target, find_options)
+            rescue EntryNotFound
+            end
+          end
+        else
+          components = requested_targets.collect do |value|
+            [_foreign_key, value]
+          end
+          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,75 @@
+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]
+        _foreign_key = foreign_key
+        if _foreign_key == "dn"
+          old_value = dn_values_to_string_values(old_value)
+        end
+        current_value = entry[_foreign_key, true]
+        current_value = dn_values_to_string_values(current_value)
+        new_value = (old_value + current_value).uniq.sort
+        if old_value != new_value
+          @owner[@options[:wrap]] = new_value
+          @owner.save unless @owner.new_entry?
+        end
+      end
+
+      def delete_entries(entries)
+        old_value = @owner[@options[:wrap], true]
+        _foreign_key = foreign_key
+        if _foreign_key == "dn"
+          old_value = dn_values_to_string_values(old_value)
+        end
+        current_value = entries.collect {|entry| entry[_foreign_key]}
+        current_value = dn_values_to_string_values(current_value)
+        new_value = old_value - current_value
+        new_value = new_value.uniq.sort
+        if old_value != new_value
+          @owner[@options[:wrap]] = new_value
+          @owner.save unless @owner.new_entry?
+        end
+      end
+
+      def find_target
+        targets, requested_targets = collect_targets(@options[:wrap], true)
+        return [] if targets.nil?
+
+        found_targets = {}
+        _foreign_key = foreign_key
+        targets.each do |target|
+          found_targets[target[_foreign_key]] ||= target
+        end
+
+        klass = foreign_class
+        requested_targets.collect do |name|
+          found_targets[name] || klass.new(name)
+        end
+      end
+
+      def foreign_key
+        @options[:primary_key_name] || foreign_class.dn_attribute
+      end
+
+      def add_entries(*entries)
+        result = true
+        load_target
+
+        flatten_deeper(entries).each do |entry|
+          infect_connection(entry)
+          insert_entry(entry) or result = false
+          @target << entry
+        end
+
+        result && self
+      end
+    end
+  end
+end

data/lib/active_ldap/association/proxy.rb

@@ -0,0 +1,107 @@
+module ActiveLdap
+  module Association
+    class Proxy
+      alias_method :proxy_respond_to?, :respond_to?
+      alias_method :proxy_extend, :extend
+      delegate :to_param, :to => :target
+
+      def initialize(owner, options)
+        @owner = owner
+        @options = options
+        reset
+        extend(options[:extend]) if options[:extend]
+      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] || @owner.dn_attribute
+      end
+
+      def foreign_key
+        @options[:foreign_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