ruby-activeldap 0.7.4 → 0.8.0

data/LICENSE

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/Manifest.txt

@@ -0,0 +1,33 @@
+Rakefile
+LICENSE
+TODO
+COPYING
+CHANGES
+README
+Manifest.txt
+lib/active_ldap/adaptor/ldap.rb
+lib/active_ldap/adaptor/base.rb
+lib/active_ldap/association/has_many_wrap.rb
+lib/active_ldap/association/has_many.rb
+lib/active_ldap/association/proxy.rb
+lib/active_ldap/association/belongs_to_many.rb
+lib/active_ldap/association/collection.rb
+lib/active_ldap/association/belongs_to.rb
+lib/active_ldap/validations.rb
+lib/active_ldap/command.rb
+lib/active_ldap/callbacks.rb
+lib/active_ldap/ldap.rb
+lib/active_ldap/timeout_stub.rb
+lib/active_ldap/timeout.rb
+lib/active_ldap/attributes.rb
+lib/active_ldap/object_class.rb
+lib/active_ldap/connection.rb
+lib/active_ldap/associations.rb
+lib/active_ldap/user_password.rb
+lib/active_ldap/schema.rb
+lib/active_ldap/configuration.rb
+lib/active_ldap/base.rb
+lib/active_ldap.rb
+benchmark/bench-al.rb
+rails/plugin/active_ldap/init.rb
+rails/plugin/active_ldap/README

data/README

@@ -0,0 +1,63 @@
+Ruby/ActiveLdap -- ruby library for object-oriented LDAP interction
+Copyright (C) 2004-2006 Will Drewry <will@alum.bu.edu>, Kouhei Sutou <kou@cozmixng.org>
+Contributors:
+ * Dick Davies <rasputnik@hellooperator.net>
+ * Nathan Kinder <quicksilver02@mac.com>
+ * Patrick Cole <pac@independent.com.au>
+ * Google Inc.
+
+DESCRIPTION
+'Ruby/ActiveLdap' is a ruby extension library which provides a clean objected
+oriented interface to the Ruby/LDAP[0] library.  It was inspired by
+ActivRecord[2]. This is not nearly as clean or as flexible as ActiveRecord, but
+it is still trivial to define new objects and manipulate them with minimal
+difficulty.
+
+For example and usage - read the rdoc in doc/ from lib/activeldap.rb.
+It is also available on the web at:
+
+http://static.dataspill.org/projects/libraries/ruby/activeldap/rdoc/
+
+PREREQUISITES
+
+  * Ruby 1.8.x [1]
+  * Ruby/LDAP [0]
+  * Log4r [4]
+  * ActiveRecord [2]
+  * (Optional) Ruby/LDAP+GSSAPI [3]
+  * An LDAP server compatible with Ruby/LDAP: OpenLDAP, etc
+
+
+NOTES
+
+  * Only GSSAPI SASL support exists due to Ruby/LDAP limitations
+  * The API is subject to change as this package slowly approaches 1.0.0
+
+
+INSTALL
+
+  - Edit active_ldap/configuration.rb with your LDAP preferences
+  - Run -
+    sudo rake install
+
+
+LICENCE
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Please see the file LICENSE for the terms of the licence.
+
+
+REFERENCES
+
+[0] - http://ruby-ldap.sourceforge.net
+[1] - http://www.ruby-lang.org
+[2] - http://activerecord.rubyonrails.org
+[3] - http://caliban.org/files/redhat/RPMS/i386/ruby-ldap-0.8.2-4.i386.rpm
+[4] - http://log4r.sourceforge.net/
+
+
+

data/Rakefile

@@ -0,0 +1,37 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+$:<<'./lib'
+require 'active_ldap'
+
+Hoe.new('ruby-activeldap', ActiveLdap::VERSION) do |project|
+  project.rubyforge_name = 'ruby-activeldap'
+  project.author = ['Will Drewry', 'Kouhei Sutou']
+  project.email = ['will@alum.bu.edu', 'kou@cozmixng.org']
+  project.summary = 'Ruby/ActiveLdap is a object-oriented API to LDAP'
+  project.url = 'http://rubyforge.org/projects/ruby-activeldap/'
+  project.test_globs = ['test/**']
+  project.changes = project.paragraphs_of('CHANGES', 0..1).join("\n\n")
+  project.extra_deps = [['log4r','>= 1.0.4'], 'activerecord']
+  project.spec_extras = {
+    :requirements => ['ruby-ldap >= 0.8.2', '(Open)LDAP server'],
+    :autorequire => 'active_ldap'
+  }
+  project.description = String.new(<<-EOF)
+    'Ruby/ActiveLdap' is a ruby extension library which provides a clean
+    objected oriented interface to the Ruby/LDAP library.  It was inspired
+    by ActiveRecord. This is not nearly as clean or as flexible as
+    ActiveRecord, but it is still trivial to define new objects and manipulate
+    them with minimal difficulty.
+  EOF
+end
+
+desc 'Tag the repository for release.'
+task :tag do
+  system "svn copy -m 'New release tag' https://ruby-activeldap.googlecode.com/svn/trunk https://ruby-activeldap.googlecode.com/svn/tags/r#{ActiveLdap::VERSION}"
+end
+
+
+
+# vim: syntax=Ruby

data/TODO

@@ -0,0 +1,31 @@
+- Fix case sensitivity in object classes
+- Add result pagination via LDAP::Controls
+- serialize & serialized_attributes
+- schema mgmt - how does AR handle it?
+- columns() -- ?
+http://api.rubyonrails.com/classes/ActiveRecord/Base.html#M000865
+- provide full documentation for new API.
+- handle all exception raised from Ruby/LDAP and wrap as
+  ActiveLdap exception. I think we need to develop an
+  application using ActiveLdap.
+- support Reloadable::Subclasses. I think we need to
+  develop a Rails + ActiveLdap application to improve
+  Rails support.
+- support Ruby/GetText.
+- support Net::LDAP as LDAP backend after Net::LDAP
+  supports START_TLS. (I made a patch and submitted to the
+  bug tracker of Net::LDAP)
+- Add locking around Timeout.alarm() to ensure a multithreaded ruby
+  app doesn't hit any race conditions
+- Add AR matching exceptions:
+* ActiveRecordError -- ActiveLdapError as base
+* AssociationTypeMismatch
+* SerializationTypeMismatch
+* ConnectionNotEstablished
+* RecordNotFound
+* LdapActionInvalid - like StatementInvalid
+* MultiparameterAssignmentErrors
+* AttributeAssignmentError
+* RecordNotSaved
+
+

