strelka 0.0.1pre4 → 0.0.1.pre129

data/lib/strelka/logging.rb

@@ -40,7 +40,10 @@ module Strelka::Logging
 		end
 
 		mod.default_logger = mod.logger = Logger.new( $stderr )
-		mod.default_logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
+		mod.default_logger.level = case
+			when $DEBUG then Logger::DEBUG
+			when $VERBOSE then Logger::INFO
+			else Logger::WARN end
 		mod.default_log_formatter = Strelka::Logging::Formatter.new( mod.default_logger )
 	end
 

data/lib/strelka/mixins.rb

@@ -137,6 +137,59 @@ module Strelka
 
 	end # module ANSIColorUtilities
 
+
+	# Hides your class's ::new method and adds a +pure_virtual+ method generator for
+	# defining API methods. If subclasses of your class don't provide implementations of
+	# "pure_virtual" methods, NotImplementedErrors will be raised if they are called.
+	#
+	#   # AbstractClass
+	#   class MyBaseClass
+	#       include Strelka::AbstractClass
+	#
+	#       # Define a method that will raise a NotImplementedError if called
+	#       pure_virtual :api_method
+	#   end
+	#
+	module AbstractClass
+
+		### Methods to be added to including classes
+		module ClassMethods
+
+			### Define one or more "virtual" methods which will raise
+			### NotImplementedErrors when called via a concrete subclass.
+			def pure_virtual( *syms )
+				syms.each do |sym|
+					define_method( sym ) do |*args|
+						raise ::NotImplementedError,
+							"%p does not provide an implementation of #%s" % [ self.class, sym ],
+							caller(1)
+					end
+				end
+			end
+
+
+			### Turn subclasses' new methods back to public.
+			def inherited( subclass )
+				subclass.module_eval { public_class_method :new }
+				super
+			end
+
+		end # module ClassMethods
+
+
+		### Inclusion callback
+		def self::included( mod )
+			super
+			if mod.respond_to?( :new )
+				mod.extend( ClassMethods )
+				mod.module_eval { private_class_method :new }
+			end
+		end
+
+
+	end # module AbstractClass
+
+
 end # module Strelka
 
 # vim: set nosta noet ts=4 sw=4:

data/lib/strelka.rb

@@ -2,6 +2,7 @@
 
 require 'mongrel2'
 require 'configurability'
+require 'configurability/config'
 
 # An application framework for Ruby-mongrel2
 # 
@@ -15,15 +16,21 @@ module Strelka
 	VERSION = '0.0.1'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: 1e34f33f76af $
+	REVISION = %q$Revision: dd54849bf817 $
 
 
 	require 'strelka/logging'
 	extend Strelka::Logging
 
+	# Combine Strelka, Mongrel2, and Configurability logging
+	Mongrel2.logger = Strelka.logger
+	Configurability.logger = Strelka.logger
+
 	require 'strelka/constants'
 	include Strelka::Constants
 
+	require 'strelka/exceptions'
+
 
 	### Get the library version. If +include_buildnum+ is true, the version string will
 	### include the VCS rev ID.
@@ -36,5 +43,19 @@ module Strelka
 	require 'strelka/app'
 	require 'strelka/httprequest'
 
+
+	# The installed Configurability::Config object
+	@config = nil
+	class << self; attr_accessor :config; end
+
+
+	### Convenience method -- Load the Configurability::Config from +configfile+
+	### and install it.
+	def self::load_config( configfile, defaults={} )
+		Strelka.log.info "Loading universal config from %p" % [ configfile ]
+		self.config = Configurability::Config.load( configfile, defaults )
+		self.config.install
+	end
+
 end # module Strelka
 

data/spec/data/error.tmpl

@@ -0,0 +1 @@
+This is an error-handler template. The request is: <?pp request ?>.

data/spec/lib/constants.rb

@@ -20,7 +20,6 @@ module Strelka::TestConstants # :nodoc:all
 		TEST_RECV_SPEC = 'tcp://127.0.0.1:9997'
 
 
-
 		# Freeze all testing constants
 		constants.each do |cname|
 			const_get(cname).freeze

data/spec/lib/helpers.rb

