strelka 0.0.1.pre177 → 0.0.1.pre184

data/lib/strelka/app/parameters.rb

@@ -35,13 +35,6 @@ require 'strelka/paramvalidator'
 #
 #   end # class UserManager
 #
-#
-# == To-Do
-#
-# _We may add support for other ways of passing parameters later,
-# e.g., via structured entity bodies like JSON, XML, YAML, etc_.
-#
-#
 module Strelka::App::Parameters
 	extend Strelka::App::Plugin
 
@@ -52,114 +45,32 @@ module Strelka::App::Parameters
 	# Class methods to add to classes with routing.
 	module ClassMethods # :nodoc:
 
-		# Pattern for matching route parameters
-		PARAMETER_PATTERN = %r{/:(?<paramname>[a-z]\w*)}i
-
-		# Param defaults
-		PARAMETER_DEFAULT_OPTIONS = {
-			:constraint  => //,
-			:required    => false,
-			:description => nil,
-		}
-
-		# Pattern to use to strip binding operators from parameter patterns so they
-		# can be used in the middle of routing Regexps.
-		PARAMETER_PATTERN_STRIP_RE = Regexp.union( '^', '$', '\\A', '\\z', '\\Z' )
-
-		# Options that are passed as Symbols to .param
-		FLAGS = [ :required, :untaint ]
-
-
-		# Default parameters hash
-		@parameters = {}
-		@untaint_all_constraints = false
-
-		# The hash of declared parameters
-		attr_reader :parameters
-
-		# The flag for untainting constrained parameters that match their constraints
-		attr_writer :untaint_all_constraints
+		##
+		# Default ParamValidator
+		@paramvalidator = Strelka::ParamValidator.new
+		attr_reader :paramvalidator
 
 
+		### :call-seq:
+		###    param( name, *flags )
+		###    param( name, constraint, *flags )
+		###    param( name, description, *flags )
+		###    param( name, constraint, description, *flags )
+		###
 		### Declare a parameter with the specified +name+ that will be validated using the given
 		### +constraint+. The +constraint+ can be any of the types supported by
 		### Strelka::ParamValidator.
-		### :call-seq:
-		#   param( name, *flags )
-		#   param( name, constraint, *flags )
-		#   param( name, description, *flags )
-		#   param( name, constraint, description, *flags )
 		def param( name, *args )
 			Strelka.log.debug "New param %p" % [ name ]
-			name = name.to_sym
-
-			# Consume the arguments
-			constraint = args.shift unless args.first.is_a?( String ) || FLAGS.include?( args.first )
-			constraint ||= name
-			description = args.shift if args.first.is_a?( String )
-			# description ||= name.to_s.capitalize
-			flags = args
-
-			# Give a regexp constraint a named capture group for the constraint name if it
-			# doesn't already have one
-			if constraint.is_a?( Regexp )
-				constraint = Regexp.compile( "(?<#{name}>" + constraint.to_s + ")" ) unless
-					constraint.names.include?( name.to_s )
-				Strelka.log.debug "  regex constraint is: %p" % [ constraint ]
-			end
-
-			# Merge the param into the parameters hash
-			options = PARAMETER_DEFAULT_OPTIONS.dup
-			options[ :constraint ]  = constraint
-			options[ :description ] = description
-			options[ :required ]    = true if flags.include?( :required )
-			options[ :untaint ]     = true if flags.include?( :untaint )
-			Strelka.log.debug "  param options are: %p" % [ options ]
-
-			self.parameters[ name ] = options
+			self.paramvalidator.add( name, *args )
 		end
 
 
 		### Get/set the untainting flag. If set, all parameters which match their constraints
 		### will also be untainted.
 		def untaint_all_constraints( newval=nil )