data/benchmark/bench-al.rb

@@ -0,0 +1,152 @@
+base = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(base))
+$LOAD_PATH.unshift(File.expand_path(File.join(base, "..", "lib")))
+
+require "active_ldap"
+require "benchmark"
+
+LDAP_SERVER = "127.0.0.1"
+LDAP_PORT = 389
+LDAP_BASE = ENV["LDAP_BASE"] || "dc=localdomain"
+LDAP_PREFIX = "ou=People"
+LDAP_USER = nil
+LDAP_PASSWORD = nil
+
+class ALUser < ActiveLdap::Base
+  ldap_mapping :dn_attribute => 'uid', :prefix => LDAP_PREFIX,
+               :classes => ['posixAccount', 'person']
+end
+
+# === search_al
+#
+def search_al
+  count = 0
+  ALUser.find(:all).each do |e|
+    count += 1
+  end
+  return count
+end # -- search_al
+
+def search_al_without_object_creation
+  count = 0
+  ALUser.search.each do |e|
+    count += 1
+  end
+  return count
+end
+
+# === search_ldap
+#
+def search_ldap(conn)
+  count = 0
+  conn.search("#{LDAP_PREFIX},#{LDAP_BASE}",
+              LDAP::LDAP_SCOPE_SUBTREE,
+              "(uid=*)") do |e|
+    count += 1
+  end
+  count
+end # -- search_ldap
+
+def populate_base
+  suffixes = []
+  ActiveLdap::Base.base.split(/,/).reverse_each do |suffix|
+    prefix = suffixes.join(",")
+    suffixes.unshift(suffix)
+    name, value = suffix.split(/=/, 2)
+    next unless name == "dc"
+    dc_class = Class.new(ActiveLdap::Base)
+    dc_class.ldap_mapping :dnattr => "dc",
+                          :prefix => "",
+                          :scope => :base,
+                          :classes => ["top", "dcObject", "organization"]
+    dc_class.instance_variable_set("@base", prefix)
+    next if dc_class.exists?(value, :prefix => "dc=#{value}")
+    dc = dc_class.new(value)
+    dc.o = dc.dc
+    dc.save
+  end
+
+  if ActiveLdap::Base.search.empty?
+    raise "Can't populate #{ActiveLdap::Base.base}"
+  end
+end
+
+def populate_users
+  ou_class = Class.new(ActiveLdap::Base)
+  ou_class.ldap_mapping :dnattr => "ou",
+                        :prefix => "",
+                        :classes => ["top", "organizationalUnit"]
+  ou_class.new(LDAP_PREFIX.split(/=/)[1]).save!
+
+  100.times do |i|
+    name = i.to_s
+    user = ALUser.new(name)
+    user.uid_number = 100000 + i
+    user.gid_number = 100000 + i
+    user.cn = name
+    user.sn = name
+    user.home_directory = "/nonexistent"
+    user.save!
+  end
+end
+
+def populate
+  populate_base
+  populate_users
+end
+
+# === main(argv)
+#
+def main(argv)
+  # Connect with AL
+  #
+  config = {
+    :host => LDAP_SERVER,
+    :port => LDAP_PORT,
+    :base => LDAP_BASE,
+  }
+
+  do_populate = LDAP_USER && LDAP_PASSWORD
+
+  if do_populate
+    config[:bind_format] = LDAP_USER
+    config[:password] = LDAP_PASSWORD
+  end
+  ActiveLdap::Base.establish_connection(config)
+
+  if do_populate
+    puts "populating..."
+    dumped_data = ActiveLdap::Base.dump(:scope => :sub)
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    populate
+  end
+
+  # Standard connection
+  #
+  conn = LDAP::Conn.new(LDAP_SERVER, LDAP_PORT)
+  al_count = 0
+  al_count_without_object_creation = 0
+  ldap_count = 0
+  Benchmark.bm(10) do |x|
+    x.report("AL") { al_count = search_al }
+    x.report("AL(No Obj)") do
+      al_count_without_object_creation = search_al_without_object_creation
+    end
+    x.report("LDAP") { ldap_count = search_ldap(conn) }
+  end
+  print "Entries processed by Ruby/ActiveLdap: #{al_count}\n"
+  print "Entries processed by Ruby/ActiveLdap (without object creation)" +
+        ": #{al_count_without_object_creation}\n"
+  print "Entries processed by Ruby/LDAP: #{ldap_count}\n"
+
+  0
+ensure
+  if do_populate
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    ActiveLdap::Base.load(dumped_data)
+  end
+end
+
+if $0 == __FILE__ then
+ exit(main(ARGV) || 1)
+end

data/lib/{activeldap.rb → active_ldap.rb}

@@ -1,14 +1,14 @@
 #!/usr/bin/ruby
-# = Ruby/ActiveLDAP 
+# = Ruby/ActiveLdap 
 #
-# "Ruby/ActiveLDAP" Copyright (C) 2004,2005 Will Drewry mailto:will@alum.bu.edu
+# "Ruby/ActiveLdap" Copyright (C) 2004,2005 Will Drewry mailto:will@alum.bu.edu
 #
 # == Introduction
 # 
-# Ruby/ActiveLDAP is a novel way of interacting with LDAP.  Most interaction with
+# Ruby/ActiveLdap is a novel way of interacting with LDAP.  Most interaction with
 # LDAP is done using clunky LDIFs, web interfaces, or with painful APIs that
-# required a thick reference manual nearby. Ruby/ActiveLDAP aims to fix that.
-# Inspired by ActiveRecord[http://activerecord.rubyonrails.org], Ruby/ActiveLDAP provides an
+# required a thick reference manual nearby. Ruby/ActiveLdap aims to fix that.
+# Inspired by ActiveRecord[http://activerecord.rubyonrails.org], Ruby/ActiveLdap provides an
 # object oriented interface to LDAP entries.
 # 
 # The target audience is system administrators and LDAP users everywhere that
@@ -29,22 +29,22 @@
 # * RFC1777[http://www.faqs.org/rfcs/rfc1777.html] - Lightweight Directory Access Protocol
 # * OpenLDAP[http://www.openldap.org]
 # 
-# === So why use Ruby/ActiveLDAP?
+# === So why use Ruby/ActiveLdap?
 # 
 # Well if you like to fumble around in the dark, dank innards of LDAP, you can
 # quit reading now.  However, if you'd like a cleaner way to integrate LDAP in to