@@ -112,6 +112,27 @@ module Strelka::SpecHelpers
 		end
 	end
 
+	### Set up a Mongrel2 configuration database according to the specified +dbspec+.
+	def setup_config_db( dbspec=':memory:' )
+		Mongrel2::Config.configure( :configdb => dbspec ) unless
+			Mongrel2::Config.db.uri[ %r{sqlite:/(.*)}, 1 ] == dbspec
+		Mongrel2::Config.init_database
+		Mongrel2::Config.db.tables.collect {|t| Mongrel2::Config.db[t] }.each( &:truncate )
+	end
+
+
+	# Helper method
+	def route( name )
+		return {:action => name.to_sym}
+	end
+
+	# Route matcher
+	RSpec::Matchers.define( :match_route ) do |routename|
+		match do |route|
+			route[:action] == routename
+		end
+	end
+
 end
 
 

data/spec/strelka/app/defaultrouter_spec.rb

@@ -26,33 +26,34 @@ describe Strelka::App::DefaultRouter do
 	end
 
 	before( :each ) do
-		@router = Strelka::App::DefaultRouter.new
+		@router = Strelka::App::Router.create( 'default' )
 	end
 
 	after( :all ) do
 		reset_logging()
 	end
 
+
 	context "a router with routes for 'foo', 'foo/bar'" do
 
 		before( :each ) do
-			@router.add_route( :GET, ['foo'], :the_foo_action )
-			@router.add_route( :GET, ['foo','bar'], :the_foo_bar_action )
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo','bar'], route(:foo_bar) )
 		end
 
 		it "routes /user/foo/bar/baz to the foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should == :the_foo_bar_action
+			@router.route_request( req ).should match_route( :foo_bar )
 		end
 
 		it "routes /user/foo/bar to the foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar' )
-			@router.route_request( req ).should == :the_foo_bar_action
+			@router.route_request( req ).should match_route( :foo_bar )
 		end
 
 		it "routes /user/foo to the foo action" do
 			req = @request_factory.get( '/user/foo' )
-			@router.route_request( req ).should == :the_foo_action
+			@router.route_request( req ).should match_route( :foo )
 		end
 
 		it "doesn't route /user" do
@@ -60,6 +61,11 @@ describe Strelka::App::DefaultRouter do
 			@router.route_request( req ).should be_nil()
 		end
 
+		it "doesn't route /user/something/foo/bar" do
+			req = @request_factory.get( '/user/something/foo/bar' )
+			@router.route_request( req ).should be_nil()
+		end
+
 		it "doesn't route /user/other" do
 			req = @request_factory.get( '/user/other' )
 			@router.route_request( req ).should be_nil()
@@ -70,34 +76,34 @@ describe Strelka::App::DefaultRouter do
 	context "a router with routes for 'foo', 'foo/bar', and a fallback action" do
 
 		before( :each ) do
-			@router.add_route( :GET, [], :the_fallback_action )
-			@router.add_route( :GET, ['foo'], :the_foo_action )
-			@router.add_route( :GET, ['foo','bar'], :the_foo_bar_action )
+			@router.add_route( :GET, [], route(:fallback) )
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo','bar'], route(:foo_bar) )
 		end
 
 		it "routes /user/foo/bar/baz to the foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should == :the_foo_bar_action
+			@router.route_request( req ).should match_route( :foo_bar )
 		end
 
 		it "routes /user/foo/bar to the foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar' )
-			@router.route_request( req ).should == :the_foo_bar_action
+			@router.route_request( req ).should match_route( :foo_bar )
 		end
 
 		it "routes /user/foo to the foo action" do
 			req = @request_factory.get( '/user/foo' )
-			@router.route_request( req ).should == :the_foo_action
+			@router.route_request( req ).should match_route( :foo )
 		end
 
 		it "routes /user to the fallback action" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should == :the_fallback_action
+			@router.route_request( req ).should match_route( :fallback )
 		end
 
 		it "routes /user/other to the fallback action" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should == :the_fallback_action
+			@router.route_request( req ).should match_route( :fallback )
 		end
 
 	end
@@ -105,34 +111,34 @@ describe Strelka::App::DefaultRouter do
 	context "a router with routes for 'foo', 'foo/\w{3}', and 'foo/\w{6}'" do
 
 		before( :each ) do
