treequel 1.0.0

data/lib/treequel/schema/matchingruleuse.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'English'
+
+require 'treequel'
+require 'treequel/mixins'
+require 'treequel/schema'
+require 'treequel/exceptions'
+
+
+# This is a class for representing matchingRuleUse declarations in a Treequel::Schema.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# :include: LICENSE
+#
+#--
+#
+# Please see the file LICENSE in the base directory for licensing details.
+#
+class Treequel::Schema::MatchingRuleUse
+	include Treequel::Loggable,
+	        Treequel::Constants::Patterns
+
+	extend Treequel::AttributeDeclarations
+
+
+	#############################################################
+	###	C L A S S   M E T H O D S
+	#############################################################
+
+	### Parse an MatchingRuleUse entry from a matchingRuleUse description from a schema.
+	def self::parse( schema, description )
+		unless match = ( LDAP_MATCHING_RULE_USE_DESCRIPTION.match(description) )
+			raise Treequel::ParseError, "failed to parse matchingRuleUse from %p" % [ description ]
+		end
+
+		oid, names, desc, obsolete, attr_oids, extensions = match.captures
+		# Treequel.logger.debug "  parsed matchingRuleUse: %p" % [ match.captures ]
+
+		# Normalize the attributes
+		names     = Treequel::Schema.parse_names( names )
+		desc      = Treequel::Schema.unquote_desc( desc )
+		attr_oids = Treequel::Schema.parse_oids( attr_oids )
+
+		return self.new( schema, oid, attr_oids, names, desc, obsolete, extensions )
+	end
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new MatchingRuleUse
+	def initialize( schema, oid, attr_oids, names=nil, desc=nil, obsolete=false, extensions=nil )
+		@schema     = schema
+
+		@oid        = oid
+		@names      = names
+		@desc       = desc
+		@obsolete   = obsolete ? true : false
+		@attr_oids  = attr_oids
+
+		@extensions = extensions
+
+		super()
+	end
+
+
+	######
+	public
+	######
+
+	# The schema the matchingRuleUse belongs to
+	attr_reader :schema
+
+	# The matchingRuleUse's oid
+	attr_reader :oid
+
+	# The Array of the matchingRuleUse's names
+	attr_reader :names
+
+	# The matchingRuleUse's description
+	attr_accessor :desc
+
+	# Is the matchingRuleUse obsolete?
+	predicate_attr :obsolete
+
+	# The OIDs of the attributes the matchingRuleUse applies to
+	attr_reader :attr_oids
+
+	# The matchingRuleUse's extensions (as a String)
+	attr_accessor :extensions
+
+
+	### Return the first of the matchingRuleUse's names, if it has any, or +nil+.
+	def name
+		return self.names.first
+	end
+
+
+	### Return a human-readable representation of the object suitable for debugging
+	def inspect
+		return "#<%s:0x%0x %s(%s) %p -> %p >" % [
+			self.class.name,
+			self.object_id / 2,
+			self.name,
+			self.oid,
+			self.desc,
+			self.attr_oids,
+		]
+	end
+
+
+	### Return Treequel::Schema::AttributeType objects for each of the types this MatchingRuleUse
+	### applies to.
+	def attribute_types
+		return self.attr_oids.collect {|oid| self.schema.attribute_types[oid] }
+	end
+
+end # class Treequel::Schema::MatchingRuleUse
+

