Fixes and test cases for Net::LDAP::Entry

 * Ensure Entry attributes can be appended using <<
 * Ensure Entry can be marshalled
 * Add test cases for the above
 * Re-factor a bit



git-svn-id: http://net-ldap.rubyforge.org/svn/trunk@288 005445c4-6811-0410-8301-cae4f0071d1d

Author: emiel

lib/net/ldap/entry.rb

@@ -75,17 +75,27 @@ class Entry
 
     # This constructor is not generally called by user code.
     #--
-    # Originally, myhash took a block so we wouldn't have to
+    # Originally, attributes took a block so we wouldn't have to
     # make sure its elements returned empty arrays when necessary.
     # Got rid of that to enable marshalling of Entry objects,
     # but that doesn't work anyway, because Entry objects have
     # singleton methods. So we define a custom dump and load.
-    def initialize dn = nil # :nodoc:
-      @myhash = {} # originally: Hash.new {|k,v| k[v] = [] }
-      @myhash[:dn] = [dn]
+    def initialize( dn = nil ) # :nodoc:
+      @attributes = {} # originally: Hash.new {|k,v| k[v] = [] }
+      @attributes[:dn] = [dn]
     end
 
-    def _dump depth
+    def attributes
+      @attributes
+    end
+
+    protected :attributes
+
+    def ==( other )
+      self.attributes == other.attributes
+    end
+
+    def _dump( depth )
       to_ldif
     end
 
@@ -98,21 +108,20 @@ def _load entry
     #--
     # Discovered bug, 26Aug06: I noticed that we're not converting the
     # incoming value to an array if it isn't already one.
-    def []= name, value # :nodoc:
+    def []=( name, value ) # :nodoc:
       sym = name.to_s.downcase.intern
       value = [value] unless value.is_a?(Array)
-      @myhash[sym] = value
+      @attributes[sym] = value
     end
 
-
     #--
     # We have to deal with this one as we do with []=
     # because this one and not the other one gets called
     # in formulations like entry["CN"] << cn.
     #
-    def [] name # :nodoc:
+    def []( name ) # :nodoc:
       name = name.to_s.downcase.intern unless name.is_a?(Symbol)
-      @myhash[name] || []
+      @attributes[name] || @attributes[name] = []
     end
 
     # Returns the dn of the Entry as a String.
@@ -122,7 +131,7 @@ def dn
 
     # Returns an array of the attribute names present in the Entry.
     def attribute_names
-      @myhash.keys
+      @attributes.keys
     end
 
     # Accesses each of the attributes present in the Entry.
@@ -133,17 +142,15 @@ def attribute_names
     #
     def each
       if block_given?
-        attribute_names.each {|a|
+        attribute_names.each do |a|
           attr_name,values = a,self[a]
           yield attr_name, values
-        }
+        end
       end
     end
 
     alias_method :each_attribute, :each
 
-
-
     # Converts the Entry to a String, representing the
     # Entry's attributes in LDIF format.
     #--
@@ -232,15 +239,15 @@ def method_missing *args, &block # :nodoc:
     def write
     end
 
-
     #--
     # Internal convenience method. It seems like the standard
     # approach in most LDAP tools to base64 encode an attribute
     # value if its first or last byte is nonprintable, or if
     # it's a password. But that turns out to be not nearly good
     # enough. There are plenty of A/D attributes that are binary
     # in the middle. This is probably a nasty performance killer.
-    def is_attribute_value_binary? value
+		#
+    def is_attribute_value_binary?( value )
       v = value.to_s
       v.each_byte {|byt|
         return true if (byt < 32) || (byt > 126)
@@ -250,11 +257,9 @@ def is_attribute_value_binary? value
       end
       false
     end
+
     private :is_attribute_value_binary?
 
   end # class Entry
 
-end # class LDAP
-end # module Net
-
-
+end; end # class Net::LDAP

test/test_entry.rb

@@ -45,6 +45,12 @@ class TestEntry < Test::Unit::TestCase
 			assert_equal ['Jensen'], @entry.sn
 		end
 
+		should 'have attributes which are appendable using <<' do
+			@entry['sn'] << 'Jensen'
+			@entry['sn'] << 'Johnson'
+			assert_equal %w(Jensen Johnson), @entry['sn']
+		end
+
 		should 'ignore case of attribute names' do
 			@entry['sn'] = 'Jensen'
 			assert_equal ['Jensen'], @entry.sn
@@ -54,5 +60,15 @@ class TestEntry < Test::Unit::TestCase
 			assert_equal ['Jensen'], @entry['Sn']
 			assert_equal ['Jensen'], @entry['SN']
 		end
+
+		should 'be capable of being (un)marshaled' do
+			@entry['sn'] << 'Jensen'
+			@entry['sn'] << 'Johnson'
+
+			entry_dump = Marshal.dump(@entry)
+			entry_load = Marshal.load(entry_dump)
+
+			assert_equal(@entry, entry_load)
+		end
 	end
 end