inversion 0.0.1

data/lib/inversion/template/yieldtag.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'pathname'
+require 'inversion/mixins'
+require 'inversion/template/tag'
+
+
+# Inversion 'yield' tag.
+#
+# A tag that yields to the block passed to Template#render (if there was one), and
+# then inserts the resulting objects.
+#
+# == Example
+#
+#   <?yield ?>
+# 
+class Inversion::Template::YieldTag < Inversion::Template::Tag
+	include Inversion::Loggable
+
+
+	### Set up a YieldTag's instance variables.
+	def initialize( * )
+		@block_value = nil
+	end
+
+
+	######
+	public
+	######
+
+	### Rendering callback -- call the block before the template this tag
+	### belongs to is rendered.
+	def before_rendering( renderstate )
+		if renderstate.block
+			self.log.debug "Yielding to %p before rendering." % [ renderstate.block ]
+			@block_value = renderstate.block.call( renderstate ) 
+			self.log.debug "  render block returned: %p" % [ @block_value ]
+		end
+	end
+
+
+	### Render the YieldTag by returning what the #render block returned during
+	### #before_rendering (if there was a block).
+	def render( renderstate )
+		self.log.debug "Rendering as block return value: %p" % [ @block_value ]
+		return @block_value
+	end
+
+end # class Inversion::Template::YieldTag
+

data/lib/inversion/tilt.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'tilt'
+
+# Only add support if Tilt's already been loaded.
+if defined?( ::Tilt )
+
+	# An adapter class for Tilt (https://github.com/rtomayko/tilt)
+	# :TODO: Add an example or two.
+	class Inversion::TiltWrapper < Tilt::Template
+
+		### Tilt::Template API: returns true if Inversion is loaded.
+		def self::engine_initialized?
+			return defined?( Inversion::Template )
+		end
+
+
+		### Tilt::Template API: lazy-load Inversion
+		def initialize_engine
+			require_template_library 'inversion'
+		end
+
+
+		### Tilt::Template API: load a template
+		def prepare
+			# Load the instance and set the path to the source
+			@template = Inversion::Template.new( self.data, self.options )
+			@template.source_file = self.file
+		end
+
+
+		### Hook the template's render phase.
+		def render( *args )
+			self.evaluate( *args )
+		end
+
+		### Tilt::Template API: render the template with the given +scope+, +locals+, and +block+.
+		def evaluate( scope, locals, &block )
+			@template.attributes.merge!( scope.to_h ) if scope.respond_to?( :to_h )
+			@template.attributes.merge!( locals )
+
+			return @template.render( &block )
+		end
+
+	end # class Inversion::TiltWrapper
+
+	# Also add #each to Inversion::Template so they can be returned from actions directly, too.
+	module Inversion::TemplateTiltAdditions
+
+		# TODO: Factor the common parts of this out in Inversion::Template so there's no
+		# duplication.
+		def each
+			self.log.info "rendering template 0x%08x (Sinatra-style)" % [ self.object_id/2 ]
+			state = Inversion::RenderState.new( nil, self.attributes, self.options )
+
+			# Pre-render hook
+			self.walk_tree {|node| node.before_rendering(state) }
+
+			self.log.debug "  rendering node tree: %p" % [ @node_tree ]
+			self.walk_tree {|node| state << node }
+
+			# Post-render hook
+			self.walk_tree {|node| node.after_rendering(state) }
+
+			self.log.info "  done rendering template 0x%08x" % [ self.object_id/2 ]
+			return state.destination.each do |node|
+				yield( node.to_s )
+			end
+		end
+
+	end # module Inversion::TemplateTiltAdditions
+
+	# Add the mixin to Template
+	class Inversion::Template
+		include Inversion::TemplateTiltAdditions
+	end
+
+
+	Tilt.register( Inversion::TiltWrapper, 'tmpl', 'inversion' )
+
+end
+

data/lib/inversion/utils.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+# vim: set nosta noet ts=4 sw=4:
+
+require 'logger'
+require 'erb'
+
+require 'inversion' unless defined?( Inversion )
+require 'inversion/mixins'
+
+
+module Inversion
+
+	# :stopdoc:
+
+	# A alternate formatter for Logger instances.
+	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
+
+
+	# A ANSI-colorized formatter for Logger instances.
+	class ColorLogFormatter < 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 LogFormatter
+
+
+	# 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
+
+end # module Inversion
+

data/spec/data/sinatra/hello.inversion

@@ -0,0 +1 @@
+Hello, Sinatra!