-# your existing code, hopefully that's why you'll want to use Ruby/ActiveLDAP.
+# your existing code, hopefully that's why you'll want to use Ruby/ActiveLdap.
 # 
 # Using LDAP directly (even with the excellent Ruby/LDAP), leaves you bound to
 # the world of the predefined LDAP API.  While this API is important for many
 # reasons, having to extract code out of LDAP search blocks and create huge
 # arrays of LDAP.mod entries make code harder to read, less intuitive, and just
-# less fun to write.  Hopefully, Ruby/ActiveLDAP will remedy all of these
+# less fun to write.  Hopefully, Ruby/ActiveLdap will remedy all of these
 # problems!
 # 
 # == Getting Started
 # 
-# Ruby/ActiveLDAP does have some overhead when you get started.  You must not
+# Ruby/ActiveLdap does have some overhead when you get started.  You must not
 # only install the package and all of it's requirements, but you must also make
 # customizations that will let it work in your environment.
 # 
@@ -63,12 +63,12 @@
 # Assuming all the requirements are installed, you can install by grabbing the latest tgz file from
 # the download site[http://projects.dataspill.org/libraries/ruby/activeldap/download.html].
 # 
-# The following steps will get the Ruby/ActiveLDAP installed in no time!
+# The following steps will get the Ruby/ActiveLdap installed in no time!
 # 
 #   $ tar -xzvf ruby-activeldap-current.tgz
 #   $ cd ruby-activeldap-VERSION
 # 
-# Edit lib/activeldap/configuration.rb replacing values to match what will work
+# Edit lib/active_ldap/configuration.rb replacing values to match what will work
 # with your LDAP servers. Please note that those variables are required, but can
 # be overridden in any program  as detailed later in this document. Also make
 # sure that "ROOT" stays all upcase.
@@ -82,7 +82,7 @@
 # Now as a quick test, you can run:
 # 
 #   $ irb
-#   irb> require 'activeldap'
+#   irb> require 'active_ldap'
 #   => true
 #   irb> exit
 # 
@@ -93,7 +93,7 @@
 # 
 # === Customizations
 # 
-# Now that Ruby/ActiveLDAP is installed and working, we still have a few more
+# Now that Ruby/ActiveLdap is installed and working, we still have a few more
 # steps to make it useful for programming.
 # 
 # Let's say that you are writing a Ruby program for managing user and group
@@ -119,46 +119,46 @@
 # 
 # == Usage
 # 
-# This section covers using Ruby/ActiveLDAP from writing extension classes to
+# This section covers using Ruby/ActiveLdap from writing extension classes to
 # writing applications that use them.
 # 
 # Just to give a taste of what's to come, here is a quick example using irb:
 # 
-#   irb> require 'activeldap'
+#   irb> require 'active_ldap'
 # 
 # Here's an extension class that maps to the LDAP Group objects:
 # 
-#   irb> class Group < ActiveLDAP::Base
+#   irb> class Group < ActiveLdap::Base
 #   irb* ldap_mapping
 #   irb* end
 # 
 # Here is the Group class in use:
 # 
-#   irb> all_groups = Group.find_all('*')
+#   irb> all_groups = Group.find(:all, '*').collect {|group| group.cn}
 #   => ["root", "daemon", "bin", "sys", "adm", "tty", ..., "develop"]
 #  
-#   irb> group = Group.new("develop")
+#   irb> group = Group.find("develop")
 #   => #<Group:0x..........>
 #  
-#   irb> group.members
+#   irb> group.members.collect {|member| member.uid}
 #   => ["drewry"]
 #  
 #   irb> group.cn
 #   => "develop"
 # 
-#   irb> group.gidNumber
+#   irb> group.gid_number
 #   => "1003"
 # 
 # That's it! No let's get back in to it.
 #
 # === Extension Classes
 # 
-# Extension classes are classes that are subclassed from ActiveLDAP::Base.  They
+# Extension classes are classes that are subclassed from ActiveLdap::Base.  They
 # are used to represent objects in your LDAP server abstractly.
 # 
 # ==== Why do I need them?
 # 
-# Extension classes are what make Ruby/ActiveLDAP "active"! They do all the
+# Extension classes are what make Ruby/ActiveLdap "active"! They do all the
 # background work to make easy-to-use objects by mapping the LDAP object's
 # attributes on to a Ruby class.
 # 
@@ -172,12 +172,13 @@
 # ===== ldap_mapping
 # 
 # ldap_mapping is the only required method to setup an extension class for use
-# with Ruby/ActiveLDAP. It must be called inside of a subclass as shown above.
+# with Ruby/ActiveLdap. It must be called inside of a subclass as shown above.
 # 
 # Below is a much more realistic Group class:
 # 
-#   class Group < ActiveLDAP::Base
-#     ldap_mapping :dnattr => 'cn', :prefix => 'ou=Groups', :classes => ['top', 'posixGroup']<
+#   class Group < ActiveLdap::Base
+#     ldap_mapping :dn_attribute => 'cn',
+#                  :prefix => 'ou=Groups', :classes => ['top', 'posixGroup']
 #                  :scope => LDAP::LDAP_SCOPE_ONELEVEL
 #   end
 # 
@@ -202,35 +203,33 @@
 # 
 #   cn=develop,ou=Groups,dc=dataspill,dc=org
 #   ^^         ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
-#  :dnattr       |         |
+#  :dn_attribute |         |
 #              :prefix     |
 #                :base from configuration.rb
 # 
-# :scope tells ActiveLDAP to only search under ou=Groups, and not to look deeper
+# :scope tells ActiveLdap to only search under ou=Groups, and not to look deeper
 # for dnattr matches. (e.g. cn=develop,ou=DevGroups,ou=Groups,dc=dataspill,dc=org)
 # 
-# Something's missing: :classes.  :classes is used to tell Ruby/ActiveLDAP what
+# Something's missing: :classes.  :classes is used to tell Ruby/ActiveLdap what
 # the minimum requirement is when creating a new object. LDAP uses objectClasses
-# to define what attributes a LDAP object may have. Ruby/ActiveLDAP needs to know
+# to define what attributes a LDAP object may have. Ruby/ActiveLdap needs to know
 # 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) or by modifying the value returned by the accessor, 
-# e.g. Group#objectClass.
+# Group#add_class(*values).
 #
 # 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
 # structural objectclasses may not be removed (or replaced).  Setting a sane default
 # may help avoid programmer error later.
 # 
