net-ldap 0.2.2 → 0.3.0

data/History.rdoc

@@ -1,3 +1,13 @@
+=== Net::LDAP 0.3.0 / 2012-02-14
+* Major changes:
+  * Now uses UTF-8 strings instead of ASCII-8 per the LDAP RFC
+Major Enhancements:
+  * Adding continuation reference processing
+* Bug Fixes:
+  * Fixes usupported object type #139
+  * Fixes Net::LDAP namespace errors
+  * Return nil instead of an empty array if the search fails
+
 === Net::LDAP 0.2.2 / 2011-03-26
 * Bug Fixes:
   * Fixed the call to Net::LDAP.modify_ops from Net::LDAP#modify.

data/Rakefile

@@ -20,7 +20,7 @@ Hoe.spec 'net-ldap' do |spec|
   spec.remote_rdoc_dir = ''
   spec.rsync_args << ' --exclude=statsvn/'
 
-  spec.url = %W(http://net-ldap.rubyforge.org/ https://github.com/ruby-ldap/ruby-net-ldap)
+  spec.url = %W(http://rubyldap.com/ https://github.com/ruby-ldap/ruby-net-ldap)
 
   spec.history_file = 'History.rdoc'
   spec.readme_file = 'README.rdoc'

data/lib/net/ber.rb

@@ -106,7 +106,7 @@ module Net # :nodoc:
   # <tr><th>BMPString</th><th>C</th><td>30: 62 (0x3e, 0b00111110)</td></tr>
   # </table>
   module BER
-    VERSION = '0.2.2'
+    VERSION = '0.3.0'
 
     ##
     # Used for BER-encoding the length and content bytes of a Fixnum integer
@@ -295,6 +295,8 @@ class Net::BER::BerIdentifiedString < String
   attr_accessor :ber_identifier
   def initialize args
     super args
+    # LDAP uses UTF-8 encoded strings
+    force_encoding('UTF-8') if respond_to?(:encoding)
   end
 end
 

data/lib/net/ber/core_ext/string.rb

@@ -12,9 +12,21 @@ module Net::BER::Extensions::String
   # User code should call either #to_ber_application_string or
   # #to_ber_contextspecific.
   def to_ber(code = 0x04)
-    [code].pack('C') + length.to_ber_length_encoding + self
+    raw_string = raw_utf8_encoded
+    [code].pack('C') + raw_string.length.to_ber_length_encoding + raw_string
   end
 
+  def raw_utf8_encoded
+    if self.respond_to?(:encode)
+      # Strings should be UTF-8 encoded according to LDAP.
+      # However, the BER code is not necessarily valid UTF-8
+      self.encode('UTF-8').force_encoding('ASCII-8BIT')
+    else
+      self
+    end
+  end
+  private :raw_utf8_encoded
+
   ##
   # Creates an application-specific BER string encoded value with the
   # provided syntax code value.

data/lib/net/ldap.rb

@@ -241,7 +241,7 @@ require 'net/ldap/entry'
 # and then keeps it open while it executes a user-supplied block.
 # Net::LDAP#open closes the connection on completion of the block.
 class Net::LDAP
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 
   class LdapError < StandardError; end
 
@@ -317,6 +317,7 @@ class Net::LDAP
     2 => "Protocol Error",
     3 => "Time Limit Exceeded",
     4 => "Size Limit Exceeded",
+    10 => "Referral",
     12 => "Unavailable crtical extension",
     14 => "saslBindInProgress",
     16 => "No Such Attribute",
@@ -619,7 +620,8 @@ class Net::LDAP
     end
 
     args[:base] ||= @base
-    result_set = (args and args[:return_result] == false) ? nil : []
+    return_result_set = args[:return_result] != false
+    result_set = return_result_set ? [] : nil
 
     if @open_connection
       @result = @open_connection.search(args) { |entry|
@@ -642,7 +644,11 @@ class Net::LDAP
       end
     end
 
-    @result == 0 and result_set
+    if return_result_set
+      @result == 0 ? result_set : nil
+    else
+      @result == 0
+    end
   end
 
   # #bind connects to an LDAP server and requests authentication based on
@@ -1320,7 +1326,7 @@ class Net::LDAP::Connection #:nodoc:
   # in the protocol.
   #++
   def search(args = {})
-    search_filter = (args && args[:filter]) || 
+    search_filter = (args && args[:filter]) ||
       Net::LDAP::Filter.eq("objectclass", "*")
     search_filter = Net::LDAP::Filter.construct(search_filter) if search_filter.is_a?(String)
     search_base = (args && args[:base]) || "dc=example, dc=com"
@@ -1389,9 +1395,9 @@ class Net::LDAP::Connection #:nodoc:
           false.to_ber,
           rfc2696_cookie.map{ |v| v.to_ber}.to_ber_sequence.to_s.to_ber
         ].to_ber_sequence if paged_searches_supported
-      controls = controls.to_ber_contextspecific(0)
+      controls = controls.empty? ? nil : controls.to_ber_contextspecific(0)
 
-      pkt = [next_msgid.to_ber, request, controls].to_ber_sequence
+      pkt = [next_msgid.to_ber, request, controls].compact.to_ber_sequence
       @conn.write pkt
 
       result_code = 0
@@ -1413,6 +1419,13 @@ class Net::LDAP::Connection #:nodoc:
         when 5 # search-result
           result_code = pdu.result_code
           controls = pdu.result_controls
+          if return_referrals && result_code == 10
+            if block_given?
+              se = Net::LDAP::Entry.new
+              se[:search_referrals] = (pdu.search_referrals || [])
+              yield se
+            end
+          end
           break
         else
           raise Net::LDAP::LdapError, "invalid response-type in search: #{pdu.app_tag}"
@@ -1521,15 +1534,17 @@ class Net::LDAP::Connection #:nodoc:
     old_dn = args[:olddn] or raise "Unable to rename empty DN"
     new_rdn = args[:newrdn] or raise "Unable to rename to empty RDN"
     delete_attrs = args[:delete_attributes] ? true : false
-		new_superior = args[:new_superior]
+    new_superior = args[:new_superior]
+
+    request = [old_dn.to_ber, new_rdn.to_ber, delete_attrs.to_ber]
+    request << new_superior.to_ber unless new_superior == nil
 
-		request = [old_dn.to_ber, new_rdn.to_ber, delete_attrs.to_ber]
-		request << new_superior.to_ber unless new_superior == nil
-  	
     pkt = [next_msgid.to_ber, request.to_ber_appsequence(12)].to_ber_sequence
     @conn.write pkt
 
-    (be = @conn.read_ber(AsnSyntax)) && (pdu = LdapPdu.new( be )) && (pdu.app_tag == 13) or raise LdapError.new( "response missing or invalid" )
+    (be = @conn.read_ber(Net::LDAP::AsnSyntax)) &&
+    (pdu = Net::LDAP::PDU.new( be )) && (pdu.app_tag == 13) or
+    raise Net::LDAP::LdapError.new( "response missing or invalid" )
     pdu.result_code
   end
 

data/lib/net/ldap/dataset.rb

@@ -117,8 +117,8 @@ class Net::LDAP::Dataset < Hash
       while line
         new_line = io.gets
 
-        if new_line =~ /^[\s]+/
-          line << " " << $'
+        if new_line =~ /^ /
+          line << $'
         else
           nextline = new_line
 

data/lib/net/ldap/pdu.rb

@@ -136,6 +136,7 @@ class Net::LDAP::PDU
       :matchedDN => sequence[1],
       :errorMessage => sequence[2]
     }
+    parse_search_referral(sequence[3]) if @ldap_result[:resultCode] == 10
   end
   private :parse_ldap_result
 

data/lib/net/snmp.rb

@@ -2,7 +2,7 @@
 # :stopdoc:
 module Net
     class SNMP
-      VERSION = '0.2.2'
+      VERSION = '0.3.0'
 
 	AsnSyntax = Net::BER.compile_syntax({
 	    :application => {

data/net-ldap.gemspec

@@ -1,8 +1,9 @@
 # -*- encoding: utf-8 -*-
+$:.unshift './lib'
 
 Gem::Specification.new do |s|
   s.name = %q{net-ldap}
-  s.version = "0.2.20110317223538"
+  s.version = Net::LDAP::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Francis Cianfrocca", "Emiel van de Laar", "Rory O'Connell", "Kaspar Schiess", "Austin Ziegler"]
@@ -20,8 +21,8 @@ Our roadmap for Net::LDAP 1.0 is to gain full <em>client</em> compliance with
 the most recent LDAP RFCs (4510–4519, plutions of 4520–4532).}
   s.email = ["blackhedd@rubyforge.org", "gemiel@gmail.com", "rory.ocon@gmail.com", "kaspar.schiess@absurd.li", "austin@rubyforge.org"]
   s.extra_rdoc_files = ["Manifest.txt", "Contributors.rdoc", "Hacking.rdoc", "History.rdoc", "License.rdoc", "README.rdoc"]
-  s.files = [".autotest", ".rspec", "Contributors.rdoc", "Hacking.rdoc", "History.rdoc", "License.rdoc", "Manifest.txt", "README.rdoc", "Rakefile", "autotest/discover.rb", "lib/net-ldap.rb", "lib/net/ber.rb", "lib/net/ber/ber_parser.rb", "lib/net/ber/core_ext.rb", "lib/net/ber/core_ext/array.rb", "lib/net/ber/core_ext/bignum.rb", "lib/net/ber/core_ext/false_class.rb", "lib/net/ber/core_ext/fixnum.rb", "lib/net/ber/core_ext/string.rb", "lib/net/ber/core_ext/true_class.rb", "lib/net/ldap.rb", "lib/net/ldap/dataset.rb", "lib/net/ldap/dn.rb", "lib/net/ldap/entry.rb", "lib/net/ldap/filter.rb", "lib/net/ldap/password.rb", "lib/net/ldap/pdu.rb", "lib/net/snmp.rb", "net-ldap.gemspec", "spec/integration/ssl_ber_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/unit/ber/ber_spec.rb", "spec/unit/ber/core_ext/string_spec.rb", "spec/unit/ldap/dn_spec.rb", "spec/unit/ldap/entry_spec.rb", "spec/unit/ldap/filter_spec.rb", "spec/unit/ldap_spec.rb", "test/common.rb", "test/test_entry.rb", "test/test_filter.rb", "test/test_ldap_connection.rb", "test/test_ldif.rb", "test/test_password.rb", "test/test_rename.rb", "test/test_snmp.rb", "test/testdata.ldif", "testserver/ldapserver.rb", "testserver/testdata.ldif", ".gemtest"]
-  s.homepage = %q{http://net-ldap.rubyforge.org/}
+  s.files = [".autotest", ".rspec", "Contributors.rdoc", "Hacking.rdoc", "History.rdoc", "License.rdoc", "Manifest.txt", "README.rdoc", "Rakefile", "autotest/discover.rb", "lib/net-ldap.rb", "lib/net/ber.rb", "lib/net/ber/ber_parser.rb", "lib/net/ber/core_ext.rb", "lib/net/ber/core_ext/array.rb", "lib/net/ber/core_ext/bignum.rb", "lib/net/ber/core_ext/false_class.rb", "lib/net/ber/core_ext/fixnum.rb", "lib/net/ber/core_ext/string.rb", "lib/net/ber/core_ext/true_class.rb", "lib/net/ldap.rb", "lib/net/ldap/dataset.rb", "lib/net/ldap/dn.rb", "lib/net/ldap/entry.rb", "lib/net/ldap/filter.rb", "lib/net/ldap/password.rb", "lib/net/ldap/pdu.rb", "lib/net/snmp.rb", "net-ldap.gemspec", "spec/integration/ssl_ber_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/unit/ber/ber_spec.rb", "spec/unit/ber/core_ext/string_spec.rb", "spec/unit/ldap/dn_spec.rb", "spec/unit/ldap/entry_spec.rb", "spec/unit/ldap/filter_spec.rb", "spec/unit/ldap_spec.rb", "test/common.rb", "test/test_entry.rb", "test/test_filter.rb", "test/test_ldap_connection.rb", "test/test_ldif.rb", "test/test_password.rb", "test/test_rename.rb", "test/test_snmp.rb", "test/testdata.ldif", "testserver/ldapserver.rb", "testserver/testdata.ldif"]
+  s.homepage = %q{http://github.com.org/ruby-ldap/ruby-net-ldap}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")

data/spec/unit/ber/ber_spec.rb

@@ -75,6 +75,21 @@ describe "BER encoding of" do
       end 
     end
   end
+  if "Ruby 1.9".respond_to?(:encoding)
+    context "strings" do
+      it "should properly encode UTF-8 strings" do
+        "\u00e5".force_encoding("UTF-8").to_ber.should ==
+          "\x04\x02\xC3\xA5"
+      end
+      it "should properly encode strings encodable as UTF-8" do
+        "teststring".encode("US-ASCII").to_ber.should == "\x04\nteststring"
+      end
+      it "should fail on strings that can not be converted to UTF-8" do
+        error = Encoding::UndefinedConversionError
+        lambda {"\x81".to_ber }.should raise_exception(error)
+      end
+    end
+  end
 end
 
 describe "BER decoding of" do
@@ -91,4 +106,4 @@ describe "BER decoding of" do
           [1, [3, "Administrator", "ad_is_bogus"]]
     end 
   end
-end
+end

data/test/test_filter.rb

@@ -31,92 +31,92 @@ class TestFilter < Test::Unit::TestCase
     assert_equal("(uid=*\\5C*)", Filter.contains("uid", "\\").to_s)	
   end
 
-	def test_c2
+  def test_c2
     assert_equal("(uid=george *)",
                  Filter.from_rfc2254("uid=george *").to_rfc2254)
     assert_equal("(uid:=george *)",
                  Filter.from_rfc2254("uid:=george *").to_rfc2254)
     assert_equal("(uid=george*)",
                  Filter.from_rfc2254(" ( uid =  george*   ) ").to_rfc2254)
-		assert_equal("(!(uid=george*))",
+    assert_equal("(!(uid=george*))",
                  Filter.from_rfc2254("uid!=george*").to_rfc2254)
-		assert_equal("(uid<=george*)",
+    assert_equal("(uid<=george*)",
                  Filter.from_rfc2254("uid <= george*").to_rfc2254)
-		assert_equal("(uid>=george*)",
+    assert_equal("(uid>=george*)",
                  Filter.from_rfc2254("uid>=george*").to_rfc2254)
-		assert_equal("(&(uid=george*)(mail=*))",
+    assert_equal("(&(uid=george*)(mail=*))",
                  Filter.from_rfc2254("(& (uid=george* ) (mail=*))").to_rfc2254)
-		assert_equal("(|(uid=george*)(mail=*))",
+    assert_equal("(|(uid=george*)(mail=*))",
                  Filter.from_rfc2254("(| (uid=george* ) (mail=*))").to_rfc2254)
-		assert_equal("(!(mail=*))",
+    assert_equal("(!(mail=*))",
                  Filter.from_rfc2254("(! (mail=*))").to_rfc2254)
-	end
+  end
 
-	def test_filter_with_single_clause
-		assert_equal("(cn=name)", Net::LDAP::Filter.construct("(&(cn=name))").to_s)
-    end
+  def test_filter_with_single_clause
+    assert_equal("(cn=name)", Net::LDAP::Filter.construct("(&(cn=name))").to_s)
+  end
 
-	def test_filters_from_ber
-		[
-			Net::LDAP::Filter.eq("objectclass", "*"),
-			Net::LDAP::Filter.pres("objectclass"),
-			Net::LDAP::Filter.eq("objectclass", "ou"),
-			Net::LDAP::Filter.ge("uid", "500"),
-			Net::LDAP::Filter.le("uid", "500"),
-			(~ Net::LDAP::Filter.pres("objectclass")),
-			(Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou")),
-			(Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou") & Net::LDAP::Filter.pres("sn")),
-			(Net::LDAP::Filter.pres("objectclass") | Net::LDAP::Filter.pres("ou") | Net::LDAP::Filter.pres("sn")),
+  def test_filters_from_ber
+    [
+      Net::LDAP::Filter.eq("objectclass", "*"),
+      Net::LDAP::Filter.pres("objectclass"),
+      Net::LDAP::Filter.eq("objectclass", "ou"),
+      Net::LDAP::Filter.ge("uid", "500"),
+      Net::LDAP::Filter.le("uid", "500"),
+      (~ Net::LDAP::Filter.pres("objectclass")),
+      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou")),
+      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou") & Net::LDAP::Filter.pres("sn")),
+      (Net::LDAP::Filter.pres("objectclass") | Net::LDAP::Filter.pres("ou") | Net::LDAP::Filter.pres("sn")),
 
-			Net::LDAP::Filter.eq("objectclass", "*aaa"),
-			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb"),
-			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc"),
-			Net::LDAP::Filter.eq("objectclass", "aaa*bbb"),
-			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc"),
-			Net::LDAP::Filter.eq("objectclass", "abc*def*1111*22*g"),
-			Net::LDAP::Filter.eq("objectclass", "*aaa*"),
-			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*"),
-			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc*"),
-			Net::LDAP::Filter.eq("objectclass", "aaa*"),
-			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*"),
-			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc*"),
-		].each do |ber|
-			f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-			assert(f == ber)
-			assert_equal(f.to_ber, ber.to_ber)
-		end
-	end
+      Net::LDAP::Filter.eq("objectclass", "*aaa"),
+      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb"),
+      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc"),
+      Net::LDAP::Filter.eq("objectclass", "aaa*bbb"),
+      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc"),
+      Net::LDAP::Filter.eq("objectclass", "abc*def*1111*22*g"),
+      Net::LDAP::Filter.eq("objectclass", "*aaa*"),
+      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*"),
+      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc*"),
+      Net::LDAP::Filter.eq("objectclass", "aaa*"),
+      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*"),
+      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc*"),
+    ].each do |ber|
+      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
+      assert(f == ber)
+      assert_equal(f.to_ber, ber.to_ber)
+    end
+  end
 
-	def test_ber_from_rfc2254_filter
-		[
-			Net::LDAP::Filter.construct("objectclass=*"),
-			Net::LDAP::Filter.construct("objectclass=ou"),
-			Net::LDAP::Filter.construct("uid >= 500"),
-			Net::LDAP::Filter.construct("uid <= 500"),
-			Net::LDAP::Filter.construct("(!(uid=*))"),
-			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))"),
-			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))"),
-			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))"),
-			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))"),
+  def test_ber_from_rfc2254_filter
+    [
+      Net::LDAP::Filter.construct("objectclass=*"),
+      Net::LDAP::Filter.construct("objectclass=ou"),
+      Net::LDAP::Filter.construct("uid >= 500"),
+      Net::LDAP::Filter.construct("uid <= 500"),
+      Net::LDAP::Filter.construct("(!(uid=*))"),
+      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))"),
+      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))"),
+      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))"),
+      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))"),
 
