net-ldap 0.1.0 → 0.1.1

data/History.txt

@@ -1,4 +1,7 @@
-=== Net::LDAP 0.1.0 / 2010-03-08
+=== Net::LDAP 0.1.1 / 2010-03-18
+* Fixing a critical problem with sockets.
+
+=== Net::LDAP 0.1.0 / 2010-03-17
 * Small fixes throughout, more to come.
 * Ruby 1.9 support added.
 * Ruby 1.8.6 and below support removed. If we can figure out a compatible way

data/Rakefile

@@ -1,14 +1,10 @@
 require "rubygems"
-require 'hanna/rdoctask'
 require 'hoe'
 
 $LOAD_PATH.unshift('lib')
 
 require 'net/ldap'
 
-require "rake/gempackagetask"
-require "rake/rdoctask"
-
 PKG_NAME    = 'net-ldap'
 PKG_VERSION = Net::LDAP::VERSION
 PKG_DIST    = "#{PKG_NAME}-#{PKG_VERSION}"

data/lib/net/ldap.rb

@@ -1,5 +1,6 @@
 require 'openssl'
 require 'ostruct'
+require 'socket'
 
 require 'net/ber'
 require 'net/ldap/pdu'
@@ -232,9 +233,9 @@ module Net
   # to the server and then keeps it open while it executes a user-supplied block. Net::LDAP#open
   # closes the connection on completion of the block.
   class LDAP
-    class LdapError < StandardError; end
+    VERSION = "0.1.1"
 
-    VERSION = "0.1.0"
+    class LdapError < StandardError; end
 
     SearchScope_BaseObject = 0
     SearchScope_SingleLevel = 1
@@ -1120,8 +1121,10 @@ module Net
       def initialize server
         begin
           @conn = TCPSocket.new( server[:host], server[:port] )
-        rescue
-          raise LdapError.new( "no connection to server" )
+        rescue SocketError
+          raise LdapError, "No such address or other socket error."
+        rescue Errno::ECONNREFUSED
+          raise LdapError, "Server #{server[:host]} refused connection on port #{server[:port]}."
         end
 
         if server[:encryption]

data/lib/net/ldap/core_ext/bignum.rb

@@ -4,9 +4,9 @@ module Net
       module Bignum
 
         def to_ber
-          # NOTE: Array#pack's 'w' is a BER _compressed_ integer. We need uncompressed
-          # BER integers, so we're not using that.
-          # See also: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/228864
+          # NOTE: Array#pack's 'w' is a BER _compressed_ integer. We need
+          # uncompressed BER integers, so we're not using that. See also:
+          # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/228864
           result = []
 
           n = self

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

@@ -36,23 +36,33 @@ module Net
         end
 
         #--
-        # Called internally to BER-encode the length and content bytes of a Fixnum.
-        # The caller will prepend the tag byte.
+        # Called internally to BER-encode the length and content bytes of a 
+        # Fixnum. The caller will prepend the tag byte.
+        #
         MAX_SIZE = 0.size
         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 = MAX_SIZE
           while size>1
-              break if (self & (0xff << (size-1)*8)) > 0 
-              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
+            # right shift size-1 bytes, mask with 0xff 
+            result << ((self >> ((size-1)*8)) & 0xff)
+            size -= 1
           end
 
           result.pack('C*')

data/lib/net/ldap/entry.rb

@@ -27,60 +27,53 @@ module Net
 class LDAP
 
 
-  # Objects of this class represent individual entries in an LDAP
-  # directory. User code generally does not instantiate this class.
-  # Net::LDAP#search provides objects of this class to user code,
-  # either as block parameters or as return values.
+  # Objects of this class represent individual entries in an LDAP directory.
+  # User code generally does not instantiate this class. Net::LDAP#search
+  # provides objects of this class to user code, either as block parameters or
+  # as return values.
   #
-  # In LDAP-land, an "entry" is a collection of attributes that are
-  # uniquely and globally identified by a DN ("Distinguished Name").
-  # Attributes are identified by short, descriptive words or phrases.
-  # Although a directory is
+  # In LDAP-land, an "entry" is a collection of attributes that are uniquely
+  # and globally identified by a DN ("Distinguished Name"). Attributes are
+  # identified by short, descriptive words or phrases. Although a directory is
   # free to implement any attribute name, most of them follow rigorous