data/lib/treequel/schema/objectclass.rb

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+
+require 'English'
+
+require 'treequel'
+require 'treequel/schema'
+require 'treequel/exceptions'
+
+
+# This is a collection of classes for representing objectClasses in a Treequel::Schema.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# * Mahlon E. Smith <mahlon@martini.nu>
+# 
+# :include: LICENSE
+#
+#--
+#
+# Please see the file LICENSE in the base directory for licensing details.
+#
+class Treequel::Schema
+
+	# The types of objectClass as specified in the schema, along with which Ruby class
+	# corresponds to it. Each class registers itself as it's defined.
+	OBJECTCLASS_TYPES = {}
+
+
+	### objectClass entries in a Treequel::Schema.
+	class ObjectClass
+		include Treequel::Loggable,
+		        Treequel::Constants::Patterns
+
+		extend Treequel::AttributeDeclarations
+
+
+		private_class_method :new
+
+		# The 'kind' of objectClasses which don't specify a 'kind' explicitly
+		DEFAULT_OBJECTCLASS_KIND = 'STRUCTURAL'
+
+
+		#############################################################
+		###	C L A S S   M E T H O D S
+		#############################################################
+
+		### Inheritance callback: Make the constructor method of all inheriting classes
+		### public.
+		def self::inherited( subclass )
+			subclass.instance_eval { public_class_method :new }
+		end
+
+
+		### Parse an ObjectClass entry from a objectClass description from a schema.
+		def self::parse( schema, description )
+			unless match = ( LDAP_OBJECTCLASS_DESCRIPTION.match(description) )
+				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 )
+
+			# Default the 'kind' attribute
+			kind ||= DEFAULT_OBJECTCLASS_KIND
+
+			# Find the appropriate concrete class to instantiate 
+			concrete_class = Treequel::Schema::OBJECTCLASS_TYPES[ kind ] or
+				raise Treequel::Error, "no such objectClass type %p: expected one of: %p" %
+					[ kind, Treequel::Schema::OBJECTCLASS_TYPES.keys ]
+
+			return concrete_class.new( schema, oid, names, desc, obsolete, sup,
+			                           must_oids, may_oids, extensions )
+		end
+
+
+		#############################################################
+		###	I N S T A N C E   M E T H O D S
+		#############################################################
+
+		### Create a new ObjectClass 
+		def initialize( schema, oid, names=nil, desc=nil, obsolete=false, sup=nil, must_oids=[],
+		                may_oids=[], extensions=nil )
+			@schema     = schema
+
+			@oid        = oid
+			@names      = names
+			@desc       = desc
+			@obsolete   = obsolete ? true : false
+			@sup_name   = sup
+			@must_oids  = must_oids
+			@may_oids   = may_oids
+			@extensions = extensions
+
+			super()
+		end
+
+
+		######
+		public
+		######
+
+		# The schema the objectClass belongs to
+		attr_reader :schema
+
+		# The objectClass's oid
+		attr_reader :oid
+
+		# The Array of the objectClass's names
+		attr_reader :names
+
+		# The objectClass's description
+		attr_accessor :desc
+
+		# Is the objectClass obsolete?
+		predicate_attr :obsolete
+
+		# The name of the objectClass's superior class (if specified)
+		attr_accessor :sup_name
+
+		# The Array of the objectClass's MUST OIDs
+		attr_reader :must_oids
+
+		# The Array of the objectClass's MAY OIDs
+		attr_reader :may_oids
+
+		# The objectClass's extensions (as a String)
+		attr_accessor :extensions
+
+
+		### Return the first of the objectClass's names, if it has any, or +nil+.
+		def name
+			return self.names.first
+		end
+
+
+		### Return Treequel::Schema::AttributeType objects for each of the objectClass's
+		### MUST attributes.
+		def must
+			self.must_oids.collect do |oid|
+				self.log.warn "No attribute type for OID %p (case bug?)" % [ oid ] unless
+					self.schema.attribute_types.key?( oid )
+				self.schema.attribute_types[oid]
+			end.compact
+		end
+
+
+		### Return Treequel::Schema::AttributeType objects for each of the objectClass's
+		### MAY attributes.
+		def may
+			self.may_oids.collect do |oid|
+				self.log.warn "No attribute type for OID %p (case bug?)" % [ oid ] unless
+					self.schema.attribute_types.key?( oid )
+				self.schema.attribute_types[oid]
+			end.compact
+		end
+
+
+		### Returns +true+ if this objectClass is STRUCTURAL. Defaults to +false+ and then
+		### overridden in StructuralObjectClass.
+		def structural?
+			return false
+		end
+
+
+		### Return a human-readable representation of the object suitable for debugging
+		def inspect
+			return %{#<%s:0x%0x %s(%s) < %s "%s" MUST: %p, MAY: %p>} % [
+				self.class.name,
+				self.object_id / 2,
+				self.name,
+				self.oid,
+				self.sup_name,
+				self.desc,
+				self.must_oids,
+				self.may_oids,
+			]
+		end
+
+
+		### Return the ObjectClass for the receiver's SUP. If this is called on
+		### 'top', returns nil.
+		def sup
+			unless name = self.sup_name
+				return nil if self.oid == Treequel::Constants::OIDS::TOP_OBJECTCLASS
+				return self.schema.object_classes[ :top ]
+			end
+			return self.schema.object_classes[ name.to_sym ]
+		end
+
+	end # class ObjectClass
+
+
+	### An LDAP objectClass of type 'ABSTRACT'. From RFC 4512:
+	### 
+	###   An abstract object class, as the name implies, provides a base of
+	###   characteristics from which other object classes can be defined to
+	###   inherit from.  An entry cannot belong to an abstract object class
+	###   unless it belongs to a structural or auxiliary class that inherits
+	###   from that abstract class.
+    ###
+	###   Abstract object classes cannot derive from structural or auxiliary
+	###   object classes.
+    ###
+	###   All structural object classes derive (directly or indirectly) from
+	###   the 'top' abstract object class.  Auxiliary object classes do not
+	###   necessarily derive from 'top'.
+	###
+	class AbstractObjectClass < Treequel::Schema::ObjectClass
+		Treequel::Schema::OBJECTCLASS_TYPES[ 'ABSTRACT' ] = self
+	end # class AbstractObjectClass
+
+
+	### An LDAP objectClass of type 'AUXILIARY'. From FC4512:
+	### 
+	###   Auxiliary object classes are used to augment the characteristics of
+	###   entries.  They are commonly used to augment the sets of attributes
+	###   required and allowed to be present in an entry.  They can be used to
+	###   describe entries or classes of entries.
+    ###
+	###   Auxiliary object classes cannot subclass structural object classes.
+    ###
+	###   An entry can belong to any subset of the set of auxiliary object
+	###   classes allowed by the DIT content rule associated with the
+	###   structural object class of the entry.  If no DIT content rule is
+	###   associated with the structural object class of the entry, the entry
+	###   cannot belong to any auxiliary object class.
+    ###
+	###   The set of auxiliary object classes that an entry belongs to can
+	###   change over time.
+	class AuxiliaryObjectClass < Treequel::Schema::ObjectClass
+		Treequel::Schema::OBJECTCLASS_TYPES[ 'AUXILIARY' ] = self
+	end # class AuxiliaryObjectClass
+
+
+	### An LDAP objectClass of type 'STRUCTURAL'. From RFC4512:
+	### 
+	###   An object class defined for use in the structural specification of
+	###   the DIT is termed a structural object class.  Structural object
+	###   classes are used in the definition of the structure of the names
+	###   of the objects for compliant entries.
+    ###   
+	###   An object or alias entry is characterized by precisely one
+	###   structural object class superclass chain which has a single
+	###   structural object class as the most subordinate object class.
+	###   This structural object class is referred to as the structural
+	###   object class of the entry.
+    ###   
+	###   Structural object classes are related to associated entries:
+    ###   
+	###     - an entry conforming to a structural object class shall
+	###       represent the real-world object constrained by the object
+	###       class;
+    ###   
+	###     - DIT structure rules only refer to structural object classes;
+	###       the structural object class of an entry is used to specify the
+	###       position of the entry in the DIT;
+    ###   
+	###     - the structural object class of an entry is used, along with an
+	###       associated DIT content rule, to control the content of an
+	###       entry.
+    ###   
+	###   The structural object class of an entry shall not be changed.
+    ### 
+	###   Each structural object class is a (direct or indirect) subclass of
+	###   the 'top' abstract object class.
+    ### 
+	###   Structural object classes cannot subclass auxiliary object classes.
+    ### 
+	###   Each entry is said to belong to its structural object class as well
+	###   as all classes in its structural object class's superclass chain.
+	### 
+	class StructuralObjectClass < Treequel::Schema::ObjectClass
+		Treequel::Schema::OBJECTCLASS_TYPES[ 'STRUCTURAL' ] = self
+
+		### Returns +true+, indicating that instances of this class are STRUCTURAL.
+		def structural?
+			return true
+		end
+
+	end # class StructuralObjectClass
+
+end # class Treequel::Schema
+

