activeldap 1.2.4 → 3.1.0

data/lib/active_ldap/adapter/base.rb

@@ -33,6 +33,7 @@ module ActiveLdap
         VALID_ADAPTER_CONFIGURATION_KEYS.each do |name|
           instance_variable_set("@#{name}", configuration[name])
         end
+        @instrumenter = ActiveSupport::Notifications.instrumenter
       end
 
       def reset_runtime
@@ -658,9 +659,10 @@ module ActiveLdap
       def log(name, info=nil)
         if block_given?
           result = nil
-          seconds = Benchmark.realtime {result = yield}
-          @runtime += seconds
-          log_info(name, seconds, info)
+          @instrumenter.instrument(
+            "log_info.active_ldap",
+            :info => info,
+            :name => name) { result = yield }
           result
         else
           log_info(name, 0, info)

data/lib/active_ldap/adapter/net_ldap_ext.rb

@@ -1,4 +1,4 @@
-require_library_or_gem 'net/ldap'
+require 'net/ldap'
 
 module Net
   class LDAP

data/lib/active_ldap/associations.rb

@@ -13,8 +13,8 @@ module ActiveLdap
     def self.append_features(base)
       super
       base.extend(ClassMethods)
-      base.class_inheritable_array(:associations)
-      base.associations = []
+      base.class_attribute(:associations)
+      base.associations ||= []
     end
 
     module ClassMethods
@@ -198,4 +198,8 @@ module ActiveLdap
       end
     end
   end
+
+  module Association
+    autoload :Children, 'active_ldap/association/children'
+  end
 end

data/lib/active_ldap/base.rb

@@ -1,6 +1,7 @@
+# -*- coding: utf-8 -*-
 # === activeldap - an OO-interface to LDAP objects inspired by ActiveRecord
 # Author: Will Drewry <will@alum.bu.edu>
-# License: See LICENSE and COPYING.txt
+# License: See LICENSE and COPYING
 # Copyright 2004-2006 Will Drewry <will@alum.bu.edu>
 # Some portions Copyright 2006 Google Inc
 #
@@ -223,6 +224,12 @@ module ActiveLdap
   end
 
   class EntryInvalid < Error
+    attr_reader :entry
+    def initialize(entry)
+      @entry = entry
+      errors = @entry.errors.full_messages.join(", ")
+      super(errors)
+    end
   end
 
   class OperationNotPermitted < Error
@@ -528,14 +535,6 @@ module ActiveLdap
       rescue
         [self]
       end
-      if ActiveRecord::Base.respond_to?(:self_and_descendents_from_active_record)
-        # ActiveRecord 2.2.2 has a typo. :<
-        alias_method(:self_and_descendents_from_active_record,
-                     :self_and_descendants_from_active_ldap)
-      else
-        alias_method(:self_and_descendants_from_active_record,
-                     :self_and_descendants_from_active_ldap)
-      end
 
       def human_name(options={})
         defaults = self_and_descendants_from_active_ldap.collect do |klass|
@@ -552,7 +551,7 @@ module ActiveLdap
 
       private
       def inspect_attributes(attributes)
-	inspected_attribute_names = {}
+        inspected_attribute_names = {}
         attributes.collect do |attribute|
           if inspected_attribute_names.has_key?(attribute.name)
             nil
@@ -778,6 +777,13 @@ module ActiveLdap
       id
     end
 
+    # Returns this entity’s dn wrapped in an Array or nil if the entity' s dn is not set.
+    def to_key
+      [dn]
+    rescue DistinguishedNameNotSetError
+      nil
+    end
+
     def dn=(value)
       set_attribute(dn_attribute_with_fallback, value)
     end
@@ -794,33 +800,6 @@ module ActiveLdap
       self.class.default_search_attribute
     end
 
-    # destroy
-    #
-    # Delete this entry from LDAP
-    def destroy
-      self.class.delete(dn)
-      @new_entry = true
-    end
-
-    def delete(options={})
-      super(dn, options)
-    end
-
-    # save
-    #
-    # Save and validate this object into LDAP
-    # either adding or replacing attributes
-    # TODO: Relative DN support
-    def save
-      create_or_update
-    end
-
-    def save!
-      unless create_or_update
-        raise EntryNotSaved, _("entry %s can't be saved") % dn
-      end
-    end
-
     # method_missing
     #
     # If a given method matches an attribute or an attribute alias
