activeldap 0.9.0 → 0.10.0

data/lib/active_ldap/object_class.rb

@@ -13,7 +13,7 @@ module ActiveLdap
     end
 
     def add_class(*target_classes)
-      replace_class((classes + target_classes.flatten).uniq)
+      replace_class(classes + target_classes)
     end
 
     def ensure_recommended_classes
@@ -21,16 +21,18 @@ module ActiveLdap
     end
 
     def remove_class(*target_classes)
-      replace_class((classes - target_classes.flatten).uniq)
+      replace_class(classes - target_classes)
     end
 
     def replace_class(*target_classes)
-      new_classes = target_classes.flatten.uniq
+      new_classes = target_classes.flatten.compact.uniq
       assert_object_classes(new_classes)
       if new_classes.sort != classes.sort
         set_attribute('objectClass', new_classes)
+        clear_object_class_based_cache
       end
     end
+    alias_method(:classes=, :replace_class)
 
     def classes
       (get_attribute('objectClass', true) || []).dup
@@ -50,7 +52,7 @@ module ActiveLdap
       unless invalid_classes.empty?
         format = _("Value in objectClass array is not a String: %s")
         invalid_classes_info = invalid_classes.collect do |invalid_class|
-          "#{invalid_class.class}:#{invalid_class.inspect}"
+          "#{invalid_class.class}: #{invalid_class.inspect}"
         end.join(", ")
         raise TypeError, format % invalid_classes_info
       end

data/lib/active_ldap/operations.rb

@@ -33,18 +33,14 @@ module ActiveLdap
         classes = options[:classes]
 
         value = value.first if value.is_a?(Array) and value.first.size == 1
-        if filter.nil? and !value.is_a?(String)
-          message = _("Search value must be a String: %s") % value.inspect
-          raise ArgumentError, message
-        end
 
         _attr, value, _prefix = split_search_value(value)
         attr ||= _attr || ensure_search_attribute
         prefix ||= _prefix
         filter ||= [attr, value]
         filter = [:and, filter, *object_class_filters(classes)]
-        _base = options[:base]
-        _base ||= [prefix, base].compact.reject{|x| x.empty?}.join(",")
+        _base = options[:base] ? [options[:base]] : [prefix, base]
+        _base = prepare_search_base(_base)
         if options.has_key?(:ldap_scope)
           logger.warning do
             _(":ldap_scope search option is deprecated. Use :scope instead.")
@@ -136,14 +132,37 @@ module ActiveLdap
         end
       end
 
+      def prepare_search_base(components)
+        components.compact.collect do |component|
+          if component.is_a?(String)
+            component
+          else
+            DN.new(*component).to_s
+          end
+        end.reject{|x| x.empty?}.join(",")
+      end
+
       def object_class_filters(classes=nil)
-        (classes || required_classes).collect do |name|
-          ["objectClass", Escape.ldap_filter_escape(name)]
+        expected_classes = (classes || required_classes).collect do |name|
+          Escape.ldap_filter_escape(name)
+        end
+        unexpected_classes = excluded_classes.collect do |name|
+          Escape.ldap_filter_escape(name)
         end
+        filters = []
+        unless expected_classes.empty?
+          filters << ["objectClass", "=", *expected_classes]
+        end
+        unless unexpected_classes.empty?
+          filters << [:not, [:or, ["objectClass", "=", *unexpected_classes]]]
+        end
+        filters
       end
 
       def split_search_value(value)
         attr = prefix = nil
+        return [attr, value, prefix] unless value.is_a?(String)
+
         begin
           dn = DN.parse(value)
           attr, value = dn.rdns.first.to_a.first
@@ -204,9 +223,10 @@ module ActiveLdap
 
       def find_every(options)
         options = options.dup
-        sort_by = options.delete(:sort_by) || sort_by
-        order = options.delete(:order) || order
+        sort_by = options.delete(:sort_by) || self.sort_by
+        order = options.delete(:order) || self.order
         limit = options.delete(:limit) if sort_by or order
+        options[:attributes] |= ["objectClass"] if options[:attributes]
 
         results = search(options).collect do |dn, attrs|
           instantiate([dn, attrs, {:connection => options[:connection]}])