-			Strelka.log.debug "Untaint all constraints: %p:%p" % [ newval, @untaint_all_constraints ]
-			@untaint_all_constraints = newval unless newval.nil?
-			return @untaint_all_constraints
-		end
-
-
-		### Turn the constraint associated with +name+ into a routing component.
-		def extract_route_from_constraint( name )
-			name.slice!( 0, 1 ) if name.start_with?( ':' )
-			Strelka.log.debug "  searching for a param for %p" % [ name ]
-			param = self.parameters[ name.to_sym ] or
-				raise ScriptError, "no parameter %p defined" % [ name ]
-
-			# Munge the constraint into a Regexp
-			constraint = param[ :constraint ]
-			re = case constraint
-				when Regexp
-					constraint
-				when Array
-					sub_res = constraint.map( &self.method(:extract_route_from_constraint) )
-					Regexp.union( sub_res )
-				when Symbol
-					re = Strelka::ParamValidator.pattern_for_constraint( constraint ) or
-						raise ScriptError, "no pattern for %p constraint" % [ constraint ]
-					/(?<#{name}>#{re})/
-				else
-					raise ScriptError,
-						"can't route on a parameter with a %p constraint %p" % [ constraint.class ]
-				end
-
-			# Unbind the pattern from beginning or end of line.
-			# :TODO: This is pretty ugly. Find a better way of modifying the regex.
-			re_str = re.to_s.
-				sub( %r{\(\?[\-mix]+:(.*)\)}, '\\1' ).
-				gsub( PARAMETER_PATTERN_STRIP_RE, '' )
-
-			return Regexp.new( re_str, re.options )
+			self.paramvalidator.untaint_all = newval unless newval.nil?
+			return self.paramvalidator.untaint_all?
 		end
 
 
@@ -167,7 +78,7 @@ module Strelka::App::Parameters
 		### declarations, too.
 		def inherited( subclass )
 			super
-			subclass.instance_variable_set( :@parameters, self.parameters.dup )
+			subclass.instance_variable_set( :@paramvalidator, self.paramvalidator.dup )
 		end
 
 	end # module ClassMethods
@@ -176,48 +87,15 @@ module Strelka::App::Parameters
 
 	### Add a ParamValidator to the given +request+ before passing it on.
 	def handle_request( request, &block )
-		profile = self.make_validator_profile( request )
-		self.log.debug "Applying validator profile: %p" % [ profile ]
-		validator = Strelka::ParamValidator.new( profile, request.params )
-		self.log.debug "  validator: %p" % [ validator ]
+		self.log.debug "[:parameters] Wrapping request with parameter validation."
 
+		validator = self.class.paramvalidator.dup
+		validator.validate( request.params )
 		request.params = validator
-		super
-	end
-
-
-
-	### Make a validator profile for Strelka::ParamValidator for the specified
-	### +request+ using the declared parameters in the App, returning it as a Hash.
-	def make_validator_profile( request )
-		profile = {
-			:required     => [],
-			:optional     => [],
-			:descriptions => {},
-			:constraints  => {},
-			:untaint_constraint_fields => [],
-			:untaint_all_constraints => self.class.untaint_all_constraints,
-		}
 
-		self.log.debug "Validator profile is: %p" % [ profile ]
-
-		return self.class.parameters.inject( profile ) do |accum, (name, opts)|
-			self.log.debug "  adding parameter: %p: %p" % [ name, opts ]
-			if opts[:required]
-				accum[:required] << name
-			else
-				accum[:optional] << name
-			end
-
-			accum[:untaint_constraint_fields] << name if opts[:untaint]
-			accum[:descriptions][ name ] = opts[:description] if opts[:description]
-			accum[:constraints][ name ] = opts[:constraint]
-
-			accum
-		end
+		super
 	end
 
-
 end # module Strelka::App::Parameters
 
 

data/lib/strelka/app/plugins.rb

@@ -118,16 +118,59 @@ class Strelka::App
 		end
 
 
-		### Extension callback -- add instance variables to extending objects.
-		def self::extended( object )
-			super
-			object.instance_variable_set( :@plugins, {} )
-		end
-
-
 		### Class methods to add to classes with plugins.
 		module ClassMethods
 
+			##
+			# 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.instance_variable_set( :@plugins, @plugins.dup )
+				subclass.instance_variable_set( :@plugins_installed_from, nil )
+			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 = Strelka::App.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 )
 
@@ -146,11 +189,10 @@ class Strelka::App
 			end
 
 
-			### Install the plugin +mod+ in the receiving class.
-			def install_plugin( mod )
-				Strelka.log.debug "  adding %p to %p" % [ mod, self ]
-				include( mod )
-
+			### 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 ]
@@ -172,27 +214,43 @@ class Strelka::App
 			end
 
 
