treequel 1.5.3 → 1.6.0

data/lib/treequel/constants.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/ruby
+#encoding: utf-8
 
 require 'uri'
 require 'ldap'
@@ -235,8 +236,8 @@ module Treequel::Constants
 		#	
 		#	SP      = 1*SPACE  ; one or more " "
 		#	WSP     = 0*SPACE  ; zero or more " "
-		SP = '[ ]+'
-		WSP = '[ ]*'
+		SP = '\x20+'
+		WSP = '\x20*'
 
 		### These are inlined for simplicity
 		#	NULL    = %x00 ; null (0)
@@ -312,9 +313,9 @@ module Treequel::Constants
 		#	UTF0    = %x80-BF
 		#	UTF1    = %x00-7F
 		#	UTF2    = %xC2-DF UTF0
-		UTF0 = /[\x80-\xbf]/
-		UTF1 = /[\x00-\x7f]/
-		UTF2 = /[\xc2-\xdf] #{UTF0}/x
+		UTF0 = /[\x80-\xbf]/n
+		UTF1 = /[\x00-\x7f]/n
+		UTF2 = /[\xc2-\xdf] #{UTF0}/xn
 
 		#	UTF3    = %xE0 %xA0-BF UTF0 / %xE1-EC 2(UTF0) / %xED %x80-9F UTF0 / %xEE-EF 2(UTF0)
 		UTF3 = /
@@ -325,7 +326,7 @@ module Treequel::Constants
 			\xed [\x80-\x9f] #{UTF0}
 			|
 			[\xee-\xef] #{UTF0}{2}
-		/x
+		/xn
 
 		#	UTF4    = %xF0 %x90-BF 2(UTF0) / %xF1-F3 3(UTF0) / %xF4 %x80-8F 2(UTF0)
 		UTF4 = /
@@ -334,7 +335,7 @@ module Treequel::Constants
 			[\xf1-\xf3] #{UTF0}{3}
 			|
 			\xf4 [\x80-\x8f] #{UTF0}{2}
-		/x
+		/xn
 
 		#	UTFMB   = UTF2 / UTF3 / UTF4
 		UTFMB = Regexp.union( UTF2, UTF3, UTF4 )
