strelka 0.0.1.pre.187 → 0.0.1.pre.193

data/lib/strelka/app/templating.rb

@@ -7,7 +7,7 @@ require 'inversion'
 require 'strelka' unless defined?( Strelka )
 require 'strelka/app' unless defined?( Strelka::App )
 
-require 'strelka/app/plugins'
+require 'strelka/plugins'
 
 
 # A templated content-generation plugin for Strelka::Apps. It uses the
@@ -88,7 +88,7 @@ require 'strelka/app/plugins'
 #
 module Strelka::App::Templating
 	include Strelka::Constants
-	extend Strelka::App::Plugin
+	extend Strelka::Plugin
 
 	run_before :routing, :negotiation, :errors
 	run_after :filters
@@ -109,7 +109,7 @@ module Strelka::App::Templating
 		def inherited( subclass )
 			super
 			subclass.instance_variable_set( :@template_map, @template_map.dup )
-			subclass.instance_variable_set( :@layout_template, @layout_template.dup )
+			subclass.instance_variable_set( :@layout_template, @layout_template.dup ) if @layout_template
 		end
 
 

data/lib/strelka/authprovider.rb

@@ -44,7 +44,8 @@ class Strelka::AuthProvider
 	include PluginFactory,
 	        Strelka::Loggable,
 	        Strelka::Constants,
-			Strelka::AbstractClass
+	        Strelka::AbstractClass,
+	        Strelka::ResponseHelpers
 
 
 	### PluginFactory API -- return the Array of directories to search for concrete
@@ -109,14 +110,5 @@ class Strelka::AuthProvider
 	end
 
 
-	### Abort the current execution and return a response with the specified
-	### http_status code immediately. The specified +message+ will be logged,
-	### and will be included in any message that is returned as part of the
-	### response. The +headers+ hash will be used to set response headers.
-	def finish_with( http_status, message, headers={} )
-		status_info = { :status => http_status, :message => message, :headers => headers }
-		throw :finish, status_info
-	end
-
 end # class Strelka::AuthProvider
 

data/lib/strelka/behavior/plugin.rb

@@ -6,7 +6,7 @@ require 'rspec'
 
 require 'strelka'
 require 'strelka/app'
-require 'strelka/app/plugins'
+require 'strelka/plugins'
 
 
 # This is a shared behavior for specs which different Strelka::App
@@ -29,8 +29,8 @@ shared_examples_for "A Strelka::App Plugin" do
 	end
 
 
-	it "extends Strelka::App::Plugin" do
-		plugin.should be_a( Strelka::App::Plugin )
+	it "extends Strelka::Plugin" do
+		plugin.should be_a( Strelka::Plugin )
 	end
 
 end

data/lib/strelka/httprequest.rb

@@ -14,7 +14,8 @@ require 'strelka/cookieset'
 # An HTTP request class.
 class Strelka::HTTPRequest < Mongrel2::HTTPRequest
 	include Strelka::Loggable,
-	        Strelka::Constants
+	        Strelka::Constants,
+	        Strelka::ResponseHelpers
 
 	# Set Mongrel2 to use Strelka's request class for HTTP requests
 	register_request_type( self, *HTTP::RFC2616_VERBS )
@@ -163,8 +164,10 @@ class Strelka::HTTPRequest < Mongrel2::HTTPRequest
 	### Return a Hash of request form data.
 	def parse_form_data
 		case self.headers.content_type
+		when nil
+			finish_with( HTTP::BAD_REQUEST, "Malformed request (no content type?)" )
 		when 'application/x-www-form-urlencoded'
-			 return merge_query_args( URI.decode_www_form(self.body) )
+			return merge_query_args( URI.decode_www_form(self.body) )
 		when 'application/json', 'text/javascript'
 			return Yajl.load( self.body )
 		when 'text/x-yaml', 'application/x-yaml'

data/lib/strelka/httprequest/session.rb

@@ -43,10 +43,11 @@ module Strelka::HTTPRequest::Session
 	end
 
 
-	### Returns +true+ if the request already has an associated session object.
+	### Returns +true+ if the request has an associated session object.
 	def session?
-		return !@session.nil?
+		return @session || Strelka::App::Sessions.session_class.has_session_for?( self )
 	end
+	alias_method :has_session?, :session?
 
 
 	### Return the session associated with the request, creating it if necessary.