-  # standards so that the range of commonly-encountered attribute
-  # names is not large.
+  # standards so that the range of commonly-encountered attribute names is not
+  # large.
   #
-  # An attribute name is case-insensitive. Most directories also
-  # restrict the range of characters allowed in attribute names.
-  # To simplify handling attribute names, Net::LDAP::Entry
-  # internally converts them to a standard format. Therefore, the
-  # methods which take attribute names can take Strings or Symbols,
-  # and work correctly regardless of case or capitalization.
+  # An attribute name is case-insensitive. Most directories also restrict the
+  # range of characters allowed in attribute names. To simplify handling
+  # attribute names, Net::LDAP::Entry internally converts them to a standard
+  # format. Therefore, the methods which take attribute names can take Strings
+  # or Symbols, and work correctly regardless of case or capitalization.
   #
-  # An attribute consists of zero or more data items called
-  # <i>values.</i> An entry is the combination of a unique DN, a set of attribute
-  # names, and a (possibly-empty) array of values for each attribute.
+  # An attribute consists of zero or more data items called <i>values.</i> An
+  # entry is the combination of a unique DN, a set of attribute names, and a
+  # (possibly-empty) array of values for each attribute.
   #
-  # Class Net::LDAP::Entry provides convenience methods for dealing
-  # with LDAP entries.
-  # In addition to the methods documented below, you may access individual
-  # attributes of an entry simply by giving the attribute name as
+  # Class Net::LDAP::Entry provides convenience methods for dealing with LDAP
+  # entries. In addition to the methods documented below, you may access
+  # individual attributes of an entry simply by giving the attribute name as
   # the name of a method call. For example:
-  #  ldap.search( ... ) do |entry|
-  #    puts "Common name: #{entry.cn}"
-  #    puts "Email addresses:"
-  #      entry.mail.each {|ma| puts ma}
-  #  end
-  # If you use this technique to access an attribute that is not present
-  # in a particular Entry object, a NoMethodError exception will be raised.
+  #
+  #   ldap.search( ... ) do |entry|
+  #     puts "Common name: #{entry.cn}"
+  #     puts "Email addresses:"
+  #     entry.mail.each {|ma| puts ma}
+  #   end
+  #
+  # If you use this technique to access an attribute that is not present in a
+  # particular Entry object, a NoMethodError exception will be raised.
   #
   #--
-  # Ugly problem to fix someday: We key off the internal hash with
-  # a canonical form of the attribute name: convert to a string,
-  # downcase, then take the symbol. Unfortunately we do this in
-  # at least three places. Should do it in ONE place.
+  # Ugly problem to fix someday: We key off the internal hash with a canonical
+  # form of the attribute name: convert to a string, downcase, then take the
+  # symbol. Unfortunately we do this in at least three places. Should do it in
+  # ONE place.
+  #
   class Entry
-
-
     # This constructor is not generally called by user code.
-    #--
-    # Originally, myhash 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 = {}
       @myhash[:dn] = [dn]
     end
 
@@ -97,20 +90,18 @@ class LDAP
     #--
     # 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:
