strelka 0.0.1.pre129 → 0.0.1.pre148

data/lib/strelka/{app/router.rb → router.rb}

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'pluginfactory'
 
@@ -14,20 +16,20 @@ require 'strelka/mixins'
 #
 #     # Create an instance of the default router strategy with the given
 #     # routes and options.
-#     Strelka::App::Router.create( 'default', routes, options )
+#     Strelka::Router.create( 'default', routes, options )
 #
 # To define your own strategy, you'll need to inherit this class, name it
-# <tt>Strelka::App::{Something}Router</tt>, save it in a file named
-# <tt>strelka/app/{something}router.rb</tt>, and be sure to override the
+# <tt>Strelka::Router::{Something}</tt>, save it in a file named
+# <tt>strelka/router/{something}.rb</tt>, and be sure to override the
 # #add_route and #route_request methods.
-class Strelka::App::Router
+class Strelka::Router
 	include PluginFactory,
 	        Strelka::Loggable,
 			Strelka::AbstractClass
 
 	### PluginFactory API -- return the Array of directories to search for plugins.
 	def self::derivative_dirs
-		return ['strelka/app']
+		return ['strelka/router']
 	end
 
 
@@ -70,4 +72,4 @@ class Strelka::App::Router
 	# the routing info Hash.
 	pure_virtual :route_request
 
-end # class Strelka::App::Router
+end # class Strelka::Router

data/lib/strelka/session/default.rb