data/lib/strelka/httpresponse/session.rb

@@ -57,13 +57,10 @@ module Strelka::HTTPResponse::Session
 			# new blank session.
 			if self.request.session?
 				self.log.debug "Getting the request's session."
-				@session = request.session
+				self.session = request.session
 			else
 				self.log.debug "No session loaded in the request; creating it in the response."
-				sessionclass = Strelka::App::Sessions.session_class
-				@session = sessionclass.load_or_create( self.request )
-				@session.namespace = self.session_namespace
-				request.session = @session
+				self.session = Strelka::App::Sessions.session_class.new
 			end
 		end
 
@@ -73,9 +70,11 @@ module Strelka::HTTPResponse::Session
 
 	### Set the request's session object.
 	def session=( new_session )
+		self.log.debug "Setting session to %p in namespace %p" % [ new_session, self.session_namespace ]
 		new_session.namespace = self.session_namespace
 		@session = new_session
-		request.session = new_session
+		self.log.debug "  session is: %p" % [ @session ]
+		# request.session = new_session # should it set the session in the request too?
 	end
 
 
@@ -83,15 +82,15 @@ module Strelka::HTTPResponse::Session
 	def session?
 		return @session || self.request.session?
 	end
+	alias_method :has_session?, :session?
 
 
 	### Tell the associated session to save itself and set up the session ID in the
 	### response, if one exists.
 	def save_session
 		if self.session?
-			session = self.session
-			self.log.debug "Saving session: %p" % [ @session ]
-			session.save( self )
+			self.log.debug "Saving session: %p" % [ self.session ]
+			self.session.save( self )
 		else
 			self.log.debug "No session to save."
 		end

data/lib/strelka/mixins.rb

@@ -333,6 +333,21 @@ module Strelka
 
 	end # module MethodUtilities
 
+
+	# A collection of functions for generating responses.
+	module ResponseHelpers
+
+		### Abort the current execution and return a response with the specified
+		### http_status code immediately. The specified +message+ will be logged,
+		### and will be included in any message that is returned as part of the
+		### response. The +headers+ hash will be used to set response headers.
+		def finish_with( http_status, message, headers={} )
+			status_info = { :status => http_status, :message => message, :headers => headers }
+			throw :finish, status_info
+		end
+
+	end # module ResponseHelpers
+
 end # module Strelka
 
 # vim: set nosta noet ts=4 sw=4:

data/lib/strelka/plugins.rb

