net-ldap 0.3.1 → 0.17.0

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

@@ -1,66 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-##
-# Ber extensions to the Fixnum class.
-module Net::BER::Extensions::Fixnum
-  ##
-  # Converts the fixnum to BER format.
-  def to_ber
-    "\002#{to_ber_internal}"
-  end
-
-  ##
-  # Converts the fixnum to BER enumerated format.
-  def to_ber_enumerated
-    "\012#{to_ber_internal}"
-  end
-
-  ##
-  # Converts the fixnum to BER length encodining format.
-  def to_ber_length_encoding
-    if self <= 127
-      [self].pack('C')
-    else
-      i = [self].pack('N').sub(/^[\0]+/,"")
-      [0x80 + i.length].pack('C') + i
-    end
-  end
-
-  ##
-  # Generate a BER-encoding for an application-defined INTEGER. Examples of
-  # such integers are SNMP's Counter, Gauge, and TimeTick types.
-  def to_ber_application(tag)
-    [0x40 + tag].pack("C") + to_ber_internal
-  end
-
-  ##
-  # Used to BER-encode the length and content bytes of a Fixnum. Callers
-  # must prepend the tag byte for the contained value.
-  def to_ber_internal
-    # CAUTION: Bit twiddling ahead. You might want to shield your eyes or
-    # something.
-
-    # Looks for the first byte in the fixnum that is not all zeroes. It does
-    # this by masking one byte after another, checking the result for bits
-    # that are left on.
-    size = Net::BER::MAX_FIXNUM_SIZE
-    while size > 1
-      break if (self & (0xff << (size - 1) * 8)) > 0
-      size -= 1
-    end
-
-    # Store the size of the fixnum in the result
-    result = [size]
-
-    # Appends bytes to result, starting with higher orders first. Extraction
-    # of bytes is done by right shifting the original fixnum by an amount
-    # and then masking that with 0xff.
-    while size > 0
-      # right shift size - 1 bytes, mask with 0xff
-      result << ((self >> ((size - 1) * 8)) & 0xff)
-      size -= 1
-    end
-
-    result.pack('C*')
-  end
-  private :to_ber_internal
-end

data/net-ldap.gemspec

@@ -1,58 +0,0 @@
-# -*- encoding: utf-8 -*-
-Gem::Specification.new do |s|
-  s.name = %q{net-ldap}
-  s.version = "0.3.1"
-
-  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"]
-  s.date = %q{2011-03-17}
-  s.description = %q{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, 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"]
-  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")
-  s.rubyforge_project = %q{net-ldap}
-  s.rubygems_version = %q{1.5.2}
-  s.summary = %q{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}
-  s.test_files = ["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"]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<hoe-git>, ["~> 1"])
-      s.add_development_dependency(%q<hoe-gemspec>, ["~> 1"])
-      s.add_development_dependency(%q<metaid>, ["~> 1"])
-      s.add_development_dependency(%q<flexmock>, ["~> 0.9.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.0"])
-      s.add_development_dependency(%q<hoe>, [">= 2.9.1"])
-    else
-      s.add_dependency(%q<hoe-git>, ["~> 1"])
-      s.add_dependency(%q<hoe-gemspec>, ["~> 1"])
-      s.add_dependency(%q<metaid>, ["~> 1"])
-      s.add_dependency(%q<flexmock>, ["~> 0.9.0"])
-      s.add_dependency(%q<rspec>, ["~> 2.0"])
-      s.add_dependency(%q<hoe>, [">= 2.9.1"])
-    end
-  else
-    s.add_dependency(%q<hoe-git>, ["~> 1"])
-    s.add_dependency(%q<hoe-gemspec>, ["~> 1"])
-    s.add_dependency(%q<metaid>, ["~> 1"])
-    s.add_dependency(%q<flexmock>, ["~> 0.9.0"])
-    s.add_dependency(%q<rspec>, ["~> 2.0"])
-    s.add_dependency(%q<hoe>, [">= 2.9.1"])
-  end
-end

data/spec/integration/ssl_ber_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-require 'net/ldap'
-
-describe "BER serialisation (SSL)" do
-  # Transmits str to #to and reads it back from #from. 
-  #
-  def transmit(str)
-    to.write(str)
-    to.close
-    
-    from.read
-  end
-    
-  attr_reader :to, :from
-  before(:each) do
-    @from, @to = IO.pipe
-    
-    # The production code operates on sockets, which do need #connect called
-    # on them to work. Pipes are more robust for this test, so we'll skip 
-    # the #connect call since it fails. 
-    flexmock(OpenSSL::SSL::SSLSocket).
-      new_instances.should_receive(:connect => nil)
-              
-    @to   = Net::LDAP::Connection.wrap_with_ssl(to)
-    @from = Net::LDAP::Connection.wrap_with_ssl(from)
-  end
-  
-  it "should transmit strings" do
-    transmit('foo').should == 'foo'
-  end 
-  it "should correctly transmit numbers" do
-    to.write 1234.to_ber
-    from.read_ber.should == 1234
-  end 
-end