-			### Load the plugins with the given +names+ and install them.
-			def plugins( *names )
-				# Load the associated Plugin Module objects
-				names.flatten.each {|name| self.load_plugin(name) }
+			### 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 = Strelka::App.loaded_plugins.tsort.reverse
-				Strelka.log.debug "Sorted plugins: app -> %p <- Mongrel2" % [ sorted_plugins ]
 
-				# Install the plugins in reverse-sorted order
 				sorted_plugins.each do |name|
-					plugin = Strelka::App.loaded_plugins[ name ]
-					Strelka.log.debug "Considering %p" % [ name ]
-					if names.include?( name ) || names.include?( plugin )
-						Strelka.log.debug "  installing"
-						self.install_plugin( plugin )
-					else
-						Strelka.log.debug "  not used by this app; skipping"
+					mod = Strelka::App.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
-			alias_method :plugin, :plugins
 
 		end # module ClassMethods
 

data/lib/strelka/app/restresources.rb

@@ -62,23 +62,6 @@ module Strelka::App::RestResources
 	}.freeze
 
 
-	### Inclusion callback -- overridden to also install dependencies.
-	def self::included( mod )
-		super
-
-		# Load the plugins this one depends on if they aren't already
-		mod.plugins :routing, :negotiation, :parameters
-
-		# Add validations for the limit and offset parameters
-		mod.param :limit, :integer
-		mod.param :offset, :integer
-
-		# Use the 'exclusive' router instead of the more-flexible
-		# Mongrel2-style default one
-		mod.router :exclusive
-	end
-
-
 	# Class methods to add to classes with REST resources.
 	module ClassMethods # :nodoc:
 		include Sequel::Inflections
@@ -96,6 +79,23 @@ module Strelka::App::RestResources
 		attr_reader :global_options
 
 
+		### Extension callback -- overridden to also install dependencies.
+		def self::extended( obj )
+			super
+
+			# Load the plugins this one depends on if they aren't already
+			obj.plugins :routing, :negotiation, :parameters
+
+			# Add validations for the limit and offset parameters
+			obj.param :limit, :integer
+			obj.param :offset, :integer
+
+			# Use the 'exclusive' router instead of the more-flexible
+			# Mongrel2-style default one
+			obj.router :exclusive
+		end
+
+
 		### Set the prefix for all following resource routes to +route+.
 		def resource_prefix( route )
 			self.global_options[ :prefix ] = route
@@ -141,7 +141,7 @@ module Strelka::App::RestResources
 		### Add parameter declarations for parameters related to +rsrcobj+.
 		def add_parameters( rsrcobj, options )
 			Strelka.log.debug "Declaring validations for columns from %p" % [ rsrcobj ]
-			self.untaint_all_constraints = true
+			self.untaint_all_constraints
 			rsrcobj.db_schema.each do |col, config|
 				Strelka.log.debug "  %s (%p)" % [ col, config[:type] ]
 				param col, config[:type]
@@ -155,9 +155,11 @@ module Strelka::App::RestResources
 			# :TODO: Documentation for HTML mode (possibly using http://swagger.wordnik.com/)
 			Strelka.log.debug "Adding OPTIONS handler for %p" % [ route, rsrcobj ]
 			self.add_route( :OPTIONS, route, options ) do |req|
+				self.log.debug "OPTIONS handler!"
 				verbs = self.class.resource_verbs[ route ].sort
 				res = req.response
 
+				self.log.debug "  making a reply with Allowed: %s" % [ verbs.join(', ') ]
 				res.header.allowed = verbs.join(', ')
 				res.content_type = 'text/plain'
 				res.body = ''
@@ -498,4 +500,10 @@ module Strelka::App::RestResources
 	end # module ClassMethods
 
 
+	### This is just here for logging.
+	def handle_request( * ) # :nodoc:
+		self.log.debug "[:restresources] handling request for REST resource."
+		super
+	end
+
 end # module Strelka::App::RestResources

data/lib/strelka/app/routing.rb

@@ -216,10 +216,12 @@ module Strelka::App::Routing
 			return pattern.split( '/' ).collect do |component|
 
 				if component.start_with?( ':' )