@@ -0,0 +1,257 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'set'
+require 'tsort'
+
+require 'strelka' unless defined?( Strelka )
+require 'strelka/mixins'
+
+module Strelka
+	extend Strelka::MethodUtilities
+
+	# A topologically-sorted hash for plugin management
+	class PluginRegistry < Hash
+		include TSort
+		alias_method :tsort_each_node, :each_key
+		def tsort_each_child( node, &block )
+			mod = fetch( node ) { [] }
+			if mod.respond_to?( :successors )
+				mod.successors.each( &block )
+			else
+				mod.each( &block )
+			end
+		end
+	end
+
+
+	# Plugin Module extension -- adds registration, load-order support, etc.
+	module Plugin
+
+		### Extension hook -- Extend the given object with methods for setting it
+		### up as a plugin for its containing namespace.
+		def self::extended( object )
+			super
+
+			# Find the plugin's namespace container, which will be the
+			# pluggable class/module
+			pluggable_name = object.name.split( '::' )[ 0..-2 ]
+			pluggable = pluggable_name.inject( Object ) do |mod, name|
+				mod.const_get( name )
+			end
+
+			Strelka.log.debug "Extending %p as a Strelka::Plugin for %p" % [ object, pluggable ]
+			object.successors = Set.new
+			object.pluggable = pluggable
+
+			# Register any pending dependencies for the newly-loaded plugin
+			name = object.plugin_name
+			if (( deps = pluggable.loaded_plugins[name] ))
+				Strelka.log.debug "  installing deferred deps for %p" % [ name ]
+				object.run_after( *deps )
+			end
+
+			Strelka.log.debug "  adding %p (%p) to the plugin registry for %p" %
+				[ name, object, pluggable ]
+			pluggable.loaded_plugins[ name ] = object
+		end
+
+
+		#############################################################
+		###	A P P E N D E D   M E T H O D S
+		#############################################################
+
+		# An Array that tracks which plugins should be installed after itself.
+		attr_accessor :successors
+
+		# The Class/Module that this plugin belongs to
+		attr_accessor :pluggable
+
+
+		### Return the name of the receiving plugin
+		def plugin_name
+			name = self.name || "anonymous#{self.object_id}"
+			name.sub!( /.*::/, '' )
+			return name.downcase.to_sym
+		end
+
+
+		### Register the receiver as needing to be run before +other_plugins+ for requests, and
+		### *after* them for responses.
+		def run_before( *other_plugins )
+			name = self.plugin_name
+			other_plugins.each do |other_name|
+				self.pluggable.loaded_plugins[ other_name ] ||= []
+				mod = self.pluggable.loaded_plugins[ other_name ]
+
+				if mod.respond_to?( :run_after )
+					mod.run_after( name )
+				else
+					Strelka.log.debug "%p plugin not yet loaded; setting up pending deps" % [ other_name ]
+					mod << name
+				end
+			end
+		end
+
+
+		### Register the receiver as needing to be run after +other_plugins+ for requests, and
+		### *before* them for responses.
+		def run_after( *other_plugins )
+			Strelka.log.debug "  %p will run after %p" % [ self, other_plugins ]
+			self.successors.merge( other_plugins )
+		end
+
+	end # module Plugin
+
+
+	# Module API for the plugin system. This mixin adds the ability to load
+	# and install plugins into the extended object.
+	module PluginLoader
+
+		### Extension callback -- initialize some data structures in the extended
+		### object.
+		def self::extended( mod )
+			super
+			mod.loaded_plugins = Strelka::PluginRegistry.new
+		end
+
+
+		##
+		# The Hash of loaded plugin modules, keyed by their downcased and symbolified
+		# name (e.g., Strelka::App::Templating => :templating)
+		attr_accessor :loaded_plugins
+
+		##
+		# If plugins have already been installed, this will be the call frame
+		# they were first installed from. This is used to warn about installing
+		# plugins twice.
+		attr_accessor :plugins_installed_from
+
+
+		### Returns +true+ if the plugins for the extended app class have already
+		### been installed.
+		def plugins_installed?
+			return !self.plugins_installed_from.nil?
+		end
+
+
+		### Extension callback -- add instance variables to extending objects.
+		def inherited( subclass )
+			super
+			@plugins ||= []
+			subclass.loaded_plugins = self.loaded_plugins
+			subclass.plugins_installed_from = nil
+			subclass.instance_variable_set( :@plugins, @plugins.dup )
+		end
+
+
+		### Load the plugins with the given +names+ and install them.
+		def plugins( *names )
+			Strelka.log.info "Adding plugins: %s" % [ names.flatten.map(&:to_s).join(', ') ]
+
+			# Load the associated Plugin Module objects
+			names.flatten.each {|name| self.load_plugin(name) }
+
+			# Add the name/s to the list of mixins to apply on startup
+			@plugins |= names
+
+			# Install the declarative half of the plugin immediately
+			names.each do |name|
+				plugin = nil
+
+				if name.is_a?( Module )
+					plugin = name
+				else
+					plugin = self.loaded_plugins[ name ]
+				end
+
+				Strelka.log.debug "  registering %p" % [ name ]
+				self.register_plugin( plugin )
+			end
+		end
+		alias_method :plugin, :plugins
+
+
+		### Load the plugin with the given +name+
+		def load_plugin( name )
+
+			# Just return Modules as-is
+			return name if name.is_a?( Strelka::Plugin )
+			mod = self.loaded_plugins[ name.to_sym ]
+
+			unless mod.is_a?( Module )
+				prefix = self.name.gsub( /::/, File::PATH_SEPARATOR )
+				Strelka.log.debug "Loading plugin from #{prefix}/#{name}"
+				require "#{prefix}/#{name}"
+				mod = self.loaded_plugins[ name.to_sym ] or
+					raise "#{name} plugin didn't load correctly."
+			end
+
+			return mod
+		end
+
+
+		### Register the plugin +mod+ in the receiving class. This adds any
+		### declaratives and class-level data necessary for configuring the
+		### plugin.
+		def register_plugin( mod )
+			if mod.const_defined?( :ClassMethods )
+				cm_mod = mod.const_get(:ClassMethods)
+				Strelka.log.debug "  adding class methods from %p" % [ cm_mod ]
+
+				extend( cm_mod )
+				cm_mod.instance_variables.each do |ivar|
+					Strelka.log.debug "  copying class instance variable %s" % [ ivar ]
+					ival = cm_mod.instance_variable_get( ivar )
+
+					# Don't duplicate modules/classes or immediates
+					instance_variable_set( ivar, Strelka::DataUtilities.deep_copy(ival) )
+				end
+			end
+		end
+
+
+		### Install the mixin part of plugins immediately before the first instance
+		### is created.
+		def new( * )
+			self.install_plugins unless self.plugins_installed?
+			super
+		end
+
+
+		### Install the mixin part of the plugin, in the order determined by
+		### the plugin registry based on the run_before and run_after specifications
+		### of the plugins themselves.
+		def install_plugins
+			if self.plugins_installed?
+				Strelka.log.warn "Plugins were already installed for %p from %p" %
+					[ self, self.plugins_installed_from ]
+				Strelka.log.info "I'll attempt to install any new ones, but plugin ordering"
+				Strelka.log.info "and other functionality might exhibit strange behavior."
+			else
+				Strelka.log.info "Installing plugins for %p." % [ self ]
+			end
+
+			sorted_plugins = self.loaded_plugins.tsort.reverse
+
+			sorted_plugins.each do |name|
+				mod = self.loaded_plugins[ name ]
+
+				unless @plugins.include?( name ) || @plugins.include?( mod )
+					Strelka.log.debug "  skipping %s" % [ name ]
+					next
+				end
+
+				Strelka.log.info "  including %p." % [ mod ]
+				include( mod )
+			end
+
+			self.plugins_installed_from = caller( 1 ).first
+		end
+
+	end # module PluginLoader
+
+end # class Strelka
+
+