-			@router.add_route( :GET, ['foo'], :the_foo_action )
-			@router.add_route( :GET, ['foo',/\w{3}/], :the_foo_threeaction )
-			@router.add_route( :GET, ['foo',/\w{6}/], :the_foo_sixaction )
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
+			@router.add_route( :GET, ['foo',/\w{6}/], route(:foo_six) )
 		end
 
 		it "routes /user/foo/barbim/baz to the foo/\w{6} action" do
 			req = @request_factory.get( '/user/foo/barbim/baz' )
-			@router.route_request( req ).should == :the_foo_sixaction
+			@router.route_request( req ).should match_route( :foo_six )
 		end
 
 		it "routes /user/foo/barbat to the foo/\w{6} action" do
 			req = @request_factory.get( '/user/foo/barbat' )
-			@router.route_request( req ).should == :the_foo_sixaction
+			@router.route_request( req ).should match_route( :foo_six )
 		end
 
 		it "routes /user/foo/bar/baz to the foo/\w{3} action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should == :the_foo_threeaction
+			@router.route_request( req ).should match_route( :foo_three )
 		end
 
 		it "routes /user/foo/bar to the foo/\w{3} action" do
 			req = @request_factory.get( '/user/foo/bar' )
-			@router.route_request( req ).should == :the_foo_threeaction
+			@router.route_request( req ).should match_route( :foo_three )
 		end
 
 		it "routes /user/foo to the foo action" do
 			req = @request_factory.get( '/user/foo' )
-			@router.route_request( req ).should == :the_foo_action
+			@router.route_request( req ).should match_route( :foo )
 		end
 
 		it "doesn't route /user" do
@@ -148,33 +154,33 @@ describe Strelka::App::DefaultRouter do
 	end
 
 	# get '/foo/\w{3}'
-		# get '/foo/\d+'
+	# get '/foo/\d+'
 
 	context "a router with routes for: 'foo/\w{3}', then 'foo/\d+'" do
 
 		before( :each ) do
-			@router.add_route( :GET, ['foo',/\w{3}/], :the_foo_threeaction )
-			@router.add_route( :GET, ['foo',/\d+/], :the_foo_digitaction )
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
+			@router.add_route( :GET, ['foo',/\d+/], route(:foo_digit) )
 		end
 
 		it "routes /user/foo/1 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/1' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 		it "routes /user/foo/12 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/12' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 		it "routes /user/foo/123 to the foo/\w{3} action" do
 			req = @request_factory.get( '/user/foo/123' )
-			@router.route_request( req ).should == :the_foo_threeaction
+			@router.route_request( req ).should match_route( :foo_three )
 		end
 
 		it "routes /user/foo/1234 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/1234' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 	end
@@ -185,28 +191,28 @@ describe Strelka::App::DefaultRouter do
 	context "a router with routes for: 'foo/\d+', then 'foo/\w{3}'" do
 
 		before( :each ) do
-			@router.add_route( :GET, ['foo',/\d+/], :the_foo_digitaction )
-			@router.add_route( :GET, ['foo',/\w{3}/], :the_foo_threeaction )
+			@router.add_route( :GET, ['foo',/\d+/], route(:foo_digit) )
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
 		end
 
 		it "routes /user/foo/1 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/1' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 		it "routes /user/foo/12 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/12' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 		it "routes /user/foo/123 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/123' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 		it "routes /user/foo/1234 to the foo/\d+ action" do
 			req = @request_factory.get( '/user/foo/1234' )
-			@router.route_request( req ).should == :the_foo_digitaction
+			@router.route_request( req ).should match_route( :foo_digit )
 		end
 
 	end