-      sym = name.to_s.downcase.intern
+    def []=(name, value) # :nodoc:
+      sym = attribute_name(name)
       value = [value] unless value.is_a?(Array)
       @myhash[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.
+    # 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:
-      name = name.to_s.downcase.intern unless name.is_a?(Symbol)
+    def [](name) # :nodoc:
+      name = attribute_name(name) unless name.is_a?(Symbol)
       @myhash[name] || []
     end
 
@@ -141,8 +132,6 @@ class LDAP
 
     alias_method :each_attribute, :each
 
-
-
     # Converts the Entry to a String, representing the
     # Entry's attributes in LDIF format.
     #--
@@ -168,24 +157,15 @@ class LDAP
 
     #--
     # TODO, doesn't support broken lines.
-    # It generates a SINGLE Entry object from an incoming LDIF stream
-    # which is of course useless for big LDIF streams that encode
-    # many objects.
+    # It generates a SINGLE Entry object from an incoming LDIF stream which is
+    # of course useless for big LDIF streams that encode many objects.
+    #
     # DO NOT DOCUMENT THIS METHOD UNTIL THESE RESTRICTIONS ARE LIFTED.
-    # As it is, it's useful for unmarshalling objects that we create,
-    # but not for reading arbitrary LDIF files.
-    # Eventually, we should have a class method that parses large LDIF
-    # streams into individual LDIF blocks (delimited by blank lines)
-    # and passes them here.
     #
-    # There is one oddity, noticed by Matthias Tarasiewicz: as originally
-    # written, this code would return an Entry object in which the DN
-    # attribute consisted of a two-element array, and the first element was
-    # nil. That's because Entry#initialize doesn't like to create an object
-    # without a DN attribute so it adds one: nil. The workaround here is
-    # to wipe out the nil DN after creating the Entry object, and trust the
-    # LDIF string to fill it in. If it doesn't we return a nil at the end.
-    # (30Sep06, FCianfrocca)
+    # As it is, it's useful for unmarshalling objects that we create, but not
+    # for reading arbitrary LDIF files. Eventually, we should have a class
+    # method that parses large LDIF streams into individual LDIF blocks
+    # (delimited by blank lines) and passes them here.
     #
     class << self
       def from_single_ldif_string ldif
@@ -204,35 +184,42 @@ class LDAP
         entry.dn ? entry : nil
       end
     end
+    
+    #--
+    # Part of the support for getter and setter style access to attributes. 
+    #
+    def respond_to?(sym)
+      name = attribute_name(sym)
+      return true if valid_attribute?(name)
+      return super
+    end
 
     #--
-    # Convenience method to convert unknown method names
-    # to attribute references. Of course the method name
-    # comes to us as a symbol, so let's save a little time
-    # and not bother with the to_s.downcase two-step.
-    # Of course that means that a method name like mAIL
-    # won't work, but we shouldn't be encouraging that
-    # kind of bad behavior in the first place.
-    # Maybe we should thow something if the caller sends
-    # arguments or a block...
+    # Supports getter and setter style access for all the attributes that this
+    # entry holds.
     #
-    def method_missing *args, &block # :nodoc:
-      s = args[0].to_s.downcase.intern
-      if attribute_names.include?(s)
-        self[s]
-      elsif s.to_s[-1] == 61 and s.to_s.length > 1
-        value = args[1] or raise RuntimeError.new( "unable to set value" )
-        value = [value] unless value.is_a?(Array)
-        name = s.to_s[0..-2].intern
-        self[name] = value
-      else
-        raise NoMethodError.new( "undefined method '#{s}'" )
+    def method_missing sym, *args, &block # :nodoc:
+      name = attribute_name(sym)
+      
+      if valid_attribute? name 
+        if setter?(sym) && args.size == 1
+          value = args.first
+          value = [value] unless value.instance_of?(Array)
+          self[name]= value
+
+          return value
+        elsif args.empty?
+          return self[name]
+        end
       end
+      
+      super
     end
 
     def write
     end
 
+  private
 
     #--
     # Internal convenience method. It seems like the standard
@@ -251,8 +238,27 @@ class LDAP
       end
       false
     end
-    private :is_attribute_value_binary?
-
+  
+    # Returns the symbol that can be used to access the attribute that
+    # sym_or_str designates.
+    #
+    def attribute_name(sym_or_str)
+      str = sym_or_str.to_s.downcase
+      
+      # Does str match 'something='? Still only returns :something
+      return str[0...-1].to_sym if str.size>1 && str[-1] == ?=
+      return str.to_sym
+    end
+    
+    # Given a valid attribute symbol, returns true. 
+    #
+    def valid_attribute?(attr_name)
+      attribute_names.include?(attr_name)
+    end
+    
+    def setter?(sym)
+      sym.to_s[-1] == ?=
+    end
   end # class Entry
 
 

data/spec/integration/ssl_ber_spec.rb

@@ -1,8 +1,5 @@
 require 'spec_helper'
 
-require 'socket'
-require 'openssl'
-
 require 'net/ldap'
 
 describe "BER serialisation (SSL)" do

data/spec/spec_helper.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Francis Cianfrocca
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-17 00:00:00 -04:00
+date: 2010-03-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency