treequel 1.2.2 → 1.3.0pre384

data/History.md

@@ -1,3 +1,42 @@
+## 1.3.0 [2011-01-07] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+* Made Treequel::Model act more like an ORM -- changes made to the object aren't synced
+  with the directory until #save is called. New methods:
+  - Treequel::Model#save
+  - Treequel::Model#modifications
+  - Treequel::Model#modifications_ldif
+  - Treequel::Model#validate
+  - Treequel::Model#valid?
+  - Treequel::Model#errors
+  - Treequel::Model#revert
+  - Treequel::Model#modified?
+  New classes:
+  - Treequel::Model::Errors
+  - Treequel::ValidationFailed
+* Extracted the controls behavior and rewrote the control specs to use it. This is
+  so people who may wish to implement their own controls can ensure that it's
+  compatible with Treequel.
+* Added a directory-introspection tool (treewhat)
+* Added Treequel::Model::ObjectClass.create for easy creation of entries that conform
+  to an objectClass mixin's criteria
+* Treequel::Directory.root_dse now returns Treequel::Branches
+* Added Treequel::Directory#reconnect.
+
+Bugfixes:
+
+* Fixed a bug in Treequel::Branch#merge for values that need conversion
+* Simplified and removed duplication from the logging code
+* Fixed a bug in the proxy method for single-letter attribute names.
+* Monkeypatched Date for LDAP time type conversions
+* Change the return values of unset attributes to distinguish between SINGLE and non-SINGLE 
+  attributes
+* Treequel::Branch
+  - Check for explicit nil DN in .new
+  - Check for nil parent_dn in #parent
+  - Use 'top' instead of :top as objectClass default
+
 
 ## 1.2.2 [2010-12-14] Michael Granger <ged@FaerieMUD.org>
 

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2008-2010, Michael Granger and Mahlon E. Smith
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author/s, nor the names of the project's
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -75,11 +75,34 @@ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+This software includes some code from the Sequel database toolkit, used under 
+the following license terms:
+
+  Copyright (c) 2007-2008 Sharon Rosner
+  Copyright (c) 2008-2010 Jeremy Evans
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to
+  deal in the Software without restriction, including without limitation the
+  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+  sell copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+    
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+     
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  
 
 ## Authors
 
-* Michael Granger
-* Mahlon E. Smith
+* Michael Granger <ged@FaerieMUD.org>
+* Mahlon E. Smith <mahlon@martini.nu>
 
 
 ## Contributors

data/Rakefile

@@ -2,9 +2,10 @@
 
 require 'hoe'
 
-Hoe.plugin :hg
+Hoe.plugin :mercurial
 Hoe.plugin :yard
 Hoe.plugin :signing
+Hoe.plugin :manualgen
 
 Hoe.plugins.delete :rubyforge
 
@@ -15,47 +16,81 @@ hoespec = Hoe.spec 'treequel' do
 	self.developer 'Michael Granger', 'ged@FaerieMUD.org'
 	self.developer 'Mahlon E. Smith', 'mahlon@martini.nu'
 
-
-	self.extra_deps <<
-		['ruby-ldap', '~> 0.9.11']
-	self.extra_dev_deps <<
-		['rspec', '~> 2.1.0'] <<
-		['ruby-termios', '~> 0.9.6'] <<
-		['ruby-terminfo', '~> 0.1.1'] <<
-		['yard', '~> 0.6.1']
+	self.extra_deps.push *{
+		'ruby-ldap' => '~> 0.9.11'
+	}
+	self.extra_dev_deps.push *{
+		'rspec'         => '~> 2.4.0',
+		'ruby-termios'  => '~> 0.9.6',
+		'ruby-terminfo' => '~> 0.1.1',
+		'columnize'     => '~> 0.3.1',
+	}
 
 	self.spec_extras[:licenses] = ["BSD"]
 	self.spec_extras[:post_install_message] = [
-			"If you want to use the included 'treequel' LDAP shell, you'll need to install",
-			"the following libraries as well:",
-			"    - termios",
-			"    - ruby-terminfo",
-			"    - columnize",
-		  ].join( "\n" )
-    self.spec_extras[:signing_key] = '/Volumes/Keys/ged-private_gem_key.pem'
+		"If you want to use the included 'treequel' LDAP shell, you'll need to install",
+		"the following libraries as well:",
+		'',
+		"    - termios",
+		"    - ruby-terminfo",
+		"    - columnize",
+		'',
+		"You can install those automatically if you use the --development flag when",
+		"installing Treequel."
+	  ].join( "\n" )
+	self.spec_extras[:signing_key] = '/Volumes/Keys/ged-private_gem_key.pem'
 
 	self.require_ruby_version( '>=1.8.7' )
 
