ruby-activeldap 0.4.4 → 0.5.0

data/lib/activeldap/associations.rb

@@ -75,7 +75,7 @@ module ActiveLDAP
       key = options[:foreign_key]  || association_id.to_s + "_id"
       local_key = options[:local_key] || ''
       class_eval <<-"end_eval"
-        def #{association_id}(objects = false)
+        def #{association_id}(objects = true)
           local_key = "#{local_key}"
           local_key = dnattr() if local_key.empty?
           return #{klass}.find_all(:attribute => "#{key}", :value => attribute_method(local_key), :objects => objects)
@@ -100,7 +100,7 @@ module ActiveLDAP
       key = options[:local_key]  || association_id.to_s + "_id"
       foreign_key = options[:foreign_key] || ''
       class_eval <<-"end_eval"
-        def #{association_id}(objects = false)
+        def #{association_id}(objects = true)
           foreign_key = "#{foreign_key}"
           if foreign_key.empty?
             foreign_key = dnattr()

data/lib/activeldap/base.rb

@@ -74,6 +74,12 @@ module ActiveLDAP
   class ConnectionError < RuntimeError
   end
 
+  # ObjectClassError
+  #
+  # An exception raised when an objectClass is not defined in the schema
+  class ObjectClassError < RuntimeError
+  end
+
 
   # Base
   #
@@ -189,7 +195,7 @@ module ActiveLDAP
       # Setup default logger to console
       if @@logger.nil?
         @@logger = Log4r::Logger.new('activeldap')
-        @@logger.level = Log4r::FATAL
+        @@logger.level = Log4r::OFF
         Log4r::StderrOutputter.new 'console'
         @@logger.add('console')
       end
@@ -240,9 +246,8 @@ module ActiveLDAP
         raise ConnectionError, "#{detail.exception} - LDAP connection failure, or server does not support schema queries."
       end
 
-
       # Cleanly return
-      return nil
+      return true
     end # Base.connect
 
     # Base.close
@@ -387,7 +392,6 @@ module ActiveLDAP
       end
 
       # Allow a single string argument
-      attr = dnattr()
       objects = false
       val = config
       # Or a hash
@@ -487,9 +491,6 @@ module ActiveLDAP
       @ldap_data = {} # original ldap entry data
       @ldap_data.default = []
       @attr_methods = {} # list of valid method calls for attributes used for dereferencing
