configurability 1.1.0 → 1.2.0

data/ChangeLog

@@ -1,8 +1,68 @@
+2012-04-25  Michael Granger  <ged@FaerieMUD.org>
+
+	* bin/configurability:
+	Add first version of a command-line utility
+	[ad1ff0049fcf] [tip]
+
+	* .hgtags:
+	Added tag v1.1.0 for changeset 070e4bfc8e55
+	[cc2d783fd316] [github/master]
+
+	* .hgsigs:
+	Added signature for changeset 2e082d901553
+	[070e4bfc8e55] [v1.1.0]
+
+	* History.rdoc:
+	Updated date of the release in history file
+	[2e082d901553]
+
+	* .rvm.gems, spec/configurability/config_spec.rb,
+	spec/configurability/deferredconfig_spec.rb:
+	Fixed spec-order bug.
+	[25ed7bedbb94]
+
+	* lib/configurability.rb:
+	Improve the log message for omitted config sections
+	[e56100a012e3]
+
+2012-04-23  Michael Granger  <ged@FaerieMUD.org>
+
+	* Rakefile:
+	Activate the :deveiate Hoe plugin in the Rakefile.
+	[4aa3a6d50599]
+
+2012-04-18  Michael Granger  <ged@FaerieMUD.org>
+
+	* README.rdoc, Rakefile:
+	Fix a FIXME, use fivefish if available.
+	[0644d0a8ff3e]
+
+	* History.rdoc, README.rdoc, lib/configurability.rb:
+	Update the README, bump the minor version, update history.
+
+	Still needs more documentation updates before release, especially
+	the README.
+	[dce671bc85e1]
+
+	* lib/configurability.rb, spec/configurability_spec.rb:
+	Added defaults-gathering API
+	[af3f708c9372]
+
+	* .rvm.gems, lib/configurability/config.rb,
+	spec/configurability/config_spec.rb, spec/lib/helpers.rb:
+	Updating some specs
+	[4a7df2547d13]
+
+	* Manifest.txt, lib/configurability.rb, lib/configurability/config.rb,
+	lib/configurability/logformatter.rb, lib/configurability/logging.rb:
+	Extracted logging out into a mixin
+	[47fe73c22f31]
+
 2012-03-13  Michael Granger  <ged@FaerieMUD.org>
 
 	* .hgtags:
 	Added tag v1.0.10 for changeset f95c9b9cfc25
-	[e4af16343901] [tip]
+	[e4af16343901]
 
 	* .hgsigs:
 	Added signature for changeset 0dcd8dcebc87

data/History.rdoc

@@ -1,3 +1,9 @@
+== v1.2.0 [2012-05-09] Michael Granger <ged@FaerieMUD.org>
+
+- Added a command-line utility.
+- Convert logging to use Loggability.
+
+
 == v1.1.0 [2012-04-25] Michael Granger <ged@FaerieMUD.org>
 
 Add a 'defaults' API that allows defaults to be gathered from any

data/Manifest.txt

@@ -4,13 +4,13 @@ LICENSE
 Manifest.txt
 README.rdoc
 Rakefile
+bin/configurability
 examples/basicconfig.rb
 examples/config.yml
 lib/configurability.rb
 lib/configurability/behavior.rb
 lib/configurability/config.rb
 lib/configurability/deferredconfig.rb
-lib/configurability/logging.rb
 spec/configurability/config_spec.rb
 spec/configurability/deferredconfig_spec.rb
 spec/configurability_spec.rb

data/Rakefile

@@ -22,6 +22,8 @@ hoespec = Hoe.spec 'configurability' do
 
 	self.developer 'Michael Granger', 'ged@FaerieMUD.org'
 
+	self.dependency 'loggability', '~> 0.1'
+
 	self.dependency 'rspec', '~> 2.4', :developer
 	self.dependency 'simplecov', '~> 0.3', :developer
 

data/bin/configurability