-	self.hg_sign_tags = true
+	self.hg_sign_tags = true if self.respond_to?( :hg_sign_tags= )
+	self.manual_source_dir = 'src' if self.respond_to?( :manual_source_dir= )
+	self.yard_opts = [ '--use-cache', '--protected', '--verbose' ] if
+		self.respond_to?( :yard_opts= )
 
-	self.yard_opts = [ '--use-cache', '--protected', '--verbose' ]
+	self.rdoc_locations << "deveiate:/usr/local/www/public/code/#{remote_rdoc_dir}"
 end
 
 ENV['VERSION'] ||= hoespec.spec.version.to_s
 
-include Hoe::MercurialHelpers
+begin
+	include Hoe::MercurialHelpers
+
+	task 'hg:precheckin' => :spec
 
-### Task: prerelease
-desc "Append the package build number to package versions"
-task :pre do
-	rev = get_numeric_rev()
-	trace "Current rev is: %p" % [ rev ]
-	hoespec.spec.version.version << "pre#{rev}"
-	Rake::Task[:gem].clear
+	### Task: prerelease
+	desc "Append the package build number to package versions"
+	task :pre do
+		rev = get_numeric_rev()
+		trace "Current rev is: %p" % [ rev ]
+		hoespec.spec.version.version << "pre#{rev}"
+		Rake::Task[:gem].clear
 
-	Gem::PackageTask.new( hoespec.spec ) do |pkg|
-		pkg.need_zip = true
-		pkg.need_tar = true
+		Gem::PackageTask.new( hoespec.spec ) do |pkg|
+			pkg.need_zip = true
+			pkg.need_tar = true
+		end
 	end
+
+	### Make the ChangeLog update if the repo has changed since it was last built
+	file '.hg/branch'
+	file 'ChangeLog' => '.hg/branch' do |task|
+		$stderr.puts "Updating the changelog..."
+		content = make_changelog()
+		File.open( task.name, 'w', 0644 ) do |fh|
+			fh.print( content )
+		end
+	end
+
+	# Rebuild the ChangeLog immediately before release
+	task :prerelease => 'ChangeLog'
+
+rescue NameError => err
+	task :no_hg_helpers do
+		fail "Couldn't define the :pre task: %s: %s" % [ err.class.name, err.message ]
+	end
+
+	task :pre => :no_hg_helpers
+	task 'ChangeLog' => :no_hg_helpers
+
 end
 

data/bin/treequel

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-
 require 'abbrev'
 require 'columnize'
 require 'diff/lcs'
@@ -44,9 +42,9 @@ module IRB # :nodoc:
 	def self.start_session( obj )
 		unless @__initialized
 			args = ARGV
-			ARGV.replace(ARGV.dup)
-			IRB.setup(nil)
-			ARGV.replace(args)
+			ARGV.replace( ARGV.dup )
+			IRB.setup( nil )
+			ARGV.replace( args )
 			@__initialized = true
 		end
 
@@ -91,16 +89,6 @@ class Treequel::Shell
 	CLEAR_TO_EOL       = "\e[K"
 	CLEAR_CURRENT_LINE = "\e[2K"
 
-	# Log levels
-	LOG_LEVELS = {
-		'debug' => Logger::DEBUG,
-		'info'  => Logger::INFO,
-		'warn'  => Logger::WARN,
-		'error' => Logger::ERROR,
-		'fatal' => Logger::FATAL,
-	}.freeze
-	LOG_LEVEL_NAMES = LOG_LEVELS.invert.freeze
-
 	# Valid connect-type arguments
 	VALID_CONNECT_TYPES = %w[tls ssl plain]
 
@@ -137,6 +125,10 @@ class Treequel::Shell
 	### the LDAP URI.
 	def self::parse_options( argv )
 		progname = File.basename( $0 )
+		loglevels = Treequel::LOG_LEVELS.
+			sort_by {|_,lvl| lvl }.
+			collect {|name,lvl| name.to_s }.
+			join(', ')
 		bind_as = nil
 
 		oparser = OptionParser.new( "Usage: #{progname} [OPTIONS] [LDAPURL]" ) do |oparser|