-# :classes isn't the only optional argument.  If :dnattr is left off, it defaults
-# to 'cn'.  If :prefix is left off, it will default to 'ou=CLASSNAME'. In this
-# case, it would be 'ou=Group'. There is also a :parent_class option which, when
-# specified, adds a method call parent() which will return the 
-# parent_class.new(parent_dn). The parent_dn is the objects dn without the dnattr
-# pair.
+# :classes isn't the only optional argument.  If :dn_attribute is left off,
+# it defaults to underscored class name or 'cn'.  If :prefix is left off,
+# it will default to 'ou=PLURALIZED_CLASSNAME'. In this
+# case, it would be 'ou=Groups'.
 # 
-# :classes should be an Array. :dnattr should be a String and so should :prefix.
+# :classes should be an Array. :dn_attribute should be a String and so should
+# :prefix.
 # 
 # 
 # ===== belongs_to
@@ -249,7 +248,7 @@
 # In the above tree, one such example would be user 'drewry' who is a part of the
 # group 'develop'. You can see this by looking at the 'memberUid' field of 'develop'.
 # 
-#   irb> develop = Group.new('develop')
+#   irb> develop = Group.find('develop')
 #   => ...
 #   irb> develop.memberUid
 #   => ['drewry', 'builder']
@@ -257,35 +256,28 @@
 # If we look at the LDAP entry for 'drewry', we do not see any references to
 # group 'develop'. In order to remedy that, we can use belongs_to
 # 
-#   irb> class User < ActiveLDAP::Base
-#   irb*   ldap_mapping :dnattr => 'uid', :prefix => 'People', :classes => ['top','account']
-#   irb*   belongs_to :groups, :class_name => 'Group', :foreign_key => 'memberUid', :local_key => 'uid'
+#   irb> class User < ActiveLdap::Base
+#   irb*   ldap_mapping :dn_attribute => 'uid', :prefix => 'People', :classes => ['top','account']
+#   irb*   belongs_to :groups, :class => 'Group', :many => 'memberUid', :foreign_key => 'uid'
 #   irb* end
 # 
 # Now, class User will have a method called 'groups' which will retrieve all
 # Group objects that a user is in.
 # 
-#   irb> me = User.new('drewry')
+#   irb> me = User.find('drewry')
 #   irb> me.groups
 #   => [#<Group:0x000001 ...>, #<Group:0x000002 ...>, ...]
-#   irb> me.groups(true).each { |group| p group.cn };nil
+#   irb> me.groups.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.each { |group| p group.dnattr };nil
+#   irb> me.groups.each { |group| p group.id };nil
 #   "cdrom"
 #   "audio"
 #   "develop"
@@ -294,18 +286,18 @@
 # Now let's talk about the arguments.  The first argument is the name of the
 # method you wish to create. In this case, we created a method called groups
 # using the symbol :groups. The next collection of arguments are actually a Hash
-# (as with ldap_mapping). :class_name should be a string that has the name of a
+# (as with ldap_mapping). :class should be a string that has the name of a
 # class you've already included. If you class is inside of a module, be sure to
-# put the whole name, e.g. :class_name => "MyLdapModule::Group". :foreign_key
-# tells belongs_to what attribute Group objects have that match the :local_key.
-# :local_key is the name of the local attribute whose value should be looked up
-# in Group under the foreign key. If :local_key is left off of the argument list,
-# it is assumed to be the dnattr. With this in mind, the above definition could
-# become:
-# 
-#   irb> class User < ActiveLDAP::Base
+# put the whole name, e.g. :class => "MyLdapModule::Group". :primary_key
+# tells belongs_to what attribute Group objects have that match the
+# :many. :many is the name of the local attribute whose value
+# should be looked up in Group under the primary key. If :foreign_key is left
+# off of the argument list, it is assumed to be the dn_attribute. With this in
+# mind, the above definition could become:
+# 
+#   irb> class User < ActiveLdap::Base
 #   irb*   ldap_mapping :dnattr => 'uid', :prefix => 'People', :classes => ['top','account']
-#   irb*   belongs_to :groups, :class_name => 'Group', :foreign_key => 'memberUid'
+#   irb*   belongs_to :groups, :class => 'Group', :many => 'memberUid'
 #   irb* end
 # 
 # In addition, you can do simple membership tests by doing the following:
@@ -322,26 +314,24 @@
 # objects from other trees listed in your object. To show this, we can just
 # invert the example from above:
 # 
-#   class Group < ActiveLDAP::Base
-#     ldap_mapping :dnattr => 'cn', :prefix => 'ou=Groups', :classes => ['top', 'posixGroup']
-#     has_many :members, :class_name => "User", :local_key => "memberUid", :foreign_key => 'uid'
+#   class Group < ActiveLdap::Base
+#     ldap_mapping :dn_attribute => 'cn', :prefix => 'ou=Groups', :classes => ['top', 'posixGroup']
+#     has_many :members, :class => "User", :wrap => "memberUid", :primary_key => 'uid'
 #   end
 # 
 # Now we can see that group develop has user 'drewry' as a member, and it can
 # even return all responses in object form just like belongs_to methods.
 # 
-#   irb> develop = Group.new('develop')
+#   irb> develop = Group.find('develop')
 #   => ...
 #   irb> develop.members
 #   => [#<User:0x000001 ...>, #<User:...>]
-#   irb> develop.members(false)
-#   => ["drewry", "builder"]
 # 
 # 
 # The arguments for has_many follow the exact same idea that belongs_to's
-# arguments followed. :local_key's contents are used to search for matching
-# :foreign_key content.  If :foreign_key is not specified, it defaults to the
-# dnattr of the specified :class_name.
+# arguments followed. :wrap's contents are used to search for matching
+# :primary_key content.  If :primary_key is not specified, it defaults to the
+# dn_attribute of the specified :class.
 # 
 # === Using these new classes
 # 
@@ -351,37 +341,35 @@
 # methods that do not fall in to these categories.
 # 
 # 
-# ==== .find and .find_all
+# ==== .find
 # 
 # .find is a class method that is accessible from any subclass of Base that has
 # 'ldap_mapping' called. When called it returns the first match of the given
 # class.
 # 
-#   irb> Group.find('*')
+#   irb> Group.find('*').cn
 #   => "root"
 # 
 # In this simple example, Group.find took the search string of 'deve*' and
 # searched for the first match in Group where the dnattr matched the query. This
 # is the simplest example of .find.
 # 
-#   irb> Group.find_all('*')
+#   irb> Group.find(:all, '*').collect {|group| group.cn}
 #   => ["root", "daemon", "bin", "sys", "adm", "tty", ..., "develop"]
 # 