@@ -1528,10 +1507,6 @@ module ActiveLdap
       attributes
     end
 
-    def create_or_update
-      new_entry? ? create : update
-    end
-
     def prepare_data_for_saving
       # Expand subtypes to real ldap_data attributes
       # We can't reuse @ldap_data because an exception would leave
@@ -1559,35 +1534,5 @@ module ActiveLdap
 
       success
     end
-
-    def create
-      prepare_data_for_saving do |data, ldap_data|
-        attributes = collect_all_attributes(data)
-        add_entry(dn, attributes)
-        @new_entry = false
-        true
-      end
-    end
-
-    def update
-      prepare_data_for_saving do |data, ldap_data|
-        new_dn_value, attributes = collect_modified_attributes(ldap_data, data)
-        modify_entry(@original_dn, attributes)
-        if new_dn_value
-          old_dn_base = DN.parse(@original_dn).parent
-          new_dn_base = dn.clone.parent
-          if old_dn_base == new_dn_base
-            new_superior = nil
-          else
-            new_superior = new_dn_base
-          end
-          modify_rdn_entry(@original_dn,
-                           "#{dn_attribute}=#{DN.escape_value(new_dn_value)}",
-                           true,
-                           new_superior)
-        end
-        true
-      end
-    end
   end # Base
 end # ActiveLdap

data/lib/active_ldap/callbacks.rb

@@ -1,25 +1,34 @@
-require 'active_record/callbacks'
+require 'active_support/core_ext/array/wrap'
 
 module ActiveLdap
   module Callbacks
-    def self.append_features(base)
-      super
-
-      base.class_eval do
-        include ActiveRecord::Callbacks
-
-        unless respond_to?(:instantiate_with_callbacks)
-          extend ClassMethods
-          class << self
-            alias_method_chain :instantiate, :callbacks
-          end
-          alias_method_chain :initialize, :callbacks
-        end
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_initialize, :after_find, :after_touch, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+      
+      define_model_callbacks :initialize, :find, :touch, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
+      
+      class << self
+        alias_method_chain :instantiate, :callbacks
+      end
+    end
 
-        def callback(method)
-          super
-        rescue ActiveRecord::ActiveRecordError
-          raise Error, $!.message
+    module ClassMethods
+      def method_added(meth)
+        super
+        if CALLBACKS.include?(meth.to_sym)
+          ActiveSupport::Deprecation.warn("Base##{meth} has been deprecated, please use Base.#{meth} :method instead", caller[0,1])
+          send(meth.to_sym, meth.to_sym)
         end
       end
     end
@@ -27,26 +36,36 @@ module ActiveLdap
     module ClassMethods
       def instantiate_with_callbacks(record)
         object = instantiate_without_callbacks(record)
+        object.send(:_run_find_callbacks)
+        object.send(:_run_initialize_callbacks)
+        object
+      end
+    end
 
-        if object.respond_to_without_attributes?(:after_find)
-          object.send(:callback, :after_find)
-        end
+    def initialize(*) #:nodoc:
+      run_callbacks(:initialize) { super }
+    end
 
-        if object.respond_to_without_attributes?(:after_initialize)
-          object.send(:callback, :after_initialize)
-        end
+    def destroy #:nodoc:
+      run_callbacks(:destroy) { super }
+    end
 
-        object
-      end
+    def touch(*) #:nodoc:
+      run_callbacks(:touch) { super }
     end
 
-    def initialize_with_callbacks(attributes = nil) #:nodoc:
-      initialize_without_callbacks(attributes)
-      result = yield self if block_given?
-      if respond_to_without_attributes?(:after_initialize)
-        callback(:after_initialize)
-      end
-      result
+  private
+
+    def create_or_update #:nodoc:
+      run_callbacks(:save) { super }
+    end
+
+    def create #:nodoc:
+      run_callbacks(:create) { super }
+    end
+
+    def update(*) #:nodoc:
+      run_callbacks(:update) { super }
     end
   end
 end