@@ -146,10 +138,9 @@ class Treequel::Shell
 				bind_as = dn
 			end
 
-			oparser.on( '--loglevel=LEVEL', '-l LEVEL', Treequel::Loggable::LEVEL.keys, 
-				"Set the logging level. Should be one of:",
-				Treequel::Loggable::LEVEL.keys.collect {|lvl| lvl.to_s } ) do |lvl|
-				Treequel.logger.level = Treequel::Loggable::LEVEL[ lvl.to_sym ] or
+			oparser.on( '--loglevel=LEVEL', '-l LEVEL', Treequel::LOG_LEVELS.keys,
+				"Set the logging level. Should be one of:", loglevels ) do |lvl|
+				Treequel.logger.level = Treequel::LOG_LEVELS[ lvl ] or
 					raise "Invalid logging level %p" % [ lvl ]
 			end
 
@@ -234,7 +225,7 @@ class Treequel::Shell
 		# If the user said to bind as someone on the command line, invoke a
 		# 'bind' command before dropping into the command line
 		if bind_as
-			options = OpenStruct.new
+			options = OpenStruct.new # dummy options object
 			self.bind_command( options, bind_as )
 		end
 
@@ -454,23 +445,23 @@ class Treequel::Shell
 	def log_command( options, *args )
 		newlevel = args.shift
 		if newlevel
-			if LOG_LEVELS.key?( newlevel )
-				Treequel.logger.level = LOG_LEVELS[ newlevel ]
+			if Treequel::LOG_LEVELS.key?( newlevel )
+				Treequel.logger.level = Treequel::LOG_LEVELS[ newlevel ]
 				message "Set log level to: %s" % [ newlevel ]
 			else
-				levelnames = LOG_LEVEL_NAMES.keys.sort.join(', ')
+				levelnames = Treequel::LOG_LEVEL_NAMES.keys.sort.join(', ')
 				raise "Invalid log level %p: valid values are:\n   %s" % [ newlevel, levelnames ]
 			end
 		else
 			message "Log level is currently: %s" %
-				[ LOG_LEVEL_NAMES[Treequel.logger.level] ]
+				[ Treequel::LOG_LEVEL_NAMES[Treequel.logger.level] ]
 		end
 	end
 	set_options :log do |oparser, options|
 		oparser.banner = "log [LEVEL]"
 		oparser.separator 'Set the logging level, or display the current level if no level ' +
 		                  "is given. Valid log levels are: %s" %
-		                  LOG_LEVEL_NAMES.keys.sort.join(', ')
+		                  Treequel::LOG_LEVEL_NAMES.keys.sort.join(', ')
 	end
 
 

data/bin/treewhat