-# Here .find_all returns all matches to the same query.  Both .find and .find_all
-# also can take more expressive arguments:
+# Here .find(:all) returns all matches to the same query.  Both .find and
+# .find(:all) also can take more expressive arguments:
 # 
-#   irb> Group.find_all(:attribute => 'gidNumber', :value => '1003', :objects => false)
+#   irb> Group.find(:all, :attribute => 'gidNumber', :value => '1003').collect {|group| group.cn}
 #   => ["develop"]
 # 
 # So it is pretty clear what :attribute and :value do - they are used to query as
-# :attribute=:value. :objects is used to return precreated objects of the given
-# Class when it is set to true.
-# 
-#   irb> Group.find_all(:attribute => 'gidNumber', :value => '1003', :objects => false)
-#   => [#<Group:0x40674a70 ..>]
+# :attribute=:value.
 # 
-# If :objects is unspecified, it defaults to false. If :attribute is unspecified,
-# it defaults to the dnattr.
+# If :attribute is unspecified, it defaults to the dn_attribute.
+#
+# It is also possible to override :attribute and :value by specifying :filter. This
+# argument allows the direct specification of a LDAP filter to retrieve objects by.
 #
 # ==== .search
 # .search is a class method that is accessible from any subclass of Base, and Base.
@@ -390,63 +378,59 @@
 # to cover 80% of the cases where a user would want to use Base.connection directly.
 #
 #   irb> Base.search(:base => 'dc=example,dc=com', :filter => '(uid=roo*)',
-#                    :scope => LDAP::LDAP_SCOPE_SUBTREE, :attrs => ['uid', 'cn'])
-#   =>  [{"dn"=>"uid=root,ou=People,dc=dataspill,dc=org","cn"=>["root"], "uidNumber"=>["0"]}]
-# You can specify the :filter, :base, :scope, and :attrs, but they all have defaults --
+#                    :scope => :sub, :attributes => ['uid', 'cn'])
+#   =>  [["uid=root,ou=People,dc=dataspill,dc=org",{"cn"=>["root"], "uidNumber"=>["0"]}]
+# You can specify the :filter, :base, :scope, and :attributes, but they all have defaults --
 #  * :filter defaults to objectClass=* - usually this isn't what you want
 #  * :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.
+#  * :scope defaults to :sub. Usually you won't need to change it
+#  * :attributes defaults to [] and is the list of attributes you want back. Empty means all of them.
 #
-# ==== #validate
+# ==== #valid?
 # 
-# validate is a method that verifies that all attributes that are required by the
-# 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.
+# valid? is a method that verifies that all attributes that are required by the
+# objects current objectClasses are populated.
 # 
-# ==== #write
+# ==== #save
 # 
-# write is a method that writes any changes to an object back to the LDAP server.
+# save is a method that writes any changes to an object back to the LDAP server.
 # It automatically handles the addition of new objects, and the modification of
 # existing ones.
 # 
-# ==== #exists?
+# ==== .exists?
 # 
 # exists? is a simple method which returns true is the current object exists in
 # LDAP, or false if it does not.
 # 
-#  irb> newuser = User.new("dshadsadsa")
-#  => ...
-#  irb> newuser.exists?
+#  irb> User.exists?("dshadsadsa")
 #  => false
 # 
 # 
-# === ActiveLDAP::Base
+# === ActiveLdap::Base
 # 
-# ActiveLDAP::Base has come up a number of times in the examples above.  Every
+# ActiveLdap::Base has come up a number of times in the examples above.  Every
 # time, it was being used as the super class for the wrapper objects. While this
 # is it's main purpose, it also handles quite a bit more in the background.
 # 
 # ==== What is it?
 # 
-# ActiveLDAP::Base is the heart of Ruby/ActiveLDAP.  It does all the schema
+# ActiveLdap::Base is the heart of Ruby/ActiveLdap.  It does all the schema
 # parsing for validation and attribute-to-method mangling as well as manage the
 # connection to LDAP.
 # 
-# ===== connect
+# ===== establish_connection
 # 
-# Base.connect takes many (optional) arguments and is used to connect to the LDAP
-# server. Sometimes you will want to connect anonymously and other times over TLS
-# with user credentials. Base.connect is here to do all of that for you.
+# Base.establish_connection takes many (optional) arguments and is used to
+# connect to the LDAP server. Sometimes you will want to connect anonymously
+# and other times over TLS with user credentials. Base.connect is here to do
+# all of that for you.
 # 
 # 
-# By default, if you call any subclass of Base, such as Group, it will call 
-# Base.connect() if these is no active LDAP connection. If your server allows
-# anonymous binding, and you only want to access data in a read-only fashion, you
-# won't need to call Base.connect. Here is a fully parameterized call:
+# By default, if you call any subclass of Base, such as Group, it will call
+# Base.establish_connection() if these is no active LDAP connection. If your
+# server allows anonymous binding, and you only want to access data in a
+# read-only fashion, you won't need to call Base.establish_connection. Here
+# is a fully parameterized call:
 # 
 #   Base.connect(
 #     :host => 'ldap.dataspill.org',
@@ -490,18 +474,18 @@
 #   whether the :password_block should be called on each reconnect.
 # * :allow_anonymous determines whether anonymous binding is allowed if other
 #   bind methods fail
-# * :try_sasl, when true, tells ActiveLDAP to attempt a SASL-GSSAPI bind
+# * :try_sasl, when true, tells ActiveLdap to attempt a SASL-GSSAPI bind
 # * :sasl_quiet, when true, tells the SASL libraries to not spew messages to STDOUT
 # * :method indicates whether to use :ssl, :tls, or :plain
 # * :retries - indicates the number of attempts to reconnect that will be undertaken when a stale connection occurs. -1 means infinite.
 # * :retry_wait - seconds to wait before retrying a connection
 # * :ldap_scope - dictates how to find objects. (Default: ONELEVEL)
-# * :return_objects - indicates whether find/find_all will return objects or just the distinguished name attribute value of the matches. Rails users will find this useful.
 # * :timeout - time in seconds - defaults to disabled. This CAN interrupt search() requests. Be warned.
 # * :retry_on_timeout - whether to reconnect when timeouts occur. Defaults to true
 # See lib/configuration.rb for defaults for each option
 # 
-# Base.connect both connects and binds in one step. It follows roughly the following approach:
+# Base.establish_connection both connects and binds in one step. It follows
+# roughly the following approach:
 # 
 # * Connect to host:port using :method
 # 