@@ -302,24 +322,101 @@ module ActiveLdap
 
     module LDIF
       def dump(options={})
-        ldifs = []
+        ldif = Ldif.new
         options = {:base => base, :scope => scope}.merge(options)
         options[:connection] ||= connection
         options[:connection].search(options) do |dn, attributes|
-          ldifs << to_ldif(dn, attributes)
+          ldif << Ldif::Record.new(dn, attributes)
         end
-        ldifs.join("\n")
+        return "" if ldif.records.empty?
+        ldif.to_s
       end
 
-      def to_ldif(dn, attributes, options={})
-        options[:connection] ||= connection
-        options[:connection].to_ldif(dn, unnormalize_attributes(attributes))
+      def to_ldif(dn, attributes)
+        record = Ldif::Record.new(dn, attributes)
+        Ldif.new([record]).to_s
       end
 
-      def load(ldifs, options={})
-        options[:connection] ||= connection
-        options[:connection].load(ldifs)
+      def load(ldif, options={})
+        return if ldif.blank?
+        Ldif.parse(ldif).each do |record|
+          record.load(self, options)
+        end
+      end
+
+      module ContentRecordLoadable
+        def load(operator, options)
+          operator.add_entry(dn, attributes, options)
+        end
+      end
+      Ldif::ContentRecord.send(:include, ContentRecordLoadable)
+
+      module AddRecordLoadable
+        def load(operator, options)
+          entries = attributes.collect do |key, value|
+            [:add, key, value]
+          end
+          options = {:controls => controls}.merge(options)
+          operator.modify_entry(dn, entries, options)
+        end
+      end
+      Ldif::AddRecord.send(:include, AddRecordLoadable)
+
+      module DeleteRecordLoadable
+        def load(operator, options)
+          operator.delete_entry(dn, {:controls => controls}.merge(options))
+        end
       end
+      Ldif::DeleteRecord.send(:include, DeleteRecordLoadable)
+
+      module ModifyNameRecordLoadable
+        def load(operator, options)
+          operator.modify_rdn_entry(dn, new_rdn, delete_old_rdn?, new_superior,
+                                    {:controls => controls}.merge(options))
+        end
+      end
+      Ldif::ModifyNameRecord.send(:include, ModifyNameRecordLoadable)
+
+      module ModifyRecordLoadable
+        def load(operator, options)
+          each do |operation|
+            operator.modify_entry(dn, operation.to_modify_entries,
+                                  {:controls => controls}.merge(options))
+          end
+        end
+
+        module AddOperationModifiable
+          def to_modify_entries
+            attributes.collect do |key, value|
+              [:add, key, value]
+            end
+          end
+        end
+        Ldif::ModifyRecord::AddOperation.send(:include, AddOperationModifiable)
+
+        module DeleteOperationModifiable
+          def to_modify_entries
+            return [[:delete, full_attribute_name, []]] if attributes.empty?
+            attributes.collect do |key, value|
+              [:delete, key, value]
+            end
+          end
+        end
+        Ldif::ModifyRecord::DeleteOperation.send(:include,
+                                                 DeleteOperationModifiable)
+
+        module ReplaceOperationModifiable
+          def to_modify_entries
+            return [[:replace, full_attribute_name, []]] if attributes.empty?
+            attributes.collect do |key, value|
+              [:replace, key, value]
+            end
+          end
+        end
+        Ldif::ModifyRecord::ReplaceOperation.send(:include,
+                                                  ReplaceOperationModifiable)
+      end
+      Ldif::ModifyRecord.send(:include, ModifyRecordLoadable)
     end
 
     module Delete
@@ -349,8 +446,12 @@ module ActiveLdap
         targets = targets.collect do |target|
           ensure_dn_attribute(ensure_base(target))
         end
+        delete_entry(targets, options)
+      end
+
+      def delete_entry(dn, options={})
         options[:connection] ||= connection
-        options[:connection].delete(targets, options)
+        options[:connection].delete(dn, options)
       end
 
       def delete_all(filter=nil, options={})
@@ -370,8 +471,8 @@ module ActiveLdap
 
     module Update
       def add_entry(dn, attributes, options={})