data/spec/strelka/app/errors_spec.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+}
+
+require 'rspec'
+require 'inversion'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/app/plugins'
+require 'strelka/app/errors'
+
+require 'strelka/behavior/plugin'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::App::Errors do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '' )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it_should_behave_like( "A Strelka::App Plugin" )
+
+
+	describe "an including App" do
+
+		before( :each ) do
+			Strelka.log.debug "Creating a new Strelka::App"
+			@app = Class.new( Strelka::App ) do
+				plugin :errors, :routing
+				def initialize( appid='params-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
+					super
+				end
+			end
+			Strelka.log.debug "  new instance is: %p" % [ @app ]
+		end
+
+		it "doesn't alter normal responses" do
+			@app.class_eval do
+				get do |req|
+					res = req.response
+					res.puts "Oh yeah! Kool-Aid!"
+					res.status = HTTP::OK
+					return res
+				end
+			end
+
+			req = @request_factory.get( '/koolaid' )
+			res = @app.new.handle( req )
+
+			res.status.should == HTTP::OK
+			res.body.should == "Oh yeah! Kool-Aid!\n"
+		end
+
+		it "raises an error if a handler is declared with both a template and a block" do
+			expect {
+				@app.class_eval do
+					on_status 404, :a_template do |*|
+						# Wait, what am I DOING?!?!
+					end
+				end
+			}.to raise_error( ArgumentError, /don't take a block/i )
+		end
+
+
+		it "raises an error if a template handler is declared but the templating plugin isn't loaded" do
+			expect {
+				@app.class_eval do
+					on_status 404, :a_template
+				end
+			}.to raise_error( ScriptError, /require the :templating plugin/i )
+		end
+
+		it "uses the fallback status handler if an error is encountered in a custom error handler" do
+			@app.class_eval do
+				on_status 404 do |*|
+					raise "A problem with the custom error-handler"
+				end
+			end
+
+			req = @request_factory.get( '/foom' )
+			res = @app.new.handle( req )
+
+			res.body.should =~ /internal server error/i
+		end
+
+		context "instance with a callback-style handler for all error statuses" do
+
+			before( :each ) do
+				@app.class_eval do
+					on_status do |res, _|
+						res.body = 'Filthy banana'
+						return res
+					end
+
+					get do |req|
+						finish_with HTTP::BAD_REQUEST, "Your sandwich is missing something."
+					end
+				end
+			end
+
+
+			it "calls the appropriate callback when the response is an error status" do
+				req = @request_factory.get( '/foom' )
+				res = @app.new.handle( req )
+
+				res.status.should == HTTP::BAD_REQUEST
+				res.body.should == 'Filthy banana'
+			end
+
+		end
+
+
+		context "instance with a callback-style handler for NOT_FOUND" do
+
+			before( :each ) do
+				@app.class_eval do
+					on_status HTTP::NOT_FOUND do |res, _|
+						res.body = 'NOPE!'
+						return res
+					end
+				end
+			end
+
+
+			it "calls the appropriate callback when the response is of the associated status" do
+				req = @request_factory.get( '/foom' )
+				res = @app.new.handle( req )
+
+				res.body.should == 'NOPE!'
+			end
+
+		end
+
+
+		context "instance with a callback-style handler for all 400-level statuses" do
+
+			before( :each ) do
+				@app.class_eval do
+					on_status 400..499 do |res, _|
+						res.body = 'Error:  JAMBA'
+						return res
+					end
+				end
+			end
+
+
+			it "calls the appropriate callback when the response is of the associated status" do
+				req = @request_factory.get( '/foom' )
+				res = @app.new.handle( req )
+
+				res.body.should == 'Error:  JAMBA'
+			end
+
+		end
+
+
+		context "instance with a template-style handler for SERVER_ERROR" do
+
+
+			before( :all ) do
+				basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+				specdir = basedir + 'spec'
+				specdata = specdir + 'data'
+
+				tmpl_paths = [ specdata ]
+				Inversion::Template.configure( :template_paths => tmpl_paths )
+			end
+
+			before( :each ) do
+				@app.class_eval do
+					plugins :templating, :routing
+					templates jamba: 'error.tmpl'
+					on_status 500, :jamba
+
+					get do |req|
+						finish_with HTTP::SERVER_ERROR, "I knitted an extra arm for his hopes and dreams."
+					end
+				end
+			end
+
+
+			it "renders the response body using the templating plugin" do
+				req = @request_factory.get( '/foom' )
+				res = @app.new.handle( req )
+
+				res.body.should =~ /error-handler template/i
+			end
+		end
+
+	end
+
+
+end
+
+
+