activeldap3 1.2.3

data/Rakefile

@@ -0,0 +1,121 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'find'
+
+base_dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(base_dir, 'lib'))
+require 'active_ldap'
+
+truncate_base_dir = Proc.new do |x|
+  x.gsub(/\A#{Regexp.escape(base_dir + File::SEPARATOR)}/, '')
+end
+
+manifest = File.join(base_dir, "Manifest.txt")
+manifest_contents = []
+base_dir_included_components = %w(CHANGES COPYING LICENSE Manifest.txt
+                                  README Rakefile TODO)
+excluded_components = %w(.svn .test-result .config doc log tmp
+                         pkg html config.yaml database.yml ldap.yml)
+excluded_suffixes = %w(.help .sqlite3)
+white_list_paths =
+  [
+   "rails/plugin/active_ldap/generators/scaffold_al/templates/ldap.yml",
+   "rails_generators/scaffold_active_ldap/templates/ldap.yml",
+  ]
+Find.find(base_dir + File::SEPARATOR) do |target|
+  target = truncate_base_dir[target]
+  components = target.split(File::SEPARATOR)
+  next if components.empty?
+  if components.size == 1 and !File.directory?(target)
+    next unless base_dir_included_components.include?(components[0])
+  end
+  unless white_list_paths.include?(target)
+    Find.prune if (excluded_components - components) != excluded_components
+    next if excluded_suffixes.include?(File.extname(target))
+  end
+  manifest_contents << target if File.file?(target)
+end
+
+File.open(manifest, "w") do |f|
+  f.puts manifest_contents.sort.join("\n")
+end
+at_exit do
+  FileUtils.rm_f(manifest)
+end
+
+# For Hoe's no user friendly default behavior. :<
+File.open("README.txt", "w") {|file| file << "= Dummy README\n== XXX\n"}
+FileUtils.cp("CHANGES", "History.txt")
+at_exit do
+  FileUtils.rm_f("README.txt")
+  FileUtils.rm_f("History.txt")
+end
+
+ENV["VERSION"] = ActiveLdap::VERSION
+project = Hoe.spec('activeldap') do
+  self.version = ActiveLdap::VERSION
+  self.rubyforge_name = 'ruby-activeldap'
+  self.author = ['Will Drewry', 'Kouhei Sutou']
+  self.email = ['redpig@dataspill.org', 'kou@cozmixng.org']
+  self.summary = 'ActiveLdap is a object-oriented API to LDAP'
+  self.url = 'http://rubyforge.org/projects/ruby-activeldap/'
+  self.test_globs = ['test/test_*.rb']
+  self.changes = self.paragraphs_of('CHANGES', 1..2).join("\n\n")
+  self.extra_deps = [
+                     # ['ruby-ldap', '= 0.9.9'],
+                     # ['net-ldap', '= 0.1.1'],
+                     ['activerecord', '= 2.3.8'],
+                     ['locale', '= 2.0.5'],
+                     ['gettext', '= 2.1.0'],
+                     ['fast_gettext', '= 0.5.8'],
+                     ['gettext_i18n_rails', '= 0.2.2'],
+                    ]
+  self.remote_rdoc_dir = "doc"
+  self.rsync_args += " --chmod=Dg+ws,Fg+w"
+  self.description = String.new(<<-EOF)
+    '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
+
+project.spec.extra_rdoc_files = ["README", "CHANGES", "COPYING", "LICENSE"]
+
+publish_docs_actions = task(:publish_docs).instance_variable_get("@actions")
+original_project_name = nil
+before_publish_docs = Proc.new do
+  original_project_name = project.name
+  project.name = "doc"
+end
+after_publish_docs = Proc.new do
+  project.name = original_project_name
+end
+publish_docs_actions.unshift(before_publish_docs)
+publish_docs_actions.push(after_publish_docs)
+
+
+rdoc_main = "lib/active_ldap.rb"
+project.spec.rdoc_options.each do |option|
+  option.replace(rdoc_main) if option == "README.txt"
+end
+ObjectSpace.each_object(Rake::RDocTask) do |task|
+  task.main = rdoc_main if task.main == "README.txt"
+  task.rdoc_files = project.spec.require_paths + project.spec.extra_rdoc_files
+end
+
+begin
+  require "gettext_i18n_rails/tasks"
+rescue LoadError
+  puts "gettext_i18n_rails is not installed, you probably should run 'rake gems:install' or 'bundle install'."
+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,32 @@
+- [1.1.x] add :readonly option to :has_many.
+- Work as framework on Rails.
+- How to support dSCorePropagationData? ignore it?
+  all systemOnly == "TRUE" attribute can be ignored?
+- Add parsing position to DistinguishedNameInvalid error like
+  <NAME=VALUE,INVALID_HERE>@<REST=INPUT>.
+- Support TLS optioins (e.g. CA certification file and so on)
+- Provide FormHelper for LDAP entry's attribute to handle multiple values
+  (["foo", "bar", ...]) and option value ({"binary" => "..."},
+  {"lang-en-us" => "..."})
+- Test SASL bind.
+- 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.
+- 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/activeldap3.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "activeldap3"
+  s.version = '1.2.3'
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Will Drewry", "Kouhei Sutou", "koutou", "Kenny Ortmann"]
+  s.email = ['kenny.ortmann@gmail.com']
+  s.homepage = "https://github.com/asynchrony/ruby-activeldap"
+  s.summary = %q{working towards getting active ldap to work on rails 3}
+  s.description = %q{working towards getting active ldap to work on rails 3}
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "po"]
+end