@@ -349,7 +350,8 @@ module Treequel::Constants
 		LEADKEYCHAR = /[#{ALPHA}]/
 
 		#	keychar = ALPHA / DIGIT / HYPHEN
-		KEYCHAR = /[#{ALPHA}#{DIGIT}\-]/
+		# NOTE: added literal '.' to work around OpenDS's non-standard matchingRule names
+		KEYCHAR = /[#{ALPHA}#{DIGIT}\-\.]/
 
 		#	number  = DIGIT / ( LDIGIT 1*DIGIT )
 		NUMBER = /[#{LDIGIT}]#{DIGIT}+|#{DIGIT}/ # Reversed for greediness
@@ -436,6 +438,23 @@ module Treequel::Constants
 		QDSTRINGLIST = /(?: #{QDSTRING} (?: #{SP} #{QDSTRING} )* )?/x
 		QDSTRINGS = / #{QDSTRING} | #{LPAREN} #{WSP} #{QDSTRINGLIST} #{WSP} #{RPAREN} /x
 
+		# Workaround for attributeType declarations that have unescaped single quotes 
+		# in them (e.g., "Change Record Object Class Definition",
+		#   http://tools.ietf.org/html/draft-good-ldap-changelog-04)
+		# It will accept an unquoted single quote as long as it's followed by
+		# a non-whitespace character.
+		MALFORMED_DSTRING = %r{
+			(?>
+				# An unescaped single quote followed by a non-whitespace character
+				#{SQUOTE} (?=\S)
+				|
+				# or correctly-escaped single-quoted string characters
+			 	#{DSTRING}
+			)*
+		}x
+		MALFORMED_QDSTRING = / #{SQUOTE} #{MALFORMED_DSTRING} #{SQUOTE} /x
+
+
 		# extensions = *( SP xstring SP qdstrings )
 		EXTENSIONS = /(?: #{SP} #{XSTRING} #{SP} #{QDSTRINGS} )*/x
 
@@ -455,9 +474,12 @@ module Treequel::Constants
 		#       [ SP "MAY" SP oids ]       ; attribute types
 		#       extensions WSP RPAREN
 
+		# Note: added 'descr' to the oid to support Sun OpenDS, which allows names instead of
+		# numericoids "for convenience". 
+		# (http://download.oracle.com/docs/cd/E19476-01/821-0509/object-class-description-format.html)
 		LDAP_OBJECTCLASS_DESCRIPTION = %r{
 			#{LPAREN} #{WSP}
-				(#{NUMERICOID})                         # $1 = oid
+				(#{NUMERICOID} | #{DESCR})              # $1 = oid
 				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2 = name
 				(?:#{SP} DESC #{SP} (#{QDSTRING}))?     # $3 = desc
 				(?:#{SP} (OBSOLETE) )?                  # $4 = obsolete
@@ -469,17 +491,70 @@ module Treequel::Constants
 			#{WSP} #{RPAREN}
 		}x
 
+		# Support for objectClass definitions with the KIND before the SUP such as those 
+		# in RFC3712
+		LDAP_MISORDERED_KIND_OBJECTCLASS_DESCRIPTION = %r{
+			#{LPAREN} #{WSP}
+				(#{NUMERICOID} | #{DESCR})              # $1 = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2 = name
+				(?:#{SP} DESC #{SP} (#{QDSTRING}))?     # $3 = desc
+				(?:#{SP} (OBSOLETE) )?                  # $4 = obsolete
+				(?:#{SP} (#{KIND}) )?                   # $5 = kind
+				(?:#{SP} SUP #{SP} (#{OIDS}) )?         # $6 = sup
+				(?:#{SP} MUST #{SP} (#{OIDS}) )?        # $7 = must attrs
+				(?:#{SP} MAY #{SP} (#{OIDS}) )?         # $8 = may attrs
+				(#{EXTENSIONS})                         # $9 = extensions
+			#{WSP} #{RPAREN}
+		}x
+
+		# Support for objectClass definitions with the KIND after the MUST and MAY
+		# sections like RFC2696's authPasswordObject
+		LDAP_TRAILING_KIND_OBJECTCLASS_DESCRIPTION = %r{
+			#{LPAREN} #{WSP}
+				(#{NUMERICOID} | #{DESCR})              # $1 = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2 = name
+				(?:#{SP} DESC #{SP} (#{QDSTRING}))?     # $3 = desc
+				(?:#{SP} (OBSOLETE) )?                  # $4 = obsolete
+				(?:#{SP} SUP #{SP} (#{OIDS}) )?         # $5 = sup
+				(?:#{SP} MUST #{SP} (#{OIDS}) )?        # $6 = must attrs
+				(?:#{SP} MAY #{SP} (#{OIDS}) )?         # $7 = may attrs
+				(?:#{SP} (#{KIND}) )?                   # $8 = kind
+				(#{EXTENSIONS})                         # $9 = extensions
+			#{WSP} #{RPAREN}
+		}x
+
+		# Support for objectClass definitions with the DESC after the SUP and KIND
+		# like draft-howard-rfc2307bis, and a bunch of "Solaris Specific" ones from 
+		# OpenDS servers.
+		LDAP_MISORDERED_DESC_OBJECTCLASS_DESCRIPTION = %r{
+			#{LPAREN} #{WSP}
+				(#{NUMERICOID} | #{DESCR})              # $1 = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2 = name
+				(?:#{SP} (OBSOLETE) )?                  # $3 = obsolete
+				(?:#{SP} SUP #{SP} (#{OIDS}) )?         # $4 = sup
+				(?:#{SP} (#{KIND}) )?                   # $5 = kind
+				(?:#{SP} DESC #{SP} (#{QDSTRING}))?     # $6 = desc
+				(?:#{SP} MUST #{SP} (#{OIDS}) )?        # $7 = must attrs
+				(?:#{SP} MAY #{SP} (#{OIDS}) )?         # $8 = may attrs
+				(#{EXTENSIONS})                         # $9 = extensions
+			#{WSP} #{RPAREN}
+		}x
+
 
 		# usage = "userApplications"     /  ; user
 		#         "directoryOperation"   /  ; directory operational
 		#         "distributedOperation" /  ; DSA-shared operational
 		#         "dSAOperation"            ; DSA-specific operational
-		USAGE = Regexp.union(
-			'userApplications',
-			'directoryOperation',
-			'distributedOperation',
-			'dSAOperation'
-		  )
+		USAGE = %r{
+			userApplications
+			|
+			directoryOperation
+			|
+			distributedOperation
+			|
+			dSAOperation
+		  }xi
+
 
 		# Attribute Type definitions are written according to the ABNF:
 		#
@@ -498,9 +573,13 @@ module Treequel::Constants
 		#            [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
 		#            [ SP "USAGE" SP usage ]       ; usage
 		#            extensions WSP RPAREN         ; extensions
+
+		# Note: added 'descr' to the oid to support Sun OpenDS, which allows names instead of
+		# numericoids "for convenience". 
+		# (https://www.opends.org/wiki/page/UnderstandingAttributeTypes)
 		LDAP_ATTRIBUTE_TYPE_DESCRIPTION = %r{
 			#{LPAREN} #{WSP}
-				(#{NUMERICOID})                         # $1  = oid
+				(#{NUMERICOID} | #{DESCR})              # $1  = oid
 				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2  = name
 				(?:#{SP} DESC #{SP} (#{QDSTRING}) )?    # $3  = description
 				(?:#{SP} (OBSOLETE) )?                  # $4  = obsolete flag
@@ -517,6 +596,50 @@ module Treequel::Constants
 			#{WSP} #{RPAREN}
 		}x
 
+		# Attribute type with an unescaped single quote in the DESC; added for schemas that
+		# include the 'changelog' attributeType from 
+		#   http://tools.ietf.org/html/draft-good-ldap-changelog-04
+		LDAP_UNESCAPE_SQUOTE_ATTRIBUTE_TYPE_DESCRIPTION = %r{
+			#{LPAREN} #{WSP}
+				(#{NUMERICOID} | #{DESCR})                     # $1  = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?            # $2  = name
+				(?:#{SP} DESC #{SP} (#{MALFORMED_QDSTRING}) )  # $3  = description
+				(?:#{SP} (OBSOLETE) )?                         # $4  = obsolete flag
+				(?:#{SP} SUP #{SP} (#{OID}) )?                 # $5  = superior type oid
+				(?:#{SP} EQUALITY #{SP} (#{OID}) )?            # $6  = equality matching rule oid
+				(?:#{SP} ORDERING #{SP} (#{OID}) )?            # $7  = ordering matching rule oid
+				(?:#{SP} SUBSTR #{SP} (#{OID}) )?              # $8  = substring matching rule oid
+				(?:#{SP} SYNTAX #{SP} (#{NOIDLEN}) )?          # $9  = value syntax matching oid
+				(?:#{SP} (SINGLE-VALUE) )?                     # $10 = single value flag
+				(?:#{SP} (COLLECTIVE) )?                       # $11 = collective flag
+				(?:#{SP} (NO-USER-MODIFICATION) )?             # $12 = no user modification flag
+				(?:#{SP} USAGE #{SP} (#{USAGE}) )?             # $13 = usage type
+				(#{EXTENSIONS})                                # $14 = extensions
+			#{WSP} #{RPAREN}
+		}x
+
+		# Support for attributeType declarations which have the SYNTAX before the EQUALITY
+		# and ORDERING (e.g., changeNumber from 
+		#   http://tools.ietf.org/html/draft-good-ldap-changelog-04 )
+		LDAP_MISORDERED_SYNTAX_ATTRIBUTE_TYPE_DESCRIPTION = %r{
+			#{LPAREN} #{WSP}
+				(#{NUMERICOID} | #{DESCR})              # $1  = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2  = name
+				(?:#{SP} DESC #{SP} (#{QDSTRING}) )?    # $3  = description
+				(?:#{SP} (OBSOLETE) )?                  # $4  = obsolete flag
+				(?:#{SP} SUP #{SP} (#{OID}) )?          # $5  = superior type oid
+				(?:#{SP} SYNTAX #{SP} (#{NOIDLEN}) )?   # $6  = value syntax matching oid
+				(?:#{SP} EQUALITY #{SP} (#{OID}) )?     # $7  = equality matching rule oid
+				(?:#{SP} ORDERING #{SP} (#{OID}) )?     # $8  = ordering matching rule oid
+				(?:#{SP} SUBSTR #{SP} (#{OID}) )?       # $9  = substring matching rule oid
+				(?:#{SP} (SINGLE-VALUE) )?              # $10 = single value flag
+				(?:#{SP} (COLLECTIVE) )?                # $11 = collective flag
+				(?:#{SP} (NO-USER-MODIFICATION) )?      # $12 = no user modification flag
+				(?:#{SP} USAGE #{SP} (#{USAGE}) )?      # $13 = usage type
+				(#{EXTENSIONS})                         # $14 = extensions
+			#{WSP} #{RPAREN}
+		}x
+
 
 		# MatchingRuleDescription = LPAREN WSP
 		# 	numericoid                 ; object identifier
@@ -527,12 +650,12 @@ module Treequel::Constants
 		# 	extensions WSP RPAREN      ; extensions
 		LDAP_MATCHING_RULE_DESCRIPTION = %r{
 			#{LPAREN} #{WSP}
-				(#{NUMERICOID})                        # $1  = oid
-				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?    # $2  = name
-				(?:#{SP} DESC #{SP} (#{QDSTRING}) )?   # $3  = description
-				(?:#{SP} (OBSOLETE) )?                 # $4  = obsolete flag
-				#{SP} SYNTAX #{SP} (#{NUMERICOID})     # $5  = syntax numeric OID
-				(#{EXTENSIONS})                        # $6 = extensions
+				(#{NUMERICOID})                         # $1  = oid
+				(?:#{SP} NAME #{SP} (#{QDESCRS}) )?     # $2  = name
+				(?:#{SP} DESC #{SP} (#{QDSTRING}) )?    # $3  = description
+				(?:#{SP} (OBSOLETE) )?                  # $4  = obsolete flag
+				#{SP} SYNTAX #{SP} (#{NUMERICOID})      # $5  = syntax numeric OID
+				(#{EXTENSIONS})                         # $6 = extensions
 			#{WSP} #{RPAREN}
 		}x
 

data/lib/treequel/directory.rb

@@ -147,6 +147,18 @@ class Treequel::Directory
 	end
 
 
+	### Copy constructor -- the duplicate should have a distinct connection, bound user, 
+	### and should have a distinct copy of the +original+'s registered controls.
+	def initialize_copy( original )
+		@conn       = nil
+		@bound_user = nil
+
+		@object_conversions    = @object_conversions.dup
+		@attribute_conversions = @attribute_conversions.dup
+		@registered_controls   = @registered_controls.dup
+	end
+
+
 	######
 	public
 	######

data/lib/treequel/model.rb

@@ -370,6 +370,9 @@ class Treequel::Model < Treequel::Branch
 		self.errors.add( :objectClass, 'must have at least one' ) if self.object_classes.empty?
 
 		super( options )
+		self.log.debug "Validations failed:\s  %s" % [ self.errors.full_messages.join("\n  ") ] if
+			self.errors.count.nonzero?
+
 		self.after_validation
 	end
 
@@ -395,8 +398,10 @@ class Treequel::Model < Treequel::Branch
 			raise Treequel::BeforeHookFailed, :save
 
 		if self.exists?
+			self.log.debug "  already exists, so updating."
 			self.update( mods )
 		else
+			self.log.debug "  doesn't exist, so creating."
 			self.create( mods )
 		end
 

data/lib/treequel/schema/attributetype.rb

@@ -59,13 +59,25 @@ class Treequel::Schema::AttributeType
 
 	### Parse an AttributeType entry from a attributeType description from a schema.
 	def self::parse( schema, description )
-		unless match = ( LDAP_ATTRIBUTE_TYPE_DESCRIPTION.match(description) )
+		oid, names, desc, obsolete, sup_oid, eqmatch_oid, ordmatch_oid, submatch_oid, syntax_oid,
+			single, collective, nousermod, usagetype, extensions = nil
+
+		case description.gsub( /[\n\t]+/, ' ' ).squeeze( ' ' )
+		when LDAP_ATTRIBUTE_TYPE_DESCRIPTION
+			oid, names, desc, obsolete, sup_oid, eqmatch_oid, ordmatch_oid, submatch_oid, syntax_oid,
+				single, collective, nousermod, usagetype, extensions = $~.captures
+		when LDAP_UNESCAPE_SQUOTE_ATTRIBUTE_TYPE_DESCRIPTION
+			oid, names, desc, obsolete, sup_oid, eqmatch_oid, ordmatch_oid, submatch_oid, syntax_oid,
+				single, collective, nousermod, usagetype, extensions = $~.captures
+			self.handle_malformed_parse( "unescaped single quote in DESC #{desc}", description )
+		when LDAP_MISORDERED_SYNTAX_ATTRIBUTE_TYPE_DESCRIPTION
+			oid, names, desc, obsolete, sup_oid, syntax_oid, eqmatch_oid, ordmatch_oid, submatch_oid,
+				single, collective, nousermod, usagetype, extensions = $~.captures
+			self.handle_malformed_parse( "misordered SYNTAX #{syntax_oid}", description )
+		else
 			raise Treequel::ParseError, "failed to parse attributeType from %p" % [ description ]
 		end
 
-		oid, names, desc, obsolete, sup_oid, eqmatch_oid, ordmatch_oid, submatch_oid, syntax_oid,
-			single, collective, nousermod, usagetype, extensions = match.captures
-
 		# Normalize the attributes
 		names = Treequel::Schema.parse_names( names )
 		desc  = Treequel::Schema.unquote_desc( desc )
@@ -94,6 +106,18 @@ class Treequel::Schema::AttributeType
 	end
 
 
+	### Handle the parse of an attributeType that matches one of the non-standard attributeType
+	### definitions found in several RFCs. If Treequel::Schema.strict_parse_mode? is +true+,
+	### this method will raise an exception.
+	def self::handle_malformed_parse( message, attr_desc )
+		raise Treequel::ParseError, "Malformed attributeType: %s: %p" % [ message, attr_desc ] if
+			Treequel::Schema.strict_parse_mode?
+		Treequel.log.info "Working around malformed attributeType: %s: %p" % [ message, attr_desc ]
+	end
+
+
+
+
 	#############################################################
 	###	I N S T A N C E   M E T H O D S
 	#############################################################

data/lib/treequel/schema/objectclass.rb

@@ -52,19 +52,41 @@ class Treequel::Schema
 		end
 
 
-		### Parse an ObjectClass entry from a objectClass description from a schema.
+		### Parse an ObjectClass entry from a objectClass +description+ from a +schema+.
+		### @param [String] description       the RFC4512-format objectClass description
+		### @param [Treequel::Schema] schema  the schema object the objectClass belongs to
+		### @return [Treequel::Schema::ObjectClass]  the resulting objectclass
 		def self::parse( schema, description )
-			unless match = ( LDAP_OBJECTCLASS_DESCRIPTION.match(description) )
+			oid, names, desc, obsolete, sup, kind, must, may, extensions = nil
+
+			# :FIXME: Change this to some sort of strategy that extracts the pieces from the
+			# description and checks to be sure everything was consumed instead of depending
+			# on the RFC's BNF. It appears people expect to be able to arbitrarily reorder
+			# them, and making a different Regexp for each exception isn't going to work
+			# long-term.
+			case description.gsub( /[\n\t]+/, ' ' ).squeeze( ' ' )
+			when LDAP_OBJECTCLASS_DESCRIPTION
+				oid, names, desc, obsolete, sup, kind, must, may, extensions = $~.captures
+			when LDAP_MISORDERED_KIND_OBJECTCLASS_DESCRIPTION
+				oid, names, desc, obsolete, kind, sup, must, may, extensions = $~.captures
+				self.handle_malformed_parse( "transposed KIND (#{kind}) and SUP (#{sup})",
+				                              description )
+			when LDAP_TRAILING_KIND_OBJECTCLASS_DESCRIPTION
+				oid, names, desc, obsolete, sup, must, may, kind, extensions = $~.captures
+				self.handle_malformed_parse( "misordered KIND (#{kind})", description )
+			when LDAP_MISORDERED_DESC_OBJECTCLASS_DESCRIPTION
+				oid, names, obsolete, sup, kind, desc, must, may, extensions = $~.captures
+				self.handle_malformed_parse( "misordered DESC (#{desc})", description )
+			else
 				raise Treequel::ParseError, "failed to parse objectClass from %p" % [ description ]
 			end
 
-			oid, names, desc, obsolete, sup, kind, must, may, extensions = match.captures
-
 			# Normalize the attributes
-			must_oids = Treequel::Schema.parse_oids( must )
-			may_oids  = Treequel::Schema.parse_oids( may )
-			names     = Treequel::Schema.parse_names( names )
-			desc      = Treequel::Schema.unquote_desc( desc )
+			must_oids  = Treequel::Schema.parse_oids( must )
+			may_oids   = Treequel::Schema.parse_oids( may )
+			names      = Treequel::Schema.parse_names( names )
+			desc       = Treequel::Schema.unquote_desc( desc )
+			extensions = extensions.strip
 
 			# Default the 'kind' attribute
 			kind ||= DEFAULT_OBJECTCLASS_KIND
@@ -79,6 +101,16 @@ class Treequel::Schema
 		end
 
 
+		### Handle the parse of an objectClass that matches one of the non-standard objectClass
+		### definitions found in several RFCs. If Treequel::Schema.strict_parse_mode? is +true+,
+		### this method will raise an exception.
+		def self::handle_malformed_parse( message, oc_desc )
+			raise Treequel::ParseError, "Malformed objectClass: %s: %p" % [ message, oc_desc ] if
+				Treequel::Schema.strict_parse_mode?
+			Treequel.log.info "Working around malformed objectClass: %s: %p" % [ message, oc_desc ]
+		end
+
+
 		#############################################################
 		###	I N S T A N C E   M E T H O D S
 		#############################################################

data/lib/treequel/schema.rb

@@ -37,6 +37,24 @@ class Treequel::Schema
 	###	C L A S S   M E T H O D S
 	#################################################################
 
+	@strict_parse_mode = false
+
+	### Set the strict-parsing +flag+. Setting this to a +true+ value causes schema-parsing
+	### errors to be propagated to the caller instead of handled by the constructor, which is
+	### the default behavior.
+	### @param [boolean] flag  the new flag value
+	def self::strict_parse_mode=( newval )
+		@strict_parse_mode = newval ? true : false
+	end
+
+
+	### Test whether or not strict-parsing mode is in effect.
+	### @return [boolean]  false if parse errors will be caught
+	def self::strict_parse_mode?
+		return @strict_parse_mode ? true : false
+	end
+
+
 	### Parse the given +oidstring+ into an Array of OIDs, with Strings for numeric OIDs and
 	### Symbols for aliases.
 	def self::parse_oids( oidstring )
@@ -162,11 +180,11 @@ class Treequel::Schema
 	### keys "objectClasses", "ldapSyntaxes", "matchingRuleUse", "attributeTypes", and 
 	### "matchingRules".
 	def initialize( hash )
-		@object_classes     = self.parse_objectclasses( hash['objectClasses'] )
-		@attribute_types    = self.parse_attribute_types( hash['attributeTypes'] )
-		@ldap_syntaxes      = self.parse_ldap_syntaxes( hash['ldapSyntaxes'] )
-		@matching_rules     = self.parse_matching_rules( hash['matchingRules'] )
-		@matching_rule_uses = self.parse_matching_rule_uses( hash['matchingRuleUse'] )
+		@object_classes     = self.parse_objectclasses( hash['objectClasses'] || [] )
+		@attribute_types    = self.parse_attribute_types( hash['attributeTypes'] || [] )
+		@ldap_syntaxes      = self.parse_ldap_syntaxes( hash['ldapSyntaxes'] || [] )
+		@matching_rules     = self.parse_matching_rules( hash['matchingRules'] || [] )
+		@matching_rule_uses = self.parse_matching_rule_uses( hash['matchingRuleUse'] || [] )
 	end
 
 
@@ -237,11 +255,17 @@ class Treequel::Schema
 	### has any).
 	def parse_objectclasses( descriptions )
 		return descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|
-			oc = Treequel::Schema::ObjectClass.parse( self, desc ) or
-				raise Treequel::Error, "couldn't create an objectClass from %p" % [ desc ]
-
-			table[ oc.oid ] = oc
-			oc.names.inject( table ) {|h, name| h[name] = oc; h }
+			begin
+				oc = Treequel::Schema::ObjectClass.parse( self, desc )
+				table[ oc.oid ] = oc
+				oc.names.inject( table ) {|h, name| h[name] = oc; h }
+			rescue Treequel::ParseError => err
+				if self.class.strict_parse_mode?
+					raise
+				else
+					self.log.warn( err.message )
+				end
+			end
 
 			table
 		end
@@ -253,11 +277,17 @@ class Treequel::Schema
 	### (if it has any).
 	def parse_attribute_types( descriptions )
 		return descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|
-			attrtype = Treequel::Schema::AttributeType.parse( self, desc ) or
-				raise Treequel::Error, "couldn't create an attributeType from %p" % [ desc ]
-
-			table[ attrtype.oid ] = attrtype
-			attrtype.names.inject( table ) {|h, name| h[name] = attrtype; h }
+			begin
+				attrtype = Treequel::Schema::AttributeType.parse( self, desc )
+				table[ attrtype.oid ] = attrtype
+				attrtype.names.inject( table ) {|h, name| h[name] = attrtype; h }
+			rescue Treequel::ParseError => err
+				if self.class.strict_parse_mode?
+					raise
+				else
+					self.log.warn( err.message )
+				end
+			end
 
 			table
 		end
@@ -269,10 +299,17 @@ class Treequel::Schema
 	def parse_ldap_syntaxes( descriptions )
 		descriptions ||= []
 		return descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|
-			syntax = Treequel::Schema::LDAPSyntax.parse( self, desc ) or
-				raise Treequel::Error, "couldn't create an LDAPSyntax from %p" % [ desc ]
+			begin
+				syntax = Treequel::Schema::LDAPSyntax.parse( self, desc )
+				table[ syntax.oid ] = syntax
+			rescue Treequel::ParseError => err
+				if self.class.strict_parse_mode?
+					raise
+				else
+					self.log.warn( err.message )
+				end
+			end
 
-			table[ syntax.oid ] = syntax
 			table
 		end
 	end
@@ -284,11 +321,17 @@ class Treequel::Schema
 	def parse_matching_rules( descriptions )
 		descriptions ||= []
 		return descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|
-			rule = Treequel::Schema::MatchingRule.parse( self, desc ) or
-				raise Treequel::Error, "couldn't create an matchingRule from %p" % [ desc ]
-
-			table[ rule.oid ] = rule
-			rule.names.inject( table ) {|h, name| h[name] = rule; h }
+			begin
+				rule = Treequel::Schema::MatchingRule.parse( self, desc )
+				table[ rule.oid ] = rule
+				rule.names.inject( table ) {|h, name| h[name] = rule; h }
+			rescue Treequel::ParseError => err
+				if self.class.strict_parse_mode?
+					raise
+				else
+					self.log.warn( err.message )
+				end
+			end
 
 			table
 		end
@@ -301,11 +344,17 @@ class Treequel::Schema
 	def parse_matching_rule_uses( descriptions )
 		descriptions ||= []
 		return descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|
-			ruleuse = Treequel::Schema::MatchingRuleUse.parse( self, desc ) or
-				raise Treequel::Error, "couldn't create an matchingRuleUse from %p" % [ desc ]
-
-			table[ ruleuse.oid ] = ruleuse
-			ruleuse.names.inject( table ) {|h, name| h[name] = ruleuse; h }
+			begin
+				ruleuse = Treequel::Schema::MatchingRuleUse.parse( self, desc )
+				table[ ruleuse.oid ] = ruleuse
+				ruleuse.names.inject( table ) {|h, name| h[name] = ruleuse; h }
+			rescue Treequel::ParseError => err
+				if self.class.strict_parse_mode?
+					raise
+				else
+					self.log.warn( err.message )
+				end
+			end
 
 			table
 		end

data/lib/treequel.rb

@@ -53,10 +53,10 @@ end
 module Treequel
 
 	# Library version
-	VERSION = '1.5.3'
+	VERSION = '1.6.0'
 
 	# VCS revision
-	REVISION = %q$Revision: 1f396aca7d8b $
+	REVISION = %q$Revision: 2639d7f96151 $
 
 	# Common paths for ldap.conf
 	COMMON_LDAP_CONF_PATHS = %w[