-			Net::LDAP::Filter.construct("objectclass=*aaa"),
-			Net::LDAP::Filter.construct("objectclass=*aaa*bbb"),
-			Net::LDAP::Filter.construct("objectclass=*aaa bbb"),
-			Net::LDAP::Filter.construct("objectclass=*aaa  bbb"),
-			Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc"),
-			Net::LDAP::Filter.construct("objectclass=aaa*bbb"),
-			Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc"),
-			Net::LDAP::Filter.construct("objectclass=abc*def*1111*22*g"),
-			Net::LDAP::Filter.construct("objectclass=*aaa*"),
-			Net::LDAP::Filter.construct("objectclass=*aaa*bbb*"),
-			Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc*"),
-			Net::LDAP::Filter.construct("objectclass=aaa*"),
-			Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
-			Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
-		].each do |ber|
-			f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-			assert(f == ber)
-			assert_equal(f.to_ber, ber.to_ber)
-		end
-	end
+      Net::LDAP::Filter.construct("objectclass=*aaa"),
+      Net::LDAP::Filter.construct("objectclass=*aaa*bbb"),
+      Net::LDAP::Filter.construct("objectclass=*aaa bbb"),
+      Net::LDAP::Filter.construct("objectclass=*aaa  bbb"),
+      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc"),
+      Net::LDAP::Filter.construct("objectclass=aaa*bbb"),
+      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc"),
+      Net::LDAP::Filter.construct("objectclass=abc*def*1111*22*g"),
+      Net::LDAP::Filter.construct("objectclass=*aaa*"),
+      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*"),
+      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc*"),
+      Net::LDAP::Filter.construct("objectclass=aaa*"),
+      Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
+      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
+    ].each do |ber|
+      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
+      assert(f == ber)
+      assert_equal(f.to_ber, ber.to_ber)
+    end
+  end
 end