data/benchmark/bench-al.rb

@@ -0,0 +1,263 @@
+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"
+
+include ActiveLdap::GetTextSupport
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  options.prefix = "ou=People"
+
+  opts.on("--prefix=PREFIX",
+          _("Specify prefix for benchmarking"),
+          _("(default: %s)") % options.prefix) do |prefix|
+    options.prefix = prefix
+  end
+end
+
+ActiveLdap::Base.setup_connection
+config = ActiveLdap::Base.configuration
+
+LDAP_HOST = config[:host]
+LDAP_METHOD = config[:method]
+if LDAP_METHOD == :ssl
+  LDAP_PORT = config[:port] || URI::LDAPS::DEFAULT_PORT
+else
+  LDAP_PORT = config[:port] || URI::LDAP::DEFAULT_PORT
+end
+LDAP_BASE = config[:base]
+LDAP_PREFIX = options.prefix
+LDAP_USER = config[:bind_dn]
+LDAP_PASSWORD = config[:password]
+
+class ALUser < ActiveLdap::Base
+  ldap_mapping :dn_attribute => 'uid', :prefix => LDAP_PREFIX,
+               :classes => ['posixAccount', 'person']
+end
+
+class ALUserLdap < ALUser
+end
+ALUserLdap.setup_connection(config.merge(:adapter => "ldap"))
+
+class ALUserNetLdap < ALUser
+end
+ALUserNetLdap.setup_connection(config.merge(:adapter => "net-ldap"))
+
+def search_al_ldap
+  count = 0
+  ALUserLdap.find(:all).each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_net_ldap
+  count = 0
+  ALUserNetLdap.find(:all).each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_ldap_without_object_creation
+  count = 0
+  ALUserLdap.search.each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_net_ldap_without_object_creation
+  count = 0
+  ALUserNetLdap.search.each do |e|
+    count += 1
+  end
+  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 search_net_ldap(conn)
+  count = 0
+  conn.search(:base => "#{LDAP_PREFIX},#{LDAP_BASE}",
+              :scope => Net::LDAP::SearchScope_WholeSubtree,
+              :filter => "(uid=*)") do |e|
+    count += 1
+  end
+  count
+end
+
+def ldap_connection
+  require 'ldap'
+  if LDAP_METHOD == :tls
+    conn = LDAP::SSLConn.new(LDAP_HOST, LDAP_PORT, true)
+  else
+    conn = LDAP::Conn.new(LDAP_HOST, LDAP_PORT)
+  end
+  conn.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+  conn.bind(LDAP_USER, LDAP_PASSWORD) if LDAP_USER and LDAP_PASSWORD
+  conn
+rescue LoadError
+  nil
+end
+
+def net_ldap_connection
+  require 'net/ldap'
+  net_ldap_conn = Net::LDAP::Connection.new(:host => LDAP_HOST,
+                                            :port => LDAP_PORT)
+  if LDAP_USER and LDAP_PASSWORD
+    net_ldap_conn.setup_encryption(:method => :start_tls) if LDAP_METHOD == :tls
+    net_ldap_conn.bind(:method => :simple,
+                       :username => LDAP_USER,
+                       :password => LDAP_PASSWORD)
+  end
+  net_ldap_conn
+rescue LoadError
+  nil
+end
+
+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 :dn_attribute => "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
+    begin
+      dc.save
+    rescue ActiveLdap::OperationNotPermitted
+    end
+  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 :dn_attribute => "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
+#
+def main(do_populate)
+  if do_populate
+    puts(_("Populating..."))
+    dumped_data = ActiveLdap::Base.dump(:scope => :sub)
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    populate
+    puts
+  end
+
+  # Standard connection
+  #
+  ldap_conn = ldap_connection
+  net_ldap_conn = net_ldap_connection
+
+  al_ldap_count = 0
+  al_net_ldap_count = 0
+  al_ldap_count_without_object_creation = 0
+  al_net_ldap_count_without_object_creation = 0
+  ldap_count = 0
+  net_ldap_count = 0
+  Benchmark.bmbm(20) do |x|
+    [1].each do |n|
+      GC.start
+      x.report("%3dx: AL(LDAP)" % n) do
+        n.times {al_ldap_count = search_al_ldap}
+      end
+      GC.start
+      x.report("%3dx: AL(Net::LDAP)" % n) do
+        n.times {al_net_ldap_count = search_al_net_ldap}
+      end
+      GC.start
+      x.report("%3dx: AL(LDAP: No Obj)" % n) do
+        n.times do
+          al_ldap_count_without_object_creation =
+            search_al_ldap_without_object_creation
+        end
+      end
+      x.report("%3dx: AL(Net::LDAP: No Obj)" % n) do
+        n.times do
+          al_net_ldap_count_without_object_creation =
+            search_al_net_ldap_without_object_creation
+        end
+      end
+      GC.start
+      if ldap_conn
+        x.report("%3dx: LDAP" % n) do
+          n.times {ldap_count = search_ldap(ldap_conn)}
+        end
+      end
+      GC.start
+      if net_ldap_conn
+        x.report("%3dx: Net::LDAP" % n) do
+          n.times {net_ldap_count = search_net_ldap(net_ldap_conn)}
+        end
+      end
+    end
+  end
+
+  puts
+  puts(_("Entries processed by Ruby/ActiveLdap + LDAP: %d") % al_ldap_count)
+  puts(_("Entries processed by Ruby/ActiveLdap + Net::LDAP: %d") % \
+       al_net_ldap_count)
+  puts(_("Entries processed by Ruby/ActiveLdap + LDAP: " \
+         "(without object creation): %d") % \
+       al_ldap_count_without_object_creation)
+  puts(_("Entries processed by Ruby/ActiveLdap + Net::LDAP: " \
+         "(without object creation): %d") % \
+       al_net_ldap_count_without_object_creation)
+  puts(_("Entries processed by Ruby/LDAP: %d") % ldap_count)
+  puts(_("Entries processed by Net::LDAP: %d") % net_ldap_count)
+ensure
+  if do_populate
+    puts
+    puts(_("Cleaning..."))
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    ActiveLdap::Base.load(dumped_data)
+  end
+end
+
+main(LDAP_USER && LDAP_PASSWORD)