data/lib/strelka/router/default.rb

@@ -8,7 +8,9 @@ require 'strelka/router'
 
 # Simple (dumb?) request router for Strelka::App-based applications.
 class Strelka::Router::Default < Strelka::Router
-	include Strelka::Loggable
+	include Strelka::Loggable,
+	        Strelka::Constants,
+	        Strelka::ResponseHelpers
 
 	### Create a new router that will route requests according to the specified
 	### +routes+. Each route is a tuple of the form:
@@ -20,6 +22,8 @@ class Strelka::Router::Default < Strelka::Router
 	###   ]
 	def initialize( routes=[], options={} )
 		@routes = Hash.new {|hash, verb| hash[verb] = {} }
+		# :FIXME: Either call #add_route for each route in 'routes', or eliminate
+		# the parameter
 
 		super
 	end
@@ -52,7 +56,8 @@ class Strelka::Router::Default < Strelka::Router
 		path.slice!( 0, 1 ) if path.start_with?( '/' ) # Strip the leading '/'
 
 		self.log.debug "Looking for a route for: %p %p" % [ verb, path ]
-		verbroutes = @routes[ verb ] or return nil
+		verbroutes = @routes[ verb ]
+		return self.allowed_response( path ) if verbroutes.empty?
 		match = self.find_longest_match( verbroutes.keys, path ) or return nil
 		self.log.debug "  longest match result: %p" % [ match ]
 
@@ -76,6 +81,26 @@ class Strelka::Router::Default < Strelka::Router
 	end
 
 
+	### If the specified +path+ matches a valid route, then respond with a
+	### 405 (Method Not Allowed) with the allowed HTTP verbs. Otherwise, return
+	### +nil+.
+	def allowed_response( path )
+		allowed_verbs = []
+
+		routes = @routes.each do |verb, verbroutes|
+			allowed_verbs << verb if self.find_longest_match( verbroutes.keys, path )
+		end
+		allowed_verbs << :HEAD if allowed_verbs.include?( :GET )
+
+		self.log.debug "Allowed methods for path %s: %p" % [ path, allowed_verbs ]
+		return nil if allowed_verbs.empty?
+
+		allowed_hdr = allowed_verbs.map {|verb| verb.to_s.upcase }.join( ', ' )
+		finish_with( HTTP::METHOD_NOT_ALLOWED, 'Method not allowed.', allow: allowed_hdr )
+	end
+
+
+
 	#########
 	protected
 	#########