activeldap 3.1.1 → 3.2.0

data/lib/active_ldap/attribute_methods/query.rb

@@ -0,0 +1,31 @@
+#
+module ActiveLdap
+  module AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix '?'
+      end
+
+    protected
+      def get_attribute_as_query(name, force_array=false)
+        name, value = get_attribute_before_type_cast(name, force_array)
+        if force_array
+          value.collect {|x| !false_value?(x)}
+        else
+          !false_value?(value)
+        end
+      end
+
+      def false_value?(value)
+        value.nil? or value == false or value == [] or
+          value == "false" or value == "FALSE" or value == ""
+      end
+
+      def attribute?(attr)
+        return get_attribute_as_query(attr)
+      end
+    end
+  end
+end

data/lib/active_ldap/attribute_methods/read.rb

@@ -0,0 +1,44 @@
+module ActiveLdap
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+    protected
+      def attribute(attr, *args)
+        return get_attribute(attr, args.first)
+      end
+
+      # get_attribute
+      #
+      # Return the value of the attribute called by method_missing?
+      def get_attribute(name, force_array=false)
+        name, value = get_attribute_before_type_cast(name, force_array)
+        return value if name.nil?
+        attribute = schema.attribute(name)
+        type_cast(attribute, value)
+      end
+
+      def type_cast(attribute, value)
+        case value
+        when Hash
+          result = {}
+          value.each do |option, val|
+            result[option] = type_cast(attribute, val)
+          end
+          if result.size == 1 and result.has_key?("binary")
+            result["binary"]
+          else
+            result
+          end
+        when Array
+          value.collect do |val|
+            type_cast(attribute, val)
+          end
+        else
+          attribute.type_cast(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_ldap/attribute_methods/write.rb

@@ -0,0 +1,38 @@
+module ActiveLdap
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix '='
+      end
+
+    protected
+      def attribute=(attr, *args)
+        return set_attribute(attr, args.first)
+      end
+
+      # set_attribute
+      #
+      # Set the value of the attribute called by method_missing?
+      def set_attribute(name, value)
+        real_name = to_real_attribute_name(name)
+        _dn_attribute = nil
+        valid_dn_attribute = true
+        begin
+          _dn_attribute = dn_attribute
+        rescue DistinguishedNameInvalid
+          valid_dn_attribute = false
+        end
+        if valid_dn_attribute and real_name == _dn_attribute
+          real_name, value = register_new_dn_attribute(real_name, value)
+        end
+        raise UnknownAttribute.new(name) if real_name.nil?
+
+        @data[real_name] = value
+        @simplified_data = nil
+      end
+
+    end
+  end
+end

data/lib/active_ldap/attributes.rb

@@ -9,17 +9,6 @@ module ActiveLdap
     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
-
       def blank_value?(value)
         case value
         when Hash
@@ -149,32 +138,35 @@ module ActiveLdap
     end
 
     private
-    def remove_attributes_protected_from_mass_assignment(targets)
+    def sanitize_for_mass_assignment(attributes, role=nil)
+      role ||= :default
+      authorizer = mass_assignment_authorizer(role)
+      black_list_p =
+        authorizer.is_a?(ActiveModel::MassAssignmentSecurity::BlackList)
+
+      always_needless_attributes = {}
       needless_attributes = {}
-      (attributes_protected_by_default +
-       (self.class.protected_attributes || [])).each do |name|
-        needless_attributes[to_real_attribute_name(name)] = true
-      end
 
       _dn_attribute = nil
       begin
         _dn_attribute = dn_attribute_with_fallback
       rescue DistinguishedNameInvalid
       end
-      targets.collect do |key, value|
+      [_dn_attribute, 'objectClass'].compact.each do |name|
+        always_needless_attributes[to_real_attribute_name(name)] = true
+      end
+      authorizer.each do |name|
+        needless_attributes[to_real_attribute_name(name)] = black_list_p
+      end
+
+      sanitized_attributes = attributes.collect do |key, value|
         key = _dn_attribute if ["id", "dn"].include?(key.to_s)
         [to_real_attribute_name(key) || key, value]
-      end.reject do |key, value|
-        needless_attributes[key]
       end
-    end
-
-    def attributes_protected_by_default
-      begin
-        _dn_attribute = dn_attribute_with_fallback
-      rescue DistinguishedNameInvalid
+      sanitized_attributes = sanitized_attributes.reject do |key, value|
+        always_needless_attributes[key] or needless_attributes[key]
       end
-      [_dn_attribute, 'objectClass'].compact
+      sanitized_attributes
     end
 
     def normalize_attribute_name(name)

data/lib/active_ldap/base.rb

@@ -281,6 +281,7 @@ module ActiveLdap
   # by extension classes.
   class Base
     include GetTextSupport
+    public :gettext
     public :_
 
     if Object.const_defined?(:Reloadable)
@@ -344,8 +345,9 @@ module ActiveLdap
         end
       end
 
-      # Connect and bind to LDAP creating a class variable for use by
-      # all ActiveLdap objects.
+      # Set LDAP connection configuration up. It doesn't connect
+      # and bind to LDAP server. A connection to LDAP server is
+      # created when it's needed.
       #
       # == +config+
       # +config+ must be a hash that may contain any of the following fields:
@@ -793,65 +795,6 @@ module ActiveLdap
       self.class.default_search_attribute
     end
 
-    # method_missing
-    #
-    # If a given method matches an attribute or an attribute alias
-    # then call the appropriate method.
-    # TODO: Determine if it would be better to define each allowed method
-    #       using class_eval instead of using method_missing.  This would
-    #       give tab completion in irb.
-    def method_missing(name, *args, &block)
-      key = name.to_s
-      case key
-      when /=$/
-        real_key = $PREMATCH
-        if have_attribute?(real_key, ['objectClass'])
-          if args.size != 1
-            raise ArgumentError,
-                    _("wrong number of arguments (%d for 1)") % args.size
-          end
-          return set_attribute(real_key, *args, &block)
-        end
-      when /(?:(_before_type_cast)|(\?))?$/
-        real_key = $PREMATCH
-        before_type_cast = !$1.nil?
-        query = !$2.nil?
-        if have_attribute?(real_key, ['objectClass'])
-          if args.size > 1
-            raise ArgumentError,
-              _("wrong number of arguments (%d for 1)") % args.size
-          end
-          if before_type_cast
-            return get_attribute_before_type_cast(real_key, *args)[1]
-          elsif query
-            return get_attribute_as_query(real_key, *args)
-          else
-            return get_attribute(real_key, *args)
-          end
-        end
-      end
-      super
-    end
-
-    # Add available attributes to the methods
-    def methods(inherited_too=true)
-      target_names = entry_attribute.all_names
-      target_names -= ['objectClass', 'objectClass'.underscore]
-      super + target_names.uniq.collect do |x|
-        [x, "#{x}=", "#{x}?", "#{x}_before_type_cast"]
-      end.flatten
-    end
-
-    alias_method :respond_to_without_attributes?, :respond_to?
-    def respond_to?(name, include_priv=false)
-      return true if super
-
-      name = name.to_s
-      return true if have_attribute?(name, ["objectClass"])
-      return false if /(?:=|\?|_before_type_cast)$/ !~ name
-      have_attribute?($PREMATCH, ["objectClass"])
-    end
-
     # Updates a given attribute and saves immediately
     def update_attribute(name, value)
       send("#{name}=", value)
@@ -885,8 +828,18 @@ module ActiveLdap
     # Do not let URL/form hackers supply the keys.
     def attributes=(new_attributes)
       return if new_attributes.blank?
+      assign_attributes(new_attributes)
+    end
+
+    def assign_attributes(new_attributes, options={})
+      return if new_attributes.blank?
+
       _schema = _local_entry_attribute = nil
-      targets = remove_attributes_protected_from_mass_assignment(new_attributes)
+      if options[:without_protection]
+        targets = new_attributes
+      else
+        targets = sanitize_for_mass_assignment(new_attributes, options[:role])
+      end
       targets.each do |key, value|
         setter = "#{key}="
         unless respond_to?(setter)
@@ -912,9 +865,10 @@ module ActiveLdap
       options = options.dup
       options[:root] ||= (self.class.name || '').underscore
       options[:root] = 'anonymous' if options[:root].blank?
-      except = options[:except]
-      if except
-        options[:except] = except.collect do |name|
+      [:only, :except].each do |attribute_names_key|
+        names = options[attribute_names_key]
+        next if names.nil?
+        options[attribute_names_key] = names.collect do |name|
           if name.to_s.downcase == "dn"
             "dn"
           else
@@ -935,23 +889,6 @@ module ActiveLdap
     end
     alias_method :has_attribute?, :have_attribute?
 
-    def reload
-      clear_association_cache
-      _, attributes = search(:value => id).find do |_dn, _attributes|
-        dn == _dn
-      end
-      if attributes.nil?
-        raise EntryNotFound, _("Can't find DN '%s' to reload") % dn
-      end
-
-      @ldap_data.update(attributes)
-      classes, attributes = extract_object_class(attributes)
-      self.classes = classes
-      self.attributes = attributes
-      @new_entry = false
-      self
-    end
-
     def [](name, force_array=false)
       if name == "dn"
         array_of(dn, force_array)
@@ -964,12 +901,6 @@ module ActiveLdap
       set_attribute(name, value)
     end
 
-    def each
-      @data.each do |key, values|
-        yield(key.dup, values.dup)
-      end
-    end
-
     def bind(config_or_password={}, config_or_ignore=nil, &block)
       if config_or_password.is_a?(String)
         config = (config_or_ignore || {}).merge(:password => config_or_password)
@@ -1004,6 +935,9 @@ module ActiveLdap
     def clear_object_class_based_cache
       @entry_attribute = nil
       @real_names = {}
+      @changed_attributes.reject! do |key, _|
+        not attribute_method?(key)
+      end
     end
 
     def schema
@@ -1130,10 +1064,26 @@ module ActiveLdap
       classes, attributes = extract_object_class(attributes)
       self.classes = classes
       self.dn = dn
-      self.attributes = attributes
+      initialize_attributes(attributes)
       yield self if block_given?
     end
 
+    def initialize_attributes(attributes)
+      _schema = _local_entry_attribute = nil
+      targets = sanitize_for_mass_assignment(attributes)
+      targets.each do |key, value|
+        unless have_attribute?(key)
+          _schema ||= schema
+          attribute = _schema.attribute(key)
+          _local_entry_attribute ||= local_entry_attribute
+          _local_entry_attribute.register(attribute)
+        end
+        set_attribute(key, value)
+      end
+      @changed_attributes.clear
+    end
+    private :initialize_attributes
+
     def instantiate(args)
       dn, attributes, options = args
       options ||= {}
@@ -1180,83 +1130,11 @@ module ActiveLdap
       @dn_split_value = nil
       @connection ||= nil
       @_hashing = false
+      @previously_changed = []
+      @changed_attributes = {}
       clear_connection_based_cache
     end
 
-    # get_attribute
-    #
-    # Return the value of the attribute called by method_missing?
-    def get_attribute(name, force_array=false)
-      name, value = get_attribute_before_type_cast(name, force_array)
-      return value if name.nil?
-      attribute = schema.attribute(name)
-      type_cast(attribute, value)
-    end
-
-    def type_cast(attribute, value)
-      case value
-      when Hash
-        result = {}
-        value.each do |option, val|
-          result[option] = type_cast(attribute, val)
-        end
-        if result.size == 1 and result.has_key?("binary")
-          result["binary"]
-        else
-          result
-        end
-      when Array
-        value.collect do |val|
-          type_cast(attribute, val)
-        end
-      else
-        attribute.type_cast(value)
-      end
-    end
-
-    def get_attribute_before_type_cast(name, force_array=false)
-      name = to_real_attribute_name(name)
-
-      value = @data[name]
-      value = [] if value.nil?
-      [name, array_of(value, force_array)]
-    end
-
-    def get_attribute_as_query(name, force_array=false)
-      name, value = get_attribute_before_type_cast(name, force_array)
-      if force_array
-        value.collect {|x| !false_value?(x)}
-      else
-        !false_value?(value)
-      end
-    end
-
-    def false_value?(value)
-      value.nil? or value == false or value == [] or
-        value == "false" or value == "FALSE" or value == ""
-    end
-
-    # set_attribute
-    #
-    # Set the value of the attribute called by method_missing?
-    def set_attribute(name, value)
-      real_name = to_real_attribute_name(name)
-      _dn_attribute = nil
-      valid_dn_attribute = true
-      begin
-        _dn_attribute = dn_attribute
-      rescue DistinguishedNameInvalid
-        valid_dn_attribute = false
-      end
-      if valid_dn_attribute and real_name == _dn_attribute
-        real_name, value = register_new_dn_attribute(real_name, value)
-      end
-      raise UnknownAttribute.new(name) if real_name.nil?
-
-      @data[real_name] = value
-      @simplified_data = nil
-    end
-
     def register_new_dn_attribute(name, value)
       @dn = nil
       @dn_is_base = false
@@ -1281,6 +1159,7 @@ module ActiveLdap
         @base_value = nil
         attr, value = bases[0].to_a[0]
         @dn_attribute = attr
+        _ = value # for suppress a warning on Ruby 1.9.3
       else
         new_name ||= @dn_attribute || dn_attribute_of_class
         new_name = to_real_attribute_name(new_name)