-        unnormalized_attributes = attributes.collect do |type, key, value|
-          [type, key, unnormalize_attribute(key, value)]
+        unnormalized_attributes = attributes.collect do |key, value|
+          [:add, key, unnormalize_attribute(key, value)]
         end
         options[:connection] ||= connection
         options[:connection].add(dn, unnormalized_attributes, options)
@@ -385,6 +486,12 @@ module ActiveLdap
         options[:connection].modify(dn, unnormalized_attributes, options)
       end
 
+      def modify_rdn_entry(dn, new_rdn, delete_old_rdn, new_superior, options={})
+        options[:connection] ||= connection
+        options[:connection].modify_rdn(dn, new_rdn, delete_old_rdn,
+                                        new_superior, options)
+      end
+
       def update(dn, attributes, options={})
         if dn.is_a?(Array)
           i = -1

data/lib/active_ldap/schema.rb

@@ -349,6 +349,9 @@ module ActiveLdap
     end
 
     class Attribute < Entry
+      include GetTextSupport
+      include HumanReadable
+
       attr_reader :super_attribute
       def initialize(name, schema)
         super(name, schema, "attributeTypes")
@@ -387,7 +390,7 @@ module ActiveLdap
       end
 
       def syntax
-        (@derived_syntax ||= [derived_syntax])[0]
+        @derived_syntax
       end
 
       def valid?(value)
@@ -395,7 +398,14 @@ module ActiveLdap
       end
 
       def validate(value)
-        send_to_syntax(nil, :validate, value)
+        error_info = validate_each_value(value)
+        return error_info if error_info
+        begin
+          normalize_value(value)
+          nil
+        rescue AttributeValueInvalid
+          [$!.message]
+        end
       end
 
       def type_cast(value)
@@ -403,13 +413,21 @@ module ActiveLdap
       end
 
       def normalize_value(value)
-        send_to_syntax(value, :normalize_value, value)
+        normalize_value_internal(value, false)
       end
 
       def syntax_description
         send_to_syntax(nil, :description)
       end
 
+      def human_attribute_name
+        self.class.human_attribute_name(self)
+      end
+
+      def human_attribute_description
+        self.class.human_attribute_description(self)
+      end
+
       private
       def attribute(attribute_name, name=@name)
         @schema.attribute_type(name, attribute_name)
@@ -429,18 +447,15 @@ module ActiveLdap
         if @syntax
           @binary_required = @syntax.binary_transfer_required?
           @binary = (@binary_required or !@syntax.human_readable?)
+          @derived_syntax = @syntax
         else
           @binary_required = false
           @binary = false
+          @derived_syntax = nil
+          @derived_syntax = @super_attribute.syntax if @super_attribute
         end
       end
 
-      def derived_syntax
-        return @syntax if @syntax
-        return @super_attribute.syntax if @super_attribute
-        nil
-      end
-
       def send_to_syntax(default_value, method_name, *args)
         _syntax = syntax
         if _syntax
@@ -449,6 +464,100 @@ module ActiveLdap
           default_value
         end
       end