data/benchmark/config.yaml.sample

@@ -0,0 +1,5 @@
+host: 127.0.0.1
+base: dc=bench,dc=localcomain
+method: :tls
+bind_dn: cn=user-name,dc=localdomain
+password: secret

data/examples/al-admin/README

@@ -0,0 +1,182 @@
+== Welcome to Rails
+
+Rails is a web-application and persistence framework that includes everything
+needed to create database-backed web-applications according to the
+Model-View-Control pattern of separation. This pattern splits the view (also
+called the presentation) into "dumb" templates that are primarily responsible
+for inserting pre-built data in between HTML tags. The model contains the
+"smart" domain objects (such as Account, Product, Person, Post) that holds all
+the business logic and knows how to persist themselves to a database. The
+controller handles the incoming requests (such as Save New Account, Update
+Product, Show Post) by manipulating the model and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails.  You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting started
+
+1. At the command prompt, start a new rails application using the rails command
+   and your application name. Ex: rails myapp
+   (If you've downloaded rails in a complete tgz or zip, this step is already done)
+2. Change directory into myapp and start the web server: <tt>script/server</tt> (run with --help for options)
+3. Go to http://localhost:3000/ and get "Welcome aboard: You’re riding the Rails!"
+4. Follow the guidelines to start developing your application
+
+
+== Web Servers
+
+By default, Rails will try to use Mongrel and lighttpd if they are installed, otherwise
+Rails will use the WEBrick, the webserver that ships with Ruby. When you run script/server,
+Rails will check if Mongrel exists, then lighttpd and finally fall back to WEBrick. This ensures
+that you can always get up and running quickly.
+
+Mongrel is a Ruby-based webserver with a C-component (which requires compilation) that is
+suitable for development and deployment of Rails applications. If you have Ruby Gems installed,
+getting up and running with mongrel is as easy as: <tt>gem install mongrel</tt>.
+More info at: http://mongrel.rubyforge.org
+
+If Mongrel is not installed, Rails will look for lighttpd. It's considerably faster than
+Mongrel and WEBrick and also suited for production use, but requires additional
+installation and currently only works well on OS X/Unix (Windows users are encouraged
+to start with Mongrel). We recommend version 1.4.11 and higher. You can download it from
+http://www.lighttpd.net.
+
+And finally, if neither Mongrel or lighttpd are installed, Rails will use the built-in Ruby
+web server, WEBrick. WEBrick is a small Ruby web server suitable for development, but not
+for production.
+
+But of course its also possible to run Rails on any platform that supports FCGI.
+Apache, LiteSpeed, IIS are just a few. For more information on FCGI,
+please visit: http://wiki.rubyonrails.com/rails/pages/FastCGI
+
+
+== Debugging Rails
+
+Have "tail -f" commands running on the server.log and development.log. Rails will
+automatically display debugging and runtime information to these files. Debugging
+info will also be shown in the browser on requests from 127.0.0.1.
+
+
+== Breakpoints
+
+Breakpoint support is available through the script/breakpointer client. This
+means that you can break out of execution at any point in the code, investigate
+and change the model, AND then resume execution! Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.find(:all)
+      breakpoint "Breaking out from the list"
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the breakpointer window. Here you can do things like:
+
+Executing breakpoint "Breaking out from the list" at .../webrick_server.rb:16 in 'breakpoint'
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8 @attributes={\"title\"=>nil, \"body\"=>nil, \"id\"=>\"1\"}>,
+       #<Post:0x14a6620 @attributes={\"title\"=>\"Rails you know!\", \"body\"=>\"Only ten..\", \"id\"=>\"2\"}>]"
+  >> @posts.first.title = "hello from a breakpoint"
+  => "hello from a breakpoint"
+
+...and even better is that you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you press CTRL-D
+
+
+== Console
+
+You can interact with the domain model by starting the console through <tt>script/console</tt>.
+Here you'll have all parts of the application configured, just like it is when the
+application is running. You can inspect domain models, change values, and save to the
+database. Starting the script without arguments will launch it in the development environment.
+Passing an argument will specify a different environment, like <tt>script/console production</tt>.
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+
+
+== Description of contents
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from ApplicationController
+  which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb.
+  Most models will descend from ActiveRecord::Base.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.rhtml for the WeblogsController#index action. All views use eRuby
+  syntax.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the common
+  header/footer method of wrapping views. In your views, define a layout using the
+  <tt>layout :default</tt> and create a file named default.rhtml. Inside default.rhtml,
+  call <% yield %> to render the view using this layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are generated
+  for you automatically when using script/generate for controllers. Helpers can be used to
+  wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database, and other dependencies.
+
+components
+  Self-contained mini-applications that can bundle together controllers, models, and views.
+
+db
+  Contains the database schema in schema.rb.  db/migrate contains all
+  the sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when generated
+  using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that doesn't
+  belong under controllers, models, or helpers. This directory is in the load path.
+
+public
+  The directory available for the web server. Contains subdirectories for images, stylesheets,
+  and javascripts. Also contains the dispatchers and the default HTML files. This should be
+  set as the DOCUMENT_ROOT of your web server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the script/generate scripts, template
+  test files will be generated for you and placed in this directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins subdirectory.
+  This directory is in the load path.