@@ -511,41 +495,32 @@
 # * If that fails, error out.
 #
 # On connect, the configuration options passed in are stored in an internal class variable
-# @@config which is used to cache the information without ditching the defaults passed in
+# @configuration which is used to cache the information without ditching the defaults passed in
 # from configuration.rb
 # 
-# ===== close
-# 
-# Base.close discards the current LDAP connection.
-# 
 # ===== connection
 # 
-# Base.connection returns the raw LDAP connection object.
+# Base.connection returns the ActiveLdap::Connection object.
 # 
 # === Exceptions
 # 
-# There are a few custom exceptions used in Ruby/ActiveLDAP. They are detailed below.
-# 
-# ==== AttributeEmpty
-# 
-# This exception is raised when a required attribute is empty. It is only raised
-# by #validate, and by proxy, #write.
+# There are a few custom exceptions used in Ruby/ActiveLdap. They are detailed below.
 # 
 # ==== DeleteError
 # 
 # This exception is raised when #delete fails. It will include LDAP error
 # information that was passed up during the error.
 # 
-# ==== WriteError
+# ==== SaveError
 # 
-# This exception is raised when there is a problem in #write updating or creating
+# This exception is raised when there is a problem in #save updating or creating
 # an LDAP entry.  Often the error messages are cryptic. Looking at the server
 # logs or doing an Ethereal[http://www.ethereal.com] dump of the connection will
 # often provide better insight.
 # 
 # ==== AuthenticationError
 # 
-# This exception is raised during Base.connect if no valid authentication methods
+# This exception is raised during Base.establish_connection if no valid authentication methods
 # succeeded.
 # 
 # ==== ConnectionError
@@ -569,7 +544,7 @@
 # 
 # === Putting it all together
 # 
-# Now that all of the components of Ruby/ActiveLDAP have been covered, it's time
+# Now that all of the components of Ruby/ActiveLdap have been covered, it's time
 # to put it all together! The rest of this section will show the steps to setup
 # example user and group management scripts for use with the LDAP tree described
 # above.
@@ -580,18 +555,18 @@
 # 
 # In ldapadmin/lib/ create the file user.rb:
 #   cat <<EOF
-#   class User < ActiveLDAP::Base
-#     ldap_mapping :dnattr => 'uid', :prefix => 'ou=People', :classes => ['top', 'account', 'posixAccount']
-#     belongs_to :groups, :class_name => 'Group', :foreign_key => 'memberUid'
+#   class User < ActiveLdap::Base
+#     ldap_mapping :dn_attribute => 'uid', :prefix => 'ou=People', :classes => ['top', 'account', 'posixAccount']
+#     belongs_to :groups, :class => 'Group', :wrap => 'memberUid'
 #   end
 #   EOF
 # 
 # In ldapadmin/lib/ create the file group.rb:
 #   cat <<EOF
-#   class Group < ActiveLDAP::Base
+#   class Group < ActiveLdap::Base
 #     ldap_mapping :classes => ['top', 'posixGroup'], :prefix => 'ou=Group'
-#     has_many :members, :class_name => "User", :local_key => "memberUid"
-#     belongs_to :primary_members, :class_name => 'User', :foreign_key => 'gidNumber', :local_key => 'gidNumber'
+#     has_many :members, :class => "User", :many => "memberUid"
+#     has_many :primary_members, :class => 'User', :foreign_key => 'gidNumber', :primary_key => 'gidNumber'
 #   end # Group
 #   EOF
 # 
@@ -603,57 +578,90 @@
 # 
 #   #!/usr/bin/ruby -W0
 # 
-#   require 'activeldap'
+#   require 'active_ldap'
 #   require 'lib/user'
 #   require 'lib/group'
 #   require 'password'
 # 
-#   (printf($stderr, "Usage:\n%s name cn uid\n", $0); exit 1) if ARGV.size != 3
-# 
-#   puts "Adding user #{ARGV[0]}"
-#   pwb = Proc.new {
-#     Password.get('Password: ')
-#   }
-#   ActiveLDAP::Base.connect(:password_block => pwb, :allow_anonymous => false)
-#   user = User.new(ARGV[0])
-#   user.objectClass = user.objectClass  << 'posixAccount' << 'shadowAccount'
-#   user.cn = ARGV[1]
-#   user.uidNumber = ARGV[2]
-#   user.gidNumber = ARGV[2]
-#   user.homeDirectory = "/home/#{ARGV[0]}"
-#   user.write
-#   puts "User created!"
-#   exit 0
-# 
-# 
+#   argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+#     opts.banner += " USER_NAME CN UID"
+#   end
+#
+#   if argv.size == 3
+#     name, cn, uid = argv
+#   else
+#     $stderr.puts opts
+#     exit 1
+#   end
+#
+#   pwb = Proc.new do |user|
+#     ActiveLdap::Command.read_password("[#{user}] Password: ")
+#   end
+#
+#   ActiveLdap::Base.establish_connection(:password_block => pwb,
+#                                         :allow_anonymous => false)
+#
+#   if User.exists?(name)
+#     $stderr.puts("User #{name} already exists.")
+#     exit 1
+#   end
+#
+#   user = User.new(name)
+#   user.add_class('shadowAccount')
+#   user.cn = cn
+#   user.uid_number = uid
+#   user.gid_number = uid
+#   user.home_directory = "/home/#{name}"
+#   user.sn = "somesn"
+#   unless user.save
+#     puts "failed"
+#     puts user.errors.full_messages
+#     exit 1
+#   end
+#
 # ==== Managing LDAP entries
 # 
 # Now let's create another dumb script for modifying users - ldapadmin/usermod:
 # 
 #   #!/usr/bin/ruby -W0
 # 
-#   require 'activeldap'
+#   require 'active_ldap'
 #   require 'lib/user'
 #   require 'lib/group'
-#   require 'password'
-# 
-#   (printf($stderr, "Usage:\n%s name cn uid\n", $0); exit 1) if ARGV.size != 3
-# 
-#   puts "Changing user #{ARGV[0]}"
-#   pwb = Proc.new {
-#     Password.get('Password: ')
-#   }
-#   ActiveLDAP::Base.connect(:password_block => pwb, :allow_anonymous => false)
-#   user = User.new(ARGV[0])
-#   user.cn = ARGV[1]
-#   user.uidNumber = ARGV[2]
-#   user.gidNumber = ARGV[2]
-#   user.write
-#   puts "Modification successful!"
-#   exit 0
-# 
-# 
 # 