data/test/test_ldif.rb

@@ -31,8 +31,20 @@ class TestLdif < Test::Unit::TestCase
   end
 
   def test_ldif_with_continuation_lines
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
-    assert_equal(true, ds.has_key?("abcdefg hijklmn"))
+    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hijklmn\r\n\r\n"))
+    assert_equal(true, ds.has_key?("abcdefghijklmn"))
+  end
+
+  def test_ldif_with_continuation_lines_and_extra_whitespace
+    ds1 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
+    assert_equal(true, ds1.has_key?("abcdefg  hijklmn"))
+    ds2 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hij  klmn\r\n\r\n"))
+    assert_equal(true, ds2.has_key?("abcdefghij  klmn"))
+  end
+
+  def test_ldif_tab_is_not_continuation
+    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: key\r\n\tnotcontinued\r\n\r\n"))
+    assert_equal(true, ds.has_key?("key"))
   end
 
   # TODO, INADEQUATE. We need some more tests

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: net-ldap
-version: !ruby/object:Gem::Version 
-  hash: 19
+version: !ruby/object:Gem::Version
+  version: 0.3.0
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
 platform: ruby
-authors: 
+authors:
 - Francis Cianfrocca
 - Emiel van de Laar
 - Rory O'Connell
@@ -18,143 +13,133 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-26 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rubyforge
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70157176040280 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 2
-        - 0
-        - 4
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.0.4
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: hoe-git
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176040280
+- !ruby/object:Gem::Dependency
+  name: hoe-git
+  requirement: &70157176059420 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 1
-        version: "1"
+      - !ruby/object:Gem::Version
+        version: '1'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: hoe-gemspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176059420
+- !ruby/object:Gem::Dependency
+  name: hoe-gemspec
+  requirement: &70157176053340 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 1
-        version: "1"
+      - !ruby/object:Gem::Version
+        version: '1'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: metaid
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176053340
+- !ruby/object:Gem::Dependency
+  name: metaid
+  requirement: &70157176052240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 1
-        version: "1"
+      - !ruby/object:Gem::Version
+        version: '1'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: flexmock
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176052240
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: &70157176069980 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 0
-        - 9
-        - 0
+      - !ruby/object:Gem::Version
         version: 0.9.0
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *70157176069980
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: &70157176078680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176078680
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70157176091860 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 0
-        version: "2.0"
+      - !ruby/object:Gem::Version
+        version: '3.10'
   type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: hoe
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: *70157176091860
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: &70157176087000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 2
-        - 9
-        - 1
-        version: 2.9.1
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
   type: :development