data/lib/active_ldap/configuration.rb

@@ -57,8 +57,8 @@ module ActiveLdap
         if config.nil?
           if defined?(LDAP_ENV)
             config = LDAP_ENV
-          elsif defined?(RAILS_ENV)
-            config = RAILS_ENV
+          elsif defined?(Rails)
+            config = Rails.env
           else
             config = {}
           end

data/lib/active_ldap/get_text/parser.rb

@@ -81,8 +81,8 @@ module ActiveLdap
             configuration = ActiveLdap::Base.configurations[configuration]
           end
         end
-        if Object.const_defined?(:RAILS_ENV)
-          rails_configuration = ActiveLdap::Base.configurations[RAILS_ENV]
+        if defined?(Rails)
+          rails_configuration = ActiveLdap::Base.configurations[Rails.env]
           configuration = rails_configuration.merge(configuration)
         end
         configuration = configuration.symbolize_keys

data/lib/active_ldap/human_readable.rb

@@ -6,7 +6,8 @@ module ActiveLdap
     end
 
     module ClassMethods
-      def human_attribute_name(attribute_or_name)
+      def human_attribute_name(attribute_or_name, options={})
+        logger.warn("options was ignored.") unless options.empty?
         msgid = human_attribute_name_msgid(attribute_or_name)
         msgid ||= human_attribute_name_with_gettext(attribute_or_name)
         s_(msgid)
@@ -16,10 +17,10 @@ module ActiveLdap
         if attribute_or_name.is_a?(Schema::Attribute)
           name = attribute_or_name.name
         else
-          attribute = schema.attribute(attribute_or_name)
+          attribute = schema.attribute(attribute_or_name.to_s)
           return nil if attribute.id.nil?
           if attribute.name == attribute_or_name or
-              attribute.aliases.include?(attribute_or_name)
+              attribute.aliases.include?(attribute_or_name.to_s)
             name = attribute_or_name
           else
             return nil
@@ -38,7 +39,7 @@ module ActiveLdap
         if attribute_or_name.is_a?(Schema::Attribute)
           attribute = attribute_or_name
         else
-          attribute = schema.attribute(attribute_or_name)
+          attribute = schema.attribute(attribute_or_name.to_s)
           return nil if attribute.nil?
         end
         description = attribute.description

data/lib/active_ldap/log_subscriber.rb