@@ -0,0 +1,209 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+
+require 'securerandom'
+require 'forwardable'
+
+require 'strelka' unless defined?( Strelka )
+require 'strelka/app' unless defined?( Strelka::App )
+require 'strelka/session'
+require 'strelka/mixins'
+
+# Default session class -- simple in-memory, cookie-based base-bones session.
+#
+# == Hash Interface
+#
+# The following methods are delegated to the inner Hash via the #namespaced_hash method:
+# #&, #==, #[], #[]=, #assoc, #case, #clear, #compare_by_identity,
+# #compare_by_identity?, #default, # #default=, #default_proc, #default_proc=,
+# #delete, #delete_if, #each, #each_key, #each_pair, #each_value,
+# #empty?, #eql?, #fetch, #flatten, #has_key?, #has_value?, #hash, #include?,
+# #index, #inspect, #invert, #keep_if, #key, #key?, #keys, #length, #member?,
+# #merge, #merge!, #pretty_print, #pretty_print_cycle, #rassoc, #rehash, #reject,
+# #reject!, #replace, #select, #select!, #shift, #size, #sql_expr, #sql_negate,
+# #sql_or, #store, #to_a, #to_hash, #to_s, #update, #value?, #values, #values_at,
+# #|, #~
+class Strelka::Session::Default < Strelka::Session
+	extend Forwardable,
+	       Strelka::Delegation
+	include Enumerable,
+	        Strelka::Loggable,
+			Strelka::DataUtilities
+
+
+	# The default name of the cookie that stores the session ID
+	DEFAULT_COOKIE_NAME = 'strelka-sessionid'
+
+	# Class-instance variables
+	@sessions = {}
+	@cookie_name = DEFAULT_COOKIE_NAME
+
+	class << self
+		# Persist sessions in memory
+		attr_reader :sessions
+
+		# The name of the cookie that stores the session ID
+		attr_accessor :cookie_name
+	end
+
+
+	### Configure the session class with the given +options+, which should be a
+	### Hash or an object that has a Hash-like interface. Sets the cookie name
+	### the session ID is stored in in responses if the +:cookie_name+ key
+	### is set.
+	def self::configure( options )
+		if options
+			self.cookie_name = options[:cookie_name] if options[:cookie_name]
+		end
+	end
+
+
+	### Load a session instance from storage using the given +session_id+ and return
+	### it. Returns +nil+ if no session could be loaded. You should probably override
+	### this, as the default just returns +nil+.
+	def self::load_session_data( session_id )
+		return Strelka::DataUtilities.deep_copy( self.sessions[session_id] )
+	end
+
+
+	### Save the given +data+ to memory associated with the given +session_id+.
+	def self::save_session_data( session_id, data )
+		self.sessions[ session_id ] = Strelka::DataUtilities.deep_copy( data )
+	end
+
+
+	### Delete the data associated with the given +session_id+ from memory.
+	def self::delete_session_data( session_id )
+		self.sessions.delete( session_id )
+	end
+
+
+	### Fetch the session ID from the given +request+, or create a new one if the
+	### request doesn't have the necessary attributes. You should override this,
+	### as the default implementation just returns +nil+.
+	def self::get_session_id( request=nil )
+		id = nil
+
+		# Fetch and untaint the existing ID if it exists and looks valid
+		if request && (cookie = request.cookies[ self.cookie_name ])
+			Strelka.log.debug "Cookie value: %p" % [ cookie.value ]
+			id = $1.untaint if cookie.value =~ /^([[:xdigit:]]+)$/i
+			Strelka.log.debug "Hmm?  %p" % [ $1 ]
+		end
+
+		return id || SecureRandom.random_bytes.unpack( 'H*' ).join
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Create a new Mongrel2::Table using the given +hash+ for initial
+	### values.
+	def initialize( session_id=nil, initial_values={} )
+		session_id ||= self.class.get_session_id
+
+		@hash       = Hash.new {|h,k| h[k] = {} }
+		@hash.merge!( initial_values )
+
+		@namespace  = nil
+
+		super
+	end
+
+
+	### Make sure the inner Hash is unique on duplications.
+	def initialize_dup( * ) # :nodoc:
+		@hash = deep_copy( @hash )
+	end
+
+
+	### Make sure the inner Hash is unique on clones.
+	def initialize_clone( * ) # :nodoc:
+		@hash = deep_copy( @hash )
+	end
+
+
+	######
+	public
+	######
+
+	# The namespace that determines which subhash of the session is exposed
+	# to the application.
+	attr_reader :namespace
+
+	# Delegate Hash methods to whichever Hash is the current namespace
+	def_method_delegators :namespaced_hash, *Hash.instance_methods( false )
+
+
+	### Set the current namespace for session values to +namespace+. Setting
+	### +namespace+ to +nil+ exposes the toplevel namespace (keys are named
+	### namespaces)
+	def namespace=( namespace )
+		@namespace = namespace.nil? ? nil : namespace.to_sym
+	end
+
+
+	### Save the session to storage and add the session cookie to the given +response+.
+	def save( response )
+		self.log.debug "Saving session %s" % [ self.session_id ]
+		self.class.save_session_data( self.session_id, @hash )
+		self.log.debug "Adding session cookie to the request."
+		response.cookies[ self.class.cookie_name ] = self.session_id
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Proxy method: handle getting/setting headers via methods instead of the
+	### index operator.
+	def method_missing( sym, *args )
+		# work magic
+		return super unless sym.to_s =~ /^([a-z]\w+)(=)?$/
+
+		# If it's an assignment, the (=)? will have matched
+		key, assignment = $1, $2
+
+		method_body = nil
+		if assignment
+			self.log.debug "Makin' a setter for %p" % [ key ]
+			method_body = self.make_setter( key )
+		else
+			self.log.debug "Makin' a getter for %p" % [ key ]
+			method_body = self.make_getter( key )
+		end
+
+		self.class.send( :define_method, sym, &method_body )
+		return self.method( sym ).call( *args )
+	end
+
+
+	### Create a Proc that will act as a setter for the given key
+	def make_setter( key )
+		return Proc.new {|new_value| self.namespaced_hash[ key.to_sym ] = new_value }
+	end
+
+
+	### Create a Proc that will act as a getter for the given key
+	def make_getter( key )
+		return Proc.new { self.namespaced_hash[key.to_sym] }
+	end
+
+
+	### Return the Hash that corresponds with the current namespace's storage. If no
+	### namespace is currently set, returns the entire session store as a Hash of Hashes
+	### keyed by namespaces as Symbols.
+	def namespaced_hash
+		if @namespace
+			self.log.debug "Returning namespaced hash: %p" % [ @namespace ]
+			return @hash[ @namespace ]
+		else
+			self.log.debug "Returning toplevel namespace"
+			return @hash
+		end
+	end
+
+end # class Strelka::Session::Default

data/lib/strelka/session.rb

@@ -0,0 +1,178 @@
+#! -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+
+require 'digest/sha1'
+require 'pluginfactory'
+
+require 'strelka' unless defined?( Strelka )
+require 'strelka/mixins'
+
+# Abstract base class for pluggable session strategies for the Sessions
+# plugin.
+#
+# To define your own session type, you'll need to inherit this class (either
+# directly or via a subclass), name it <tt>Strelka::Session::{Something}</tt>,
+# save it in a file named <tt>strelka/session/{something}.rb</tt>, and
+# override the required methods.
+#
+# The class methods you'll need to provide implementations for are:
+#
+# * self.configure
+# * self.get_session_id
+# * self.load_session_data
+# * self.save_session_data
+# * self.delete_session_data
+#
+# The instance methods fetch and set values in the session itself, and manipulate
+# the namespace that's used to partition session data between applications:
+#
+# * #[]
+# * #[]=
+# * #save
+# * #delete
+# * #key?
+# * #namespace=
+# * #namespace
+#
+# These methods provide basic functionality, but you might find it more efficient
+# to override them:
+#
+# * self.load_or_create
+# * self.load
+#
+#
+class Strelka::Session
+	include PluginFactory,
+	        Strelka::Loggable,
+			Strelka::AbstractClass
+
+
+	### PluginFactory API -- return the Array of directories to search for concrete
+	### Session classes.
+	def self::derivative_dirs
+		return ['strelka/session']
+	end
+
+
+	### Configure the session class with the given +options+, which should be a
+	### Hash or an object that has a Hash-like interface. This is a no-op by
+	### default.
+	def self::configure( options )
+	end
+
+
+	### Fetch the session ID from the given +request+, or create a new one if the
+	### request is +nil+ or doesn't have the necessary attributes. You should
+	### override this, as the default implementation just returns +nil+.
+	def self::get_session_id( request=nil )
+		return nil
+	end
+
+
+	### Load session data for the specified +session_id+.  This should return a data
+	### structure that can #merge!, or +nil+ if there was no existing session data
+	### associated with +session_id+.
+	def self::load_session_data( session_id )
+		return nil
+	end
+
+
+	### Save the session data for the specified +session_id+.
+	def self::save_session_data( session_id, data )
+	end
+
+
+	### Delete the session data for the specified +session_id+.
+	def self::delete_session_data( session_id )
+	end
+
+
+	### Load a session instance from storage using the given +session_id+ and return
+	### it. Returns +nil+ if no session could be loaded. You can either overload
+	### ::load_session_data if you are loading a data structure, or override ::load
+	### if you're serializing the session object directly.
+	def self::load( session_id )
+		values = self.load_session_data( session_id ) or return nil
+		return new( session_id, values )
+	end
+
+
+	### Return an instance of the session class that's associated with the specified
+	### request, either loading one from the persistant store, or creating a new one
+	### if it can't be loaded or +request+ is nil.
+	def self::load_or_create( request=nil )
+		session_id = self.get_session_id( request )
+		return self.load( session_id ) || new( session_id )
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Set up a new instance with the given +session_id+ and +initial_values+.
+	def initialize( session_id, initial_values={} ) # :notnew:
+		@session_id = session_id
+	end
+
+
+	######
+	public
+	######
+
+	# The key of the session in the session store
+	attr_reader :session_id
+
+
+	# :call-seq:
+	#   session[ key ]  -> object
+	#
+	# Index operator -- fetch the value associated with +key+ in the current namespace
+	pure_virtual :[]
+
+
+	# :call-seq:
+	#   session[ key ] = object
+	#
+	# Index set operator -- set the value associated with +key+ in the current
+	# namespace to +object+.
+	pure_virtual :[]=
+
+
+	# :call-seq:
+	#   save( response )
+	#
+	# Save the session and set up the specified +response+ to persist the
+	# session ID.
+	pure_virtual :save
+
+
+	# :call-seq:
+	#   key?( key ) -> boolean
+	#
+	# Returns +true+ if the specified +key+ exists in the current namespace.
+	pure_virtual :key?
+
+
+	# :call-seq:
+	#   namespace = new_namespace
+	#
+	# Set the namespace of the session that will be used for future access.
+	pure_virtual :namespace=
+
+
+	# :call-seq:
+	#   namespace -> symbol
+	#
+	# Return the current namespace of the session.
+	pure_virtual :namespace
+
+
+	# :call-seq:
+	#   delete( key ) -> object
+	#
+	# Remove the value associated with the specified +key+ from the current namespace
+	# and return it, if it exists.
+	pure_virtual :delete
+
+end # class Strelka::Session

data/lib/strelka.rb

@@ -1,22 +1,24 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'mongrel2'
 require 'configurability'
 require 'configurability/config'
 
 # An application framework for Ruby-mongrel2
-# 
+#
 # == Author/s
 #
 # * Michael Granger <ged@FaerieMUD.org>
-# 
+#
 module Strelka
 
 	# Library version constant
 	VERSION = '0.0.1'
 
 	# Version-control revision constant
-	REVISION = %q$Revision: dd54849bf817 $
+	REVISION = %q$Revision: fa6133ac407d $
 
 
 	require 'strelka/logging'

data/spec/lib/constants.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'strelka' unless defined?( Strelka )
 

data/spec/lib/helpers.rb

@@ -133,6 +133,13 @@ module Strelka::SpecHelpers
 		end
 	end
 
+	# Collection .all? matcher
+	RSpec::Matchers.define( :all_be_a ) do |expected|
+		match do |collection|
+			collection.all? {|obj| obj.is_a?(expected) }
+		end
+	end
+
 end
 
 

data/spec/strelka/app/errors_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'
@@ -99,79 +101,57 @@ describe Strelka::App::Errors do
 			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
+		it "calls a callback-style handler for any status when finished with BAD_REQUEST" do
+			@app.class_eval do
+				on_status do |res, info|
+					res.body = '(%d) Filthy banana' % [ info[:status] ]
+					return res
+				end
 
-					get do |req|
-						finish_with HTTP::BAD_REQUEST, "Your sandwich is missing something."
-					end
+				get do |req|
+					finish_with HTTP::BAD_REQUEST, "Your sandwich is missing something."
 				end
 			end
 
+			req = @request_factory.get( '/foom' )
+			res = @app.new.handle( req )
 
-			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
-
+			res.status.should == HTTP::BAD_REQUEST
+			res.body.should == '(400) Filthy banana'
 		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
+		it "calls a callback-style handler for NOT_FOUND when the response is NOT_FOUND" do
+			@app.class_eval do
+				on_status HTTP::NOT_FOUND do |res, _|
+					res.body = 'NOPE!'
+					return res
 				end
 			end
 
+			req = @request_factory.get( '/foom' )
+			res = @app.new.handle( req )
 
-			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
-
+			res.body.should == 'NOPE!'
 		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
+		it "calls a callback-style handler for all 400-level statuses when the response is NOT_FOUND" do
+			@app.class_eval do
+				on_status 400..499 do |res, _|
+					res.body = 'Error:  JAMBA'
+					return res
 				end
 			end
 
+			req = @request_factory.get( '/foom' )
+			res = @app.new.handle( req )
 
-			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
-
+			res.body.should == 'Error:  JAMBA'
 		end
 
 
-		context "instance with a template-style handler for SERVER_ERROR" do
-
+		context "template-style handlers" do
 
 			before( :all ) do
 				basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent

data/spec/strelka/app/filters_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'

data/spec/strelka/app/negotiation_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'

data/spec/strelka/app/parameters_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'
@@ -173,7 +175,7 @@ describe Strelka::App::Parameters do
 				req = @request_factory.get( '/user/search' )
 				@app.new.handle( req )
 
-				req.params.should be_a( Strelka::App::ParamValidator )
+				req.params.should be_a( Strelka::ParamValidator )
 				req.params.should have_errors()
 				req.params.error_messages.should == ["Missing value for 'Username'"]
 			end
@@ -182,7 +184,7 @@ describe Strelka::App::Parameters do
 				req = @request_factory.get( '/user/search?username=anheptoh'.taint )
 				@app.new.handle( req )
 
-				req.params.should be_a( Strelka::App::ParamValidator )
+				req.params.should be_a( Strelka::ParamValidator )
 				req.params.should be_okay()
 				req.params.should_not have_errors()
 				req.params[:username].should == 'anheptoh'

data/spec/strelka/app/plugins_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'
@@ -34,9 +36,9 @@ describe Strelka::App::Plugins do
 	RSpec::Matchers.define( :order ) do |item|
 		match do |enumerable|
 			if defined?( @before )
-				enumerable.index( @before ) < enumerable.index( item ) 
+				enumerable.index( @before ) < enumerable.index( item )
 			elsif defined?( @after )
-				enumerable.index( @after ) > enumerable.index( item ) 
+				enumerable.index( @after ) > enumerable.index( item )
 			else
 				raise "No .before or .after to compare against!"
 			end

data/spec/strelka/app/restresources_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'

data/spec/strelka/app/routing_spec.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 BEGIN {
 	require 'pathname'
@@ -184,13 +186,13 @@ describe Strelka::App::Routing do
 		end
 
 
-		it "uses the Strelka::App::DefaultRouter as it's router by default" do
+		it "uses the Strelka::Router::Default as it's router by default" do
 			@app.routerclass.should == :default
-			@app.new.router.should be_a( Strelka::App::DefaultRouter )
+			@app.new.router.should be_a( Strelka::Router::Default )
 		end
 
 		it "can specify a different Router class than the default" do
-			class MyRouter < Strelka::App::Router; end
+			class MyRouter < Strelka::Router; end
 			@app.class_eval do
 				router MyRouter
 			end