-      @must = {} # list of schema required attributes
-      @may = {} # list of schema optional attributes
-      @sup = {} # list of schema supplemental attributes
 
       # Break val apart if it is a dn
       if val.match(/^#{dnattr()}=([^,=]+),#{base()}$/i)
@@ -504,7 +505,7 @@ module ActiveLDAP
         @exists = false
         # Setup what should eb authoritative
         @dn = "#{dnattr()}=#{val},#{base()}"
-        send(:objectClass=, required_classes())
+        send(:apply_objectclass, required_classes())
       else # do a search then
         # Search for the existing entry
         begin
@@ -521,9 +522,9 @@ module ActiveLDAP
               @@logger.debug("finished make_subtypes for #{attr}")
               # Add subtype to any existing values
               if @ldap_data.has_key? safe_attr
-	        value.each do |v|
+                value.each do |v|
                   @ldap_data[safe_attr].push(v)
-		end
+                end
               else
                 @ldap_data[safe_attr] = value
               end
@@ -531,7 +532,7 @@ module ActiveLDAP
           end
           @exists = true
           # Populate schema data
-          send(:objectClass=, @ldap_data['objectClass'])
+          send(:apply_objectclass, @ldap_data['objectClass'])
 
           # Populate real data now that we have the schema with aliases
           @ldap_data.each do |pair|
@@ -542,10 +543,11 @@ module ActiveLDAP
           @exists = false
           # Create what should be the authoritative DN
           @dn = "#{dnattr()}=#{val},#{base()}"
-          send(:objectClass=, required_classes())
+          send(:apply_objectclass, required_classes())
 
           # Setup dn attribute (later rdn too!)
           attr_sym = "#{dnattr()}=".to_sym
+          @@logger.debug("new: setting dnattr: #{dnattr()} = #{val}")
           send(attr_sym, val)
         end
       end
@@ -560,79 +562,10 @@ module ActiveLDAP
     # attributes dynamically without schema awareness
     def attributes
       @@logger.debug("stub: attributes called")
+      send(:apply_objectclass, @data['objectClass']) if @data['objectClass'] != @last_oc
       return @attr_methods.keys
     end
 
-    # objectClass=
-    #
-    # objectClass= special case for updating appropriately
-    # This updates the objectClass entry in @data. It also
-    # updating all required and allowed attributes while
-    # removing defined attributes that are no longer valid
-    # given the new objectclasses.
-    def objectClass=(val)
-      @@logger.debug("stub: objectClass=(#{val.inspect}) called")
-      if val.class != Array
-        raise TypeError, 'objectClass must be an Array'
-      end
-
-      val.each do |klass|
-        unless klass.class == String
-          raise TypeError, "Value in array is not a String. (#{klass.class})"
-        end
-        unless Base.schema.names("objectClasses").member? klass
-          # TODO MAKE OWN EXCEPTION
-          raise RuntimeError, "objectClass '#{klass}' unknown to LDAP server"
-        end
-      end
-
-      # make sure this doesn't drop any of the required objectclasses
-      required_classes().each do |oc|
-        unless val.member? oc
-          raise "'#{oc}' must be a defined objectClass for class '#{self.class}'"
-        end
-      end
-
-      # Set the actual objectClass data
-      define_attribute_methods('objectClass')
-      @data['objectClass'] = val.uniq
-
-      # Build |data| from schema
-      # clear attr_method mapping first
-      @attr_methods = {}
-      @must = {}
-      @may = {}
-      @sup = {}
-      val.each do |objc|
-        # Setup dependencies for validation pre-save
-        @must[objc] = Base.schema.attr('objectClasses', objc, 'MUST')
-        @may[objc] = Base.schema.attr('objectClasses', objc, 'MAY')
-        @sup[objc] = Base.schema.attr('objectClasses', objc, 'SUP')
-        @must[objc] = [] if @must[objc].nil?
-        @may[objc] = [] if @may[objc].nil?
-        @sup[objc] = [] if @sup[objc].nil?
-
-        # setup the alias/attr method mapping for @must
-        @must[objc].each do |attr|
-          # Update attr_method with appropriate
-          define_attribute_methods(attr)
-        end
-
-        # setup the alias/attr method mapping for @may
-        @may[objc].each do |attr|
-          define_attribute_methods(attr)
-        end
-      end
-
-      # Delete all now invalid attributes given the new objectClasses
-      @data.keys.each do |key|
-        # If it's not a proper aliased attribute, drop it
-        unless @attr_methods.has_key? key
-          @data.delete(key)
-        end
-      end
-    end
-
     # exists?
     #
     # Return whether the entry exists in LDAP or not
@@ -654,15 +587,38 @@ module ActiveLDAP
     # Basic validation:
     # - Verify that every 'MUST' specified in the schema has a value defined
     # - Enforcement of undefined attributes is handled in the objectClass= method
+    # Must call enforce_types() first before enforcement can be guaranteed
     def validate
       @@logger.debug("stub: validate called")
-      @must.each do |oc|
-         oc[1].each do |req_attr|
-          # TODO: should I ever check if key exists? bug if it doesnt...
+      # Clean up attr values, etc
+      send(:enforce_types)
+
+      # Validate objectclass settings
+      @data['objectClass'].each do |klass|
+        unless klass.class == String
+          raise TypeError, "Value in objectClass array is not a String. (#{klass.class}:#{klass.inspect})"
+        end
+        unless Base.schema.names("objectClasses").member? klass
+          raise ObjectClassError, "objectClass '#{klass}' unknown to LDAP server."
+        end
+      end
+
+      # make sure this doesn't drop any of the required objectclasses
+      required_classes().each do |oc|
+        unless @data['objectClass'].member? oc.to_s
+          raise ObjectClassError, "'#{oc}' must be a defined objectClass for class '#{self.class}' as set in the ldap_mapping"
+        end
+      end
+
+      # Make sure all MUST attributes have a value
+      @data['objectClass'].each do |objc|
+        must = Base.schema.attr('objectClasses', objc, 'MUST')
+        may = Base.schema.attr('objectClasses', objc, 'MAY')
+        must.each do |req_attr|
           deref = @attr_methods[req_attr]
           if @data[deref] == []
             raise AttributeEmpty,
-              "objectClass '#{oc[0]}' requires attribute '#{Base.schema.attribute_aliases(req_attr).join(', ')}'"
+              "objectClass '#{objc}' requires attribute '#{Base.schema.attribute_aliases(req_attr).join(', ')}'"
           end
         end
       end
@@ -836,7 +792,7 @@ module ActiveLDAP
           @@logger.debug("#write: add successful")
           @exists = true
         rescue LDAP::ResultError => detail
-          raise WriteError, "Could not add LDAP entry[#{Base.conn.err2string(Base.conn.err)}]: #{detail}"
+          raise WriteError, "Could not add LDAP entry[#{Base.connection.err2string(Base.connection.err)}]: #{detail}"
         end
       end
       @@logger.debug("#write: resetting @ldap_data to a dup of @data")
@@ -855,15 +811,25 @@ module ActiveLDAP
     #       give tab completion in irb.
     def method_missing(name, *args)
       @@logger.debug("stub: called method_missing(#{name.inspect}, #{args.inspect})")
+
+      # dynamically update the available attributes without requiring an
+      # explicit call. The cache 'last_oc' saves a lot of cpu time.
+      if @data['objectClass'] != @last_oc
+        @@logger.debug("method_missing(#{name.inspect}, #{args.inspect}): updating apply_objectclass(#{@data['objectClass'].inspect})")
+        send(:apply_objectclass, @data['objectClass'])
+      end
       key = name.to_s
       case key
         when /^(\S+)=$/
           real_key = $1
+          @@logger.debug("method_missing: attr_methods has_key? #{real_key}")
           if @attr_methods.has_key? real_key
             raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" if args.size != 1
+            @@logger.debug("method_missing: calling :attribute_method=(#{real_key}, #{args[0]})")
             return send(:attribute_method=, real_key, args[0])
           end
         else
+          @@logger.debug("method_missing: attr_methods has_key? #{key}")
           if @attr_methods.has_key? key
             raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" if args.size > 1
             return attribute_method(key, *args)
@@ -872,29 +838,97 @@ module ActiveLDAP
       raise NoMethodError, "undefined method `#{key}' for #{self}"
     end
 
+    # Add available attributes to the methods
+    alias_method :__methods, :methods
+    def methods
+      return __methods + attributes()
+    end
+
 
      private
 
+      # enforce_types
+      #
+      # enforce_types applies your changes without attempting to write to LDAP. This means that
+      # if you set userCertificate to somebinary value, it will wrap it up correctly.
+      def enforce_types
+        @@logger.debug("stub: enforce_types called")
+        send(:apply_objectclass, @data['objectClass']) if @data['objectClass'] != @last_oc
+        # Enforce attribute value formatting
+        @data.keys.each do |key|
+          @data[key] = attribute_input_handler(key, @data[key])
+        end
+        @@logger.debug("stub: enforce_types done")
+        return true
+      end
+
+
+
+      # apply_objectclass
+      #
+      # objectClass= special case for updating appropriately
+      # This updates the objectClass entry in @data. It also
+      # updating all required and allowed attributes while
+      # removing defined attributes that are no longer valid
+      # given the new objectclasses.
+      def apply_objectclass(val)
+        @@logger.debug("stub: objectClass=(#{val.inspect}) called")
+        new_oc = val
+        new_oc = [val] if new_oc.class != Array
+        return new_oc if @last_oc == new_oc
+
+        # Store for caching purposes
+        @last_oc = new_oc.dup
+
+         # Set the actual objectClass data
+        define_attribute_methods('objectClass')
+        @data['objectClass'] = new_oc.uniq
+
+        # Build |data| from schema
+        # clear attr_method mapping first
+        @attr_methods = {}
+        attributes = []
+        new_oc.each do |objc|
+          # get all attributes for the class
+          attributes += Base.schema.class_attributes(objc.to_s)
+        end
+        attributes.uniq
+        attributes.each do |attr|
+            # Update attr_method with appropriate
+            define_attribute_methods(attr)
+        end
+
+        # Delete all now innew_ocid attributes given the new objectClasses
+        @data.keys.each do |key|
+          # If it's not a proper aliased attribute, drop it
+          unless @attr_methods.has_key? key
+            @data.delete(key)
+          end
+        end
+      end
+
+
+
      # Enforce typing:
      # Hashes are for subtypes
      # Arrays are for multiple entries
      def attribute_input_handler(attr, value)
        @@logger.debug("stub: called attribute_input_handler(#{attr.inspect}, #{value.inspect})")
        if attr.nil?
-         raise RuntimeError, 'attr argument must not be nil.'
+         raise RuntimeError, 'The first argument, attr, must not be nil. Please report this as a bug!'
        end
        binary = Base.schema.binary_required? attr
        single = Base.schema.single_value? attr
        case value.class.to_s
          when 'Array'
            if single and value.size > 1
-             raise TypeError, "This attribute can only have a single value"
+             raise TypeError, "Attribute #{attr} can only have a single value"
            end
            value.map! do |entry|
-	     if entry.class != Hash
-	       @@logger.debug("coercing value for #{attr} into a string because nested values exceeds a useful depth: #{entry.inspect} -> #{entry.to_s}")
-	       entry = entry.to_s
-	     end
+             if entry.class != Hash
+               @@logger.debug("coercing value for #{attr} into a string because nested values exceeds a useful depth: #{entry.inspect} -> #{entry.to_s}")
+               entry = entry.to_s
+             end
              entry = attribute_input_handler(attr, entry)[0]
            end
          when 'Hash'
@@ -1073,38 +1107,31 @@ module ActiveLDAP
      # attribute_method
      #
      # Return the value of the attribute called by method_missing?
-     def attribute_method(method, arrays = false)
-       @@logger.debug("stub: called attribute_method(#{method.inspect}, #{arrays.inspect}")
+     def attribute_method(method, not_array = false)
+       @@logger.debug("stub: called attribute_method(#{method.inspect}, #{not_array.inspect}")
        attr = @attr_methods[method]
 
        # Return a copy of the stored data
-       return @data[attr].dup if arrays
-       return array_of(@data[attr].dup, false)
+       return array_of(@data[attr].dup, false) if not_array
+       return @data[attr]
      end
 
 
      # attribute_method=
      #
      # Set the value of the attribute called by method_missing?
-     def attribute_method=(method, arg)
-       @@logger.debug("stub: called attribute_method=(#{method.inspect}, #{arg.inspect}")
-       # Copy input
-       begin
-         value = arg.dup
-       rescue TypeError
-         value = arg.to_s
-       end
-
+     def attribute_method=(method, value)
+       @@logger.debug("stub: called attribute_method=(#{method.inspect}, #{value.inspect})")
        # Get the attr and clean up the input
        attr = @attr_methods[method]
-       value = attribute_input_handler(attr, value)
-
+       @@logger.debug("attribute_method=(#{method.inspect}, #{value.inspect}): method maps to #{attr}")
+       #value = attribute_input_handler(attr, value)
        # Assign the value 
        @data[attr] = value
 
        # Return a copy of what got saved
        @@logger.debug("stub: exitting attribute_method=")
-       return @data[attr].dup
+       return @data[attr]
      end
 
     
@@ -1119,8 +1146,10 @@ module ActiveLDAP
        end
        aliases = Base.schema.attribute_aliases(attr)
        aliases.each do |ali|
+         @@logger.debug("associating #{ali} --> #{attr}")
          @attr_methods[ali] = attr
        end
+       @@logger.debug("stub: leaving define_attribute_methods(#{attr.inspect})")
      end
 
     # array_of

data/lib/activeldap/schema2.rb

@@ -3,8 +3,9 @@ require 'ldap/schema'
 
 module LDAP
   class Schema2 < Schema
-    @@cache = {}
-  
+    @@attr_cache = {}
+    @@class_cache = {}
+
     # attr
     # 
     # This is just like LDAP::Schema#attr except that it allows
@@ -18,19 +19,19 @@ module LDAP
       return '' if at.empty?
 
       # Check already parsed options first
-      if @@cache.has_key? sub \
-        and @@cache[sub].has_key? type \
-        and @@cache[sub][type].has_key? at
-          return @@cache[sub][type][at].dup
+      if @@attr_cache.has_key? sub \
+        and @@attr_cache[sub].has_key? type \
+        and @@attr_cache[sub][type].has_key? at
+          return @@attr_cache[sub][type][at].dup
       end
 
       # Initialize anything that is required
-      unless @@cache.has_key? sub
-        @@cache[sub] = {}
+      unless @@attr_cache.has_key? sub
+        @@attr_cache[sub] = {}
       end
       
-      unless @@cache[sub].has_key? type
-        @@cache[sub][type] = {}
+      unless @@attr_cache[sub].has_key? type
+        @@attr_cache[sub][type] = {}
       end
 
       at = at.upcase
@@ -47,31 +48,31 @@ module LDAP
         multi = ''
         case line
           when /#{at}\s+[\)A-Z]/
-            @@cache[sub][type][at] = ['TRUE']
+            @@attr_cache[sub][type][at] = ['TRUE']
             return ['TRUE']
           when /#{at}\s+'(.+?)'/
-            @@cache[sub][type][at] = [$1]
+            @@attr_cache[sub][type][at] = [$1]
             return [$1]
           when /#{at}\s+\((.+?)\)/
             multi = $1
           when /#{at}\s+\(([\w\d\s\.]+)\)/
             multi = $1
           when /#{at}\s+([\w\d\.]+)/
-            @@cache[sub][type][at] = [$1]
+            @@attr_cache[sub][type][at] = [$1]
             return [$1]
         end
         # Split up multiple matches
         # if oc then it is sep'd by $
         # if attr then bu spaces
         if multi.match(/\$/)
-          @@cache[sub][type][at] = multi.split("$").collect{|attr| attr.strip}
-          return @@cache[sub][type][at].dup
+          @@attr_cache[sub][type][at] = multi.split("$").collect{|attr| attr.strip}
+          return @@attr_cache[sub][type][at].dup
         elsif not multi.empty?
-          @@cache[sub][type][at] = multi.gsub(/'/, '').split(' ').collect{|attr| attr.strip}
-          return @@cache[sub][type][at].dup
+          @@attr_cache[sub][type][at] = multi.gsub(/'/, '').split(' ').collect{|attr| attr.strip}
+          return @@attr_cache[sub][type][at].dup
         end
       end
-      @@cache[sub][type][at] = []
+      @@attr_cache[sub][type][at] = []
       return []
     end
 
@@ -140,24 +141,63 @@ module LDAP
 
       return false
     end # binary_required?
+
+    # class_attributes
+    #
+    # Returns an Array of all the valid attributes (but not with full aliases)
+    # for the given objectClass
+    def class_attributes(objc)
+      if @@class_cache.has_key? objc
+        return @@class_cache[objc]
+      end
+
+      # First get all the current level attributes
+      @@class_cache[objc] = attr('objectClasses', objc, 'MUST') + attr('objectClasses', objc, 'MAY')
+
+      # Now add all attributes from the parent object (SUPerclasses)
+      # Hopefully an iterative approach will be pretty speedy
+      # 1. build complete list of SUPs
+      # 2. Add attributes from each
+      sups = attr('objectClasses', objc, 'SUP')
+      loop do 
+        start_size = sups.size
+	new_sups = []
+        sups.each do |sup|
+          new_sups += attr('objectClasses', sup, 'SUP')
+        end
+	sups += new_sups
+	sups = sups.uniq
+        break if sups.size == start_size
+      end
+      sups.each do |sup|
+        @@class_cache[objc] += attr('objectClasses', sup, 'MUST') + attr('objectClasses', sup, 'MAY')
+      end
+
+      # Clean out the dupes.
+      @@class_cache[objc] = @@class_cache[objc].uniq
+
+      # Return the cached value
+      return @@class_cache[objc].dup
+    end
+    
   end # Schema2
 
   class Conn
     def schema(base = nil, attrs = nil, sec = 0, usec = 0)
       attrs ||= [
-	'objectClasses',
-	'attributeTypes',
-	'matchingRules',
-	'matchingRuleUse',
-	'dITStructureRules',
-	'dITContentRules',
-	'nameForms',
-	'ldapSyntaxes',
+        'objectClasses',
+        'attributeTypes',
+        'matchingRules',
+        'matchingRuleUse',
+        'dITStructureRules',
+        'dITContentRules',
+        'nameForms',
+        'ldapSyntaxes',
       ]
       base ||= root_dse(['subschemaSubentry'], sec, usec)[0]['subschemaSubentry'][0]
       base ||= 'cn=schema'
       ent = search2(base, LDAP_SCOPE_BASE, '(objectClass=subschema)',
-		    attrs, false, sec, usec)
+                    attrs, false, sec, usec)
       return Schema2.new(ent[0])
     end
   end

data/lib/activeldap.rb

@@ -212,7 +212,8 @@
 # what classes are required when creating a new object.  Of course, you can leave
 # that field out to default to ['top'] only.  Then you can let each application
 # choose what objectClasses their objects should have by calling the method e.g.
-# Group#objectClass=(value).
+# Group#objectClass=(value) or by modifying the value returned by the accessor, 
+# e.g. Group#objectClass.
 #
 # Note that is can be very important to define the default :classes value. Due to
 # implementation choices with most LDAP servers, once an object is created, its
@@ -259,28 +260,26 @@
 # Group objects that a user is in.
 # 
 #   irb> me = User.new('drewry')
-#   => ...
 #   irb> me.groups
-#   => ["cdrom", "audio", "develop"]
-# 
-# Methods created with belongs_to also take an optional argument: objects. This
-# argument specifies whether it will return the value of the 'dnattr' of the
-# objects, or whether it will return Group objects.
-# 
-#   irb> me.groups(true)
 #   => [#<Group:0x000001 ...>, #<Group:0x000002 ...>, ...]
 #   irb> me.groups(true).each { |group| p group.cn };nil
 #   "cdrom"
 #   "audio"
 #   "develop"
 #   => nil
-# 
 #   (Note: nil is just there to make the output cleaner...)
 # 
+# Methods created with belongs_to also take an optional argument: objects. This
+# argument specifies whether it will return the value of the 'dnattr' of the
+# objects, or whether it will return Group objects. 
+# 
+#   irb> me.groups(false)
+#   => ["cdrom", "audio", "develop"]
+# 
 # TIP: If you weren't sure what the distinguished name attribute was for Group,
 # you could also do the following:
 # 
-#   irb> me.groups(true).each { |group| p group.dnattr };nil
+#   irb> me.groups.each { |group| p group.dnattr };nil
 #   "cdrom"
 #   "audio"
 #   "develop"
@@ -328,9 +327,9 @@
 #   irb> develop = Group.new('develop')
 #   => ...
 #   irb> develop.members
-#   => ["drewry", "builder"]
-#   irb> develop.members(true)
 #   => [#<User:0x000001 ...>, #<User:...>]
+#   irb> develop.members(false)
+#   => ["drewry", "builder"]
 # 
 # 
 # The arguments for has_many follow the exact same idea that belongs_to's
@@ -392,11 +391,13 @@
 #  * :base defaults to the base of the class this is executed from (as set in ldap_mapping)
 #  * :scope defaults to LDAP::LDAP_SCOPE_SUBTREE. Usually you won't need to change it
 #  * :attrs defaults to [] and is the list of attrs you want back. Empty means all of them.
-# 
+#
 # ==== #validate
 # 
 # validate is a method that verifies that all attributes that are required by the
-# objects current objectClasses are populated. This is called by #write prior to
+# objects current objectClasses are populated. This also will call the
+# private "#enforce_types" method. This will make sure that all values defined are
+# valid to be written to LDAP.  #validate is called by #write prior to
 # performing any action. Its explicit use in an application is unnecessary, and
 # it may become a private method in the future.
 # 
@@ -536,6 +537,11 @@
 # LDAP server could be created. Check you configuration.rb, Base.connect
 # arguments, and network connectivity! Also check your LDAP server logs to see
 # if it ever saw the request.
+#
+# ==== ObjectClassError
+#
+# This exception is raised when an object class is used that is not defined
+# in the schema.
 # 
 # === Others
 # 
@@ -752,26 +758,26 @@
 # and everything should work well.
 # 
 #
-# ==== Array results for everything
+# ==== Non-array results for single values
 #
-# Even though Ruby/ActiveLDAP tries to be convenient by returning Arrays only
-# when an LDAP object attribute has multiple values, sometimes this can be a
-# programmatic nightmare. If you would like to force all returned values to
-# come in Array form, just query like so:
+# Even though Ruby/ActiveLDAP attempts to maintain programmatic ease by 
+# returning Array values only. By specifying 'false' as an argument to 
+# any attribute method you will get back a String if it is single value.
+# This is useful when you are just dumping values for human reading.
+# Here's an example:
 #
 #   irb> user = User.new('drewry')
 #   => ...
-#   irb> user.cn(true)
-#   => ["Will Drewry"]
+#   irb> user.cn(false)
+#   => "Will Drewry"
 #
-# That's it. Now you can ALWAYS get Arrays back without having to write your own
-# wrappers.
+# That's it. Now you can make human-readable output faster.
 # 
 # ==== Dynamic attribute crawling
 # 
-# If you use tab completion in irb, you'll notice that you can't tab complete the
-# dynamic attributes available for each object. You can still see what's available with the method call
-# #attributes.
+# If you use tab completion in irb, you'll notice that you /can/ tab complete the dynamic 
+# attribute methods. You can still see which methods are for attributes using 
+# Base#attributes:
 # 
 #   irb> d = Group.new('develop')
 #   => ...
@@ -892,7 +898,7 @@ require 'activeldap/configuration'
 require 'activeldap/schema2'
 
 module ActiveLDAP
-  VERSION = "0.4.4"
+  VERSION = "0.5.0"
 end
 
 ActiveLDAP::Base.class_eval do

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: ruby-activeldap
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
-date: 2004-10-10
+  version: 0.5.0
+date: 2004-10-21
 summary: Ruby/ActiveLDAP is a object-oriented API to LDAP
 require_paths: 
   - lib