arrow 1.0.7

data/lib/arrow/logger/apacheoutputter.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'arrow/mixins'
+require 'arrow/logger'
+require 'arrow/logger/outputter'
+
+# The Arrow::Logger::ApacheOutputter class, a derivative of
+# Apache::Logger::Outputter. Instances of this class write log messages of the
+# corresponding error level to the Apache log
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::ApacheOutputter < Arrow::Logger::Outputter
+
+	# The default description
+	DefaultDescription = "Apache Log Outputter"
+
+	# The default interpolatable string that's used to build the message to
+	# output
+	DefaultFormat =
+		%q{#{name}#{frame ? '('+frame+')' : ''}: #{msg[0,2048]}}
+
+	# The Logger log levels (copied for easy access)
+	LEVELS = Arrow::Logger::LEVELS
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new Arrow::Logger::ApacheOutputter object that will write
+	### to the apache log, and use the given +description+ and +format+.
+	def initialize( uri, description=DefaultDescription, format=DefaultFormat )
+		super
+	end
+
+
+	######
+	public
+	######
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the target
+	### output mechanism.
+	def write( time, level, name, frame, msg )
+		return unless defined?( ::Apache )
+		srvr = ::Apache.request.server
+		return unless srvr.loglevel >= LEVELS[ level ]
+
+		# Translate calls to log.warning into Apache::Server#log_warn
+		level = :warn if level == :warning
+
+		logMethod = srvr.method( "log_#{level}" )
+		super {|msg|
+			# Escape any unexpanded sprintf format patterns
+			msg.gsub!( /%/, '%%' )
+			logMethod.call( msg )
+		}
+	end
+
+
+end # class Arrow::Logger::ApacheOutputter
+
+
+
+

data/lib/arrow/logger/arrayoutputter.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'arrow/mixins'
+require 'arrow/logger/outputter'
+require 'arrow/logger/htmloutputter'
+
+# Accumulate logging messages in HTML fragments into an Array which can later be fetched.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::ArrayOutputter < Arrow::Logger::Outputter
+	include Arrow::HTMLUtilities
+
+	# Default decription used when creating instances
+	DEFAULT_DESCRIPTION = "Array Outputter"
+
+	# The default logging output format
+	HTML_FORMAT = %q{
+	<div class="log-message #{level}">
+		<span class="log-time">#{time.strftime('%Y/%m/%d %H:%M:%S')}</span>
+		<span class="log-level">#{level}</span>
+		:
+		<span class="log-name">#{escaped_name}</span>
+		<span class="log-frame">#{frame ? '('+frame+'): ' : ''}</span>
+		<span class="log-message-text">#{escaped_msg}</span>
+	</div>
+	}
+
+	### Override the default to intitialize the Array.
+	def initialize( uri, description=DEFAULT_DESCRIPTION, format=HTML_FORMAT ) # :notnew:
+		@array = []
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The Array any output log messages get appended to
+	attr_reader :array
+
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the target
+	### output mechanism. Subclasses can call this with a block which will
+	### be passed the formatted message. If no block is supplied by the
+	### child, this method will check to see if $DEBUG is set, and if it is,
+	### write the log message to $deferr.
+	def write( time, level, name, frame, msg )
+		escaped_msg = escape_html( msg )
+		escaped_name = escape_html( name )
+		html = self.format.interpolate( binding )
+
+		@array << html
+	end
+
+
+end # class Arrow::Logger::ArrayOutputter
+

data/lib/arrow/logger/coloroutputter.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+require 'arrow/logger/fileoutputter'
+
+# A derivative of Arrow::Logger::FileOutputter that outputs logging messages 
+# in ANSI colors according to their level.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::ColorOutputter < Arrow::Logger::FileOutputter
+
+	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
+	AnsiAttributes = {
+		'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
+	}
+
+
+	# Default color map: :level => %w{color scheme}
+	DEFAULT_COLOR_SCHEME = {
+		:debug		=> %w{dark white},
+		:info		=> %w{cyan},
+		:notice		=> %w{bold cyan},
+		:warning	=> %w{bold yellow},
+		:error		=> %w{bold red},
+		:crit		=> %w{bold white on_red},
+		:alert		=> %w{bold blink white on_red},
+		:emerg		=> %w{bold blink yellow on_red},
+	}
+
+	# Default decription used when creating instances
+	DEFAULT_DESCRIPTION = "Logging Outputter"
+
+	# The default logging output format
+	DEFAULT_FORMAT =
+		%q{#{time.strftime('%Y/%m/%d %H:%M:%S')} [#{level}]: #{name} } +
+			%q{#{frame ? '('+frame+')' : ''}: #{msg}}
+
+
+
+	### Override the default to add color scheme instance variable
+	def initialize( uri, description=DEFAULT_DESCRIPTION, format=DEFAULT_FORMAT ) # :notnew:
+		super
+		@color_scheme = DEFAULT_COLOR_SCHEME.dup
+	end
+
+
+	######
+	public
+	######
+
+	# The color scheme hash for this logger
+	attr_reader :color_scheme
+
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the logfile.
+	def write( time, level, name, frame, msg )
+		colors = @color_scheme[level]
+		super do |msg|
+			color_msg = colorize( msg, colors )
+			@io.puts( color_msg )
+		end
+	end
+
+
+	#######
+	private
+	#######
+
+	### Create a string that contains the ANSI codes specified and return it
+	def ansi_code( *attributes )
+		attr = attributes.flatten.collect {|a| AnsiAttributes[a] }.compact.join(';')
+		if attr.empty? 
+			return ''
+		else
+			return "\e[%sm" % attr
+		end
+	end
+
+
+	### Colorize the given +string+ with the specified +attributes+ and return 
+	### it, handling line-endings, etc.
+	def colorize( string, *attributes )
+		ending = string[/(\s)$/] || ''
+		string = string.rstrip
+		return ansi_code( *attributes ) + string + ansi_code( 'reset' ) + ending
+	end
+
+end # class Arrow::Logger::ColorOutputter
+

data/lib/arrow/logger/fileoutputter.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'stringio'
+require 'arrow/logger'
+require 'arrow/logger/outputter'
+
+# The Arrow::Logger::FileOutputter class, a derivative of
+# Apache::Logger::Outputter. This is an outputter that writes to a
+# file or other filehandle.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::FileOutputter < Arrow::Logger::Outputter
+
+	# The default description
+	DEFAULT_DESCRIPTION = "File Outputter"
+
+	# The default format (copied from the superclass)
+	DEFAULT_FORMAT = Arrow::Logger::Outputter::DEFAULT_FORMAT
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new Arrow::Logger::FileOutputter object. The +io+ argument
+	### can be an IO or StringIO object, in which case output is sent to it
+	### directly, a String, in which case it is used as the first argument
+	### to File.open, or an Integer file descriptor, in which case a new IO
+	### object is created which appends to the file handle matching that
+	### descriptor.
+	def initialize( uri, description=DEFAULT_DESCRIPTION, format=DEFAULT_FORMAT )
+		if uri.hierarchical?
+			@io = File.open( uri.path, File::WRONLY|File::CREAT )
+		else
+			case uri.opaque
+			when /(std|def)err/i
+				@io = $stderr
+			when /(std|def)out/i
+				@io = $defout
+			when /^(\d+)$/
+				@io = IO.for_fd( Integer($1), "w" )
+			else
+				raise "Unrecognized log URI '#{uri}'"
+			end
+		end
+
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The filehandle open to the logfile
+	attr_accessor :io
+
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the logfile.
+	def write( time, level, name, frame, msg )
+		if block_given?
+			super
+		else
+			super {|msg| @io.puts(msg) }
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Returns a String which should be included in the implementation-specific part 
+	### of the object's inspection String.
+	def inspection_details
+		io_desc = 
+			case @io
+			when $stderr
+				'STDERR'
+			when $stdout
+				'STDOUT'
+			when StringIO
+				'(StringIO 0x%0x)' % [ @io.object_id * 2 ]
+			else
+				'(IO: fd %d)' % [ @io.fileno ]
+			end
+
+		return [ super, io_desc ].join(', ')
+	end
+
+end # class Arrow::Logger::FileOutputter

data/lib/arrow/logger/htmloutputter.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'arrow/mixins'
+require 'arrow/logger/fileoutputter'
+
+# Output logging messages in HTML fragments with classes that match their level. 
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::HtmlOutputter < Arrow::Logger::FileOutputter
+	include Arrow::HTMLUtilities
+
+	# Default decription used when creating instances
+	DEFAULT_DESCRIPTION = "HTML Fragment Logging Outputter"
+
+	# The default logging output format
+	HTML_FORMAT = %q{
+	<div class="log-message #{level}">
+		<span class="log-time">#{time.strftime('%Y/%m/%d %H:%M:%S')}</span>
+		<span class="log-level">#{level}</span>
+		:
+		<span class="log-name">#{escaped_name}</span>
+		<span class="log-frame">#{frame ? '('+frame+'): ' : ''}</span>
+		<span class="log-message-text">#{escaped_msg}</span>
+	</div>
+	}
+
+
+	### Override the default argument values.
+	def initialize( uri, description=DEFAULT_DESCRIPTION, format=HTML_FORMAT ) # :notnew:
+		super
+	end
+
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the target
+	### output mechanism. Subclasses can call this with a block which will
+	### be passed the formatted message. If no block is supplied by the
+	### child, this method will check to see if $DEBUG is set, and if it is,
+	### write the log message to $stderr.
+	def write( time, level, name, frame, msg )
+		escaped_msg = escape_html( msg )
+		escaped_name = escape_html( name )
+		html = @format.interpolate( binding )
+
+		@io.puts( html )
+	end
+
+
+end # class Arrow::Logger::HtmlOutputter
+

data/lib/arrow/logger/outputter.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'arrow/monkeypatches'
+require 'pluginfactory'
+require 'uri'
+
+# 
+# The Arrow::Logger::Outputter class, which is the abstract base class for 
+# objects that control where logging output is sent in an Arrow::Logger object. 
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Logger::Outputter
+	include PluginFactory
+
+
+	# The default description
+	DEFAULT_DESCRIPTION = "Logging Outputter"
+
+	# The default interpolatable string that's used to build the message to
+	# output
+	DEFAULT_FORMAT =
+		%q{#{time.strftime('%Y/%m/%d %H:%M:%S')} [#{level}]: #{name} } +
+			%q{#{frame ? '('+frame+')' : ''}: #{msg[0,1024]}}
+
+
+	#############################################################
+	###	C L A S S   M E T H O D S
+	#############################################################
+
+	### Specify the directory to look for the derivatives of this class in.
+	def self::derivativeDirs
+		["arrow/logger"]
+	end
+
+
+	### Parse the given string into a URI object, appending the path part if
+	### it doesn't exist.
+	def self::parse_uri( str )
+		return str if str.is_a?( URI::Generic )
+		str += ":." if str.match( /^\w+$/ )
+		URI.parse( str )
+	end
+
+
+	### Create a new Arrow::Logger::Outputter object of the type specified 
+	### by +uri+.
+	def self::create( uri, *args )
+		uri = self.parse_uri( uri ) if uri.is_a?( String )
+		super( uri.scheme.dup, uri, *args )
+	end
+
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new Arrow::Logger::Outputter object with the given +uri+,
+	### +description+ and sprintf-style +format+.
+	def initialize( uri, description=DEFAULT_DESCRIPTION, format=DEFAULT_FORMAT )
+		@description = description
+		@format = format
+	end
+
+
+	######
+	public
+	######
+
+	# The outputter's description, for introspection utilities.
+	attr_accessor :description
+
+	# The uninterpolated string format for this outputter. This message
+	# written will be formed by interpolating this string in the #write
+	# method's context immediately before outputting.
+	attr_accessor :format
+
+
+	### Write the given +level+, +name+, +frame+, and +msg+ to the target
+	### output mechanism. Subclasses can call this with a block which will
+	### be passed the formatted message. If no block is supplied by the
+	### child, this method will check to see if $DEBUG is set, and if it is,
+	### write the log message to $stderr.
+	def write( time, level, name, frame, msg )
+		msg = @format.interpolate( binding )
+
+		if block_given?
+			yield( msg )
+		else
+			$stderr.puts( msg ) if $DEBUG
+		end
+	end
+
+
+	### Returns a human-readable description of the object as a String
+	def inspect
+		"#<%s:0x%0x %s>" % [
+			self.class.name,
+			self.object_id * 2,
+			self.inspection_details,
+		]
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Returns a String which should be included in the implementation-specific part 
+	### of the object's inspection String.
+	def inspection_details
+		return "%s (%s)" % [ self.description, self.format ]
+	end
+	
+
+end # class Arrow::Logger::Outputter
+
+