data/spec/spec.opts

@@ -1,2 +0,0 @@
---format specdoc
---colour

data/spec/spec_helper.rb

@@ -1,5 +0,0 @@
-require 'net/ldap'
-
-RSpec.configure do |config|
-  config.mock_with :flexmock
-end

data/spec/unit/ber/ber_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-require 'net/ber'
-require 'net/ldap'
-
-describe "BER encoding of" do
-  
-  RSpec::Matchers.define :properly_encode_and_decode do 
-    match do |given|
-      given.to_ber.read_ber.should == given
-    end
-  end
-   
-  context "arrays" do
-    it "should properly encode/decode []" do
-      [].should properly_encode_and_decode
-    end 
-    it "should properly encode/decode [1,2,3]" do
-      ary = [1,2,3]
-      encoded_ary = ary.map { |el| el.to_ber }.to_ber
-      
-      encoded_ary.read_ber.should == ary
-    end 
-  end
-  context "booleans" do
-    it "should encode true" do
-      true.to_ber.should == "\x01\x01\x01"
-    end
-    it "should encode false" do
-      false.to_ber.should == "\x01\x01\x00"
-    end
-  end
-  context "numbers" do
-    # Sample based
-    {
-      0           => "\x02\x01\x00", 
-      1           => "\x02\x01\x01", 
-      127         => "\x02\x01\x7F", 
-      128         => "\x02\x01\x80", 
-      255         => "\x02\x01\xFF", 
-      256         => "\x02\x02\x01\x00", 
-      65535       => "\x02\x02\xFF\xFF", 
-      65536       => "\x02\x03\x01\x00\x00", 
-      16_777_215  => "\x02\x03\xFF\xFF\xFF", 
-      0x01000000  => "\x02\x04\x01\x00\x00\x00", 
-      0x3FFFFFFF  => "\x02\x04\x3F\xFF\xFF\xFF", 
-      0x4FFFFFFF  => "\x02\x04\x4F\xFF\xFF\xFF", 
-      
-      # Some odd samples...
-      5           => "\002\001\005", 
-      500         => "\002\002\001\364", 
-      50_000      => "\x02\x02\xC3P", 
-      5_000_000_000  => "\002\005\001*\005\362\000"
-    }.each do |number, expected_encoding| 
-      it "should encode #{number} as #{expected_encoding.inspect}" do
-        number.to_ber.should == expected_encoding
-      end 
-    end
-
-    # Round-trip encoding: This is mostly to be sure to cover Bignums well.
-    context "when decoding with #read_ber" do
-      it "should correctly handle powers of two" do
-        100.times do |p|
-          n = 2 << p
-          
-          n.should properly_encode_and_decode
-        end
-      end 
-      it "should correctly handle powers of ten" do
-        100.times do |p|
-          n = 5 * 10**p
-          
-          n.should properly_encode_and_decode
-        end
-      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
-  context "numbers" do
-    it "should decode #{"\002\001\006".inspect} (6)" do
-      "\002\001\006".read_ber(Net::LDAP::AsnSyntax).should == 6
-    end
-    it "should decode #{"\004\007testing".inspect} ('testing')" do
-      "\004\007testing".read_ber(Net::LDAP::AsnSyntax).should == 'testing'
-    end
-    it "should decode an ldap bind request" do
-      "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus".
-        read_ber(Net::LDAP::AsnSyntax).should ==
-          [1, [3, "Administrator", "ad_is_bogus"]]
-    end 
-  end
-end

