activeldap 1.0.2 → 1.0.9

data/lib/active_ldap/ldif.rb

@@ -32,7 +32,10 @@ module ActiveLdap
 
       module_function
       def binary_value?(value)
-        if /\A#{Parser::SAFE_STRING}\z/u =~ value
+        if value.respond_to?(:encoding)
+          return true if value.encoding == Encoding.find("ascii-8bit")
+        end
+        if /\A#{Parser::SAFE_STRING}\z/ =~ value
           false
         else
           true
@@ -45,7 +48,7 @@ module ActiveLdap
 
         if value[-1, 1] == ' ' or binary_value?(value)
           result << ":"
-          value = [value].pack("m").gsub(/\n/u, '')
+          value = [value].pack("m").gsub(/\n/, '')
         end
         result << " "
 
@@ -61,7 +64,7 @@ module ActiveLdap
         result << "#{first_line_value}\n"
         return result if rest_value.nil?
 
-        rest_value.scan(/.{1,#{SIZE - 1}}/u).each do |line|
+        rest_value.scan(/.{1,#{SIZE - 1}}/).each do |line| # FIXME
           result << " #{line}\n"
         end
         result
@@ -95,19 +98,19 @@ module ActiveLdap
         @source = source
       end
 
-      ATTRIBUTE_TYPE_CHARS = /[a-zA-Z][a-zA-Z0-9\-]*/u
-      SAFE_CHAR = /[\x01-\x09\x0B-\x0C\x0E-\x7F]/u
-      SAFE_INIT_CHAR = /[\x01-\x09\x0B-\x0C\x0E-\x1F\x21-\x39\x3B\x3D-\x7F]/u
-      SAFE_STRING = /#{SAFE_INIT_CHAR}#{SAFE_CHAR}*/u
-      FILL = / */u
+      ATTRIBUTE_TYPE_CHARS = /[a-zA-Z][a-zA-Z0-9\-]*/
+      SAFE_CHAR = /[\x01-\x09\x0B-\x0C\x0E-\x7F]/
+      SAFE_INIT_CHAR = /[\x01-\x09\x0B-\x0C\x0E-\x1F\x21-\x39\x3B\x3D-\x7F]/
+      SAFE_STRING = /#{SAFE_INIT_CHAR}#{SAFE_CHAR}*/
+      FILL = / */
       def parse
         return @ldif if @ldif
 
         @scanner = Scanner.new(@source)
-        raise version_spec_is_missing unless @scanner.scan(/version:/u)
+        raise version_spec_is_missing unless @scanner.scan(/version:/)
         @scanner.scan(FILL)
 
-        version = @scanner.scan(/\d+/u)
+        version = @scanner.scan(/\d+/)
         raise version_number_is_missing if version.nil?
 
         version = Integer(version)
@@ -122,13 +125,19 @@ module ActiveLdap
 
       private
       def read_base64_value
-        value = @scanner.scan(/[a-zA-Z0-9\+\/=]+/u)
+        value = @scanner.scan(/[a-zA-Z0-9\+\/=]+/)
         return nil if value.nil?
-        value.unpack("m")[0].chomp
+        encoding = value.encoding if value.respond_to?(:encoding)
+        value = value.unpack("m")[0].chomp
+        if value.respond_to?(:force_encoding)
+          value.force_encoding(encoding)
+          value.force_encoding("ascii-8bit") unless value.valid_encoding?
+        end
+        value
       end
 
       def read_external_file
-        uri_string = @scanner.scan(URI::REGEXP::ABS_URI)
+        uri_string = @scanner.scan(URI::ABS_URI)
         raise uri_is_missing if uri_string.nil?
         uri = nil
         begin
@@ -138,7 +147,7 @@ module ActiveLdap
         end
 
         if uri.scheme == "file"
-          File.open(uri.path, "rb").read
+          File.open(uri.path, "rb") {|file| file.read}
         else
           uri.read
         end
@@ -196,7 +205,7 @@ module ActiveLdap
 
       def parse_options
         options = []
-        while @scanner.scan(/;/u)
+        while @scanner.scan(/;/)
           option = @scanner.scan(ATTRIBUTE_TYPE_CHARS)
           raise option_is_missing if option.nil?
           options << option
@@ -205,11 +214,11 @@ module ActiveLdap
       end
 
       def parse_attribute_value(accept_external_file=true)
-        raise attribute_value_separator_is_missing if @scanner.scan(/:/u).nil?
-        if @scanner.scan(/:/u)
+        raise attribute_value_separator_is_missing if @scanner.scan(/:/).nil?
+        if @scanner.scan(/:/)
           @scanner.scan(FILL)
           read_base64_value
-        elsif accept_external_file and @scanner.scan(/</u)
+        elsif accept_external_file and @scanner.scan(/</)
           @scanner.scan(FILL)
           read_external_file
         else
@@ -219,16 +228,16 @@ module ActiveLdap
       end
 
       def parse_control
-        return nil if @scanner.scan(/control:/u).nil?
+        return nil if @scanner.scan(/control:/).nil?
         @scanner.scan(FILL)
-        type = @scanner.scan(/\d+(?:\.\d+)*/u)
+        type = @scanner.scan(/\d+(?:\.\d+)*/)
         raise control_type_is_missing if type.nil?
         criticality = nil
-        if @scanner.scan(/ +/u)
-          criticality = @scanner.scan(/true|false/u)
+        if @scanner.scan(/ +/)
+          criticality = @scanner.scan(/true|false/)
           raise criticality_is_missing if criticality.nil?
         end
-        value = parse_attribute_value if @scanner.check(/:/u)
+        value = parse_attribute_value if @scanner.check(/:/)
         raise separator_is_missing unless @scanner.scan_separator
         ChangeRecord::Control.new(type, criticality, value)
       end
@@ -244,11 +253,11 @@ module ActiveLdap
       end
 
       def parse_change_type
-        return nil unless @scanner.scan(/changetype:/u)
+        return nil unless @scanner.scan(/changetype:/)
         @scanner.scan(FILL)
         type = @scanner.check(ATTRIBUTE_TYPE_CHARS)
         raise change_type_value_is_missing if type.nil?
-        unless @scanner.scan(/add|delete|modrdn|moddn|modify/u)
+        unless @scanner.scan(/add|delete|modrdn|moddn|modify/)
           raise unknown_change_type(type)
         end
 
@@ -257,20 +266,20 @@ module ActiveLdap
       end
 
       def parse_modify_name_record(klass, dn, controls)
-        raise new_rdn_mark_is_missing unless @scanner.scan(/newrdn\b/u)
+        raise new_rdn_mark_is_missing unless @scanner.scan(/newrdn\b/)
         new_rdn = parse_attribute_value(false)
         raise new_rdn_value_is_missing if new_rdn.nil?
         raise separator_is_missing unless @scanner.scan_separator
 
-        unless @scanner.scan(/deleteoldrdn:/u)
+        unless @scanner.scan(/deleteoldrdn:/)
           raise delete_old_rdn_mark_is_missing
         end
         @scanner.scan(FILL)
-        delete_old_rdn = @scanner.scan(/[01]/u)
+        delete_old_rdn = @scanner.scan(/[01]/)
         raise delete_old_rdn_value_is_missing if delete_old_rdn.nil?
         raise separator_is_missing unless @scanner.scan_separator
 
-        if @scanner.scan(/newsuperior\b/u)
+        if @scanner.scan(/newsuperior\b/)
           @scanner.scan(FILL)
           new_superior = parse_attribute_value(false)
           raise new_superior_value_is_missing if new_superior.nil?
@@ -281,16 +290,16 @@ module ActiveLdap
       end
 
       def parse_modify_spec
-        return nil unless @scanner.check(/(#{ATTRIBUTE_TYPE_CHARS}):/u)
+        return nil unless @scanner.check(/(#{ATTRIBUTE_TYPE_CHARS}):/)
         type = @scanner[1]
-        unless @scanner.scan(/(?:add|delete|replace):/u)
+        unless @scanner.scan(/(?:add|delete|replace):/)
           raise unknown_modify_type(type)
         end
         @scanner.scan(FILL)
         attribute, options = parse_attribute_description
         raise separator_is_missing unless @scanner.scan_separator
-        attributes = parse_attributes {@scanner.check(/-/u)}
-        raise modify_spec_separator_is_missing unless @scanner.scan(/-/u)
+        attributes = parse_attributes {@scanner.check(/-/)}
+        raise modify_spec_separator_is_missing unless @scanner.scan(/-/)
         raise separator_is_missing unless @scanner.scan_separator
         [type, attribute, options, attributes]
       end
@@ -335,18 +344,18 @@ module ActiveLdap
       end
 
       def parse_record
-        raise dn_mark_is_missing unless @scanner.scan(/dn:/u)
-        if @scanner.scan(/:/u)
+        raise dn_mark_is_missing unless @scanner.scan(/dn:/)
+        if @scanner.scan(/:/)
           @scanner.scan(FILL)
           dn = read_base64_value
           raise dn_is_missing if dn.nil?
           dn = parse_dn(dn)
         else
           @scanner.scan(FILL)
-          dn = @scanner.scan(/#{SAFE_STRING}$/u)
+          dn = @scanner.scan(/#{SAFE_STRING}$/)
           if dn.nil?
             partial_dn = @scanner.scan(SAFE_STRING)
-            raise dn_has_invalid_character(@scanner.check(/./u)) if partial_dn
+            raise dn_has_invalid_character(@scanner.check(/./)) if partial_dn
             raise dn_is_missing
           end
           dn = parse_dn(dn)
@@ -485,8 +494,8 @@ module ActiveLdap
     end
 
     class Scanner
-      SEPARATOR = /(?:\r\n|\n)/u
-      SEPARATORS = /(?:(?:^#.*)?#{SEPARATOR})+/u
+      SEPARATOR = /(?:\r\n|\n)/
+      SEPARATORS = /(?:(?:^#.*)?#{SEPARATOR})+/
 
       def initialize(source)
         @source = source
@@ -543,7 +552,7 @@ module ActiveLdap
         _consumed_source = consumed_source
         return 1 if _consumed_source.empty?
 
-        n = _consumed_source.to_a.size
+        n = Compatible.string_to_lines(_consumed_source).size
         n += 1 if _consumed_source[-1, 1] == "\n"
         n
       end
@@ -556,21 +565,27 @@ module ActiveLdap
       end
 
       def position
-        @scanner.pos - (@sub_scanner.string.length - @sub_scanner.pos)
+        sub_scanner_string = @sub_scanner.string
+        if sub_scanner_string.respond_to?(:bytesize)
+          sub_scanner_string_size = sub_scanner_string.bytesize
+        else
+          sub_scanner_string_size = sub_scanner_string.size
+        end
+        @scanner.pos - (sub_scanner_string_size - @sub_scanner.pos)
       end
 
       private
       def next_segment
         loop do
-          segment = @scanner.scan(/.+(?:#{SEPARATOR} .*)*#{SEPARATOR}?/u)
+          segment = @scanner.scan(/.+(?:#{SEPARATOR} .*)*#{SEPARATOR}?/)
           return @sub_scanner if segment.nil?
           next if segment[0, 1] == "#"
-          return StringScanner.new(segment.gsub(/\r?\n /u, ''))
+          return StringScanner.new(segment.gsub(/\r?\n /, ''))
         end
       end
 
       def consumed_source
-        @source[0,  position]
+        @source[0, position]
       end
     end
 

data/lib/active_ldap/operations.rb

@@ -62,18 +62,18 @@ module ActiveLdap
         }
 
         options[:connection] ||= connection
-        options[:connection].search(search_options) do |dn, attrs|
+        values = options[:connection].search(search_options) do |dn, attrs|
           attributes = {}
-          attrs.each do |key, value|
+          attrs.each do |key, _value|
             normalized_attr, normalized_value =
-              normalize_attribute_options(key, value)
+              normalize_attribute_options(key, _value)
             attributes[normalized_attr] ||= []
             attributes[normalized_attr].concat(normalized_value)
           end
-          value = [dn, attributes]
-          value = yield(value) if block_given?
-          value
+          [dn, attributes]
         end
+        values = values.collect {|_value| yield(_value)} if block_given?
+        values
       end
 
       def exist?(dn, options={})
@@ -196,14 +196,18 @@ module ActiveLdap
       #
       # Finds the first match for value where |value| is the value of some
       # |field|, or the wildcard match. This is only useful for derived classes.
-      # usage: Subclass.find(:attribute => "cn", :value => "some*val")
-      #        Subclass.find('some*val')
+      # usage: Subclass.find(:all, :attribute => "cn", :value => "some*val")
+      #        Subclass.find(:all, 'some*val')
       def find(*args)
         options = extract_options_from_args!(args)
         args = [:first] if args.empty? and !options.empty?
         case args.first
         when :first
+          options[:value] ||= args[1]
           find_initial(options)
+        when :last
+          options[:value] ||= args[1]
+          find_last(options)
         when :all
           options[:value] ||= args[1]
           find_every(options)
@@ -212,11 +216,38 @@ module ActiveLdap
         end
       end
 
+      # A convenience wrapper for <tt>find(:first,
+      # *args)</tt>. You can pass in all the same arguments
+      # to this method as you can to <tt>find(:first)</tt>.
+      def first(*args)
+        find(:first, *args)
+      end
+
+      # A convenience wrapper for <tt>find(:last,
+      # *args)</tt>. You can pass in all the same arguments
+      # to this method as you can to <tt>find(:last)</tt>.
+      def last(*args)
+        find(:last, *args)
+      end
+
+      # This is an alias for find(:all).  You can pass in
+      # all the same arguments to this method as you can
+      # to find(:all)
+      def all(*args)
+        find(:all, *args)
+      end
+
       private
       def find_initial(options)
         find_every(options.merge(:limit => 1)).first
       end
 
+      def find_last(options)
+        order = options[:order] || self.order || 'ascend'
+        order = normalize_sort_order(order) == :ascend ? :descend : :ascend
+        find_initial(options.merge(:order => order))
+      end
+
       def normalize_sort_order(value)
         case value.to_s
         when /\Aasc(?:end)?\z/i
@@ -509,9 +540,9 @@ module ActiveLdap
         if dn.is_a?(Array)
           i = -1
           dns = dn
-          dns.collect do |dn|
+          dns.collect do |_dn|
             i += 1
-            update(dn, attributes[i], options)
+            update(_dn, attributes[i], options)
           end
         else
           object = find(dn, options)

data/lib/active_ldap/schema.rb

@@ -1,7 +1,9 @@
 module ActiveLdap
   class Schema
+    include GetTextSupport
+
     def initialize(entries)
-      @entries = default_entries.merge(entries || {})
+      @entries = normalize_entries(entries || {})
       @schema_info = {}
       @class_attributes_info = {}
       @cache = {}
@@ -123,6 +125,12 @@ module ActiveLdap
       end
     end
 
+    def dit_content_rule_attribute(name, attribute_name)
+      cache([:dit_content_rule_attribute, name, attribute_name]) do
+        fetch("dITContentRules", name, attribute_name)
+      end
+    end
+
     def ldap_syntax(name)
       cache([:ldap_syntax, name]) do
         Syntax.new(name, self)
@@ -143,6 +151,17 @@ module ActiveLdap
       end
     end
 
+    def dump(output=nil)
+      require 'pp'
+      output ||= STDOUT
+      if output.respond_to?(:write)
+        PP.pp(@entries, output)
+      else
+        open(output, "w") {|out| PP.pp(@entries, out)}
+      end
+      nil
+    end
+
     private
     def cache(key)
       (@cache[key] ||= [yield])[0]
@@ -242,9 +261,23 @@ module ActiveLdap
         "objectClasses" => [],
         "attributeTypes" => [],
         "ldapSyntaxes" => [],
+        "dITContentRules" => [],
+        "matchingRules" => [],
       }
     end
 
+    def normalize_entries(entries)
+      normalized_entries = default_entries
+      normalized_keys = normalized_entries.keys
+      entries.each do |name, values|
+        normalized_name = normalized_keys.find do |key|
+          key.downcase == name
+        end
+        normalized_entries[normalized_name || name] = values
+      end
+      normalized_entries
+    end
+
     class Entry
       include Comparable
 
@@ -260,11 +293,12 @@ module ActiveLdap
 
       def eql?(other)
         self.class == other.class and
-          id == other.id
+          (id == other.id or
+           (id.nil? and other.nil? and name == other.name))
       end
 
       def hash
-        id.hash
+        id.nil? ? name.hash : id.hash
       end
 
       def <=>(other)
@@ -615,9 +649,9 @@ module ActiveLdap
       def collect_attributes
         must = attribute('MUST').reject do |name|
           UNWRITABLE_MUST_ATTRIBUTES.include?(name)
-        end
+        end.uniq
         must = must.collect {|name| @schema.attribute(name)}
-        may = attribute('MAY').collect {|name| @schema.attribute(name)}
+        may = attribute('MAY').uniq.collect {|name| @schema.attribute(name)}
 
         all_must = must.dup
         all_may = may.dup
@@ -634,7 +668,8 @@ module ActiveLdap
       end
 
       def attribute(attribute_name, name=@name)
-        @schema.object_class_attribute(name, attribute_name)
+        @schema.object_class_attribute(name, attribute_name) +
+          @schema.dit_content_rule_attribute(name, attribute_name)
       end
     end
   end

data/lib/active_ldap/user_password.rb

@@ -1,6 +1,6 @@
 require 'English'
-require 'md5'
-require 'sha1'
+require 'digest/md5'
+require 'digest/sha1'
 
 module ActiveLdap
   module UserPassword
@@ -43,7 +43,7 @@ module ActiveLdap
     end
 
     def md5(password)
-      "{MD5}#{[MD5.md5(password).digest].pack('m').chomp}"
+      "{MD5}#{[Digest::MD5.digest(password)].pack('m').chomp}"
     end
 
     def smd5(password, salt=nil)
@@ -51,7 +51,7 @@ module ActiveLdap
         raise ArgumentError, _("salt size must be == 4: %s") % salt.inspect
       end
       salt ||= Salt.generate(4)
-      md5_hash_with_salt = "#{MD5.md5(password + salt).digest}#{salt}"
+      md5_hash_with_salt = "#{Digest::MD5.digest(password + salt)}#{salt}"
       "{SMD5}#{[md5_hash_with_salt].pack('m').chomp}"
     end
 
@@ -60,7 +60,7 @@ module ActiveLdap
     end
 
     def sha(password)
-      "{SHA}#{[SHA1.sha1(password).digest].pack('m').chomp}"
+      "{SHA}#{[Digest::SHA1.digest(password)].pack('m').chomp}"
     end
 
     def ssha(password, salt=nil)
@@ -68,7 +68,7 @@ module ActiveLdap
         raise ArgumentError, _("salt size must be == 4: %s") % salt.inspect
       end
       salt ||= Salt.generate(4)
-      sha1_hash_with_salt = "#{SHA1.sha1(password + salt).digest}#{salt}"
+      sha1_hash_with_salt = "#{Digest::SHA1.digest(password + salt)}#{salt}"
       "{SSHA}#{[sha1_hash_with_salt].pack('m').chomp}"
     end
 
@@ -77,7 +77,7 @@ module ActiveLdap
     end
 
     module Salt
-      CHARS = ['.', '/', '0'..'9', 'A'..'Z', 'a'..'z'].collect do |x|
+      CHARS = ['.', '/'] + ['0'..'9', 'A'..'Z', 'a'..'z'].collect do |x|
         x.to_a
       end.flatten
 

data/lib/active_ldap/validations.rb

@@ -1,5 +1,3 @@
-require 'active_record/validations'
-
 module ActiveLdap
   module Validations
     def self.append_features(base)
@@ -84,7 +82,10 @@ module ActiveLdap
         return
       end
       if _dn and exist?
-        format = _("is duplicated: %s")
+        format = _("%{fn} is duplicated: %s")
+        unless ActiveLdap.get_text_supported?
+          format = format.sub(/^%\{fn\} /, '')
+        end
         errors.add("dn", format % _dn)
       end
     end
@@ -92,9 +93,13 @@ module ActiveLdap
     def validate_dn
       dn
     rescue DistinguishedNameInvalid
-      errors.add("dn", _("is invalid: %s") % $!.message)
+      format = _("%{fn} is invalid: %s")
+      format = format.sub(/^%\{fn\} /, '') unless ActiveLdap.get_text_supported?
+      errors.add("dn", format % $!.message)
     rescue DistinguishedNameNotSetError
-      errors.add("dn", _("isn't set: %s") % $!.message)
+      format = _("%{fn} isn't set: %s")
+      format = format.sub(/^%\{fn\} /, '') unless ActiveLdap.get_text_supported?
+      errors.add("dn", format % $!.message)
     end
 
     def validate_excluded_classes
@@ -112,9 +117,10 @@ module ActiveLdap
       names = unexpected_classes.collect do |object_class|
         self.class.human_object_class_name(object_class)
       end
-      format = n_("has excluded value: %s",
-                  "has excluded values: %s",
+      format = n_("%{fn} has excluded value: %s",
+                  "%{fn} has excluded values: %s",
                   names.size)
+      format = format.sub(/^%\{fn\} /, '') unless ActiveLdap.get_text_supported?
       errors.add("objectClass", format % names.join(", "))
     end
 
@@ -143,12 +149,15 @@ module ActiveLdap
           end
           args = [self.class.human_object_class_name(object_class)]
           if aliases.empty?
-            format = _("is required attribute by objectClass '%s'")
+            format = _("%{fn} is required attribute by objectClass '%s'")
           else
-            format = _("is required attribute by objectClass " \
+            format = _("%{fn} is required attribute by objectClass " \
                        "'%s': aliases: %s")
             args << aliases.join(', ')
           end
+          unless ActiveLdap.get_text_supported?
+            format = format.sub(/^%\{fn\} /, '')
+          end
           errors.add(real_name, format % args)
         end
       end
@@ -157,7 +166,7 @@ module ActiveLdap
     def validate_ldap_values
       entry_attribute.schemata.each do |name, attribute|
         value = self[name]
-        next if value.blank?
+        next if self.class.blank_value?(value)
         validate_ldap_value(attribute, name, value)
       end
     end
@@ -169,11 +178,14 @@ module ActiveLdap
                 self.class.human_syntax_description(attribute.syntax),
                 failed_reason]
       if option
-        format = _("(%s) has invalid format: %s: required syntax: %s: %s")
+        format = _("%{fn}(%s) has invalid format: %s: required syntax: %s: %s")
       else
-        format = _("has invalid format: %s: required syntax: %s: %s")
+        format = _("%{fn} has invalid format: %s: required syntax: %s: %s")
       end
       params.unshift(option) if option
+      unless ActiveLdap.get_text_supported?
+        format = format.sub(/^%\{fn\} ?/, '')
+      end
       errors.add(name, format % params)
     end
   end

data/lib/active_ldap/xml.rb

@@ -5,7 +5,7 @@ require 'active_ldap/ldif'
 module ActiveLdap
   class Xml
     class Serializer
-      PRINTABLE_STRING = /[\x20-\x7e\w\s]*/um
+      PRINTABLE_STRING = /[\x20-\x7e\w\s]*/
 
       def initialize(dn, attributes, schema, options={})
         @dn = dn
@@ -64,7 +64,7 @@ module ActiveLdap
             targets.concat(normalize_value(real_value, options))
           end
         else
-          if /\A#{PRINTABLE_STRING}\z/u !~ value
+          if /\A#{PRINTABLE_STRING}\z/ !~ value
             value = [value].pack("m").gsub(/\n/u, '')
             options += ["base64"]
           end