ruby-activeldap 0.8.2 → 0.8.3

data/lib/active_ldap/adapter/net_ldap_ext.rb

@@ -1,29 +0,0 @@
-require_library_or_gem 'net/ldap'
-
-module Net
-  class LDAP
-    class Entry
-      alias initialize_without_original_attribute_names initialize
-      def initialize(*args)
-        @original_attribute_names = []
-        initialize_without_original_attribute_names(*args)
-      end
-
-      alias aset_without_original_attribute_names []=
-      def []=(name, value)
-        @original_attribute_names << name
-        aset_without_original_attribute_names(name, value)
-      end
-
-      def original_attribute_names
-        @original_attribute_names.compact.uniq
-      end
-
-      def each_attribute
-        attribute_names.sort_by {|name| name.to_s}.each do |name|
-          yield name, self[name]
-        end
-      end
-    end
-  end
-end

data/lib/active_ldap/association/belongs_to.rb

@@ -1,40 +0,0 @@
-require 'active_ldap/association/proxy'
-
-module ActiveLdap
-  module Association
-    class BelongsTo < Proxy
-      def replace(entry)
-        if entry.nil?
-          @target = @owner[@options[:foreign_key_name]] = nil
-        else
-          @target = (Proxy === entry ? entry.target : entry)
-          unless entry.new_entry?
-            @owner[@options[:foreign_key_name]] = entry[primary_key]
-          end
-          @updated = true
-        end
-
-        loaded
-        entry
-      end
-
-      def updated?
-        @updated
-      end
-
-      private
-      def have_foreign_key?
-        not @owner[@options[:foreign_key_name]].nil?
-      end
-
-      def find_target
-        value = @owner[@options[:foreign_key_name]]
-        raise EntryNotFound if value.nil?
-        filter = {primary_key => value}
-        result = foreign_class.find(:all, :filter => filter, :limit => 1)
-        raise EntryNotFound if result.empty?
-        result.first
-      end
-    end
-  end
-end

data/lib/active_ldap/association/belongs_to_many.rb

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

data/lib/active_ldap/association/collection.rb

@@ -1,80 +0,0 @@
-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|
-          result &&= insert_entry(entry) unless @owner.new_entry?
-          @target << entry
-        end
-
-        result && self
-      end
-    end
-  end
-end

data/lib/active_ldap/association/has_many.rb

@@ -1,40 +0,0 @@
-require 'active_ldap/association/collection'
-
-module ActiveLdap
-  module Association
-    class HasMany < Collection
-      private
-      def insert_entry(entry)
-        entry[primary_key] = @owner[@options[:foreign_key_name]]
-        entry.save
-      end
-
-      def find_target
-        foreign_base_key = primary_key
-        components = @owner[@options[:foreign_key_name], true].collect do |value|
-          key = val = nil
-          if foreign_base_key == "dn"
-            key, val = value.split(",")[0].split("=") unless value.empty?
-          else
-            key, val = foreign_base_key, value
-          end
-          [key, val]
-        end.reject do |key, val|
-          key.nil? or val.nil?
-        end
-        foreign_class.find(:all, :filter => [:or, *components])
-      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_wrap.rb

@@ -1,55 +0,0 @@
-require 'active_ldap/association/collection'
-
-module ActiveLdap
-  module Association
-    class HasManyWrap < Collection
-      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
-        foreign_base_key = primary_key
-        requested_targets = @owner[@options[:wrap], true]
-
-        components = requested_targets.collect do |value|
-          key = val = nil
-          if foreign_base_key == "dn"
-            key, val = value.split(",")[0].split("=") unless value.empty?
-          else
-            key, val = foreign_base_key, value
-          end
-          [key, val]
-        end.reject do |key, val|
-          key.nil? or val.nil?
-        end
-        return [] if components.empty?
-
-        klass = foreign_class
-        found_targets = {}
-        klass.find(:all, :filter => [:or, *components]).each do |target|
-          found_targets[target.send(foreign_base_key)] ||= target
-        end
-
-        requested_targets.collect do |name|
-          found_targets[name] || klass.new(name)
-        end
-      end
-    end
-  end
-end

data/lib/active_ldap/association/proxy.rb

@@ -1,89 +0,0 @@
-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
-    end
-  end
-end

data/lib/active_ldap/associations.rb

@@ -1,162 +0,0 @@
-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)
-    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
-        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
-  end
-end