data/spec/inversion/mixins_spec.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env rspec -cfd -b
+# vim: set noet nosta sw=4 ts=4 :
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname( __FILE__ ).dirname.parent.parent
+	libdir = basedir + 'lib'
+
+	$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 )
+}
+
+require 'rspec'
+require 'spec/lib/helpers'
+
+require 'inversion/mixins'
+
+
+describe Inversion, "mixins" do
+
+	describe Inversion::Loggable do
+		before(:each) do
+			@logfile = StringIO.new('')
+			Inversion.logger = Logger.new( @logfile )
+
+			@test_class = Class.new do
+				include Inversion::Loggable
+
+				def log_test_message( level, msg )
+					self.log.send( level, msg )
+				end
+
+				def logdebug_test_message( msg )
+					self.log_debug.debug( msg )
+				end
+			end
+			@obj = @test_class.new
+		end
+
+
+		it "is able to output to the log via its #log method" do
+			@obj.log_test_message( :debug, "debugging message" )
+			@logfile.rewind
+			@logfile.read.should =~ /debugging message/
+		end
+
+		it "is able to output to the log via its #log_debug method" do
+			@obj.logdebug_test_message( "sexydrownwatch" )
+			@logfile.rewind
+			@logfile.read.should =~ /sexydrownwatch/
+		end
+	end
+
+
+	describe Inversion::HashUtilities do
+		it "includes a function for stringifying Hash keys" do
+			testhash = {
+				:foo => 1,
+				:bar => {
+					:klang => 'klong',
+					:barang => { :kerklang => 'dumdumdum' },
+				}
+			}
+
+			result = Inversion::HashUtilities.stringify_keys( testhash )
+
+			result.should be_an_instance_of( Hash )
+			result.should_not be_equal( testhash )
+			result.should == {
+				'foo' => 1,
+				'bar' => {
+					'klang' => 'klong',
+					'barang' => { 'kerklang' => 'dumdumdum' },
+				}
+			}
+		end
+
+
+		it "includes a function for symbolifying Hash keys" do
+			testhash = {
+				'foo' => 1,
+				'bar' => {
+					'klang' => 'klong',
+					'barang' => { 'kerklang' => 'dumdumdum' },
+				}
+			}
+
+			result = Inversion::HashUtilities.symbolify_keys( testhash )
+
+			result.should be_an_instance_of( Hash )
+			result.should_not be_equal( testhash )
+			result.should == {
+				:foo => 1,
+				:bar => {
+					:klang => 'klong',
+					:barang => { :kerklang => 'dumdumdum' },
+				}
+			}
+		end
+
+	end
+
+
+	describe Inversion::AbstractClass do
+
+		context "mixed into a class" do
+			it "will cause the including class to hide its ::new method" do
+				testclass = Class.new { include Inversion::AbstractClass }
+
+				expect {
+					testclass.new
+				}.to raise_error( NoMethodError, /private/ )
+			end
+
+		end
+
+
+		context "mixed into a superclass" do
+
+			before(:each) do
+				testclass = Class.new {
+					include Inversion::AbstractClass
+					pure_virtual :test_method
+				}
+				subclass = Class.new( testclass )
+				@instance = subclass.new
+			end
+
+
+			it "raises a NotImplementedError when unimplemented API methods are called" do
+				expect {
+					@instance.test_method
+				}.to raise_error( NotImplementedError, /does not provide an implementation of/ )
+			end
+
+			it "declares the virtual methods so that they can be used with arguments under Ruby 1.9" do
+				expect {
+					@instance.test_method( :some, :arguments )
+				}.to raise_error( NotImplementedError, /does not provide an implementation of/ )
+			end
+
+		end
+
+	end
+
+
+	describe Inversion::Escaping do
+
+		before( :each ) do
+			objclass = Class.new do
+				include Inversion::Escaping
+
+				def render( state )
+					return self.escape( "<something>", state )
+				end
+			end
+			@obj = objclass.new
+		end
+
+		it "adds configurable escaping to including classes" do
+			render_state = Inversion::RenderState.new( {}, :escape_format => :html )
+			@obj.render( render_state ).should == "&lt;something&gt;"
+		end
+
+		it "doesn't escape anything if escaping is disabled" do
+			render_state = Inversion::RenderState.new( {}, :escape_format => nil )
+			@obj.render( render_state ).should == "<something>"
+		end
+
+		it "doesn't escape anything if escaping is set to ':none'" do
+			render_state = Inversion::RenderState.new( {}, :escape_format => :none )
+			@obj.render( render_state ).should == "<something>"
+		end
+	end
+
+end
+