activeldap 1.0.9 → 1.1.0

data/lib/active_ldap/association/belongs_to_many.rb

@@ -6,11 +6,11 @@ module ActiveLdap
       private
       def insert_entry(entry)
         old_value = entry[@options[:many], true]
-        foreign_key_name = @options[:foreign_key_name]
-        if foreign_key_name == "dn"
+        primary_key_name = @options[:primary_key_name]
+        if primary_key_name == "dn"
           old_value = dn_values_to_string_values(old_value)
         end
-        new_value = old_value + @owner[foreign_key_name, true]
+        new_value = old_value + @owner[primary_key_name, true]
         new_value = new_value.uniq.sort
         if old_value != new_value
           entry[@options[:many]] = new_value
@@ -21,11 +21,11 @@ module ActiveLdap
       def delete_entries(entries)
         entries.each do |entry|
           old_value = entry[@options[:many], true]
-          foreign_key_name = @options[:foreign_key_name]
-          if foreign_key_name == "dn"
+          primary_key_name = @options[:primary_key_name]
+          if primary_key_name == "dn"
             old_value = dn_values_to_string_values(old_value)
           end
-          new_value = old_value - @owner[foreign_key_name, true]
+          new_value = old_value - @owner[primary_key_name, true]
           new_value = new_value.uniq.sort
           if old_value != new_value
             entry[@options[:many]] = new_value
@@ -35,7 +35,7 @@ module ActiveLdap
       end
 
       def find_target
-        values = @owner[@options[:foreign_key_name], true].compact
+        values = @owner[@options[:primary_key_name], true].compact
         return [] if values.empty?
 
         key = @options[:many]

data/lib/active_ldap/association/has_many.rb

@@ -8,17 +8,17 @@ module ActiveLdap
 
       private
       def insert_entry(entry)
-        entry[primary_key] = @owner[@options[:foreign_key_name]]
+        entry[@options[:foreign_key_name]] = @owner[primary_key]
         entry.save
       end
 
       def find_target
-        collect_targets(:foreign_key_name)
+        collect_targets(:primary_key_name)
       end
 
       def delete_entries(entries)
-        key = primary_key
-        components = @owner[@options[:foreign_key_name], true].reject do |value|
+        key = @options[:foreign_key_name]
+        components = @owner[primary_key, true].reject do |value|
           value.nil?
         end
         filter = [:and,

data/lib/active_ldap/associations.rb

@@ -37,7 +37,9 @@ module ActiveLdap
       # Example:
       #  belongs_to :groups, :class_name => "Group",
       #             :many => "memberUid" # Group#memberUid
-      #             # :foreign_key => "uid" # User#uid
+      #             # :primary_key => "uid" # User#uid
+      #             ## deprecated since 1.1.0. Use :primary_key instead.
+      #             ## :foreign_key => "uid" # User#uid
       #             # dn attribute value is used by default
       #  belongs_to :primary_group, :class_name => "Group",
       #             :foreign_key => "gidNumber", # User#gidNumber
@@ -61,7 +63,14 @@ module ActiveLdap
         }
         if opts[:many]
           association_class = Association::BelongsToMany
-          opts[:foreign_key_name] ||= dn_attribute
+          foreign_key_name = opts[:foreign_key_name]
+          if foreign_key_name
+            message = _(":foreign_key belongs_to(:many) option is " \
+                        "deprecated since 1.1.0. Use :primary_key instead.")
+            ActiveSupport::Deprecation.warn(message)
+            opts[:primary_key_name] ||= foreign_key_name
+          end
+          opts[:primary_key_name] ||= dn_attribute
         else
           association_class = Association::BelongsTo
           opts[:foreign_key_name] ||= "#{association_id}_id"
@@ -92,15 +101,19 @@ module ActiveLdap
       #
       # Example:
       #   has_many :primary_members, :class_name => "User",