+#   argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+#     opts.banner += " USER_NAME CN UID"
+#   end
+#
+#   if argv.size == 3
+#     name, cn, uid = argv
+#   else
+#     $stderr.puts opts
+#     exit 1
+#   end
+#
+#   pwb = Proc.new do |user|
+#     ActiveLdap::Command.read_password("[#{user}] Password: ")
+#   end
+#
+#   ActiveLdap::Base.establish_connection(:password_block => pwb,
+#                                         :allow_anonymous => false)
+#
+#   unless User.exists?(name)
+#     $stderr.puts("User #{name} doesn't exist.")
+#     exit 1
+#   end
+#
+#   user = User.find(name)
+#   user.cn = cn
+#   user.uid_number = uid
+#   user.gid_number = uid
+#   unless user.save
+#     puts "failed"
+#     puts user.errors.full_messages
+#     exit 1
+#   end
+#
 # ==== Removing LDAP entries
 # 
 # And finally, a dumb script for removing user - ldapadmin/userdel:
@@ -661,26 +669,38 @@
 # 
 #   #!/usr/bin/ruby -W0
 # 
-#   require 'activeldap'
+#   require 'active_ldap'
 #   require 'lib/user'
 #   require 'lib/group'
-#   require 'password'
-# 
-#   (printf($stderr, "Usage:\n%s name\n", $0); exit 1) if ARGV.size != 1
-# 
-#   puts "Changing user #{ARGV[0]}"
-#   pwb = Proc.new {
-#     Password.get('Password: ')
-#   }
-#   ActiveLDAP::Base.connect(:password_block => pwb, :allow_anonymous => false)
-#   user = User.new(ARGV[0])
-#   user.delete
-#   puts "User has been delete"
-#   exit 0
 # 
+#   argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+#     opts.banner += " USER_NAME"
+#   end
+#
+#   if argv.size == 1
+#     name = argv.shift
+#   else
+#     $stderr.puts opts
+#     exit 1
+#   end
+#
+#   pwb = Proc.new do |user|
+#     ActiveLdap::Command.read_password("[#{user}] Password: ")
+#   end
+#
+#   ActiveLdap::Base.establish_connection(:password_block => pwb,
+#                                         :allow_anonymous => false)
+#
+#   unless User.exists?(name)
+#     $stderr.puts("User #{name} doesn't exist.")
+#     exit 1
+#   end
+#
+#   User.destroy(name)
+#
 # === Advanced Topics
 # 
-# Below are some situation tips and tricks to get the most out of Ruby/ActiveLDAP.
+# Below are some situation tips and tricks to get the most out of Ruby/ActiveLdap.
 # 
 #
 # ==== Binary data and other subtypes
@@ -697,9 +717,9 @@
 #   irb> user.cn
 #   => ["wad", {"lang-en-us" => ["wad", "Will Drewry"]}]
 #   # Now let's add a binary X.509 certificate (assume objectClass is correct)
-#   irb> user.userCertificate = File.read('example.der')
+#   irb> user.user_certificate = File.read('example.der')
 #   => ...
-#   irb> user.write
+#   irb> user.save
 #
 # So that's a lot to take in. Here's what is going on. I just set the LDAP 
 # object's cn to "wad" and cn:lang-en-us to ["wad", "Will Drewry"].
@@ -711,11 +731,11 @@
 # from breaking, and my code from crying.  For correctness, I could have easily 
 # done the following:
 #
-#   irb>  user.userCertificate = {'binary' => File.read('example.der')}
+#   irb>  user.user_certificate = {'binary' => File.read('example.der')}
 #
 # You should note that some binary data does not use the binary subtype all the time.
 # One example is jpegPhoto. You can use it as jpegPhoto;binary or just as jpegPhoto.
-# Since the schema dictates that it is a binary value, Ruby/ActiveLDAP will write
+# Since the schema dictates that it is a binary value, Ruby/ActiveLdap will write
 # it as binary, but the subtype will not be automatically appended as above. The
 # use of the subtype on attributes like jpegPhoto is ultimately decided by the 
 # LDAP site policy and not by any programmatic means.
@@ -742,7 +762,7 @@
 # Example:
 # 
 #   ./myldap.rb:
-#   require 'activeldap'
+#   require 'active_ldap'
 #   require 'myldap/user'
 #   require 'myldap/group'
 #   module MyLDAP
@@ -750,18 +770,18 @@
 # 
 #   ./myldap/user.rb:
 #   module MyLDAP
-#   class User < ActiveLDAP::Base
-#     ldap_mapping :dnattr => 'uid', :prefix => 'ou=People', :classes => ['top', 'account', 'posixAccount']
-#     belongs_to :groups, :class_name => 'MyLDAP::Group', :foreign_key => 'memberUid'
+#   class User < ActiveLdap::Base
+#     ldap_mapping :dn_attribute => 'uid', :prefix => 'ou=People', :classes => ['top', 'account', 'posixAccount']
+#     belongs_to :groups, :class => 'MyLDAP::Group', :many => 'memberUid'
 #   end
 #   end
 # 
 #   ./myldap/group.rb:
 #   module MyLDAP
-#   class Group < ActiveLDAP::Base
+#   class Group < ActiveLdap::Base
 #     ldap_mapping :classes => ['top', 'posixGroup'], :prefix => 'ou=Group'
-#     has_many :members, :class_name => 'MyLDAP::User', :local_key => 'memberUid'
-#     belongs_to :primary_members, :class_name => 'MyLDAP::User', :foreign_key => 'gidNumber', :local_key => 'gidNumber'
+#     has_many :members, :class => 'MyLDAP::User', :wrap => 'memberUid'
+#     has_many :primary_members, :class => 'MyLDAP::User', :foreign_key => 'gidNumber', :primary_key => 'gidNumber'
 #   end
 #   end
 # 
@@ -775,68 +795,43 @@
 # and everything should work well.
 # 
 #
-# ==== Non-array results for single values
+# ==== force array results for single values
 #
-# 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.
+# Even though Ruby/ActiveLdap attempts to maintain programmatic ease by 
+# returning Array values only. By specifying 'true' as an argument to 
+# any attribute method you will get back a Array if it is single value.
 # Here's an example:
 #
 #   irb> user = User.new('drewry')
 #   => ...
-#   irb> user.cn(false)
-#   => "Will Drewry"
+#   irb> user.cn(true)
+#   => ["Will Drewry"]
 #
-# 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/ tab complete the dynamic 
 # attribute methods. You can still see which methods are for attributes using 
