treequel 1.0.1 → 1.0.4

data/bin/treequel

@@ -4,7 +4,9 @@ require 'rubygems'
 
 require 'abbrev'
 require 'columnize'
+require 'diff/lcs'
 require 'digest/sha1'
+require 'irb'
 require 'logger'
 require 'open3'
 require 'optparse'
@@ -16,6 +18,7 @@ require 'tempfile'
 require 'terminfo'
 require 'termios'
 require 'uri'
+require 'yaml'
 
 require 'treequel'
 require 'treequel/mixins'
@@ -33,6 +36,41 @@ class OpenStruct
 end
 
 
+### IRb.start_session, courtesy of Joel VanderWerf in [ruby-talk:42437].
+require 'irb'
+require 'irb/completion'
+
+module IRB # :nodoc:
+	def self.start_session( obj )
+		unless @__initialized
+			args = ARGV
+			ARGV.replace(ARGV.dup)
+			IRB.setup(nil)
+			ARGV.replace(args)
+			@__initialized = true
+		end
+
+		workspace = WorkSpace.new( obj )
+		irb = Irb.new( workspace )
+
+		@CONF[:IRB_RC].call( irb.context ) if @CONF[:IRB_RC]
+		@CONF[:MAIN_CONTEXT] = irb.context
+
+		begin
+			prevhandler = Signal.trap( 'INT' ) do
+				irb.signal_handle
+			end
+
+			catch( :IRB_EXIT ) do
+				irb.eval_input
+			end
+		ensure
+			Signal.trap( 'INT', prevhandler )
+		end
+
+	end
+end
+
 # The Treequel shell.
 class Treequel::Shell
 	include Readline,
@@ -41,6 +79,8 @@ class Treequel::Shell
 	        Treequel::Constants::Patterns,
 	        Treequel::HashUtilities
 
+	extend Treequel::ANSIColorUtilities
+
 	# Prompt text for #prompt_for_multiple_values
 	MULTILINE_PROMPT = <<-'EOF'
 	Enter one or more values for '%s'.
@@ -61,8 +101,11 @@ class Treequel::Shell
 	}.freeze
 	LOG_LEVEL_NAMES = LOG_LEVELS.invert.freeze
 
+	# Valid connect-type arguments
+	VALID_CONNECT_TYPES = %w[tls ssl plain]
+
 	# Command option parsers
-	OPTION_PARSERS = {}
+	@@option_parsers = {}
 
 	# Path to the default history file
 	HISTORY_FILE = Pathname( "~/.treequel.history" )
@@ -75,6 +118,59 @@ class Treequel::Shell
 	###	C L A S S   M E T H O D S
 	#################################################################
 
+	### Run the shell.
+	def self::run( args )
+		Treequel.logger.formatter = Treequel::ColorLogFormatter.new( Treequel.logger )
+		bind_as, uri = self.parse_options( args )
+
+		directory = if uri
+			Treequel.directory( uri )
+		else
+			Treequel.directory_from_config
+		end
+
+		Treequel::Shell.new( directory ).run( bind_as )
+	end
+
+
+	### Parse command-line options for shell startup and return an options struct and
+	### the LDAP URI.
+	def self::parse_options( argv )
+		progname = File.basename( $0 )
+		bind_as = nil
+
+		oparser = OptionParser.new( "Usage: #{progname} [OPTIONS] [LDAPURL]" ) do |oparser|
+			oparser.separator ' '
+
+			oparser.on( '--binddn=DN', '-b DN', String, "Bind as DN" ) do |dn|
+				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
+					raise "Invalid logging level %p" % [ lvl ]
+			end
+
+			oparser.on( '--debug', '-d', FalseClass, "Turn debugging on" ) do
+				$DEBUG = true
+				$trace = true
+				Treequel.logger.level = Logger::DEBUG
+			end
+
+			oparser.on("-h", "--help", "Show this help message.") do
+				$stderr.puts( oparser )
+				exit!
+			end
+		end
+
+		remaining_args = oparser.parse( argv )
+
+		return bind_as, *remaining_args
+	end
+
+
 	### Create an option parser from the specified +block+ for the given +command+ and register
 	### it. Many thanks to apeiros and dominikh on #Ruby-Pro for the ideas behind this.
 	def self::set_options( command, &block )
@@ -84,7 +180,7 @@ class Treequel::Shell
 		end
 		oparser.default_argv = []
 
-		OPTION_PARSERS[command.to_sym] = [oparser, options]
+		@@option_parsers[command.to_sym] = [oparser, options]
 	end
 
 
@@ -92,14 +188,12 @@ class Treequel::Shell
 	###	I N S T A N C E   M E T H O D S
 	#################################################################
 