data/lib/treequel/sequel_integration.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'treequel' 
+require 'treequel/filter'
+
+begin
+	require 'sequel'
+rescue LoadError => err
+	Treequel.logger.info "Sequel library didn't load: %s: %s" % [ err.class.name, err.message ]
+	Treequel.logger.debug "  " + err.backtrace.join( "\n  " )
+end
+	
+
+# Provide a dummy Sequel::SQL::Expression class for when the Sequel library
+# isn't installed.
+unless defined?( Sequel ) && 
+	Sequel.const_defined?( :SQL ) && 
+	Sequel::SQL.const_defined?( :Expression )
+
+	module Sequel # :nodoc: all
+		module SQL
+			class Expression; end
+		end
+	end
+end
+

data/lib/treequel/utils.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/ruby
+
+require 'logger'
+require 'erb'
+require 'bigdecimal'
+require 'date'
+
+require 'treequel'
+# require 'treequel/constants'
+
+
+module Treequel # :nodoc:
+
+	# 
+	# A alternate formatter for Logger instances.
+	# 
+	# == Usage
+	# 
+	#   require 'treequel/utils'
+	#   Treequel.logger.formatter = Treequel::LogFormatter.new( Treequel.logger )
+	# 
+	# == Version
+	#
+	#  $Id$
+	#
+	# == Authors
+	#
+	# * Michael Granger <ged@FaerieMUD.org>
+	#
+	# :include: LICENSE
+	#
+	#--
+	#
+	# Please see the file LICENSE in the 'docs' directory for licensing details.
+	#
+	class LogFormatter < Logger::Formatter
+
+		# The format to output unless debugging is turned on
+		DEFAULT_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"
+
+		# The format to output if debugging is turned on
+		DEFAULT_DEBUG_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"
+
+
+		### Initialize the formatter with a reference to the logger so it can check for log level.
+		def initialize( logger, format=DEFAULT_FORMAT, debug=DEFAULT_DEBUG_FORMAT ) # :notnew:
+			@logger       = logger
+			@format       = format
+			@debug_format = debug
+
+			super()
+		end
+
+		######
+		public
+		######
+
+		# The Logger object associated with the formatter
+		attr_accessor :logger
+
+		# The logging format string
+		attr_accessor :format
+
+		# The logging format string that's used when outputting in debug mode
+		attr_accessor :debug_format
+
+
+		### Log using either the DEBUG_FORMAT if the associated logger is at ::DEBUG level or
+		### using FORMAT if it's anything less verbose.
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity,                                                     # %5$s
+				progname,                                                     # %6$s
+				msg                                                           # %7$s
+			]
+
+			if @logger.level == Logger::DEBUG
+				return self.debug_format % args
+			else
+				return self.format % args
+			end
+		end
+	end # class LogFormatter
+
+
+	# 
+	# An alternate formatter for Logger instances that outputs +div+ HTML
+	# fragments.
+	# 
+	# == Usage
+	# 
+	#   require 'treequel/utils'
+	#   Treequel.logger.formatter = Treequel::HtmlLogFormatter.new( Treequel.logger )
+	# 
+	# == Version
+	#
+	#  $Id$
+	#
+	# == Authors
+	#
+	# * Michael Granger <ged@FaerieMUD.org>
+	#
+	# :include: LICENSE
+	#
+	#--
+	#
+	# Please see the file LICENSE in the 'docs' directory for licensing details.
+	#
+	class HtmlLogFormatter < Logger::Formatter
+		include ERB::Util  # for html_escape()
+
+		# The default HTML fragment that'll be used as the template for each log message.
+		HTML_LOG_FORMAT = %q{
+		<div class="log-message %5$s">
+			<span class="log-time">%1$s.%2$06d</span>
+			[
+				<span class="log-pid">%3$d</span>
+				/
+				<span class="log-tid">%4$s</span>
+			]
+			<span class="log-level">%5$s</span>
+			:
+			<span class="log-name">%6$s</span>
+			<span class="log-message-text">%7$s</span>
+		</div>
+		}
+
+		### Override the logging formats with ones that generate HTML fragments
+		def initialize( logger, format=HTML_LOG_FORMAT ) # :notnew:
+			@logger = logger
+			@format = format
+			super()
+		end
+
+
+		######
+		public
+		######
+
+		# The HTML fragment that will be used as a format() string for the log
+		attr_accessor :format
+
+
+		### Return a log message composed out of the arguments formatted using the
+		### formatter's format string
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity.downcase,                                                     # %5$s
+				progname,                                                     # %6$s
+				html_escape( msg ).gsub(/\n/, '<br />')                       # %7$s
+			]
+
+			return self.format % args
+		end
+
+	end # class HtmlLogFormatter
+
+end # module Treequel
+
+# vim: set nosta noet ts=4 sw=4:
+