treequel 1.0.4 → 1.1.0

data/ChangeLog

@@ -1,4 +1,133 @@
-261[tip]   0188c2ba5b7e   2010-07-07 23:21 -0700   ged
+304[tip]   92c28b14730a   2010-09-20 13:51 -0700   ged
+  Added tag 1.1.0 for changeset b415e0fce774
+
+303[1.1.0]   b415e0fce774   2010-09-20 13:51 -0700   ged
+  Added signature for changeset 4ba782a3a7e4
+
+302   4ba782a3a7e4   2010-09-17 09:09 -0700   ged
+  Include mixins for inherited objectClasses, too.
+
+301   f075a27a35eb   2010-09-17 09:03 -0700   ged
+  Updated build system
+
+300   c77bac0bf816   2010-09-17 09:02 -0700   ged
+  Manual updates for the Model section (paired with Mahlon)
+
+299   1b375c5dc123   2010-09-15 16:46 -0700   ged
+  Use the #syntax method instead of the syntax_oid in #inspect output so inherited syntaxes are shown
+
+298   0786411cd707   2010-09-15 16:43 -0700   ged
+  Use the system LDAP config if no URI is given
+
+297   d3a6c89d8004   2010-09-15 16:42 -0700   ged
+  Un-spam debugging on entry lookup
+
+296   2101482df41f   2010-09-15 16:41 -0700   ged
+  Overriding #inspect in Treequel::Model to show the list of extensions applied to the entry
+
+295   a384412c0e6f   2010-08-25 16:56 -0700   ged
+  Rescue the right error in Treequel::Model#method_missing and add a spec for the negative case.
+
+294   b220a83d31b5   2010-08-25 16:48 -0700   ged
+  Load the entry from Model's #method_missing to catch calls to methods that are added via
+
+293   2753f8405caf   2010-08-23 17:12 -0700   ged
+  Fixing object/attribute mapping for attributes whose types that inherit their syntax from their superclass
+
+292   2e2b035d3721   2010-08-23 15:19 -0700   ged
+  Coverage improvements, manual work
+
+291   693a163bd068   2010-08-23 08:36 -0700   ged
+  Started catching the manual up to 1.1.0.
+
+290   df0b0594cb62   2010-08-23 08:36 -0700   ged
+  Made Treequel::Branch#delete with no arguments delete the entry
+
+289   31fc0ea1ea31   2010-08-19 16:35 -0700   ged
+  Fixes for Ruby 1.9.2.
+
+288   7c7d3e2034b0   2010-08-19 07:21 -0700   ged
+  Build system update; fixed ruby-termios dependency
+
+287   f9151315d37f   2010-08-18 17:35 -0700   ged
+  Implement Branchset operators
+
+286   cd3ef7e3ffb0   2010-08-16 17:20 -0700   ged
+  Reworked operational attributes to use the 'USAGE' attribute at Mahlon's suggestion.
+
+285   dfb032f5e5c1   2010-08-16 17:19 -0700   ged
+  Fixes for Treequel::Model instantiation and lookup.
+
+284   844ee21c6916   2010-08-16 17:05 -0700   ged
+  Made Treequel::Schema::Table Enumerable
+
+283   ff2629196b4e   2010-08-06 16:11 -0700   ged
+  Don't add the objectClass attribute when searching through Treequel::Model if
+
+282   d4e58760ee34   2010-08-06 15:02 -0700   ged
+  Handle Sequel's Ruby1.9 Symbol-operator workaround in filter attributes
+
+281   d60c6b83db01   2010-08-06 15:02 -0700   ged
+  Also output empty-string attributes as non-binary
+
+280   bb182f705fe5   2010-08-05 14:07 -0700   ged
+  Unwrap base64ed LDIF lines before wrapping them to the new line length.
+
+279   32084630894f   2010-08-05 11:14 -0700   ged
+  Fix LDIF-generation for really reals.
+
+278   aabbab99b093   2010-08-05 10:40 -0700   ged
+  Optimizations, logging cleanup.
+
+277   7a4f2e5bef0a   2010-08-02 08:45 -0700   ged
+  Bugfixes.
+
+276   2f741e5294bf   2010-07-29 14:34 -0700   ged
+  Filter component symmetry, Model refactor
+
+275   bc0bc3aea136   2010-07-28 09:06 -0700   ged
+  Added support for Sequel-style #or: branchset.filter( :something ).or( :somethingelse ).
+
+274   30091794b910   2010-07-28 07:14 -0700   ged
+  Added Treequel::Model#respond_to?
+
+273   e9c908b1f426   2010-07-27 08:05 -0700   ged
+  Bugfix, make object conversion work for setting attributes too.
+
+272   30ba889041a8   2010-07-26 20:04 -0700   ged
+  Bugfixes, coverage of LDIF-generation.
+
+271   a6dd7b685a6a   2010-07-16 18:32 -0700   ged
+  Fixing the "cd .." special case
+
+270   2793fa802dad   2010-07-14 20:16 -0700   ged
+  Untaint objectClasses passed to Treequel::Model::mixins_for_objectclasses.
+
+269   b76dd9ca1f3f   2010-07-13 19:14 -0700   ged
+  The workaround for two-param syntax mapping Procs didn't work after all. Modifying
+
+268   70cc87a200ad   2010-07-13 19:08 -0700   ged
+  Added schema-object roundtripping, with a script/specs to test it.
+
+267   47e865bfef9e   2010-07-13 12:31 -0700   ged
+  Added the ability to set the default results class on a per-directory basis.
+
+266   c61373e3dc49   2010-07-13 08:03 -0700   ged
+  Fixes for Apache DS and bugfix in Treequel::Model.
+
+265   601003ff3077   2010-07-10 17:16 -0700   ged
+  Treequel::Model bugfix
+
+264   a76065cfeba0   2010-07-09 07:19 -0700   ged
+  Adding Treequel::Model, bumping version to 1.1.0.
+
+263:262,261   6dd6cb37f5ce   2010-07-09 07:16 -0700   ged
+  Merged with 47bb9cd7af3b
+
+262:258   3f4134d20d9d   2010-07-08 09:40 -0700   ged
+  Delegate the Treequel::Directory#root_dse method through its #conn
+
+261   0188c2ba5b7e   2010-07-07 23:21 -0700   ged
   Added tag 1.0.4 for changeset 0ec4ff0ce67f
 
 260[1.0.4]   0ec4ff0ce67f   2010-07-07 23:21 -0700   ged