@@ -0,0 +1,318 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'abbrev'
+require 'trollop'
+require 'highline'
+require 'shellwords'
+require 'sysexits'
+
+require 'treequel'
+require 'treequel/mixins'
+require 'treequel/constants'
+
+
+# A tool for displaying information about a directory's records and schema artifacts.
+class Treequel::What
+	extend Sysexits
+	include Sysexits,
+	        Treequel::Loggable,
+	        Treequel::ANSIColorUtilities,
+	        Treequel::Constants::Patterns,
+	        Treequel::HashUtilities
+
+	COLOR_SCHEME = HighLine::ColorScheme.new do |scheme|
+		scheme[:header]	   = [ :bold, :yellow ]
+		scheme[:subheader] = [ :bold, :white ]
+		scheme[:key]	   = [ :white ]
+		scheme[:value]	   = [ :bold, :white ]
+		scheme[:error]	   = [ :red ]
+		scheme[:warning]   = [ :yellow ]
+		scheme[:message]   = [ :reset ]
+	end
+
+
+	### Run the utility with the given +args+.
+	def self::run( args )
+		HighLine.color_scheme = COLOR_SCHEME
+
+		oparser = self.make_option_parser
+		opts = Trollop.with_standard_exception_handling( oparser ) do
+			oparser.parse( args )
+		end
+
+		pattern = oparser.leftovers.join( ' ' ) if oparser.leftovers
+
+		self.new( opts ).run( pattern )
+		exit :ok
+
+	rescue => err
+		Treequel.logger.fatal "Oops: %s: %s" % [ err.class.name, err.message ]
+		Treequel.logger.debug { '  ' + err.backtrace.join("\n  ") }
+
+		exit :software_error
+	end
+
+
+	### Create and configure a command-line option parser for the command.
+	### @return [Trollop::Parser] the option parser
+	def self::make_option_parser
+		progname = File.basename( $0 )
+		default_directory = Treequel.directory_from_config
+		loglevels = Treequel::LOG_LEVELS.
+			sort_by {|name,lvl| lvl }.
+			collect {|name,lvl| name.to_s }.
+			join( ', ' )
+
+		return Trollop::Parser.new do
+			banner "Usage: #{progname} [OPTIONS] [PATTERN]"
+
+			text ''
+			text %{Search for an object in an LDAP directory that matches PATTERN and } +
+			     %{display some information about it.}
+			text ''
+			text %{The PATTERN can be the DN (or RDN relative to the base) of an entry, } +
+			     %{a search filter, or the name of an artifact in the directory's schema, } +
+			     %{such as an objectClass, matching rule, syntax, etc.}
+			text ''
+			text %{If no PATTERN is specified, general information about the directory is } +
+			     %{output instead.}
+			text ''
+
+			text 'Options:'
+			opt :ldapurl, "Specify the directory to connect to.",
+				:default => default_directory.uri.to_s
+			opt :debug, "Turn debugging on. Also sets the --loglevel to 'debug'."
+			opt :loglevel, "Set the logging level. Must be one of: #{loglevels}",
+				:default => Treequel::LOG_LEVEL_NAMES[ Treequel.logger.level ]
+			opt :binddn, "The DN of the user to bind as. Defaults to anonymous binding.",
+				:type => :string
+		end
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Create a new instance of the command and set it up with the given
+	### +options+.
+	def initialize( options )
+		Treequel.logger.formatter = Treequel::ColorLogFormatter.new( Treequel.logger )
+
+		if options.debug
+			$DEBUG = true
+			$VERBOSE = true
+			Treequel.logger.level = Logger::DEBUG
+		elsif options.loglevel
+			Treequel.logger.level = Treequel::LOG_LEVELS[ options.loglevel ]
+		end
+
+		@options   = options
+		@prompt    = HighLine.new
+		@directory = Treequel.directory( options.ldapurl )
+
+		self.log.debug "Created new treewhat command object for %s" % [ @directory ]
+	end
+
+
+	######
+	public
+	######
+
+	# The LDAP directory the command will connect to
+	attr_reader :directory
+
+	# The Trollop options hash the command will read its configuration from
+	attr_reader :options
+
+	# The HighLine object to use for prompting and displaying stuff
+	attr_reader :prompt
+
+
+	### Display an +object+ highlighted as a header.
+	def print_header( object )
+		self.prompt.say( self.prompt.color(object.to_s, :header) )
+	end
+
+
+
+	### Run the command with the specified +pattern+.
+	def run( pattern=nil )
+		self.log.debug "Running with pattern = %p" % [ pattern ]
+
+		self.bind_to_directory if self.options.binddn
+
+		case pattern
+
+		# No argument
+		when NilClass, ''
+			self.show_directory_overview
+
+		# DN/RDN or filter if it contains a '='
+		when /=/
+			self.show_entry( pattern )
+
+		# Otherwise, try to find a schema item that matches
+		else
+			self.show_schema_artifact( pattern )
+		end
+
+	end
+
+
+	### Prompt for a password and then bind to the command's directory using the binddn in
+	### the options.
+	def bind_to_directory
+		binddn = self.options.binddn or
+			raise ArgumentError, "no binddn in the options hash?!"
+		self.log.debug "Attempting to bind to the directory as %s" % [ binddn ]
+
+		pass = self.prompt.ask( "password: " ) {|q| q.echo = '*' }
+		user = Treequel::Branch.new( self.directory, binddn )
+
+		self.directory.bind_as( user, pass )
+		self.log.debug "  bound as %s" % [ user ]
+
+		return true
+	end
+
+
+	### Show general information about the directory if the user doesn't give a pattern on
+	### the command line.
+	def show_directory_overview
+		pr  = self.prompt
+		dir = self.directory
+
+		self.print_header( dir.uri.to_s )
+		pr.say( "\n" )
+		pr.say( dir.schema.to_s )
+
+	end
+
+
+
+	#
+	# 'Show entry' mode
+	#
+
+	### Fetch an entry from the directory and display it like Treequel's editing mode.
+	def show_entry( pattern )
+		dir = self.directory
+		branch = Treequel::Branch.new( dir, pattern )
+
+		if !branch.exists?
+			branch = Treequel::Branch.new( dir, pattern + ',' + dir.base_dn )
+		end
+
+		if !branch.exists?
+			branch = dir.filter( pattern ).first
+		end
+
+		if !branch
+			self.prompt.say( self.prompt.color("No match.", :error) )
+		end
+
+		yaml = self.branch_as_yaml( branch )
+		self.prompt.say( yaml )
+	end
+
+
+	### Return the specified Treequel::Branch object as YAML. If +include_operational+ is true,
+	### include the entry's operational attributes. If +extra_objectclasses+ contains
+	### one or more objectClass OIDs, include their MUST and MAY attributes when building the 
+	### YAML representation of the branch.
+	def branch_as_yaml( object, include_operational=false )
+		object.include_operational_attrs = include_operational
+
+		# Make sure the displayed entry has the MUST attributes
+		entryhash = stringify_keys( object.must_attributes_hash )
+		entryhash.merge!( object.entry || {} )
+		entryhash['objectClass'] ||= []
+
+		entryhash.delete( 'dn' ) # Special attribute, can't be edited
+
+		yaml = entryhash.to_yaml
+		yaml[ 5, 0 ] = self.prompt.color( "# #{object.dn}\n", :header )
+
+		# Make comments out of MAY attributes that are unset
+		mayhash = stringify_keys( object.may_attributes_hash )
+		self.log.debug "MAY hash is: %p" % [ mayhash ]
+		mayhash.delete_if {|attrname,val| entryhash.key?(attrname) }
+		yaml << mayhash.to_yaml[5..-1].gsub( /\n\n/, "\n" ).gsub( /^/, '# ' )
+
+		return yaml
+	end
+
+
+
+
+	#
+	# 'Show schema artifact' mode
+	#
+
+	SCHEMA_ARTIFACT_TYPES = [
+		:object_classes,
+		:attribute_types,
+		:ldap_syntaxes,
+		:matching_rules,
+		:matching_rule_uses,
+	  ]
+
+	### Find an artifact in the directory's schema that matches +pattern+, and display it
+	### if it exists.
+	def show_schema_artifact( pattern )
+		pr        = self.prompt
+		schema    = self.directory.schema
+		artifacts = SCHEMA_ARTIFACT_TYPES.
+			collect {|type| schema.send( type ).values.uniq }.flatten
+
+		if match = find_exact_matching_artifact( artifacts, pattern )
+			self.display_schema_artifact( match )
+		elsif match = find_substring_matching_artifact( artifacts, pattern )
+			pr.say( "No exact match. Falling back to substring match:" )
+			self.display_schema_artifact( match )
+		else
+			pr.say( pr.color("No match.", :error) )
+		end
+	end
+
+
+	### Display a schema artifact in a readable way.
+	def display_schema_artifact( artifact )
+		self.prompt.say( artifact.class.name.sub(/.*::/, '') + ' ' )
+		self.prompt.say( artifact.to_s )
+	end
+
+
+	### Try to find an artifact in +artifacts+ whose name or oid matches +pattern+ exactly.
+	### Returns the first matching artifact.
+	def find_exact_matching_artifact( artifacts, pattern )
+		self.log.debug "Trying to find an exact match for %p in %d artifacts." %
+			[ pattern, artifacts.length ]
+		return artifacts.find do |obj|
+			(obj.respond_to?( :names ) && obj.names.map(&:to_s).include?(pattern) ) ||
+			(obj.respond_to?( :name )  && obj.name.to_s == pattern ) ||
+			(obj.respond_to?( :oid )   && obj.oid == pattern )
+		end
+	end
+
+
+	### Try to find an artifact in +artifacts+ whose name or oid contains +pattern+.
+	### Returns the first matching artifact.
+	def find_substring_matching_artifact( artifacts, pattern )
+		pattern = Regexp.new( Regexp.escape(pattern), Regexp::IGNORECASE )
+
+		return artifacts.find do |obj|
+			(obj.respond_to?( :names ) && obj.names.find {|name| name.to_s =~ pattern} ) ||
+			(obj.respond_to?( :name )  && obj.name.to_s =~ pattern ) ||
+			(obj.respond_to?( :oid )   && obj.oid =~ pattern )
+		end
+	end
+
+
+end # class Treequel::What
+
+
+Treequel::What.run( ARGV.dup )
+