-  version_requirements: *id007
-description: "Net::LDAP for Ruby (also called net-ldap) implements client access for the\n\
-  Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for\n\
-  accessing distributed directory services. Net::LDAP is written completely in\n\
-  Ruby with no external dependencies. It supports most LDAP client features and a\n\
-  subset of server features as well.\n\n\
-  Net::LDAP has been tested against modern popular LDAP servers including\n\
-  OpenLDAP and Active Directory. The current release is mostly compliant with\n\
-  earlier versions of the IETF LDAP RFCs (2251\xE2\x80\x932256, 2829\xE2\x80\x932830, 3377, and 3771).\n\
-  Our roadmap for Net::LDAP 1.0 is to gain full <em>client</em> compliance with\n\
-  the most recent LDAP RFCs (4510\xE2\x80\x934519, plus portions of 4520\xE2\x80\x934532)."
-email: 
+  prerelease: false
+  version_requirements: *70157176087000
+description: ! 'Net::LDAP for Ruby (also called net-ldap) implements client access
+  for the
+
+  Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for
+
+  accessing distributed directory services. Net::LDAP is written completely in
+
+  Ruby with no external dependencies. It supports most LDAP client features and a
+
+  subset of server features as well.
+
+
+  Net::LDAP has been tested against modern popular LDAP servers including
+
+  OpenLDAP and Active Directory. The current release is mostly compliant with
+
+  earlier versions of the IETF LDAP RFCs (2251–2256, 2829–2830, 3377, and 3771).
+
+  Our roadmap for Net::LDAP 1.0 is to gain full <em>client</em> compliance with
+
+  the most recent LDAP RFCs (4510–4519, plus portions of 4520–4532).'
+email:
 - blackhedd@rubyforge.org
 - gemiel@gmail.com
 - rory.ocon@gmail.com
 - kaspar.schiess@absurd.li
 - austin@rubyforge.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - Manifest.txt
 - Contributors.rdoc
 - Hacking.rdoc
 - History.rdoc
 - License.rdoc
 - README.rdoc
-files: 
+files:
 - .autotest
 - .rspec
 - Contributors.rdoc
@@ -205,44 +190,35 @@ files:
 - testserver/ldapserver.rb
 - testserver/testdata.ldif
 - .gemtest
-has_rdoc: true
-homepage: http://net-ldap.rubyforge.org/
+homepage: http://rubyldap.com/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 57
-      segments: 
-      - 1
-      - 8
-      - 7
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: net-ldap
-rubygems_version: 1.5.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Net::LDAP for Ruby (also called net-ldap) implements client access for the Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for accessing distributed directory services
-test_files: 
+summary: Net::LDAP for Ruby (also called net-ldap) implements client access for the
+  Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for accessing
+  distributed directory services
+test_files:
 - test/test_entry.rb
 - test/test_filter.rb
 - test/test_ldap_connection.rb