-      #            :primary_key => "gidNumber", # User#gidNumber
-      #            :foreign_key => "gidNumber"  # Group#gidNumber
+      #            :primary_key => "gidNumber", # Group#gidNumber
+      #            :foreign_key => "gidNumber"  # User#gidNumber
+      #            ## deprecated since 1.1.0. Those options
+      #            ## are inverted.
+      #            # :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]
         klass ||= (options[:class_name] || association_id.to_s).classify
-        foreign_key = options[:foreign_key] || "#{association_id}_id"
+        foreign_key = options[:foreign_key]
         primary_key = options[:primary_key]
         set_associated_class(association_id, klass)
 
@@ -112,9 +125,20 @@ module ActiveLdap
           :extend => options[:extend],
         }
         if opts[:wrap]
+          opts[:foreign_key_name] ||= "#{association_id}_id"
           association_class = Association::HasManyWrap
         else
           association_class = Association::HasMany
+          primary_key_name = opts[:primary_key_name]
+          foreign_key_name = opts[:foreign_key_name]
+          if primary_key_name != foreign_key_name and
+              !new.have_attribute?(primary_key_name)
+            message = _(":primary_key and :foreign_key has_many options are " \
+                        "inverted their mean since 1.1.0. Please invert them.")
+            ActiveSupport::Deprecation.warn(message)
+            opts[:foreign_key_name] = primary_key_name
+            opts[:primary_key_name] = foreign_key_name
+          end
         end
 
         association_accessor(association_id) do |target|

data/lib/active_ldap/attributes.rb

@@ -40,8 +40,11 @@ module ActiveLdap
         when Hash
           result = {}
           value.each do |k, v|
-            result[k] = remove_blank_value(v) || []
+            v = remove_blank_value(v)
+            next if v.nil?
+            result[k] = v
           end
+          result = nil if result.blank?
           result
         when Array
           result = []
@@ -50,6 +53,7 @@ module ActiveLdap
             next if v.nil?
             result << v
           end
+          result = nil if result.blank?
           result
         when String
           if /\A\s*\z/ =~ value

data/lib/active_ldap/base.rb

@@ -678,7 +678,17 @@ module ActiveLdap
     #   [ User.find("a"), User.find("b"), User.find("c") ] &
     #     [ User.find("a"), User.find("d") ] # => [ User.find("a") ]
     def hash
-      dn.hash
+      return super if @_hashing # workaround for GetText :<
+      _dn = nil
+      begin
+        @_hashing = true
+        _dn = dn
+      rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
+        return super
+      ensure
+        @_hashing = false
+      end
+      _dn.hash
     end
 
     def may
@@ -897,6 +907,7 @@ module ActiveLdap
     def to_xml(options={})
       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|
@@ -1151,6 +1162,7 @@ module ActiveLdap
       @dn_is_base = false
       @dn_split_value = nil
       @connection ||= nil
+      @_hashing = false
       clear_connection_based_cache
     end
 
@@ -1322,7 +1334,7 @@ module ActiveLdap
       ensure_update_dn
       dn_value = id
       if dn_value.nil?
-        format =_("%s's DN attribute (%s) isn't set")
+        format = _("%s's DN attribute (%s) isn't set")
         message = format % [self.inspect, dn_attribute]
         raise DistinguishedNameNotSetError.new, message
       end
@@ -1394,17 +1406,9 @@ module ActiveLdap
         value = self.class.remove_blank_value(value) || []
         next if v == value
 
-        # Create mod entries
-        if self.class.blank_value?(value)
-          # Since some types do not have equality matching rules,
-          # delete doesn't work
-          # Replacing with nothing is equivalent.
-          if !data.has_key?(k) and schema.attribute(k).binary_required?
-            value = [{'binary' => []}]
-          end
-        else
-          # Ditched delete then replace because attribs with no equality
-          # match rules will fails
+        if self.class.blank_value?(value) and
+            schema.attribute(k).binary_required?
+          value = [{'binary' => []}]
         end
         attributes.push([:replace, k, value])
       end

data/lib/active_ldap/configuration.rb