-# Base#attributes:
+# Base#attribute_names:
 # 
 #   irb> d = Group.new('develop')
 #   => ...
-#   irb> d.attributes
+#   irb> d.attribute_names
 #   => ["gidNumber", "cn", "memberUid", "commonName", "description", "userPassword", "objectClass"]
 # 
 # 
-# ==== Advanced LDAP queries
-# 
-# With the addition of Base.search, you can do arbitrary queries against LDAP
-# without needed to understand how to use Ruby/LDAP.
-#
-# If that's still not enough, you can access the
-# Ruby/LDAP connection object using the class method Base.connection.  You can
-# do all of your LDAP specific calls here and then continue about your normal
-# Ruby/ActiveLDAP business afterward.
-#
-#
-# ==== Reusing LDAP::Entry objects without reusing the LDAP connection
-#
-# You can call Klass.new(entry) where Klass is some subclass of Base and
-# enty is an LDAP::entry. This use of 'new' is is meant for use from
-# within find_all and find, but you can also use it in tandem with advanced
-# LDAP queries.
-#
-# See tests/benchmark for more insight.
-# 
 # ==== Juggling multiple LDAP connections
 # 
 # In the same vein as the last tip, you can use multiple LDAP connections by
-# saving old connections and then resetting them as follows:
+# per class as follows:
 # 
-#   irb> Base.connect()
+#   irb> anon_class = Class.new(Base)
 #   => ...
-#   irb> anon_conn = Base.connection
+#   irb> anon_class.establish_connection
 #   => ...
-#   irb> Base.connect(password_block => {'mypass'})
+#   irb> auth_class = Class.new(Base)
 #   => ...
-#   irb> auth_conn = Base.connection
+#   irb> auth_class.establish_connection(password_block => {'mypass'})
 #   => ...
-#   irb> Base.connection = anon_conn
-#   ...
 # 
 # This can be useful for doing authentication tests and other such tricks.
 # 
@@ -855,7 +850,7 @@
 # experiment. That's exactly how I ended up with this package. If you come up
 # with something cool, please share it!
 #
-# The internal structure of ActiveLDAP::Base, and thus all its subclasses, is
+# The internal structure of ActiveLdap::Base, and thus all its subclasses, is
 # still in flux. I've tried to minimize the changes to the overall API, but
 # the internals are still rough around the edges.
 #
@@ -865,37 +860,37 @@
 # from Base:
 #   * Base.base()
 #   * Base.required_classes()
-#   * Base.dnattr()
+#   * Base.dn_attribute()
 # You can access these from custom class methods by calling MyClass.base(),
 # or whatever. There are predefined instance methods for getting to these
 # from any new instance methods you define:
 #  * Base#base()
 #  * Base#required_classes()
-#  * Base#dnattr()
+#  * Base#dn_attribute()
 #
 # ===== What else?
 #
 # Well if you want to use the LDAP connection for anything, I'd suggest still
 # calling Base.connection to get it. There really aren't many other internals
-# that need to be worried about.  You could rebind with Base.do_bind, and get
-# the LDAP schema with Base.schema.
+# that need to be worried about.  You could get the LDAP schema with
+# Base.schema.
 #
 # The only other useful tricks are dereferencing and accessing the stored
 # data. Since LDAP attributes can have multiple names, e.g. cn or commonName,
 # any methods you write might need to figure it out. I'd suggest just
-# calling self.[attribname] to get the value, but if that's not good enough,
-# you can call look up the stored name in the @attr_method Array as follows:
-#    irb> @attr_method['commonName']
+# calling self[attribname] to get the value, but if that's not good enough,
+# you can call look up the stored name by #to_real_attribute_name as follows:
+#    irb> to_real_attribute_name('commonName')
 #    => 'cn'
 #
 # This tells you the name the attribute is stored in behind the scenes (@data).
-# Again, self.[attribname] should be enough for most extensions, but if not,
+# Again, self[attribname] should be enough for most extensions, but if not,
 # it's probably safe to dabble here.
 #
 # Also, if you like to look up all aliases for an attribute, you can call the
 # following:
 #
-#  irb> attribute_aliases('cn')
+#  irb> schema.attribute_aliases('cn')
 #  => ['cn','commonName']
 #
 # This is discovered automagically from the LDAP server's schema.
@@ -904,7 +899,7 @@
 #
 # === Speed
 # 
-# Currently, Ruby/ActiveLDAP could be faster.  I have some recursive type
+# Currently, Ruby/ActiveLdap could be faster.  I have some recursive type
 # checking going on which slows object creation down, and I'm sure there
 # are many, many other places optimizations can be done.  Feel free
 # to send patches, or just hang in there until I can optimize away the
@@ -919,25 +914,47 @@
 # Blanket warning hiding. Remove for debugging
 $VERBOSE, verbose = false, $VERBOSE
 
-require 'activeldap/ldap'
-require 'activeldap/schema2'
 if RUBY_PLATFORM.match('linux')
-  require 'activeldap/timeout'
+  require 'active_ldap/timeout'
 else
-  require 'activeldap/timeout_stub'
+  require 'active_ldap/timeout_stub'
+end
+
+require_gem_if_need = Proc.new do |library_name, gem_name|
+  begin
+    require library_name
+  rescue LoadError
+    require 'rubygems'
+    require_gem gem_name
+    require library_name
+  end
 end
-require 'activeldap/base'
-require 'activeldap/associations'
-require 'activeldap/configuration'
 
+require_gem_if_need.call("active_support", "activesupport")
+require 'active_ldap/base'
+require 'active_ldap/associations'
+require 'active_ldap/configuration'
+require 'active_ldap/connection'
+require 'active_ldap/attributes'
+require 'active_ldap/object_class'
+require 'active_ldap/adaptor/ldap'
+
+require_gem_if_need.call("active_record/base", "activerecord")
+require 'active_ldap/validations'
+require 'active_ldap/callbacks'
 
-module ActiveLDAP
-  VERSION = "0.7.4"
+module ActiveLdap
+  VERSION = "0.8.0"
 end
 
-ActiveLDAP::Base.class_eval do
-  include ActiveLDAP::Configuration
-  include ActiveLDAP::Associations
+ActiveLdap::Base.class_eval do
+  include ActiveLdap::Configuration
+  include ActiveLdap::Connection
+  include ActiveLdap::Attributes
+  include ActiveLdap::ObjectClass
+  include ActiveLdap::Associations
+  include ActiveLdap::Validations
+  include ActiveLdap::Callbacks
 end
 
 $VERBOSE = verbose