-	### Create a new shell that will traverse the directory at the specified +uri+.
-	def initialize( uri )
-		Treequel.logger.level = Logger::WARN
-		Treequel.logger.formatter = Treequel::ColorLogFormatter.new( Treequel.logger )
-
-		@uri        = uri
+	### Create a new shell for the specified +directory+.
+	### @param [Treequel::Directory] directory  the LDAP directory to navigate
+	def initialize( directory )
+		@dir        = directory
+		@uri        = directory.uri
 		@quit       = false
-		@dir        = Treequel.directory( @uri )
 		@currbranch = @dir
 		@columns    = TermInfo.screen_width
 		@rows       = TermInfo.screen_height
@@ -110,8 +204,24 @@ class Treequel::Shell
 	end
 
 
+	######
+	public
+	######
+
+	# The number of columns in the current terminal
+	attr_reader :columns
+
+	# The number of rows in the current terminal
+	attr_reader :rows
+
+	# The flag which causes the shell to exit after the current loop
+	attr_accessor :quit
+
+
 	### The command loop: run the shell until the user wants to quit
-	def run
+	### @param [String]              bind_as    The DN of the user to bind as. If none is
+	###                                         specified, the shell will bind anonymously.
+	def run( bind_as=nil )
 		@original_tty_settings = IO.read( '|-' ) or exec 'stty', '-g'
 		message "Connected to %s" % [ @uri ]
 
@@ -121,6 +231,13 @@ class Treequel::Shell
 		# Load saved command-line history
 		self.read_history
 
+		# 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
+			self.bind_command( options, bind_as )
+		end
+
 		# Run until something sets the quit flag
 		until @quit
 			$stderr.puts
@@ -137,7 +254,7 @@ class Treequel::Shell
 			elsif input == ''
 				self.log.debug "No command. Re-displaying the prompt."
 
-			# Parse everything else into command + everything else
+			# Parse everything else into command + args
 			else
 				self.log.debug "Dispatching input: %p" % [ input ]
 				self.dispatch_cmd( input )
@@ -164,8 +281,8 @@ class Treequel::Shell
 
 			# If there's a registered optionparser for the command, use it to 
 			# split out options and arguments, then pass those to the command.
-			if OPTION_PARSERS.key?( full_command )
-				oparser, options = OPTION_PARSERS[ full_command ]
+			if @@option_parsers.key?( full_command )
+				oparser, options = @@option_parsers[ full_command ]
 				self.log.debug "Got an option-parser for #{full_command}."
 
 				cmdargs = oparser.parse( args )
@@ -176,6 +293,7 @@ class Treequel::Shell
 
 			# ...otherwise just call it with all the args.
 			else
+				self.log.warn "  no options defined for '%s' command" % [ command ]
 				meth.call( *args )
 			end
 
@@ -196,6 +314,21 @@ class Treequel::Shell
 	protected
 	#########
 
+	### Fetch a Treequel::Directory object for the directory at the given +uri+, or
+	### quit with an error if unable to do so.
+	def get_ldap_directory( uri, options )
+		if uri.port == LDAP::LDAP_PORT
+			if options.try_tls
+				return Treequel.directory( uri, :connect_type => :tls )
+			else
+				return Treequel.directory( uri, :connect_type => :plain )
+			end
+		else
+			return Treequel.directory( uri, :connect_type => :ssl )
+		end
+	end
+
+
 	### Set up Readline completion
 	def setup_completion
 		Readline.completion_proc = self.method( :completion_callback ).to_proc
@@ -210,7 +343,7 @@ class Treequel::Shell
 
 		if histfile.exist?
 			lines = histfile.readlines.collect {|line| line.chomp }
-			self.log.debug "Read %d saved history commands from %s." % [ lines.nitems, histfile ]
+			self.log.debug "Read %d saved history commands from %s." % [ lines.length, histfile ]
 			Readline::HISTORY.push( *lines )
 		else
 			self.log.debug "History file '%s' was empty or non-existant." % [ histfile ]
@@ -224,7 +357,7 @@ class Treequel::Shell
 
 		lines = Readline::HISTORY.to_a.reverse.uniq.reverse
 		lines = lines[ -DEFAULT_HISTORY_SIZE, DEFAULT_HISTORY_SIZE ] if
-			lines.nitems > DEFAULT_HISTORY_SIZE
+			lines.length > DEFAULT_HISTORY_SIZE
 
 		self.log.debug "Saving %d history lines to %s." % [ lines.length, histfile ]
 
@@ -240,7 +373,11 @@ class Treequel::Shell
 		parts = Shellwords.shellwords( input )
 
 		# If there aren't any arguments, it's command completion