data/Rakefile

@@ -18,6 +18,7 @@ BEGIN {
 	libdir = basedir + "lib"
 	extdir = libdir + Config::CONFIG['sitearch']
 
+	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
 	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
 	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
 }
@@ -76,7 +77,7 @@ elsif VERSION_FILE.exist?
 	PKG_VERSION = VERSION_FILE.read[ /VERSION\s*=\s*['"](\d+\.\d+\.\d+)['"]/, 1 ]
 end
 
-PKG_VERSION = '0.0.0' unless defined?( PKG_VERSION )
+PKG_VERSION = '0.0.0' unless defined?( PKG_VERSION ) && !PKG_VERSION.nil?
 
 PKG_FILE_NAME = "#{PKG_NAME.downcase}-#{PKG_VERSION}"
 GEM_FILE_NAME = "#{PKG_FILE_NAME}.gem"
@@ -169,7 +170,7 @@ include RakefileHelpers
 
 # Set the build ID if the mercurial executable is available
 if hg = which( 'hg' )
-	id = IO.read('|-') or exec hg.to_s, 'id', '-n'
+	id = `#{hg} id -n`.chomp
 	PKG_BUILD = "pre%03d" % [(id.chomp[ /^[[:xdigit:]]+/ ] || '1')]
 else
 	PKG_BUILD = 'pre000'
@@ -226,9 +227,9 @@ DEVELOPMENT_DEPENDENCIES = {
 	'text-format'  => '>= 1.0.0',
 	'tmail'        => '>= 1.2.3.1',
 	'diff-lcs'     => '>= 1.1.2',
-	'termios' => '>= 0.9.4',
 	'columnize' => '>= 0.3.1',
 	'diff-lcs' => '>= 1.1.2',
+	'ruby-termios' => '>= 0.9.6',
 	'ruby-terminfo' => '>= 0.1.1',
 }
 
@@ -277,6 +278,10 @@ GEMSPEC   = Gem::Specification.new do |gem|
 	gem.files             = RELEASE_FILES
 	gem.test_files        = SPEC_FILES
 
+	# signing key and certificate chain
+	gem.signing_key       = '/Volumes/Keys/ged-private_gem_key.pem'
+	gem.cert_chain        = [File.expand_path('~/.gem/ged-public_gem_cert.pem')]
+
 	DEPENDENCIES.each do |name, version|
 		version = '>= 0' if version.length.zero?
 		gem.add_runtime_dependency( name, version )

data/Rakefile.local

@@ -13,6 +13,8 @@ require 'pp'
 
 MANUAL_PAGES = Pathname.glob( MANUALDIR + '**/*.page' )
 
+RCOV_EXCLUDES.replace( RCOV_EXCLUDES + ',sequel_integration\.rb' )
+
 task :local => :check_manual
 task :manual => :check_manual
 

data/bin/treeirb

@@ -6,8 +6,12 @@ require 'irb/cmd/nop'
 require 'treequel'
 
 
-uri = ARGV.shift or raise "usage: #$0 [LDAPURI]"
-$dir = Treequel.directory( uri )
+if uri = ARGV.shift
+	$dir = Treequel.directory( uri )
+else
+	$dir = Treequel.directory_from_config
+end
+
 $stderr.puts "Directory is in $dir:", '  ' + $dir.inspect
 
 IRB.start( $0 )

data/bin/treequel

@@ -571,7 +571,7 @@ class Treequel::Shell
 		# Calcuate column widths
 		oclen = children.map do |subbranch|
 			subbranch.include_operational_attrs = true
-			subbranch[:structuralObjectClass].length
+			subbranch[:structuralObjectClass] ? subbranch[:structuralObjectClass].length : 0
 		end.max
 
 		# Set up sorting by collecting all the requested sort criteria as Proc objects which
@@ -610,7 +610,7 @@ class Treequel::Shell
 			return
 		end
 
-		return self.parent_command if rdn == '..'
+		return self.parent_command( options ) if rdn == '..'
 
 		raise "invalid RDN %p" % [ rdn ] unless RELATIVE_DISTINGUISHED_NAME.match( rdn )
 
@@ -868,9 +868,10 @@ class Treequel::Shell
 		metadatalen = oclen + 16 + 6 # oc + timestamp + whitespace
 		maxdesclen = self.columns - metadatalen - rdn.length - 5
 
+		modtime = branch[:modifyTimestamp] || branch[:createTimestamp]
 		return "%#{oclen}s  %s  %s%s %s" % [
-			branch[:structuralObjectClass],
-			branch[:modifyTimestamp].strftime('%Y-%m-%d %H:%M'),
+			branch[:structuralObjectClass] || '',
+			modtime.strftime('%Y-%m-%d %H:%M'),
 			rdn,
 			branch[:hasSubordinates] ? '/' : '',
 			single_line_description( branch, maxdesclen )

data/lib/treequel/branch.rb

@@ -69,7 +69,8 @@ class Treequel::Branch
 	### @param [String] dn  The DN of the entry the Branch is wrapping.
 	### @param [LDAP::Entry, Hash] entry  The entry object if it's already been fetched.
 	def initialize( directory, dn, entry=nil )
-		raise ArgumentError, "invalid DN" unless dn.match( Patterns::DISTINGUISHED_NAME )
+		raise ArgumentError, "invalid DN" unless
+			dn.match( Patterns::DISTINGUISHED_NAME ) || dn.empty?
 		raise ArgumentError, "can't cast a %s to an LDAP::Entry" % [entry.class.name] unless
 			entry.nil? || entry.is_a?( Hash )
 
@@ -104,7 +105,7 @@ class Treequel::Branch
 
 	# Whether or not to include operational attributes when fetching the Branch's entry
 	predicate_attr :include_operational_attrs
-
+	alias_method :include_operational_attributes?, :include_operational_attrs?
 
 	### Change the DN the Branch uses to look up its entry.
 	### 
@@ -124,6 +125,7 @@ class Treequel::Branch
 		self.clear_caches
 		@include_operational_attrs = new_setting ? true : false
 	end
+	alias_method :include_operational_attributes=, :include_operational_attrs=
 
 
 	### Return the attribute/s which make up this Branch's RDN.
@@ -181,6 +183,7 @@ class Treequel::Branch
 	### @return [String]
 	def parent_dn
 		return nil if self.dn == self.directory.base_dn
+		return '' if self.dn.index( ',' ).nil?
 		return self.split_dn( 2 ).last
 	end
 
@@ -260,35 +263,21 @@ class Treequel::Branch
 	end
 
 
-	### Make LDIF for the given +attribute+ and its +values+, wrapping at the given
-	### +width+.
-	### 
-	### @param [String] attribute  the attribute
-	### @param [Array<String>] values  the values for the given +attribute+
-	### @param [Fixnum] width  the maximum width of the lines to return
-	def ldif_for_attr( attribute, values, width )
-		ldif = ''
-
-		Array( values ).each do |val|
-			line = "#{attribute}:"
+	### Return the Branch as a Hash.
+	### @see Treequel::Branch#[]
+	### @return [Hash]  the entry as a Hash with converted values
+	def to_hash
+		entry = self.entry || self.valid_attributes_hash
+		self.log.debug "  making a Hash from an entry: %p" % [ entry ]
 
-			if val =~ /^#{LDIF_SAFE_STRING}$/
-				line << ' ' << val.to_s
+		return entry.keys.inject({}) do |hash, attribute|
+			if attribute == 'dn'
+				hash[ attribute ] = self.dn
 			else
-				line << ': ' << [ val ].pack( 'm' ).chomp
+				hash[ attribute ] = self[ attribute ]
 			end
-
-			# calculate how many times the line needs to be split, then add any 
-			# additional splits that need to be added because of the additional
-			# fold characters
-			splits  = ( line.length / width )
-			splits += ( splits * LDIF_FOLD_SEPARATOR.length ) / width
-			splits.times {|i| line[ width * (i+1), 0 ] = LDIF_FOLD_SEPARATOR }
-
-			ldif << line << "\n"
+			hash
 		end
-
-		return ldif
 	end
 
 
@@ -298,32 +287,9 @@ class Treequel::Branch
 		attrsym = attrname.to_sym
 
 		unless @values.key?( attrsym )
-			directory = self.directory
-			entry = self.entry or return nil
-			return nil unless (( value = entry[attrsym.to_s] ))
-
-			self.log.debug "  value is not cached; checking its attributeType"
-			if attribute = directory.schema.attribute_types[ attrsym ]
-				self.log.debug "  attribute exists; checking the entry for a value"
-
-				syntax_oid = attribute.syntax_oid
-
-				if attribute.single?
-					self.log.debug "    attributeType is SINGLE; unwrapping the Array"
-					@values[ attrsym ] = directory.convert_syntax_value( syntax_oid, value.first )
-				else
-					self.log.debug "    attributeType is not SINGLE; keeping the Array"
-					@values[ attrsym ] = value.collect do |raw|
-						directory.convert_syntax_value( syntax_oid, raw )
-					end
-					@values[ attrsym ].freeze if @values[ attrsym ].is_a?( Array )
-				end
-
-			else
-				self.log.info "no attributeType for %p" % [ attrsym ]
-				@values[ attrsym ] = value
-				@values[ attrsym ].freeze
-			end
+			value = self.get_converted_object( attrsym )
+			value.freeze if value.respond_to?( :freeze )
+			@values[ attrsym ] = value
 		else
 			self.log.debug "  value is cached."
 		end
@@ -349,6 +315,7 @@ class Treequel::Branch
 	### @param [Object] value  the attribute value
 	def []=( attrname, value )
 		value = [ value ] unless value.is_a?( Array )
+		value.collect! {|val| self.get_converted_attribute(attrname, val) }
 		self.log.debug "Modifying %s to %p" % [ attrname, value ]
 		self.directory.modify( self, attrname.to_s => value )
 		@values.delete( attrname.to_sym )
@@ -384,19 +351,25 @@ class Treequel::Branch
 	### 
 	### @return [TrueClass] if the delete succeeded
 	def delete( *attributes )
-		self.log.debug "Deleting attributes: %p" % [ attributes ]
-		mods = attributes.flatten.collect do |attribute|
-			if attribute.is_a?( Hash )
-				attribute.collect do |key,vals|
-					vals = Array( vals ).collect {|val| val.to_s }
-					LDAP::Mod.new( LDAP::LDAP_MOD_DELETE, key.to_s, vals )
+		if attributes.empty?
+			self.log.info "No attributes specified; deleting entire entry for %s" % [ self.dn ]
+			self.directory.delete( self )
+		else
+			self.log.debug "Deleting attributes: %p" % [ attributes ]
+			mods = attributes.flatten.collect do |attribute|
+				if attribute.is_a?( Hash )
+					attribute.collect do |key,vals|
+						vals = Array( vals ).collect {|val| val.to_s }
+						LDAP::Mod.new( LDAP::LDAP_MOD_DELETE, key.to_s, vals )
+					end
+				else
+					LDAP::Mod.new( LDAP::LDAP_MOD_DELETE, attribute.to_s, [] )
 				end
-			else
-				LDAP::Mod.new( LDAP::LDAP_MOD_DELETE, attribute.to_s, [] )
-			end
-		end.flatten
+			end.flatten
+
+			self.directory.modify( self, mods )
+		end
 
-		self.directory.modify( self, mods )
 		self.clear_caches
 
 		return true
@@ -478,7 +451,8 @@ class Treequel::Branch
 	### @param [String] rdn  The RDN of the child to fetch.
 	### @return [Treequel::Branch]
 	def get_child( rdn )
-		newdn = [ rdn, self.dn ].join( ',' )
+		self.log.debug "Getting child %p from base = %p" % [ rdn, self.dn ]
+		newdn = [ rdn, self.dn ].reject {|part| part.empty? }.join( ',' )
 		return self.class.new( self.directory, newdn )
 	end
 
@@ -517,6 +491,21 @@ class Treequel::Branch
 	end
 
 
+	### Return the receiver's operational attributes as attributeType schema objects.
+	###
+	### @return [Array<Treequel::Schema::AttributeType>]  the operational attributes
+	def operational_attribute_types
+		return self.directory.schema.operational_attribute_types
+	end
+
+
+	### Return OIDs (numeric OIDs as Strings, named OIDs as Symbols) for each of the 
+	### receiver's operational attributes.
+	def operational_attribute_oids
+		return self.operational_attribute_types.map( &:oid )
+	end
+
+
 	### Return Treequel::Schema::AttributeType instances for each of the receiver's
 	### objectClass's MUST attributeTypes. If any +additional_object_classes+ are given, 
 	### include the MUST attributeTypes for them as well. This can be used to predict what
@@ -626,22 +615,29 @@ class Treequel::Branch
 			end
 		end
 
-		attrhash[ :objectClass ] |= additional_object_classes
+		# :FIXME: Does the resulting hash need the additional objectClasses? objectClass is
+		#         MUST via 'top', so it should already exist in that hash when merged with
+		#         this one...
+		# attrhash[ :objectClass ] |= additional_object_classes
+
 		return attrhash
 	end
 
 
 	### Return Treequel::Schema::AttributeType instances for the set of all of the receiver's
-	### MUST and MAY attributeTypes.
+	### MUST and MAY attributeTypes plus the operational attributes.
 	### 
 	### @return [Array<Treequel::Schema::AttributeType>]
 	def valid_attribute_types
-		return self.must_attribute_types | self.may_attribute_types
+		return self.must_attribute_types |
+		       self.may_attribute_types  |
+		       self.operational_attribute_types
 	end
 
 
 	### Return a uniqified Array of OIDs (numeric OIDs as Strings, named OIDs as Symbols) for
-	### the set of all of the receiver's MUST and MAY attributeTypes.
+	### the set of all of the receiver's MUST and MAY attributeTypes plus the operational
+	### attributes.
 	### 
 	### @return [Array<String, Symbol>]
 	def valid_attribute_oids
@@ -649,8 +645,10 @@ class Treequel::Branch
 	end
 
 
-	### If the given +attroid+ is a valid attributeType name or numeric OID, return the 
+	### If the attribute associated with the given +attroid+ is in the list of valid 
+	### attributeTypes for the receiver given its objectClasses, return the 
 	### AttributeType object that corresponds with it. If it isn't valid, return nil.
+	### Includes operational attributes.
 	###
 	### @param [String,Symbol] attroid  a numeric OID (as a String) or a named OID (as a Symbol)
 	### @return [Treequel::Schema::AttributeType] the validated attributeType
@@ -660,7 +658,7 @@ class Treequel::Branch
 
 
 	### Return +true+ if the specified +attrname+ is a valid attributeType given the
-	### receiver's current objectClasses.
+	### receiver's current objectClasses. Does not include operational attributes.
 	### 
 	### @param [String, Symbol] the OID (numeric or name) of the attribute in question
 	### @return [Boolean]
@@ -736,7 +734,6 @@ class Treequel::Branch
 
 	### Fetch the entry from the Branch's directory.
 	def lookup_entry
-		self.log.debug "Looking up entry for %p" % [ self ]
 		if self.include_operational_attrs?
 			self.log.debug "  including operational attributes."
 			return self.directory.get_extended_entry( self )
@@ -747,6 +744,42 @@ class Treequel::Branch
 	end
 
 
+	### Get the value associated with +attrsym+, convert it to a Ruby object if the Branch's
+	### directory has a conversion rule, and return it.
+	def get_converted_object( attrsym )
+		return nil unless self.entry
+		value = self.entry[ attrsym.to_s ] or return nil
+
+		if attribute = self.directory.schema.attribute_types[ attrsym ]
+			if attribute.single?
+				value = self.directory.convert_to_object( attribute.syntax.oid, value.first )
+			else
+				value = value.collect do |raw|
+					self.directory.convert_to_object( attribute.syntax.oid, raw )
+				end
+			end
+		else
+			self.log.info "no attributeType for %p" % [ attrsym ]
+		end
+
+		return value
+	end
+
+
+	### Convert the specified +object+ according to the Branch's directory's conversion rules, 
+	### and return it.
+	def get_converted_attribute( attrsym, object )
+		if attribute = self.directory.schema.attribute_types[ attrsym ]
+			self.log.debug "converting %p object to a %p attribute" %
+				[ attrsym, attribute.syntax.oid ]
+			return self.directory.convert_to_attribute( attribute.syntax.oid, object )
+		else
+			self.log.info "no attributeType for %p" % [ attrsym ]
+			return object.to_s
+		end
+	end
+
+
 	### Clear any cached values when the structural state of the object changes.
 	### @return [void]
 	def clear_caches
@@ -793,6 +826,34 @@ class Treequel::Branch
 		end
 	end
 
+
+	### Make LDIF for the given +attribute+ and its +values+, wrapping at the given
+	### +width+.
+	### 
+	### @param [String] attribute  the attribute
+	### @param [Array<String>] values  the values for the given +attribute+
+	### @param [Fixnum] width  the maximum width of the lines to return
+	def ldif_for_attr( attribute, value, width )
+		unsplit_line = "#{attribute}:"
+
+		if value.empty? || value =~ /\A#{LDIF_SAFE_STRING}\Z/
+			unsplit_line << ' ' << value.to_s
+		else
+			unsplit_line << ': ' << [ value ].pack( 'm' ).chomp
+		end
+		unsplit_line.gsub!( /\n/, '' )
+
+		ldif = ''
+		ldif << unsplit_line.slice!( 0, width ) << LDIF_FOLD_SEPARATOR until
+		 	unsplit_line.empty?
+
+		ldif.rstrip!
+		ldif << "\n"
+
+		return ldif
+	end
+
+
 end # class Treequel::Branch
 
 

data/lib/treequel/branchcollection.rb

@@ -178,19 +178,30 @@ class Treequel::BranchCollection
 	end
 
 
-	### Return a new Treequel::BranchCollection that includes both the receiver's Branchsets and
-	### those in +other_object+ (or +other_object+ itself if it's a Branchset).
+	### Return either a new Treequel::BranchCollection that includes both the receiver's 
+	### Branchsets and those in +other_object+ (if it responds_to #branchsets), or the results
+	### from executing the BranchCollection's search with +other_object+ appended if it doesn't.
+	### @param [Object] other_object
 	def +( other_object )
 		if other_object.respond_to?( :branchsets )
 			return self.class.new( self.branchsets + other_object.branchsets )
-		elsif other_object.respond_to?( :branchset )
-			return self.class.new( self.branchsets + [other_object.branchset] )
-		else
+		elsif other_object.respond_to?( :collection )
 			return self.class.new( self.branchsets + [other_object] )
+		else
+			return self.all + Array( other_object )
 		end
 	end
 
 
+	### Return the results from each of the receiver's Branchsets without the +other_object+.
+	### @param [#dn]  other_object  the object to omit from the results. Must respond_to #dn.
+	### @return [Array<Treequel::Branch>]
+	def -( other_object )
+		other_dn = other_object.dn
+		return self.reject {|branch| branch.dn == other_dn }
+	end
+
+
 	### Return a new Treequel::BranchCollection that contains the union of the branchsets from both
 	### collections.
 	def &( other_collection )

data/lib/treequel/branchset.rb

@@ -176,12 +176,26 @@ class Treequel::Branchset
 	end
 
 
-	### Create a BranchCollection from the receiver and the +other_branchset+ and return 
-	### it. 
-	### @param [Treequel::Branchset] other_branchset  the branchset to combine with
-	### @return [Treequel::BranchCollection]  the resulting collection object
-	def +( other_branchset )
-		return Treequel::BranchCollection.new( self, other_branchset )
+	### If given another Branchset or a BranchCollection, return a BranchCollection that includes
+	### them both. If given anything else, execute the search and return 
+	### @param [Treequel::Branchset, Treequel::Branch] other  the branchset or branch to combine 
+	###                                                       with
+	### @return [Treequel::BranchCollection, Array<Treequel::Branch>]
+	def +( other )
+		if other.is_a?( Treequel::BranchCollection ) || other.is_a?( Treequel::Branchset )
+			return Treequel::BranchCollection.new( self, other )
+		else
+			return self.all + Array( other )
+		end
+	end
+
+
+	### Return the results of executing the search without the +other_object+.
+	### @param [#dn] other_object  the object to omit from the results; must respond_to #dn.
+	### @return [Array<Treequel::Branch>]
+	def -( other_object )
+		other_dn = other_object.dn
+		return self.reject {|branch| branch.dn == other_dn }
 	end
 
 
@@ -276,6 +290,23 @@ class Treequel::Branchset
 	end
 
 
+	### Add an alternate filter to an existing filter by ORing them.
+	### @param filterspec  the filter spec to OR with the existing filter
+	### @raises [Treequel::InvalidOperation]  if there is no existing filter
+	### @see Treequel::Filter.new  for specifics on what +filterspec+ can be
+	def or( *filterspec )
+		opts = self.options
+		existing_filter = self.filter
+		raise Treequel::ExpressionError, "no existing filter" if
+			existing_filter.promiscuous?
+
+		newfilter = Treequel::Filter.new( *filterspec )
+
+		self.log.debug "cloning %p with alternative filterspec: %p" % [ self, filterspec ]
+		return self.clone( :filter => (self.filter | newfilter) )
+	end
+
+
 	### If called with no argument, returns the current scope of the Branchset. If 
 	### called with an argument (which should be one of the keys of 
 	### Treequel::Constants::SCOPE), returns a clone of the receiving Branchset

data/lib/treequel/constants.rb

@@ -141,6 +141,18 @@ module Treequel::Constants
 	FEATURE_NAMES = FEATURE_OIDS.invert.freeze
 
 
+	### The list of RFC4512 operational attributes that "SHOULD" be maintained.
+	### (http://tools.ietf.org/html/rfc4512#section-3.4)
+	MINIMAL_OPERATIONAL_ATTRIBUTES = [
+		:creatorsName,
+		:createTimestamp,
+		:modifiersName,
+		:modifyTimestamp,
+		:structuralObjectClass,
+		:governingStructureRule,
+	]
+
+
 	### OIDs of RFC values
 	module OIDS