+					Strelka.log.debug "translating parameter component %p to a regexp" % [component]
 					raise ScriptError,
 						"parameter-based routing not supported without a 'parameters' plugin" unless
-						self.respond_to?( :extract_route_from_constraint )
-					self.extract_route_from_constraint( component )
+						self.respond_to?( :paramvalidator )
+					component = component.slice( 1..-1 )
+					self.paramvalidator.constraint_regexp_for( component )
 				else
 					component
 				end
@@ -249,6 +251,8 @@ module Strelka::App::Routing
 
 	### Dispatch the request using the Router.
 	def handle_request( request, &block )
+		self.log.debug "[:routing] Routing request using %p" % [ self.router.class ]
+
 		if route = self.router.route_request( request )
 			# Track which route was chosen for later plugins
 			request.notes[:routing][:route] = route
@@ -257,6 +261,8 @@ module Strelka::App::Routing
 		else
 			finish_with HTTP::NOT_FOUND, "The requested resource was not found on this server."
 		end
+
+		self.log.debug "[:routing] Done with routing."
 	end
 
 end # module Strelka::App::Routing

data/lib/strelka/app/sessions.rb

@@ -172,6 +172,13 @@ module Strelka::App::Sessions
 		return super
 	end
 
+
+	### This is just here for logging.
+	def handle_request( * ) # :nodoc:
+		self.log.debug "[:sessions] Adding sessions to the transaction."
+		super
+	end
+
 end # module Strelka::App::Sessions
 
 

data/lib/strelka/app/templating.rb

@@ -90,7 +90,7 @@ module Strelka::App::Templating
 	include Strelka::Constants
 	extend Strelka::App::Plugin
 
-	run_before :routing, :negotiation
+	run_before :routing, :negotiation, :errors
 	run_after :filters
 
 

data/lib/strelka/app.rb

@@ -53,8 +53,8 @@ class Strelka::App < Mongrel2::Handler
 		Strelka.logger.level = Logger::DEBUG if $VERBOSE
 		Strelka.logger.formatter = Strelka::Logging::ColorFormatter.new( Strelka.logger ) if $stderr.tty?
 
+		Strelka.log.info "Starting up with appid %p." % [ appid ]
 		super( appid )
-
 	end
 
 
@@ -172,6 +172,13 @@ class Strelka::App < Mongrel2::Handler
 	###	I N S T A N C E   M E T H O D S
 	#################################################################
 
+	### Dump the application stack when a new instance is created.
+	def initialize( * )
+		self.dump_application_stack
+		super
+	end
+
+
 	######
 	public
 	######
@@ -192,11 +199,15 @@ class Strelka::App < Mongrel2::Handler
 
 		# Dispatch the request after allowing plugins to to their thing
 		status_info = catch( :finish ) do
+			self.log.debug "Starting dispatch of request %p" % [ request ]
 
 			# Run fixup hooks on the request
 			request = self.fixup_request( request )
+			self.log.debug "  done with request fixup"
 			response = self.handle_request( request )
+			self.log.debug "  done with handler"
 			response = self.fixup_response( response )
+			self.log.debug "  done with response fixup"
 
 			nil # rvalue for the catch
 		end
@@ -337,5 +348,18 @@ class Strelka::App < Mongrel2::Handler
 		return response
 	end
 
+
+	### Output the application stack into the logfile.
+	def dump_application_stack
+		stack = self.class.ancestors.
+			reverse.
+			drop_while {|mod| mod != Strelka::App }.
+			select {|mod| mod.respond_to?(:plugin_name) }.
+			reverse.
+			collect {|mod| mod.plugin_name }
+
+		self.log.info "Application stack: request -> %s" % [ stack.join(" -> ") ]
+	end
+
 end # class Strelka::App
 

data/lib/strelka/constants.rb

@@ -12,7 +12,9 @@ module Strelka::Constants
 	include Mongrel2::Constants
 
 	# The data directory in the project if that exists, otherwise the gem datadir
-	DATADIR = if File.directory?( 'data/strelka' )
+	DATADIR = if ENV['STRELKA_DATADIR']
+			Pathname( ENV['STRELKA_DATADIR'] )
+		elsif File.directory?( 'data/strelka' )
 			Pathname( 'data/strelka' )
 		elsif path = Gem.datadir('strelka')
 			Pathname( path )