@@ -107,10 +107,9 @@ module ActiveLdap
             target.base = value.gsub(/['}{#]/, '')
           when :scope, :ldap_scope
             if key == :ldap_scope
-              logger.warning do
-                _(":ldap_scope configuration option is deprecated. " \
-                  "Use :scope instead.")
-              end
+              message = _(":ldap_scope configuration option is deprecated. " \
+                          "Use :scope instead.")
+              ActiveSupport::Deprecation.warn(message)
             end
             target.scope = value
             configuration[:scope] = value

data/lib/active_ldap/connection.rb

@@ -95,9 +95,9 @@ module ActiveLdap
           raise AdapterNotFound.new(adapter)
         end
         if config.has_key?(:ldap_scope)
-          logger.warning do
-            _(":ldap_scope connection option is deprecated. Use :scope instead.")
-          end
+          message = _(":ldap_scope connection option is deprecated. " \
+                      "Use :scope instead.")
+          ActiveSupport::Deprecation.warn(message)
           config[:scope] ||= config.delete(:ldap_scope)
         end
         config = remove_connection_related_configuration(config)

data/lib/active_ldap/get_text/parser.rb

@@ -11,7 +11,7 @@ module ActiveLdap
         configuration = default_configuration.merge(configuration)
 
         configuration = extract_options(configuration)
-        ActiveLdap::Base.establish_connection(configuration)
+        ActiveLdap::Base.setup_connection(configuration)
       end
 
       def parse(file, targets=[])
@@ -72,7 +72,9 @@ module ActiveLdap
           if File.exists?(configuration)
             require 'erb'
             require 'yaml'
-            configuration = YAML.load(ERB.new(File.read(configuration)).result)
+            erb = ERB.new(File.read(configuration))
+            erb.filename = configuration
+            configuration = YAML.load(erb.result)
           else
             ENV["RAILS_ENV"] = configuration
             require 'config/environment'

data/lib/active_ldap/helper.rb

@@ -29,5 +29,64 @@ module ActiveLdap
       Base.human_syntax_description(syntax)
     end
     alias_method(:lsd_, :ldap_syntax_description_gettext)
+
+    def ldap_field(type, object_name, method, options={})
+      case type
+      when "radio_button", "check_box", "text_area"
+        form_method = type
+      else
+        form_method = "#{type}_field"
+      end
+
+      object = options[:object]
+      if object.nil?
+        normalized_object_name = object_name.to_s.sub(/\[\](\])?$/, "\\1")
+        object = instance_variable_get("@#{normalized_object_name}")
+      end
+      values = object.nil? ? nil : object[method, true]
+      values = [nil] if values.blank?
+      required_ldap_options = options.delete(:ldap_options) || []
+      required_ldap_options.each do |required_ldap_option|
+        found = false
+        values.each do |value|
+          next unless value.is_a?(Hash)
+          if Hash.to_a[0].to_s == required_ldap_option.to_s
+            found = true
+            break
+          end
+        end
+        values << {required_ldap_option => ""} unless found
+      end
+
+      fields = []
+      collect_values = Proc.new do |value, ldap_options|
+        case value
+        when Hash
+          value.each do |k, v|
+            collect_values.call(v, ldap_options + [k])
+          end
+        when Array
+          value.each do |v|
+            collect_values.call(v, ldap_options)
+          end
+        else
+          id = "#{object_name}_#{method}"
+          name = "#{object_name}[#{method}][]"
+          ldap_options.collect.each do |ldap_option|
+            id << "_#{ldap_option}"
+            name << "[#{ldap_option}][]"
+          end
+          ldap_value_options = {:id => id, :name => name, :value => value}
+          field = send(form_method, object_name, method,
+                       ldap_value_options.merge(options))
+           if block_given?
+             field = yield(field, {:options => ldap_options, :value => value})
+           end
+          fields << field unless field.blank?
+        end
+      end
+      collect_values.call(values, [])
+      fields.join("\n")
+    end
   end
 end

data/lib/active_ldap/operations.rb

@@ -46,9 +46,9 @@ module ActiveLdap
         _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.")
-          end
+          message = _(":ldap_scope search option is deprecated. " \
+                      "Use :scope instead.")
+          ActiveSupport::Deprecation.warn(message)
           options[:scope] ||= options[:ldap_scope]
         end
         search_options = {
@@ -497,18 +497,23 @@ module ActiveLdap
         options[:connection].delete(dn, options)
       end
 
-      def delete_all(filter=nil, options={})
-        options = {:base => base, :scope => scope}.merge(options)
-        options = options.merge(:filter => filter) if filter
-        options[:connection] ||= connection
-        conn = options[:connection]
-        targets = conn.search(options).collect do |dn, attributes|
+      def delete_all(options_or_filter=nil, deprecated_options=nil)
+        if deprecated_options.nil?
+          if options_or_filter.is_a?(String)
+            options = {:filter => options_or_filter}
+          else
+            options = (options_or_filter || {}).dup
+          end
+        else
+          options = deprecated_options.merge(:filter => options_or_filter)
+        end
+        targets = search(options).collect do |dn, attributes|
           dn
         end.sort_by do |dn|
           dn.upcase.reverse
         end.reverse
 
-        conn.delete(targets)
+        options[:connection].delete(targets)
       end
     end
 

data/lib/active_ldap/xml.rb

@@ -1,4 +1,5 @@
 require 'erb'
+require 'builder'
 
 require 'active_ldap/ldif'
 
@@ -16,17 +17,18 @@ module ActiveLdap
 
       def to_s
         root = @options[:root]
-        result = "<#{root}>\n"
-        target_attributes.each do |key, values|
-          values = normalize_values(values).sort_by {|value, _| value}
-          if @schema.attribute(key).single_value?
-            result << "  #{serialize_attribute_value(key, *values[0])}\n"
-          else
-            result << serialize_attribute_values(key, values)
+        indent = @options[:indent] || 2
+        xml = @options[:builder] || Builder::XmlMarkup.new(:indent => indent)
+        xml.tag!(root) do
+          target_attributes.each do |key, values|
+            values = normalize_values(values).sort_by {|value, _| value}
+            if @schema.attribute(key).single_value?
+              serialize_attribute_value(xml, key, *values[0])
+            else
+              serialize_attribute_values(xml, key, values)
+            end
           end
         end
-        result << "</#{root}>\n"
-        result
       end
 
       private
@@ -77,36 +79,26 @@ module ActiveLdap
         targets
       end
 
-      def serialize_attribute_values(name, values)
-        return "" if values.blank?
+      def serialize_attribute_values(xml, name, values)
+        return if values.blank?
 
-        result = ""
         if name == "dn" or @options[:type].to_s.downcase == "ldif"
-          values.collect do |value, xml_attributes|
-            xml = serialize_attribute_value(name, value, xml_attributes)
-            result << "  #{xml}\n"
+          values.each do |value, xml_attributes|
+            serialize_attribute_value(xml, name, value, xml_attributes)
           end
         else
           plural_name = name.pluralize
-          result << "  <#{plural_name} type=\"array\">\n"
-          values.each do |value, xml_attributes|
-            xml = serialize_attribute_value(name, value, xml_attributes)
-            result << "    #{xml}\n"
+          attributes = @options[:skip_types] ? {} : {"type" => "array"}
+          xml.tag!(plural_name, attributes) do
+            values.each do |value, xml_attributes|
+              serialize_attribute_value(xml, name, value, xml_attributes)
+            end
           end
-          result << "  </#{plural_name}>\n"
         end
-        result
       end
 
-      def serialize_attribute_value(name, value, xml_attributes)
-        if xml_attributes.blank?
-          xml_attributes = ""
-        else
-          xml_attributes = " " + xml_attributes.collect do |n, v|
-            "#{ERB::Util.h(n)}=\"#{ERB::Util.h(v)}\""
-          end.join(" ")
-        end
-        "<#{name}#{xml_attributes}>#{ERB::Util.h(value)}</#{name}>"
+      def serialize_attribute_value(xml, name, value, xml_attributes)
+        xml.tag!(name, value, xml_attributes)
       end
     end