@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+# vim: set nosta noet ts=4 sw=4:
+
+require 'configurability'
+require 'configurability/config'
+require 'trollop'
+require 'highline'
+
+# Have to do it this way to avoid the vendored 'sysexits' under OSX.
+gem 'sysexits'
+require 'sysexits'
+
+
+# A tool for setting up and running Configurability apps
+class Configurability::Command
+	extend ::Sysexits,
+	       Loggability
+	include Sysexits
+
+	# Loggability API -- log messages through the Configurability module's logger
+	log_to :configurability
+
+	# Make a HighLine color scheme
+	COLOR_SCHEME = HighLine::ColorScheme.new do |scheme|
+		scheme[:header]    = [ :bold, :yellow ]
+		scheme[:subheader] = [ :bold, :white ]
+		scheme[:key]       = [ :white ]
+		scheme[:value]     = [ :bold, :white ]
+		scheme[:error]     = [ :red ]
+		scheme[:warning]   = [ :yellow ]
+		scheme[:message]   = [ :reset ]
+	end
+
+
+	# Class instance variables
+	@command_help = Hash.new {|h,k| h[k] = { :desc => nil, :usage => ''} }
+	@prompt = @option_parser = nil
+
+
+	### Run the utility with the given +args+.
+	def self::run( args )
+		HighLine.color_scheme = COLOR_SCHEME
+
+		oparser = self.make_option_parser
+		opts = Trollop.with_standard_exception_handling( oparser ) do
+			oparser.parse( args )
+		end
+
+		command = oparser.leftovers.shift
+		self.new( opts ).run( command, *oparser.leftovers )
+		exit :ok
+
+	rescue => err
+		self.log.fatal "Oops: %s: %s" % [ err.class.name, err.message ]
+		self.log.debug { '  ' + err.backtrace.join("\n  ") }
+
+		exit :software_error
+	end
+
+
+	### Return a String that describes the available commands, e.g., for the 'help'
+	### command.
+	def self::make_command_table
+		commands = self.available_commands
+
+		# Build the command table
+		col1len = commands.map( &:length ).max
+		return commands.collect do |cmd|
+			helptext = self.help( cmd.to_sym ) or next # no help == invisible command
+			"%s  %s" % [
+				self.prompt.color(cmd.rjust(col1len), :key),
+				self.prompt.color(helptext, :value)
+			]
+		end.compact
+	end
+
+
+	### Return an Array of the available commands.
+	def self::available_commands
+		return self.public_instance_methods( false ).
+			map( &:to_s ).
+			grep( /_command$/ ).
+			map {|methodname| methodname.sub(/_command$/, '') }.
+			sort
+	end
+
+
+	### Create and configure a command-line option parser for the command.
+	### Returns a Trollop::Parser.
+	def self::make_option_parser
+		unless @option_parser
+			progname = File.basename( $0 )
+
+			# Make a list of the log level names and the available commands
+			loglevels = Loggability::LOG_LEVELS.
+				sort_by {|name,lvl| lvl }.
+				collect {|name,lvl| name.to_s }.
+				join( ', ' )
+			command_table = self.make_command_table
+
+			@option_parser = Trollop::Parser.new do
+				banner "Configurability Reports"
+
+				text ''
+				command_table.each {|line| text(line) }
+				text ''
+
+				text 'Global Options'
+				opt :require, "Require one or more additional libraries.",
+					:multi => true, :type => :string
+				opt :include, "Add additional directories to the load path.",
+					:multi => true, :type => :string, :short => :I
+				text ''
+
+				text 'Other Options:'
+				opt :debug, "Turn debugging on. Also sets the --loglevel to 'debug'."
+				opt :loglevel, "Set the logging level. Must be one of: #{loglevels}",
+					:default => Configurability.logger.level.to_s
+			end
+		end
+
+		return @option_parser
+	end
+
+
+	### Add a help string for the given +command+.
+	def self::help( command, helpstring=nil )
+		if helpstring
+			@command_help[ command.to_sym ][:desc] = helpstring
+		end
+
+		return @command_help[ command.to_sym ][:desc]
+	end
+
+
+	### Add/fetch the +usagestring+ for +command+.
+	def self::usage( command, usagestring=nil )
+		if usagestring
+			prefix = usagestring[ /\A(\s+)/, 1 ]
+			usagestring.gsub!( /^#{prefix}/m, '' ) if prefix
+
+			@command_help[ command.to_sym ][:usage] = usagestring
+		end
+
+		return @command_help[ command.to_sym ][:usage]
+	end
+
+
+	### Return the global Highline prompt object, creating it if necessary.
+	def self::prompt
+		unless @prompt
+			@prompt = HighLine.new
+
+			columns = @prompt.output_cols.nonzero? || 80
+			rows    = @prompt.output_rows.nonzero? || 1000
+
+			@prompt.page_at = rows - 5
+			@prompt.wrap_at = columns - 2
+		end
+
+		return @prompt
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Create a new instance of the command and set it up with the given
+	### +options+.
+	def initialize( options )
+		Loggability.format_with( :color ) if $stderr.tty?
+		@options = options
+
+		if @options.debug
+			$DEBUG = true
+			$VERBOSE = true
+			Loggability.level = :debug
+		elsif @options.loglevel
+			Loggability.level = @options.loglevel
+		end
+
+		self.log.debug "Options are: %p" % [ options ]
+	end
+
+
+	######
+	public
+	######
+
+	# The Trollop options hash the command will read its configuration from
+	attr_reader :options
+
+
+	# Delegate the instance #prompt method to the class method instead
+	define_method( :prompt, &self.method(:prompt) )
+
+
+	### Run the command with the specified +command+ and +args+.
+	def run( command, *args )
+		command ||= 'info'
+		cmd_method = nil
+		loglevel = Configurability.logger.level
+
+		# Unshift directories to the load path specified with -I
+		self.options[:include].each do |path|
+			dirs = path.split( File::PATH_SEPARATOR )
+			self.log.debug "Prepending %p to the load path..." % [ dirs ]
+			$LOAD_PATH.unshift( *dirs )
+		end
+
+		# Require libraries specified with -r
+		self.options[:require].each do |lib|
+			$stderr.puts "Requiring %p..." % [ lib ]
+			require( lib )
+		end
+
+		Loggability.level = loglevel
+		begin
+			cmd_method = self.method( "#{command}_command" )
+		rescue NameError => err
+			error "No such command %p" % [ command ]
+			exit :usage
+		end
+
+		cmd_method.call( *args )
+	end
+
+
+	#
+	# Commands
+	#
+
+	### The 'help' command
+	def help_command( *args )
+
+		# Subcommand help
+		if !args.empty?
+			command = args.shift
+
+			if self.class.available_commands.include?( command )
+				header( self.class.help(command) )
+				desc = "\n" + 'Usage: ' + command + ' ' + self.class.usage(command) + "\n"
+				message( desc )
+			else
+				error "No such command %p" % [ command ]
+			end
+
+		# Help by itself show the table of available commands
+		else
+			command_table = self.class.make_command_table
+			header "Available Commands"
+			message( *command_table )
+		end
+
+	end
+	help :help, "Show help for a single COMMAND if given, or list available commands if not"
+	usage :help, "[COMMAND]"
+
+
+	### The 'info' command
+	def info_command( *args )
+		header "Configurability Report"
+
+		cobjects = Configurability.configurable_objects
+
+		if cobjects.empty?
+			message "No objects extended with Configurability were loaded.",
+			        "You can use the -I and -r flags to include library paths",
+			        "and require libraries."
+		else
+			colwidth = cobjects.map {|obj| obj.config_key.length }.max
+			colwidth = 10 if colwidth < 10
+
+			subheader "%*s   %s" % [ colwidth, "Config Key", "Configurable Object" ]
+			cobjects.each do |obj|
+				message "%*s : %p" % [ colwidth, obj.config_key, obj ]
+			end
+		end
+	end
+	help :info, "Show objects with Configurability in loaded code. Use -r " +
+		"to require additional libraries."
+
+
+	### The 'version' command
+	def version_command( *args )
+		message( "<%= color 'Version:', :header %> " + Configurability.version_string(true) )
+	end
+	help :version, "Prints the Ruby-Mongrel2 version."
+
+
+	#
+	# Helper methods
+	#
+
+
+
+	#
+	# Utility methods
+	#
+
+	### Output normal output
+	def message( *parts )
+		self.prompt.say( parts.map(&:to_s).join($/) )
+	end
+
+
+	### Output the given +text+ highlighted as a header.
+	def header( text )
+		message( self.prompt.color(text, :header) )
+	end
+
+
+	### Output the given +text+ highlighted as a subheader.
+	def subheader( text )
+		message( self.prompt.color(text, :subheader) )
+	end
+
+
+	### Output the given +text+ highlighted as an error.
+	def error( text )
+		message( self.prompt.color(text, :error) )
+	end
+
+
+	### Output the given +items+ as a columnar list.
+	def list( *items )
+		message( self.prompt.list(items.flatten.compact.map(&:to_s), :columns_down) )
+	end
+
+end # class Configurability::Command
+
+
+Configurability::Command.run( ARGV.dup )
+

data/lib/configurability.rb

@@ -1,24 +1,27 @@
 #!/usr/bin/env ruby
 
+require 'loggability'
 require 'yaml'
 
 # A configuration mixin for Ruby classes.
-# 
+#
 # == Author/s
-# 
+#
 # * Michael Granger <ged@FaerieMUD.org>
-# 
+#
 module Configurability
+	extend Loggability
 
-	# Library version constant
-	VERSION = '1.1.0'
 
-	# Version-control revision constant
-	REVISION = %q$Revision: e56100a012e3 $
+	# Loggability API -- set up a Loggability logger for the library
+	log_as :configurability
 
 
-	require 'configurability/logging'
-	extend Configurability::Logging
+	# Library version constant
+	VERSION = '1.2.0'
+
+	# Version-control revision constant
+	REVISION = %q$Revision: 6b5e075386ee $
 
 	require 'configurability/deferredconfig'
 

data/lib/configurability/config.rb

@@ -9,12 +9,12 @@ require 'logger'
 require 'configurability'
 
 # A configuration object class for systems with Configurability
-# 
+#
 # == Author/s
 #
 # * Michael Granger <ged@FaerieMUD.org>
 # * Mahlon E. Smith <mahlon@martini.nu>
-# 
+#
 # This class also delegates some of its methods to the underlying struct:
 #
 # [Configurability::Config::Struct#to_hash]
@@ -33,9 +33,14 @@ require 'configurability'
 #      #[] (delegated to its internal Struct)
 # [Configurability::Config::Struct#[]=]
 #      #[]= (delegated to its internal Struct)
-# 
+#
 class Configurability::Config
-	extend Forwardable
+	extend Forwardable,
+	       Loggability
+
+
+   	# Loggability API -- set up logging through the Configurability module's logger
+	log_to :configurability
 
 
 	#############################################################

data/spec/lib/helpers.rb

@@ -19,120 +19,37 @@ require 'yaml'
 
 SimpleCov.start do
 	add_filter '/spec/'
-	add_filter '/textmate-command/'
 end
 require 'configurability'
 
 
-# An alternate formatter for Logger instances that outputs +div+ HTML
-# fragments.
-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
-
 ### RSpec helper functions.
 module Configurability::SpecHelpers
 
-	LEVEL = {
-		:debug => Logger::DEBUG,
-		:info  => Logger::INFO,
-		:warn  => Logger::WARN,
-		:error => Logger::ERROR,
-		:fatal => Logger::FATAL,
-	  }
-
-	class ArrayLogger
-		### Create a new ArrayLogger that will append content to +array+.
-		def initialize( array )
-			@array = array
-		end
-
-		### Write the specified +message+ to the array.
-		def write( message )
-			@array << message
-		end
-
-		### No-op -- this is here just so Logger doesn't complain
-		def close; end
-
-	end # class ArrayLogger
-
-
 	###############
 	module_function
 	###############
 
 	### Reset the logging subsystem to its default state.
 	def reset_logging
-		Configurability.reset_logger
+		Loggability.formatter = nil
+		Loggability.output_to( $stderr )
+		Loggability.level = :fatal
 	end
 
 
 	### Alter the output of the default log formatter to be pretty in SpecMate output
-	def setup_logging( level=Logger::FATAL )
-
-		# Turn symbol-style level config into Logger's expected Fixnum level
-		level = LEVEL[ level ] if LEVEL.key?( level )
+	def setup_logging( level=:fatal )
 
 		# Only do this when executing from a spec in TextMate
 		if ENV['HTML_LOGGING'] || (ENV['TM_FILENAME'] && ENV['TM_FILENAME'] =~ /_spec\.rb/)
-			Thread.current['logger-output'] = []
-			logdevice = ArrayLogger.new( Thread.current['logger-output'] )
-			Configurability.logger = Logger.new( logdevice )
-			Configurability.logger.formatter = HtmlLogFormatter.new( Configurability.logger )
+			logarray = []
+			Thread.current['logger-output'] = logarray
+			Loggability.output_to( logarray )
+			Loggability.format_as( :html )
+			Loggability.level = :debug
 		else
-			logger = Logger.new( $stderr )
-			Configurability.logger = logger
-			Configurability.logger.level = level
+			Loggability.level = level
 		end
 	end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: configurability
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -36,8 +36,24 @@ cert_chain:
   YUhDS0xaZFNLai9SSHVUT3QrZ2JsUmV4OEZBaDhOZUEKY21saFhlNDZwWk5K
   Z1dLYnhaYWg4NWpJang5NWhSOHZPSStOQU01aUg5a09xSzEzRHJ4YWNUS1Bo
   cWo1UGp3RgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-date: 2012-04-26 00:00:00.000000000 Z
+date: 2012-05-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: loggability
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: hoe-mercurial
   requirement: !ruby/object:Gem::Requirement
@@ -61,7 +77,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -69,7 +85,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -146,7 +162,8 @@ description: ! 'Configurability is a unified, unintrusive, assume-nothing config
   single action.'
 email:
 - ged@FaerieMUD.org
-executables: []
+executables:
+- configurability
 extensions: []
 extra_rdoc_files:
 - History.rdoc
@@ -159,13 +176,13 @@ files:
 - Manifest.txt
 - README.rdoc
 - Rakefile
+- bin/configurability
 - examples/basicconfig.rb
 - examples/config.yml
 - lib/configurability.rb
 - lib/configurability/behavior.rb
 - lib/configurability/config.rb
 - lib/configurability/deferredconfig.rb
-- lib/configurability/logging.rb
 - spec/configurability/config_spec.rb
 - spec/configurability/deferredconfig_spec.rb
 - spec/configurability_spec.rb
@@ -196,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: configurability
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Configurability is a unified, unintrusive, assume-nothing configuration system

metadata.gz.sig

@@ -1,2 +1 @@
-J:5��I�(e��}�=�2?ޛv 9.^�|
-G	�XK�"��&��G�Yl��N�У����P��t�x$��v;��=߈��PA��@X��tN����u����1��y�x~�
ˣ+F��K)�FO��>�ص�w
oٸ�^��w�>�l��7T�L	�`�_�m�
+A=��%���ۋc����M�2V������J}2�q�NCL5�nW�]9��h ����;�5'�G�g��l�M!Ǝ���k��q���0"��}�F����TTn^&f�h+����r���<P���/��tG9�67!�t��0��c�	sY�]� c�n��B!�„�a!Yc��>3�8W[ÅVIA�D�}+��

data/lib/configurability/logging.rb

@@ -1,300 +0,0 @@
-# -*- ruby -*-
-# vim: set nosta noet ts=4 sw=4:
-# encoding: utf-8
-
-require 'logger'
-require 'date'
-
-require 'configurability' unless defined?( Configurability )
-
-
-# A mixin that provides a top-level logging subsystem based on Logger.
-module Configurability::Logging
-
-	### Logging
-	# Log levels
-	LOG_LEVELS = {
-		'debug' => Logger::DEBUG,
-		'info'  => Logger::INFO,
-		'warn'  => Logger::WARN,
-		'error' => Logger::ERROR,
-		'fatal' => Logger::FATAL,
-	}.freeze
-	LOG_LEVEL_NAMES = LOG_LEVELS.invert.freeze
-
-
-	### Inclusion hook
-	def self::extended( mod )
-		super
-
-		class << mod
-			# the log formatter that will be used when the logging subsystem is reset
-			attr_accessor :default_log_formatter
-
-			# the logger that will be used when the logging subsystem is reset
-			attr_accessor :default_logger
-
-			# the logger that's currently in effect
-			attr_accessor :logger
-			alias_method :log, :logger
-			alias_method :log=, :logger=
-		end
-
-		mod.default_logger = mod.logger = Logger.new( $stderr )
-		mod.default_logger.level = case
-			when $DEBUG then Logger::DEBUG
-			when $VERBOSE then Logger::INFO
-			else Logger::WARN end
-		mod.default_log_formatter = Configurability::Logging::Formatter.new( mod.default_logger )
-	end
-
-
-	### Reset the global logger object to the default
-	def reset_logger
-		self.logger = self.default_logger
-		self.logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
-		self.logger.formatter = self.default_log_formatter
-	end
-
-
-	### Returns +true+ if the global logger has not been set to something other than
-	### the default one.
-	def using_default_logger?
-		return self.logger == self.default_logger
-	end
-
-
-	# A alternate formatter for Logger instances.
-	class Formatter < 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 Formatter
-
-
-	# A ANSI-colorized formatter for Logger instances.
-	class ColorFormatter < Logger::Formatter
-
-		# Set some ANSI escape code constants (Shamelessly stolen from Perl's
-		# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
-		ANSI_ATTRIBUTES = {
-			'clear'      => 0,
-			'reset'      => 0,
-			'bold'       => 1,
-			'dark'       => 2,
-			'underline'  => 4,
-			'underscore' => 4,
-			'blink'      => 5,
-			'reverse'    => 7,
-			'concealed'  => 8,
-
-			'black'      => 30,   'on_black'   => 40,
-			'red'        => 31,   'on_red'     => 41,
-			'green'      => 32,   'on_green'   => 42,
-			'yellow'     => 33,   'on_yellow'  => 43,
-			'blue'       => 34,   'on_blue'    => 44,
-			'magenta'    => 35,   'on_magenta' => 45,
-			'cyan'       => 36,   'on_cyan'    => 46,
-			'white'      => 37,   'on_white'   => 47
-		}
-
-
-		### Create a string that contains the ANSI codes specified and return it
-		def self::ansi_code( *attributes )
-			attributes.flatten!
-			attributes.collect! {|at| at.to_s }
-			return '' unless /(?:vt10[03]|xterm(?:-color)?|linux|screen)/i =~ ENV['TERM']
-			attributes = ANSI_ATTRIBUTES.values_at( *attributes ).compact.join(';')
-
-			if attributes.empty?
-				return ''
-			else
-				return "\e[%sm" % attributes
-			end
-		end
-
-
-		### Colorize the given +string+ with the specified +attributes+ and
-		### return it, handling line-endings, color reset, etc.
-		def self::colorize( *args )
-			string = ''
-
-			if block_given?
-				string = yield
-			else
-				string = args.shift
-			end
-
-			ending = string[/(\s)$/] || ''
-			string = string.rstrip
-
-			return self.ansi_code( args.flatten ) + string + self.ansi_code( 'reset' ) + ending
-		end
-
-
-		# Color settings
-		LEVEL_FORMATS = {
-			:debug => colorize( :bold, :black ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"},
-			:info  => colorize( :normal ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
-			:warn  => colorize( :bold, :yellow ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
-			:error => colorize( :red ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
-			:fatal => colorize( :bold, :red, :on_white ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
-		}
-
-
-		### Initialize the formatter with a reference to the logger so it can check for log level.
-		def initialize( logger, settings={} ) # :notnew:
-			settings = LEVEL_FORMATS.merge( settings )
-
-			@logger   = logger
-			@settings = settings
-
-			super()
-		end
-
-		######
-		public
-		######
-
-		# The Logger object associated with the formatter
-		attr_accessor :logger
-
-		# The formats, by level
-		attr_accessor :settings
-
-
-		### Log using the format associated with the severity
-		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
-			]
-
-			return self.settings[ severity.downcase.to_sym ] % args
-		end
-
-	end # class Formatter
-
-
-	# An alternate formatter for Logger instances that outputs +div+ HTML
-	# fragments.
-	class HtmlFormatter < Logger::Formatter
-
-		# 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
-				escape_html( msg ).gsub(/\n/, '<br />')                       # %7$s
-			]
-
-			return self.format % args
-		end
-
-
-		#######
-		private
-		#######
-
-		### Escape any HTML special characters in +string+.
-		def escape_html( string )
-			return string.
-				gsub( '&', '&amp;' ).
-				gsub( '<', '&lt;'  ).
-				gsub( '>', '&gt;'  )
-		end
-
-	end # class HtmlFormatter
-
-
-end # module Configurability
-