data/spec/unit/ber/core_ext/string_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'metaid'
-
-describe String, "when extended with BER core extensions" do
-  describe "<- #read_ber! (consuming read_ber method)" do
-    context "when passed an ldap bind request and some extra data" do
-      attr_reader :str, :result
-      before(:each) do
-        @str = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED" 
-        @result = str.read_ber!(Net::LDAP::AsnSyntax)
-      end
-      
-      it "should correctly parse the ber message" do
-        result.should == [1, [3, "Administrator", "ad_is_bogus"]]
-      end 
-      it "should leave unconsumed part of message in place" do
-        str.should == " UNCONSUMED"
-      end
-
-      context "if an exception occurs during #read_ber" do
-        attr_reader :initial_value
-        before(:each) do
-          stub_exception_class = Class.new(StandardError)
-          
-          @initial_value = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus" 
-          @str = initial_value.dup 
-
-          # Defines a string
-          io = StringIO.new(initial_value)
-          io.meta_def :read_ber do |syntax|
-            read
-            raise stub_exception_class
-          end
-          flexmock(StringIO).should_receive(:new).and_return(io)
-          
-          begin
-            str.read_ber!(Net::LDAP::AsnSyntax)            
-          rescue stub_exception_class
-            # EMPTY ON PURPOSE
-          else
-            raise "The stub code should raise an exception!"
-          end
-        end
-        
-        it "should not modify string" do
-          str.should == initial_value
-        end
-      end
-    end
-  end
-end

data/spec/unit/ldap/dn_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'net/ldap/dn'
-
-describe Net::LDAP::DN do
-  describe "<- .construct" do
-    attr_reader :dn
-
-    before(:each) do
-      @dn = Net::LDAP::DN.new('cn', ',+"\\<>;', 'ou=company')
-    end
-
-    it "should construct a Net::LDAP::DN" do
-      dn.should be_an_instance_of(Net::LDAP::DN)
-    end 
-
-    it "should escape all the required characters" do
-      dn.to_s.should == 'cn=\\,\\+\\"\\\\\\<\\>\\;,ou=company'
-    end
-  end
-
-  describe "<- .to_a" do
-    context "parsing" do
-      {
-        'cn=James, ou=Company\\,\\20LLC' => ['cn','James','ou','Company, LLC'],
-        'cn =  \ James , ou  =  "Comp\28ny"  ' => ['cn',' James','ou','Comp(ny'],
-        '1.23.4=  #A3B4D5  ,ou=Company' => ['1.23.4','#A3B4D5','ou','Company'],
-      }.each do |key, value|
-        context "(#{key})" do
-          attr_reader :dn
-
-          before(:each) do
-            @dn = Net::LDAP::DN.new(key)
-          end
-
-          it "should decode into a Net::LDAP::DN" do
-            dn.should be_an_instance_of(Net::LDAP::DN)
-          end
-
-          it "should return the correct array" do
-            dn.to_a.should == value
-          end
-        end
-      end
-    end
-
-    context "parsing bad input" do
-      [
-        'cn=James,',
-        'cn=#aa aa',
-        'cn="James',
-        'cn=J\ames',
-        'cn=\\',
-        '1.2.d=Value',
-        'd1.2=Value',
-      ].each do |value|
-        context "(#{value})" do
-          attr_reader :dn
-
-          before(:each) do
-            @dn = Net::LDAP::DN.new(value)
-          end
-
-          it "should decode into a Net::LDAP::DN" do
-            dn.should be_an_instance_of(Net::LDAP::DN)
-          end
-
-          it "should raise an error on parsing" do
-            lambda { dn.to_a }.should raise_error
-          end
-        end
-      end
-    end
-  end
-
-  describe "<- .escape(str)" do
-    it "should escape ,, +, \", \\, <, >, and ;" do
-      Net::LDAP::DN.escape(',+"\\<>;').should == '\\,\\+\\"\\\\\\<\\>\\;'
-    end 
-  end
-end

data/spec/unit/ldap/entry_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Net::LDAP::Entry do
-  attr_reader :entry
-  before(:each) do
-    @entry = Net::LDAP::Entry.from_single_ldif_string(
-      %Q{dn: something
-foo: foo
-barAttribute: bar
-      }
-    )
-  end
-
-  describe "entry access" do
-    it "should always respond to #dn" do
-      entry.should respond_to(:dn)
-    end 
-    
-    context "<- #foo" do
-      it "should respond_to?" do
-        entry.should respond_to(:foo)
-      end 
-      it "should return 'foo'" do
-        entry.foo.should == ['foo']
-      end
-    end
-    context "<- #Foo" do
-      it "should respond_to?" do
-        entry.should respond_to(:Foo)
-      end 
-      it "should return 'foo'" do
-        entry.foo.should == ['foo']
-      end 
-    end
-    context "<- #foo=" do
-      it "should respond_to?" do
-        entry.should respond_to(:foo=)
-      end 
-      it "should set 'foo'" do
-        entry.foo= 'bar'
-        entry.foo.should == ['bar']
-      end 
-    end
-    context "<- #fOo=" do
-      it "should return 'foo'" do
-        entry.fOo= 'bar'
-        entry.fOo.should == ['bar']
-      end 
-    end
-  end
-end