@@ -0,0 +1,50 @@
+module ActiveLdap
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["active_ldap_runtime"] = value
+    end
+    
+    def self.runtime
+      Thread.current["active_ldap_runtime"] ||= 0
+    end
+    
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+    
+    def initialize
+      super
+      @odd_or_even = false
+    end
+    
+    def log_info(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+  
+      payload = event.payload
+      name = 'LDAP: %s (%.1fms)' % [payload[:name], event.duration]
+      info = payload[:info].inspect
+  
+      if odd?
+        name_color, dump_color = "4;36;1", "0;1"
+      else
+        name_color, dump_color = "4;35;1", "0"
+      end
+  
+      debug "  \e[#{name_color}m#{name}\e[0m: \e[#{dump_color}m#{info}\e[0m"
+    end
+    
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+    
+    def logger
+      ActiveLdap::Base.logger
+    end
+  end
+end
+
+ActiveLdap::LogSubscriber.attach_to :active_ldap
+
+

data/lib/active_ldap/persistence.rb

@@ -0,0 +1,65 @@
+module ActiveLdap
+  module Persistence
+
+    # destroy
+    #
+    # Delete this entry from LDAP
+    def destroy
+      self.class.delete(dn)
+      @new_entry = true
+    end
+
+    def delete(options={})
+      super(dn, options)
+    end
+
+    # save
+    #
+    # Save and validate this object into LDAP
+    # either adding or replacing attributes
+    # TODO: Relative DN support
+    def save(*)
+      create_or_update
+    end
+
+    def save!(*)
+      unless create_or_update
+        raise EntryNotSaved, _("entry %s can't be saved") % dn
+      end
+    end
+
+    def create_or_update
+      new_entry? ? create : update
+    end
+
+    def create
+      prepare_data_for_saving do |data, ldap_data|
+        attributes = collect_all_attributes(data)
+        add_entry(dn, attributes)
+        @new_entry = false
+        true
+      end
+    end
+
+    def update
+      prepare_data_for_saving do |data, ldap_data|
+        new_dn_value, attributes = collect_modified_attributes(ldap_data, data)
+        modify_entry(@original_dn, attributes)
+        if new_dn_value
+          old_dn_base = DN.parse(@original_dn).parent
+          new_dn_base = dn.clone.parent
+          if old_dn_base == new_dn_base
+            new_superior = nil
+          else
+            new_superior = new_dn_base
+          end
+          modify_rdn_entry(@original_dn,
+                           "#{dn_attribute}=#{DN.escape_value(new_dn_value)}",
+                           true,
+                           new_superior)
+        end
+        true
+      end
+    end
+  end # Persistence
+end # ActiveLdap

data/lib/active_ldap/railtie.rb

@@ -0,0 +1,40 @@
+require 'active_ldap'
+require 'rails'
+
+module ActiveLdap
+  class Railtie < Rails::Railtie
+    config.app_generators.orm :active_ldap
+
+    initializer "active_ldap.setup_connection" do
+      ldap_configuration_file = Rails.root.join('config', 'ldap.yml')
+      if File.exist?(ldap_configuration_file)
+        configurations = YAML::load(ERB.new(IO.read(ldap_configuration_file)).result)
+        ActiveLdap::Base.configurations = configurations
+        ActiveLdap::Base.setup_connection
+      else
+        ActiveLdap::Base.class_eval do
+          format =_("You should run 'rails generator active_ldap:scaffold' to make %s.")
+          logger.error(format % ldap_configuration_file)
+        end
+      end
+    end
+
+    initializer "active_ldap.logger", :before => "active_ldap.setup_connection" do
+      ActiveLdap::Base.logger ||= ::Rails.logger
+    end
+
+    initializer "active_ldap.action_view_helper" do
+      class ::ActionView::Base
+        include ActiveLdap::Helper
+      end
+    end
+
+    # Expose Ldap runtime to controller for logging.
+    initializer "active_ldap.log_runtime" do |app|
+      require "active_ldap/railties/controller_runtime"
+      ActiveSupport.on_load(:action_controller) do
+        include ActiveLdap::Railties::ControllerRuntime
+      end
+    end
+  end
+end

data/lib/active_ldap/railties/controller_runtime.rb

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/module/attr_internal'
+require 'active_ldap/log_subscriber'
+
+module ActiveLdap
+  module Railties
+    module ControllerRuntime #:nodoc:
+      extend ActiveSupport::Concern
+      
+    protected
+      
+      attr_internal :ldap_runtime
+      
+      def process_action(action, *args)
+        # We also need to reset the runtime before each action
+        # because of queries in middleware or in cases we are streaming
+        # and it won't be cleaned up by the method below.
+        ActiveLdap::LogSubscriber.reset_runtime
+        super
+      end
+      
+      def cleanup_view_runtime
+        if ActiveLdap::Base.connected?
+          ldap_rt_before_render = ActiveLdap::LogSubscriber.reset_runtime
+          runtime = super
+          ldap_rt_after_render = ActiveLdap::LogSubscriber.reset_runtime
+          self.ldap_runtime = ldap_rt_before_render + ldap_rt_after_render
+          runtime - ldap_rt_after_render
+        else
+          super
+        end
+      end
+      
+      def append_info_to_payload(payload)
+        super
+        payload[:ldap_runtime] = ldap_runtime
+      end
+      
+      module ClassMethods
+        def log_process_action(payload)
+          messages, ldap_runtime = super, payload[:ldap_runtime]
+          messages << ("ActiveLdap: %.1fms" % ldap_runtime.to_f) if ldap_runtime
+          messages
+        end
+      end
+    end
+  end
+end
+

data/lib/active_ldap/user_password.rb

@@ -1,4 +1,5 @@
 require 'English'
+require 'base64'
 require 'digest/md5'
 require 'digest/sha1'
 

data/lib/active_ldap/validations.rb

@@ -1,81 +1,29 @@
 module ActiveLdap
   module Validations
-    def self.append_features(base)
-      super
-
-      base.class_eval do
-        alias_method :new_record?, :new_entry?
-        class << self
-          alias_method :human_attribute_name_active_ldap,
-                       :human_attribute_name
-        end
-        include ActiveRecord::Validations
-        class << self
-          alias_method :human_attribute_name_active_record,
-                       :human_attribute_name
-          alias_method :human_attribute_name,
-                       :human_attribute_name_active_ldap
-          unless method_defined?(:human_attribute_name_with_gettext)
-            def human_attribute_name_with_gettext(attribute_key_name)
-              s_("#{self}|#{attribute_key_name.humanize}")
-            end
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+    
+    included do
+      alias_method :new_record?, :new_entry?
+      class << self
+        unless method_defined?(:human_attribute_name_with_gettext)
+          def human_attribute_name_with_gettext(attribute_key_name, options={})
+            logger.warn("options was ignored.") unless options.empty?
+            s_("#{self}|#{attribute_key_name.to_s.humanize}")
           end
         end
+      end
 
-        class_local_attr_accessor true, :validation_skip_attributes
-        remove_method :validation_skip_attributes
-        self.validation_skip_attributes = []
-
-        # Workaround for GetText's ugly implementation
-        begin
-          instance_method(:save_without_validation)
-        rescue NameError
-          alias_method_chain :save, :validation
-          alias_method_chain :save!, :validation
-          alias_method_chain :update_attribute, :validation_skipping
-        end
-
-        validate_on_create :validate_duplicated_dn_creation
-        validate_on_update :validate_duplicated_dn_rename
-        validate :validate_dn
-        validate :validate_excluded_classes
-        validate :validate_required_ldap_values
-        validate :validate_ldap_values
-
-        class << self
-          if method_defined?(:evaluate_condition)
-            def evaluate_condition_with_active_ldap_support(condition, entry)
-              evaluate_condition_without_active_ldap_support(condition, entry)
-            rescue ActiveRecord::ActiveRecordError
-              raise Error, $!.message
-            end
-            alias_method_chain :evaluate_condition, :active_ldap_support
-          end
-        end
-
-        def save_with_active_ldap_support!
-          save_without_active_ldap_support!
-        rescue ActiveRecord::RecordInvalid
-          raise EntryInvalid, $!.message
-        end
-        alias_method_chain :save!, :active_ldap_support
+      class_local_attr_accessor true, :validation_skip_attributes
+      remove_method :validation_skip_attributes
+      self.validation_skip_attributes = []
 
-        private
-        def run_validations_with_active_ldap_support(validation_method)
-          run_validations_without_active_ldap_support(validation_method)
-        rescue ActiveRecord::ActiveRecordError
-          raise Error, $!.message
-        end
-        if private_method_defined?(:run_validations)
-          alias_method_chain :run_validations, :active_ldap_support
-        else
-          alias_method(:run_callbacks_with_active_ldap_support,
-                       :run_validations_with_active_ldap_support)
-          alias_method_chain :run_callbacks, :active_ldap_support
-          alias_method(:run_validations_without_active_ldap_support,
-                       :run_callbacks_without_active_ldap_support)
-        end
-      end
+      validate :validate_duplicated_dn_creation, :on => :create
+      validate :validate_duplicated_dn_rename, :on => :update
+      validate :validate_dn
+      validate :validate_excluded_classes
+      validate :validate_required_ldap_values
+      validate :validate_ldap_values
     end
 
     def validation_skip_attributes
@@ -86,6 +34,20 @@ module ActiveLdap
       @validation_skip_attributes = attributes
     end
 
+    def valid?(context = nil)
+      context ||= (new_entry? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    def save(*)
+      valid? ? super: false
+    end
+
+    def save!(*)
+      valid? ? super: raise(EntryInvalid.new(self))
+    end
+
     private
     def format_validation_message(format, parameters)
       format % parameters