+
+      def validate_each_value(value, option=nil)
+        failed_reason = nil
+        case value
+        when Hash
+          original_option = option
+          value.each do |sub_option, val|
+            opt = [original_option, sub_option].compact.join(";")
+            failed_reason, option = validate_each_value(val, opt)
+            break if failed_reason
+          end
+        when Array
+          original_option = option
+          value.each do |val|
+            failed_reason, option = validate_each_value(val, original_option)
+            break if failed_reason
+          end
+        else
+          failed_reason = send_to_syntax(nil, :validate, value)
+        end
+        return nil if failed_reason.nil?
+        [failed_reason, option]
+      end
+
+      def normalize_value_internal(value, have_binary_mark)
+        case value
+        when Array
+          normalize_array_value(value, have_binary_mark)
+        when Hash
+          normalize_hash_value(value, have_binary_mark)
+        else
+          if value.blank?
+            value = []
+          else
+            value = send_to_syntax(value, :normalize_value, value)
+          end
+          if !have_binary_mark and binary_required?
+            [{'binary' => value}]
+          else
+            value.is_a?(Array) ? value : [value]
+          end
+        end
+      end
+
+      def normalize_array_value(value, have_binary_mark)
+        if single_value? and value.reject {|v| v.is_a?(Hash)}.size > 1
+          format = _("Attribute %s can only have a single value: %s")
+          message = format % [human_attribute_name, value.inspect]
+          raise AttributeValueInvalid.new(self, value, message)
+        end
+        if value.empty?
+          if !have_binary_mark and binary_required?
+            [{'binary' => value}]
+          else
+            value
+          end
+        else
+          value.collect do |entry|
+            normalize_value_internal(entry, have_binary_mark)[0]
+          end
+        end
+      end
+
+      def normalize_hash_value(value, have_binary_mark)
+        if value.size > 1
+          format = _("Attribute %s: Hash must have one key-value pair only: %s")
+          message = format % [human_attribute_name, value.inspect]
+          raise AttributeValueInvalid.new(self, value, message)
+        end
+
+        if !have_binary_mark and binary_required? and !have_binary_key?(value)
+          [append_binary_key(value)]
+        else
+          key = value.keys[0]
+          have_binary_mark ||= key == "binary"
+          [{key => normalize_value_internal(value.values[0], have_binary_mark)}]
+        end
+      end
+
+      def have_binary_key?(hash)
+        key, value = hash.to_a[0]
+        return true if key == "binary"
+        return have_binary_key?(value) if value.is_a?(Hash)
+        false
+      end
+
+      def append_binary_key(hash)
+        key, value = hash.to_a[0]
+        if value.is_a?(Hash)
+          append_binary_key(value)
+        else
+          hash.merge(key => {"binary" => value})
+        end
+      end
     end
 
     class ObjectClass < Entry

data/lib/active_ldap/schema/syntaxes.rb

@@ -165,12 +165,32 @@ module ActiveLdap
 
       class GeneralizedTime < Base
         SYNTAXES["1.3.6.1.4.1.1466.115.121.1.24"] = self
+        FORMAT = /\A
+                  (\d{4,4})?
+                  (\d{2,2})?
+                  (\d{2,2})?
+                  (\d{2,2})?
+                  (\d{2,2})?
+                  (\d{2,2})?
+                  ([,.]\d+)?
+                  ([+-]\d{4,4}|Z)?
+                 \z/x
 
         def type_cast(value)
           return value if value.nil? or value.is_a?(Time)
-          begin
-            Time.parse(value)
-          rescue ArgumentError
+          match_data = FORMAT.match(value)
+          if match_data
+            required_components = match_data.to_a[1, 6]
+            return value if required_components.any?(&:nil?)
+            year, month, day, hour, minute, second =
+              required_components.collect(&:to_i)
+            fraction = match_data[-2]
+            fraction = fraction.to_f if fraction
+            time_zone = match_data[-1]
+            Time.send(:make_time,
+                      year, month, day, hour, minute, second, fraction,
+                      time_zone, Time.now)
+          else
             value
           end
         end
@@ -190,20 +210,12 @@ module ActiveLdap
 
         private
         def validate_normalized_value(value, original_value)
-          match_data = /\A
-                         (\d{4,4})?
-                         (\d{2,2})?
-                         (\d{2,2})?
-                         (\d{2,2})?
-                         (\d{2,2})?
-                         (\d{2,2}(?:[,.]\d+)?)?
-                         ([+-]\d{4,4}|Z)?
-                        \z/x.match(value)
+          match_data = FORMAT.match(value)
           if match_data
-            year, month, day, hour, minute, second, time_zone =
+            year, month, day, hour, minute, second, fraction, time_zone =
               match_data.to_a[1..-1]
             missing_components = []
-            %w(year month day hour minute).each do |component|
+            %w(year month day hour minute second).each do |component|
               missing_components << component unless eval(component)
             end
             if missing_components.empty?
@@ -231,7 +243,7 @@ module ActiveLdap
         end
 
         def normalize_value(value)
-          if value.is_a?(Integer)
+          if value.is_a?(::Integer)
             value.to_s
           else
             value
@@ -309,7 +321,12 @@ module ActiveLdap
           DN.parse("#{value}=dummy")
           nil
         rescue DistinguishedNameInvalid
-          _("%s is invalid OID format") % original_value.inspect
+          reason = $!.reason
+          if reason
+            _("%s is invalid OID format: %s") % [original_value.inspect, reason]
+          else
+            _("%s is invalid OID format") % original_value.inspect
+          end
         end
       end