-		if parts.length == 1
+		if parts.empty?
+			possible_completions = @commands.sort
+			self.log.debug "  possible completions: %p" % [ possible_completions ]
+			return possible_completions
+		elsif parts.length == 1
 			# One completion means it's an unambiguous match, so just complete it.
 			possible_completions = @commands.grep( /^#{Regexp.quote(input)}/ ).sort
 			self.log.debug "  possible completions: %p" % [ possible_completions ]
@@ -273,15 +410,15 @@ class Treequel::Shell
 
 	### Show help text for the specified command, or a list of all available commands 
 	### if none is specified.
-	def help_command( *args )
+	def help_command( options, *args )
 		if args.empty?
 			$stderr.puts
 			message colorize( "Available commands", :bold, :white ),
 				*columnize(@commands)
 		else
 			cmd = args.shift.to_sym
-			if OPTION_PARSERS.key?( cmd )
-				oparser, _ = OPTION_PARSERS[ cmd ]
+			if @@option_parsers.key?( cmd )
+				oparser, _ = @@option_parsers[ cmd ]
 				self.log.debug "Setting summary width to: %p" % [ @columns ]
 				oparser.summary_width = @columns
 				output = oparser.to_s.sub( /^(.*?)\n/ ) do |match|
@@ -291,22 +428,30 @@ class Treequel::Shell
 				$stderr.puts
 				message( output )
 			else
-				error_message( "No help for '#{cmd}'" )
+				error_message( "No help for '#{cmd.inspect}'" )
 			end
 		end
 	end
+	set_options :help do |oparser, options|
+		oparser.banner = "help [COMMAND]"
+		oparser.separator 'Display general help, or help for a specific COMMAND.'
+	end
 
 
 	### Quit the shell.
-	def quit_command( *args )
+	def quit_command( options, *args )
 		message "Okay, exiting."
-		@quit = true
+		self.quit = true
+	end
+	set_options :help do |oparser, options|
+		oparser.banner = "quit"
+		oparser.separator 'Exit the shell.'
 	end
 
 
 	### Set the logging level (if invoked with an argument) or display the current
 	### level (with no argument).
-	def log_command( *args )
+	def log_command( options, *args )
 		newlevel = args.shift
 		if newlevel
 			if LOG_LEVELS.key?( newlevel )
@@ -321,24 +466,49 @@ class Treequel::Shell
 				[ 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(', ')
+	end
 
 
 	### Display LDIF for the specified RDNs.
-	def cat_command( *args )
+	def cat_command( options, *args )
 		args.each do |rdn|
+			extended = rdn.chomp!( '+' )
+
 			branch = @currbranch.get_child( rdn )
-			message( format_ldif(branch.to_ldif) )
+			branch.include_operational_attrs = true if extended
+
+			if branch.exists?
+				ldifstring = branch.to_ldif( self.columns - 2 )
+				self.log.debug "LDIF: #{ldifstring.dump}"
+
+				message( format_ldif(ldifstring) )
+			else
+				error_message( "No such entry %s" % [branch.dn] )
+			end
 		end
 	end
+	set_options :cat do |oparser, options|
+		oparser.banner = "cat [RDN]+"
+		oparser.separator 'Display the entries specified by RDN as LDIF.'
+	end
 
 
 	### Display YAML for the specified RDNs.
-	def yaml_command( *args )
+	def yaml_command( options, *args )
 		args.each do |rdn|
 			branch = @currbranch.get_child( rdn )
 			message( branch_as_yaml(branch) )
 		end
 	end
+	set_options :yaml do |oparser, options|
+		oparser.banner = "yaml [RDN]+"
+		oparser.separator 'Display the entries specified by RDN as YAML.'
+	end
 
 
 	### List the children of the branch specified by the given +rdn+, or the current branch if none
@@ -371,68 +541,70 @@ class Treequel::Shell
 		end
 	end
 	set_options :ls do |oparser, options|
-		oparser.banner = "ls [OPTIONS] [DNs]"
+		oparser.banner = "ls [OPTIONS] [DN]+"
+		oparser.separator 'List the entries specified, or the current entry if none are specified.'
+		oparser.separator ''
 
 		oparser.on( "-l", "--long", FalseClass, "List in long format." ) do 
 			options.longform = true
 		end
+		oparser.on( "-t", "--timesort", FalseClass,
+		            "Sort by time modified (most recently modified first)." ) do 
+			options.timesort = true
+		end
+		oparser.on( "-d", "--dirsort", FalseClass,
+		            "Sort entries with subordinate entries before those without." ) do 
+			options.dirsort = true
+		end
+		oparser.on( "-r", "--reverse", FalseClass, "Reverse the entry sort functions." ) do 
+			options.reversesort = true
+		end
 
 	end
 
 
 	### Generate long-form output lines for the 'ls' command for the given +branch+.
 	def make_longform_ls_output( branch, options )
-		rows = []
 		children = branch.children
-		rows << colorize( :underscore, :cyan ) { "total %d" % [children.length] }
+		header = colorize( :underscore, :cyan ) { "total %d" % [children.length] }
 
 		# Calcuate column widths
-		oclen = children.map do |branch|
-			branch.include_operational_attrs = true
-			branch[:structuralObjectClass].length
-		end.max
-		moddnlen = children.map do |branch|
-			branch[:modifiersName].length
+		oclen = children.map do |subbranch|
+			subbranch.include_operational_attrs = true
+			subbranch[:structuralObjectClass].length
 		end.max
 
-		children.
-			sort_by {|branch| branch.rdn.downcase }.
-			each do |branch|
-				# -rw-r--r--   2 mgranger staff   979 2009-07-27 11:55 Rakefile.local
-				# 
-				# modifiersName: cn=admin,dc=laika,dc=com
-				# hasSubordinates: TRUE
-				# modifyTimestamp: 20090520232650Z
-				# structuralObjectClass: organizationalUnit
-				rows << "%#{oclen}s  %#{moddnlen}s  %s  %s%s" % [
-					branch[:structuralObjectClass],
-					branch[:modifiersName],
-					branch[:modifyTimestamp].strftime('%Y-%m-%d %H:%M'),
-					format_rdn( branch.rdn ),
-					branch[:hasSubordinates] ? '/' : ''
-				]
-			end
+		# Set up sorting by collecting all the requested sort criteria as Proc objects which
+		# will be applied
+		sortfuncs = []
+		sortfuncs << lambda {|subbranch| subbranch[:hasSubordinates] ? 0 : 1 } if options.dirsort
+		sortfuncs << lambda {|subbranch| subbranch[:modifyTimestamp] } if options.timesort
+ 		sortfuncs << lambda {|subbranch| subbranch.rdn.downcase }
 
-		return rows
+		rows = children.
+			sort_by {|subbranch| sortfuncs.collect {|func| func.call(subbranch) } }.
+			collect {|subbranch| self.format_description(subbranch, oclen) }
+
+		return [ header ] + (options.reversesort ? rows.reverse : rows)
 	end
 
 
 	### Generate short-form 'ls' output for the given +branch+ and return it.
 	def make_shortform_ls_output( branch, options )
+		branch.include_operational_attrs = true
 		entries = branch.children.
-			collect {|b| b.rdn }.
+			collect {|b| b.rdn + (b[:hasSubordinates] ? '/' : '') }.
 			sort_by {|rdn| rdn.downcase }
-		return columnize( entries ).
-			collect do |row|
-				row.gsub( /#{ATTRIBUTE_TYPE}=\s*\S+/ ) do |rdn|
-					format_rdn( rdn )
-				end
-			end
+		self.log.debug "Displaying %d entries in short form." % [ entries.length ]
+
+		return columnize( entries ).gsub( /#{ATTRIBUTE_TYPE}=\s*\S+/ ) do |rdn|
+			format_rdn( rdn )
+		end
 	end
 
 
 	### Change the current working DN to +rdn+.
-	def cdn_command( rdn=nil, *args )
+	def cdn_command( options, rdn=nil, *args )
 		if rdn.nil?
 			@currbranch = @dir.base
 			return
@@ -446,64 +618,91 @@ class Treequel::Shell
 		pairs.each do |dnpair|
 			self.log.debug "  cd to %p" % [ dnpair ]
 			attribute, value = dnpair.split( /=/, 2 )
-			self.log.debug "  changing to %s( %p )" % [ attribute, value ]
-			@currbranch = @currbranch.send( attribute, value )
+			self.log.debug "  changing to %s( %p )" % [ attribute.downcase, value ]
+			@currbranch = @currbranch.send( attribute.downcase, value )
 		end
 	end
+	set_options :cdn do |oparser, options|
+		oparser.banner = "cdn <RDN>"
+		oparser.separator 'Change the current entry to <RDN>.'
+	end
 
 
 	### Change the current working DN to the current entry's parent.
-	def parent_command( *args )
+	def parent_command( options, *args )
 		parent = @currbranch.parent or raise "%s is the root DN" % [ @currbranch.dn ]
 
 		self.log.debug "  changing to %s" % [ parent.dn ]
 		@currbranch = parent
 	end
+	set_options :parent do |oparser, options|
+		oparser.banner = "parent"
+		oparser.separator "Change to the current entry's parent."
+	end
+
+
+	# ### Create the entry specified by +rdn+.
+	def create_command( options, rdn )
+		branch = @currbranch.get_child( rdn )
+
+		raise "#{branch.dn}: already exists." if branch.exists?
+		create_new_entry( branch )
+	end
+	set_options :create do |oparser, options|
+		oparser.banner = "create <RDN>"
+		oparser.separator "Create a new entry at <RDN>."
+	end
 
 
 	### Edit the entry specified by +rdn+.
-	#def edit_command( options, rdn )
-	#	branch = @currbranch.get_child( rdn )
-	#	entryhash = nil
-	#
-	#	if options.newentry
-	#		raise "#{branch.dn} already exists." if branch.exists?
-	#		object_classes = prompt_for_multiple_values( "Entry objectClasses:" )
-	#		entryhash = branch.valid_attributes_hash( *object_classes )
-	#		newhash = edit_in_yaml( entryhash )
-	#		args = object_classes + [newhash]
-	#		branch.create( *args )
-	#	else
-	#		raise "#{branch.dn}: no such entry. Did you mean to create it with -n?" unless
-	#		 	branch.exists?
-	#		entryhash = branch.entry
-	#		newhash = edit_in_yaml( entryhash )
-	#		branch.merge( entryhash )
-	#	end
-	#
-	#	message "Saved #{rdn}."
-	#end
-	#set_options :edit do |oparser, options|
-	#	oparser.banner = "edit [OPTIONS] DN"
-	#
-	#	oparser.on( "-n", "--new", FalseClass, 
-	#		"Create a new entry instead of editing an existing one." ) do 
-	#		options.newentry = true
-	#	end
-	#
-	#end
+	def edit_command( options, rdn )
+		branch = @currbranch.get_child( rdn )
 
+		raise "#{branch.dn}: no such entry. Did you mean to 'create' it instead? " unless
+		 	branch.exists?
 
-	### Convert the given +patterns+ to branchsets relative to the current branch and return
-	### them. This is used to map shell arguments like 'cn=*', 'Hosts', 'cn=dav*' into
-	### branchsets that will find matching entries.
-	def convert_to_branchsets( *patterns )
-		self.log.debug "Turning %d patterns into branchsets." % [ patterns.length ]
-		return patterns.collect do |pat|
-			key, val = pat.split( /\s*=\s*/, 2 )
-			self.log.debug "  making a filter out of %p => %p" % [ key, val ]
-			@currbranch.filter( key => val )
+		if entryhash = edit_in_yaml( branch )
+			branch.merge( entryhash )
 		end
+
+		message "Saved #{rdn}."
+	end
+	set_options :edit do |oparser, options|
+		oparser.banner = "edit <RDN>"
+		oparser.separator "Edit the entry at RDN as YAML."
+	end
+
+
+	### Change the DN of an entry
+	def mv_command( options, rdn, newdn )
+		branch = @currbranch.get_child( rdn )
+
+		raise "#{branch.dn}: no such entry" unless branch.exists?
+		olddn = branch.dn
+		branch.move( newdn )
+		message "  %s -> %s: success" % [ olddn, branch.dn ]
+	end
+	set_options :mv do |oparser, options|
+		oparser.banner = "mv <RDN> <NEWRDN>"
+		oparser.separator "Move the entry at RDN to NEWRDN"
+	end
+
+
+	### Copy an entry
+	def cp_command( options, rdn, newrdn )
+		branch = @currbranch.get_child( rdn )
+		newbranch = @currbranch.get_child( newrdn )
+
+		raise "#{branch.dn}: already exists" if newbranch.exists?
+
+		attributes = branch.entry.merge( :dn => newbranch.dn )
+		newbranch.create( attributes )
+
+		message "  %s -> %s: success" % [ rdn, branch.dn ]
+	end
+	set_options :cp do |oparser, options|
+		oparser.banner = "cp <RDN> <NEWRDN>"
+		oparser.separator "Copy the entry at RDN to a new entry at NEWRDN"
 	end
 
 
@@ -515,17 +714,29 @@ class Treequel::Shell
 		branches = coll.all
 
 		msg = "About to delete the following entries:\n" +
-			branches.collect {|br| "  #{br.dn}" }.join("\n")
+			columnize( branches.collect {|br| br.dn } )
 
-		ask_for_confirmation( msg ) do
-			branches.each do |branch|
-				branch.delete
-				message "Deleted #{branch.dn}." 
+		if options.force
+			branches.each do |br|
+				br.directory.delete( br )
+				message "  delete %s: success" % [ br.dn ]
+			end
+		else
+			ask_for_confirmation( msg ) do
+				branches.each do |br|
+					br.directory.delete( br )
+					message "  delete %s: success" % [ br.dn ]
+				end
 			end
 		end
 	end
 	set_options :rm do |oparser, options|
-		oparser.banner = "rm [DNs]"
+		oparser.banner = "rm <RDN>+"
+		oparser.separator 'Remove the entries at the given RDNs.'
+
+		oparser.on( '-f', '--force', TrueClass, "Force -- remove without confirmation." ) do
+			options.force = true
+		end
 	end
 
 
@@ -538,16 +749,32 @@ class Treequel::Shell
 		message "Searching for entries that match '#{branchset.to_s}'"
 
 		entries = branchset.all
-		output = columnize( entries ).
-			collect do |row|
-				row.gsub( /#{ATTRIBUTE_TYPE}=\s*\S+/ ) do |rdn|
-					format_rdn( rdn )
-				end
-			end
+		output = columnize( entries ).gsub( /#{ATTRIBUTE_TYPE}=\s*\S+/ ) do |rdn|
+			format_rdn( rdn )
+		end
 		message( output )
 	end
 	set_options :grep do |oparser, options|
-		oparser.banner = "grep [OPTIONS] FILTER"
+		oparser.banner = "grep [OPTIONS] <FILTER>"
+		oparser.separator 'Search for children of the current entry that match the given FILTER'
+
+		oparser.on( '-r', '--recursive', TrueClass, "Search recursively." ) do
+			options.force = true
+		end
+	end
+
+
+	### Show who the shell is currently bound as.
+	def whoami_command( options, *args )
+		if user = @dir.bound_user
+			message "Bound as #{user}"
+		else
+			message "Bound anonymously"
+		end
+	end
+	set_options :whoami do |oparser, options|
+		oparser.banner = "whoami"
+		oparser.separator 'Display the DN of the user the shell is bound as.'
 	end
 
 
@@ -564,17 +791,37 @@ class Treequel::Shell
 		else
 			user = @dir.filter( :uid => binddn ).first
 		end
-		raise "No user found for %p" % [ binddn ] unless user.exists?
 
 		@dir.bind( user, password )
 		message "Bound as #{user}"
 	end
 	set_options :bind do |oparser, options|
 		oparser.banner = "bind [BIND_DN or UID]"
+		oparser.separator "Bind as BIND_DN or UID"
 		oparser.separator "If you don't specify a BIND_DN, you will be prompted for it."
 	end
 
 
+	### Start an IRB session on either the current branchset, if invoked with no arguments, or
+	### on a branchset for the specified +rdn+ if one is given.
+	def irb_command( options, *args )
+		branch = nil
+		if args.empty?
+			branch = @currbranch
+		else
+			branch = @currbranch.get_child( args.first )
+		end
+
+		self.log.debug "Setting up IRb shell"
+		IRB.start_session( branch )
+	end
+	set_options :irb do |oparser, options|
+		oparser.banner = "irb [RDN]"
+		oparser.separator "Start an IRb shell with either the current branch (if none is " +
+		 	"specified) or a branch for the entry specified by the given RDN."
+	end
+
+
 	### Handle a command from the user that doesn't exist.
 	def handle_missing_cmd( *args )
 		command = args.shift || '(testing?)'
@@ -593,18 +840,84 @@ class Treequel::Shell
 	end
 
 
-	#######
-	private
-	#######
+	### Convert the given +patterns+ to branchsets relative to the current branch and return
+	### them. This is used to map shell arguments like 'cn=*', 'Hosts', 'cn=dav*' into
+	### branchsets that will find matching entries.
+	def convert_to_branchsets( *patterns )
+		self.log.debug "Turning %d patterns into branchsets." % [ patterns.length ]
+		return patterns.collect do |pat|
+			key, val = pat.split( /\s*=\s*/, 2 )
+			self.log.debug "  making a filter out of %p => %p" % [ key, val ]
+			@currbranch.filter( key => val )
+		end
+	end
+
+
+	#################################################################
+	###	U T I L I T Y   M E T H O D S
+	#################################################################
+
+	### Return the description of the specified +branch+ suitable for displaying in
+	### the directory listing.
+	### @param [Treequel::Branch] branch  the branch to be described
+	### @param [Fixnum] oclen             the length of the largest objectclass that 
+	###                                   will be displayed; used to calculate the 
+	###                                   width of the objectclass column.
+	def format_description( branch, oclen=40 )
+		rdn = format_rdn( branch.rdn )
+		metadatalen = oclen + 16 + 6 # oc + timestamp + whitespace
+		maxdesclen = self.columns - metadatalen - rdn.length - 5
+
+		return "%#{oclen}s  %s  %s%s %s" % [
+			branch[:structuralObjectClass],
+			branch[:modifyTimestamp].strftime('%Y-%m-%d %H:%M'),
+			rdn,
+			branch[:hasSubordinates] ? '/' : '',
+			single_line_description( branch, maxdesclen )
+		]
+	end
+
+
+	### Generate a single-line description from the specified +branch+
+	def single_line_description( branch, maxlen=80 )
+		return '' unless branch[:description] && branch[:description].first
+		desc = branch[:description].join('; ').gsub( /\n+/, '' )
+		desc[ maxlen..desc.length ] = '...' if desc.length > maxlen
+		return '(' + desc + ')'
+	end
+
+
+	### Create a new entry in the directory for the specified +branch+.
+	def create_new_entry( branch )
+		raise "#{branch.dn} already exists." if branch.exists?
+
+		# Prompt for the list of included objectClasses and build the appropriate
+		# blank entry with them in mind.
+		completions = branch.directory.schema.object_classes.keys.collect {|oid| oid.to_s }
+		self.log.debug "Prompting for new entry object classes with %d completions." %
+			[ completions.length ]
+		object_classes = prompt_for_multiple_values( "Entry objectClasses:", nil, completions ).
+			collect {|arg| arg.strip }.compact
+		self.log.debug "  user wants %d objectclasses: %p" % [ object_classes.length, object_classes ]
+
+		# Edit the entry
+		if newhash = edit_in_yaml( branch, object_classes )
+			branch.create( newhash )
+			message "Saved #{branch.dn}."
+		else
+			error_message "#{branch.dn} not saved."
+		end
+	end
+
 
 	### Dump the specified +object+ to a file as YAML, invoke an editor on it, then undump the 
 	### result. If the file has changed, return the updated object, else returns +nil+.
-	def edit_in_yaml( object )
-		yaml = branch_as_yaml( object )
+	def edit_in_yaml( object, object_classes=[] )
+		yaml = branch_as_yaml( object, false, object_classes )
 		filename = Digest::SHA1.hexdigest( yaml )
 		tempfile = Tempfile.new( filename )
 
-		message "Object as YAML is: ", yaml
+		self.log.debug "Object as YAML is: %p" % [ yaml ]
 		tempfile.print( yaml )
 		tempfile.close
 
@@ -620,20 +933,26 @@ class Treequel::Shell
 
 
 	### Return the specified Treequel::Branch object as YAML. If +include_operational+ is true,
-	### include the entry's operational attributes.
-	def branch_as_yaml( object, include_operational=false )
+	### 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, extra_objectclasses=[] )
 		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 )
-		dn = entryhash.delete( 'dn' )
-		
+		entryhash = stringify_keys( object.must_attributes_hash(*extra_objectclasses) )
+		entryhash.merge!( object.entry || {} )
+		entryhash.merge!( object.rdn_attributes )
+		entryhash['objectClass'] ||= []
+		entryhash['objectClass'] |= extra_objectclasses
+
+		entryhash.delete( 'dn' ) # Special attribute, can't be edited
+
 		yaml = entryhash.to_yaml
-		yaml[ 5, 0 ] = "# #{dn}\n"
-		
+		yaml[ 5, 0 ] = "# #{object.dn}\n"
+
 		# Make comments out of MAY attributes that are unset
-		mayhash = stringify_keys( object.may_attributes_hash )
+		mayhash = stringify_keys( object.may_attributes_hash(*extra_objectclasses) )
 		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( /^/, '# ' )
@@ -655,84 +974,6 @@ class Treequel::Shell
 	end
 
 
-	### Return the specified args as a string, quoting any that have a space.
-	def quotelist( *args )
-		return args.flatten.collect {|part| part =~ /\s/ ? part.inspect : part}
-	end
-
-
-	### Run the specified command +cmd+ with system(), failing if the execution
-	### fails.
-	def run_command( *cmd )
-		cmd.flatten!
-
-		if cmd.length > 1
-			self.log.debug( quotelist(*cmd) )
-		else
-			self.log.debug( cmd )
-		end
-
-		if $dryrun
-			self.log.error "(dry run mode)"
-		else
-			system( *cmd )
-			unless $?.success?
-				raise "Command failed: [%s]" % [cmd.join(' ')]
-			end
-		end
-	end
-
-
-	### Run the given +cmd+ with the specified +args+ without interpolation by the shell and
-	### return anything written to its STDOUT.
-	def read_command_output( cmd, *args )
-		self.log.debug "Reading output from: %s" % [ cmd, quotelist(cmd, *args) ]
-		output = IO.read( '|-' ) or exec cmd, *args
-		return output
-	end
-
-
-	### Run a subordinate Rake process with the same options and the specified +targets+.
-	def rake( *targets )
-		opts = ARGV.select {|arg| arg[0,1] == '-' }
-		args = opts + targets.map {|t| t.to_s }
-		run 'rake', '-N', *args
-	end
-
-
-	### Open a pipe to a process running the given +cmd+ and call the given block with it.
-	def pipeto( *cmd )
-		$DEBUG = true
-
-		cmd.flatten!
-		self.log.info( "Opening a pipe to: ", cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
-		if $dryrun
-			message "(dry run mode)"
-		else
-			open( '|-', 'w+' ) do |io|
-
-				# Parent
-				if io
-					yield( io )
-
-				# Child
-				else
-					exec( *cmd )
-					raise "Command failed: [%s]" % [cmd.join(' ')]
-				end
-			end
-		end
-	end
-
-
-	### Return the fully-qualified path to the specified +program+ in the PATH.
-	def which( program )
-		ENV['PATH'].split(/:/).
-			collect {|dir| Pathname.new(dir) + program }.
-			find {|path| path.exist? && path.executable? }
-	end
-
-
 	### Output the specified message +parts+.
 	def message( *parts )
 		$stderr.puts( *parts )
@@ -805,25 +1046,37 @@ class Treequel::Shell
 
 
 	### Prompt for an array of values
-	def prompt_for_multiple_values( label, default=nil )
-	    message( MULTILINE_PROMPT % [label] )
-	    if default
+	def prompt_for_multiple_values( label, default=nil, completions=[] )
+		old_completion_proc = nil
+
+		message( MULTILINE_PROMPT % [label] )
+		if default
 			message "Enter a single blank line to keep the default:\n  %p" % [ default ]
 		end
 
-	    results = []
-	    result = nil
+		results = []
+		result = nil
+
+		if !completions.empty?
+			self.log.debug "Prompting with %d completions." % [ completions.length ]
+			old_completion_proc = Readline.completion_proc
+			Readline.completion_proc = Proc.new do |input|
+				completions.flatten.grep( /^#{Regexp.quote(input)}/i ).sort
+			end
+		end
 
-	    begin
-	        result = readline( make_prompt_string("> ") )
+		begin
+			result = readline( make_prompt_string("> ") )
 			if result.nil? || result.empty?
 				results << default if default && results.empty?
 			else
-	        	results << result 
+				results << result 
 			end
-	    end until result.nil? || result.empty?
+		end until result.nil? || result.empty?
 
-	    return results.flatten
+		return results.flatten
+	ensure
+		Readline.completion_proc = old_completion_proc if old_completion_proc
 	end
 
 
@@ -884,43 +1137,6 @@ class Treequel::Shell
 	alias :prompt_for_confirmation :ask_for_confirmation
 
 
-	### Search line-by-line in the specified +file+ for the given +regexp+, returning the
-	### first match, or nil if no match was found. If the +regexp+ has any capture groups,
-	### those will be returned in an Array, else the whole matching line is returned.
-	def find_pattern_in_file( regexp, file )
-		rval = nil
-
-		File.open( file, 'r' ).each do |line|
-			if (( match = regexp.match(line) ))
-				rval = match.captures.empty? ? match[0] : match.captures
-				break
-			end
-		end
-
-		return rval
-	end
-
-
-	### Search line-by-line in the output of the specified +cmd+ for the given +regexp+,
-	### returning the first match, or nil if no match was found. If the +regexp+ has any 
-	### capture groups, those will be returned in an Array, else the whole matching line
-	### is returned.
-	def find_pattern_in_pipe( regexp, *cmd )
-		output = []
-
-		self.log.info( cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
-		Open3.popen3( *cmd ) do |stdin, stdout, stderr|
-			stdin.close
-
-			output << stdout.gets until stdout.eof?
-			output << stderr.gets until stderr.eof?
-		end
-
-		result = output.find { |line| regexp.match(line) } 
-		return $1 || result
-	end
-
-
 	### Invoke the user's editor on the given +filename+ and return the exit code
 	### from doing so.
 	def edit( filename )
@@ -941,8 +1157,8 @@ class Treequel::Shell
 
 	### Return an ANSI-colored version of the given +rdn+ string.
 	def format_rdn( rdn )
-		rdn.split( /,/ ).collect do |rdn|
-			key, val = rdn.split( /\s*=\s*/, 2 )
+		rdn.split( /,/ ).collect do |rdn_part|
+			key, val = rdn_part.split( /\s*=\s*/, 2 )
 			colorize( :white ) { key } +
 				colorize( :bold, :black ) { '=' } +
 				colorize( :bold, :white ) { val }
@@ -952,15 +1168,33 @@ class Treequel::Shell
 
 	### Highlight LDIF and return it.
 	def format_ldif( ldif )
-		return ldif.gsub( /^(\S[^:]*)(::?)\s*(.*)$/ ) do
-			key, sep, val = $1, $2, $3
-			case sep
-			when '::'
-				colorize( :cyan ) { key } + ':: ' + colorize( :dark, :white ) { val }
-			when ':'
-				colorize( :bold, :cyan ) { key } + ': ' + colorize( :dark, :white ) { val }
+		self.log.debug "Formatting LDIF: %p" % [ ldif ]
+		return ldif.gsub( LDIF_ATTRVAL_SPEC ) do
+			key, val = $1, $2.strip
+			self.log.debug "  formatting attribute: [ %p, %p ], remainder: %p" %
+				[ key, val, $POSTMATCH ]
+
+			case val
+
+			# Base64-encoded value
+			when /^:/
+				val = val[1..-1].strip
+				key +
+					colorize( :dark, :green ) { ':: ' } +
+					colorize( :green ) { val } + "\n"
+
+			# URL
+			when /^</
+				val = val[1..-1].strip
+				key +
+					colorize( :dark, :yellow ) { ':< ' } +
+					colorize( :yellow ) { val } + "\n"
+
+			# Regular attribute
 			else
-				key + sep + ' ' + val
+				key +
+					colorize( :dark, :white ) { ': ' } +
+					colorize( :bold, :white ) { val } + "\n"
 			end
 		end
 	end
@@ -975,6 +1209,5 @@ class Treequel::Shell
 end # class Treequel::Shell
 
 
-ldapuri = URI( ARGV.shift || 'ldap://localhost' )
-Treequel::Shell.new( ldapuri ).run
+Treequel::Shell.run( ARGV.dup )