strelka 0.6.0 → 0.7.0

data/lib/strelka/app/errors.rb

@@ -86,7 +86,7 @@ module Strelka::App::Errors
 
 
 	# Plugin load order
-	run_before :routing
+	run_outside :routing
 
 
 	# Class-level functionality

data/lib/strelka/app/filters.rb

@@ -10,7 +10,8 @@ require 'strelka/app' unless defined?( Strelka::App )
 module Strelka::App::Filters
 	extend Strelka::Plugin
 
-	run_before :routing, :templating
+	run_inside  :templating
+	run_outside :routing
 
 
 	# Class methods to add to classes with routing.
@@ -68,7 +69,7 @@ module Strelka::App::Filters
 
 		self.apply_request_filters( request )
 		response = super
-		self.apply_response_filters( response )
+		self.apply_response_filters( request.response )
 
 		return response
 	end

data/lib/strelka/app/negotiation.rb

@@ -29,8 +29,8 @@ module Strelka::App::Negotiation
 	include Strelka::Constants
 	extend Strelka::Plugin
 
-	run_before :routing
-	run_after  :filters, :templating, :parameters
+	run_outside :routing, :filters
+	run_inside  :templating, :parameters
 
 
 	# Class methods to add to classes with content-negotiation.

data/lib/strelka/app/parameters.rb

@@ -73,8 +73,7 @@ require 'strelka/paramvalidator'
 module Strelka::App::Parameters
 	extend Strelka::Plugin
 
-	run_before :routing
-	run_after :filters
+	run_outside :routing, :filters
 
 
 	# Class methods to add to classes with routing.

data/lib/strelka/app/restresources.rb

@@ -369,7 +369,7 @@ module Strelka::App::RestResources
 		end
 
 
-		### Add a handler method for updating all instances of +rsrcobj+ collection.
+		### Add a handler method for replacing all instances of +rsrcobj+ collection.
 		### PUT /resources
 		def add_collection_update_handler( route, rsrcobj, options )
 			pkey = rsrcobj.primary_key
@@ -388,7 +388,8 @@ module Strelka::App::RestResources
 				# Save it in a transaction, erroring if any of 'em fail validations
 				begin
 					rsrcobj.db.transaction do
-						rsrcobj.update( newvals )
+						rsrcobj.truncate
+						rsrcobj.create( newvals )
 					end
 				rescue Sequel::ValidationFailed => err
 					finish_with( HTTP::BAD_REQUEST, err.message )

data/lib/strelka/app/routing.rb

@@ -106,7 +106,7 @@ module Strelka::App::Routing
 	log_to :strelka
 
 	# Plugins API -- set up load order
-	run_after :templating, :filters, :parameters
+	run_inside :templating, :filters, :parameters
 
 
 	# Class methods to add to classes with routing.

data/lib/strelka/app/sessions.rb

@@ -94,9 +94,9 @@ module Strelka::App::Sessions
 	# Configurability API -- specify which section of the config this class gets
 	config_key :sessions
 
-	# Plugins API -- Specify load order; run as late as possible so other plugins
+	# Plugins API -- Specify load order; run as early as possible so other plugins
 	# can use the session
-	run_after :templating, :filters, :parameters
+	run_outside :templating, :filters, :parameters
 
 
 	# Class methods and instance variables to add to classes with sessions.

data/lib/strelka/app/templating.rb

@@ -74,6 +74,10 @@ require 'strelka/plugins'
 #
 # It will be loaded, set as the response body, and the above common objects added to it.
 #
+# :TODO: Explain how returning things other than responses doesn't work well with
+#        :filters and maybe other plugins that run inside :templating.
+#
+#
 # === Layouts
 #
 # Very often, you'll want all or most of the views in your app to share a common page
@@ -116,14 +120,13 @@ module Strelka::App::Templating
 	log_to :strelka
 
 	# Run order
-	run_before :routing, :negotiation, :errors
-	run_after :filters
+	run_outside :routing, :negotiation, :errors, :filters
 
 
 	### Return an Array of Pathnames to all directories named 'templates' under the
 	### data dirctories of loaded gems which have a dependency on Strelka.
 	def self::discover_template_dirs
-		directories = Strelka::App.discover_data_dirs.values.flatten
+		directories = Strelka::Discovery.discover_data_dirs.values.flatten
 
 		self.log.debug "Discovered data directories: %p" % [ directories ]
 
@@ -282,6 +285,7 @@ module Strelka::App::Templating
 		# Not templated; returned as-is
 		else
 			self.log.debug "  response isn't templated; returning nil"
+			# :TODO: Return the response instead of nil
 			return nil
 		end
 	end

data/lib/strelka/app.rb

@@ -10,12 +10,14 @@ require 'mongrel2/handler'
 require 'strelka' unless defined?( Strelka )
 require 'strelka/mixins'
 require 'strelka/plugins'
+require 'strelka/discovery'
 
 
 # The Strelka HTTP application base class.
 class Strelka::App < Mongrel2::Handler
 	extend Loggability,
 	       Configurability,
+		   Strelka::Discovery,
 	       Strelka::MethodUtilities,
 	       Strelka::PluginLoader
 	include Strelka::Constants,
@@ -85,29 +87,14 @@ class Strelka::App < Mongrel2::Handler
 	### to the 'app' section of the config that will be passed to you when the config
 	### is loaded.
 	def self::configure( config=nil )
-		config = self.defaults.merge( config || {} )
-
+		config = Strelka::App.defaults.merge( config || {} )
 		self.devmode = config[:devmode] || $DEBUG
-		self.app_glob_pattern = config[:app_glob_pattern]
-		self.local_data_dirs  = config[:local_data_dirs]
-
 		self.log.info "Enabled developer mode." if self.devmode?
 	end
 
 
-	### Inheritance callback -- add subclasses to @subclasses so .load can figure out which
-	### classes correspond to which files.
-	def self::inherited( subclass )
-		super
-		self.log.debug "Adding %p to the subclasses hash." % [ subclass ]
-		Strelka::App.subclasses[ @loading_file ] << subclass #if self == Strelka::App
-	end
-
-
-
 	### Overridden from Mongrel2::Handler -- use the value returned from .default_appid if
-	### one is not specified, and automatically install the config DB if it hasn't been
-	### already.
+	### one is not specified.
 	def self::run( appid=nil )
 		appid ||= self.default_appid
 		self.log.info "Starting up with appid %p." % [ appid ]
@@ -134,134 +121,6 @@ class Strelka::App < Mongrel2::Handler
 	end
 
 
-	### Return a Hash of glob patterns for matching data directories for the latest
-	### versions of all installed gems which have a dependency on Strelka, keyed
-	### by gem name.
-	def self::discover_data_dirs
-		datadirs = {
-			'' => self.local_data_dirs
-		}
-
-		# Find all the gems that depend on Strelka
-		gems = Gem::Specification.find_all do |gemspec|
-			gemspec.dependencies.find {|dep| dep.name == 'strelka'}
-		end
-
-		self.log.debug "Found %d gems with a Strelka dependency" % [ gems.length ]
-
-		# Find all the files under those gems' data directories that match the application
-		# pattern
-		gems.sort.reverse.each do |gemspec|
-			# Only look at the latest version of the gem
-			next if datadirs.key?( gemspec.name )
-			datadirs[ gemspec.name ] = File.join( gemspec.full_gem_path, "data", gemspec.name )
-		end
-
-		self.log.debug "  returning data directories: %p" % [ datadirs ]
-		return datadirs
-	end
-
-
-	### Return a Hash of Strelka app files as Pathname objects from installed gems,
-	### keyed by gemspec name .
-	def self::discover_paths
-		appfiles = {}
-
-		self.discover_data_dirs.each do |gemname, dir|
-			pattern = File.join( dir, self.app_glob_pattern )
-			appfiles[ gemname ] = Pathname.glob( pattern )
-		end
-
-		return appfiles
-	end
-
-
-	### Return an Array of Strelka::App classes loaded from the installed Strelka gems.
-	def self::discover
-		discovered_apps = []
-		app_paths = self.discover_paths
-
-		self.log.debug "Loading apps from %d discovered paths" % [ app_paths.length ]
-		app_paths.each do |gemname, paths|
-			self.log.debug "  loading gem %s" % [ gemname ]
-			gem( gemname ) unless gemname == ''
-
-			self.log.debug "  loading apps from %s: %d handlers" % [ gemname, paths.length ]
-			paths.each do |path|
-				classes = begin
-					Strelka::App.load( path )
-				rescue StandardError, ScriptError => err
-					self.log.error "%p while loading Strelka apps from %s: %s" %
-						[ err.class, path, err.message ]
-					self.log.debug "Backtrace: %s" % [ err.backtrace.join("\n\t") ]
-					[]
-				end
-				self.log.debug "  loaded app classes: %p" % [ classes ]
-
-				discovered_apps += classes
-			end
-		end
-
-		return discovered_apps
-	end
-
-
-	### Find the first app with the given +appname+ and return the path to its file and the name of
-	### the gem it's from. If the optional +gemname+ is given, only consider apps from that gem.
-	### Raises a RuntimeError if no app with the given +appname+ was found.
-	def self::find( appname, gemname=nil )
-		discovered_apps = self.discover_paths
-
-		path = nil
-		if gemname
-			discovered_apps[ gemname ].each do |apppath|
-				self.log.debug "    %s (%s)" % [ apppath, apppath.basename('.rb') ]
-				if apppath.basename('.rb').to_s == appname
-					path = apppath
-					break
-				end
-			end
-		else
-			self.log.debug "No gem name; searching them all:"
-			discovered_apps.each do |disc_gemname, paths|
-				self.log.debug "  %s: %d paths" % [ disc_gemname, paths.length ]
-				path = paths.find do |apppath|
-					self.log.debug "    %s (%s)" % [ apppath, apppath.basename('.rb') ]
-					self.log.debug "    %p vs. %p" % [ apppath.basename('.rb').to_s, appname ]
-					apppath.basename('.rb').to_s == appname
-				end or next
-				gemname = disc_gemname
-				break
-			end
-		end
-
-		unless path
-			msg = "Couldn't find an app named '#{appname}'"
-			msg << " in the #{gemname} gem" if gemname
-			raise( msg )
-		end
-		self.log.debug "  found: %s" % [ path ]
-
-		return path, gemname
-	end
-
-
-	### Load the specified +file+, and return any Strelka::App subclasses that are loaded
-	### as a result.
-	def self::load( file )
-		self.log.debug "Loading application/s from %p" % [ file ]
-		@loading_file = Pathname( file ).expand_path
-		self.subclasses.delete( @loading_file )
-		Kernel.load( @loading_file.to_s )
-		new_subclasses = self.subclasses[ @loading_file ]
-		self.log.debug "  loaded %d new app class/es" % [ new_subclasses.size ]
-
-		return new_subclasses
-	ensure
-		@loading_file = nil
-	end
-
-
 	#
 	# :section: Application declarative methods
 	#
@@ -463,6 +322,7 @@ class Strelka::App < Mongrel2::Handler
 		# Some status codes allow explanatory text to be returned; some forbid it. Append the
 		# message for those that allow one.
 		unless request.verb == :HEAD || response.bodiless?
+			self.log.debug "Writing plain-text response body: %p" % [ message ]
 			response.content_type = 'text/plain'
 			response.puts( message )
 		end

data/lib/strelka/behavior/plugin.rb

@@ -10,7 +10,7 @@ require 'strelka/plugins'
 
 
 # This is a shared behavior for specs which different Strelka::App
-# plugins share in common. If you're creating a Strelka::App plugin,
+# plugins share in common. If you're creating A Strelka Plugin,
 # you can test its conformity to the expectations placed on them by
 # adding this to your spec:
 #
@@ -18,11 +18,11 @@ require 'strelka/plugins'
 #
 #    describe YourPlugin do
 #
-#      it_should_behave_like "A Strelka::App Plugin"
+#      it_should_behave_like "A Strelka Plugin"
 #
 #    end
 
-shared_examples_for "A Strelka::App Plugin" do
+shared_examples_for "A Strelka Plugin" do
 
 	let( :plugin ) do
 		described_class
@@ -30,7 +30,7 @@ shared_examples_for "A Strelka::App Plugin" do
 
 
 	it "extends Strelka::Plugin" do
-		plugin.should be_a( Strelka::Plugin )
+		expect( plugin ).to be_a( Strelka::Plugin )
 	end
 
 end

data/lib/strelka/discovery.rb

@@ -0,0 +1,211 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'rubygems'
+require 'strelka' unless defined?( Strelka )
+
+
+# The Strelka application-discovery system.
+module Strelka::Discovery
+	extend Loggability,
+	       Configurability,
+	       Strelka::MethodUtilities
+
+
+	# Loggability API -- log to the Strelka logger
+	log_to :strelka
+
+	# Configurability API -- use the 'discovery' section of the config
+	config_key :discovery
+
+
+	# Default config
+	CONFIG_DEFAULTS = {
+		app_glob_pattern: '{apps,handlers}/**/*',
+		local_data_dirs:  'data/*',
+	}.freeze
+
+
+	##
+	# The Hash of Strelka::App subclasses, keyed by the Pathname of the file they were
+	# loaded from, or +nil+ if they weren't loaded via ::load.
+	singleton_attr_reader :subclasses
+
+	##
+	# The glob(3) pattern for matching Apps during discovery
+	singleton_attr_accessor :app_glob_pattern
+
+	##
+	# The glob(3) pattern for matching local data directories during discovery. Local
+	# data directories are evaluated relative to the CWD.
+	singleton_attr_accessor :local_data_dirs
+
+	##
+	# The name of the file that's currently being loaded (if any)
+	singleton_attr_reader :loading_file
+
+
+	# Module instance variables
+	@subclasses       = Hash.new {|h,k| h[k] = [] }
+	@loading_file     = nil
+	@app_glob_pattern = CONFIG_DEFAULTS[:app_glob_pattern]
+	@local_data_dirs  = CONFIG_DEFAULTS[:local_data_dirs]
+
+
+	### Configure the App. Override this if you wish to add additional configuration
+	### to the 'app' section of the config that will be passed to you when the config
+	### is loaded.
+	def self::configure( config=nil )
+		config = self.defaults.merge( config || {} )
+
+		self.app_glob_pattern = config[:app_glob_pattern]
+		self.local_data_dirs  = config[:local_data_dirs]
+	end
+
+
+	### Return a Hash of glob patterns for matching data directories for the latest
+	### versions of all installed gems which have a dependency on Strelka, keyed
+	### by gem name.
+	def self::discover_data_dirs
+		datadirs = {
+			'' => self.local_data_dirs
+		}
+
+		# Find all the gems that depend on Strelka
+		gems = Gem::Specification.find_all do |gemspec|
+			gemspec.dependencies.find {|dep| dep.name == 'strelka'}
+		end
+
+		self.log.debug "Found %d gems with a Strelka dependency" % [ gems.length ]
+
+		# Find all the files under those gems' data directories that match the application
+		# pattern
+		gems.sort.reverse.each do |gemspec|
+			# Only look at the latest version of the gem
+			next if datadirs.key?( gemspec.name )
+			datadirs[ gemspec.name ] = File.join( gemspec.full_gem_path, "data", gemspec.name )
+		end
+
+		self.log.debug "  returning data directories: %p" % [ datadirs ]
+		return datadirs
+	end
+
+
+	### Return a Hash of Strelka app files as Pathname objects from installed gems,
+	### keyed by gemspec name .
+	def self::discover_paths
+		appfiles = {}
+
+		self.discover_data_dirs.each do |gemname, dir|
+			pattern = File.join( dir, self.app_glob_pattern )
+			appfiles[ gemname ] = Pathname.glob( pattern )
+		end
+
+		return appfiles
+	end
+
+
+	### Return an Array of Strelka::App classes loaded from the installed Strelka gems.
+	def self::discover
+		discovered_apps = []
+		app_paths = self.discover_paths
+
+		self.log.debug "Loading apps from %d discovered paths" % [ app_paths.length ]
+		app_paths.each do |gemname, paths|
+			self.log.debug "  loading gem %s" % [ gemname ]
+			gem( gemname ) unless gemname == ''
+
+			self.log.debug "  loading apps from %s: %d handlers" % [ gemname, paths.length ]
+			paths.each do |path|
+				classes = begin
+					self.load( path )
+				rescue StandardError, ScriptError => err
+					self.log.error "%p while loading Strelka apps from %s: %s" %
+						[ err.class, path, err.message ]
+					self.log.debug "Backtrace: %s" % [ err.backtrace.join("\n\t") ]
+					[]
+				end
+				self.log.debug "  loaded app classes: %p" % [ classes ]
+
+				discovered_apps += classes
+			end
+		end
+
+		return discovered_apps
+	end
+
+
+	### Find the first app with the given +appname+ and return the path to its file and the name of
+	### the gem it's from. If the optional +gemname+ is given, only consider apps from that gem.
+	### Raises a RuntimeError if no app with the given +appname+ was found.
+	def self::find( appname, gemname=nil )
+		discovered_apps = self.discover_paths
+
+		path = nil
+		if gemname
+			discovered_apps[ gemname ].each do |apppath|
+				self.log.debug "    %s (%s)" % [ apppath, apppath.basename('.rb') ]
+				if apppath.basename('.rb').to_s == appname
+					path = apppath
+					break
+				end
+			end
+		else
+			self.log.debug "No gem name; searching them all:"
+			discovered_apps.each do |disc_gemname, paths|
+				self.log.debug "  %s: %d paths" % [ disc_gemname, paths.length ]
+				path = paths.find do |apppath|
+					self.log.debug "    %s (%s)" % [ apppath, apppath.basename('.rb') ]
+					self.log.debug "    %p vs. %p" % [ apppath.basename('.rb').to_s, appname ]
+					apppath.basename('.rb').to_s == appname
+				end or next
+				gemname = disc_gemname
+				break
+			end
+		end
+
+		unless path
+			msg = "Couldn't find an app named '#{appname}'"
+			msg << " in the #{gemname} gem" if gemname
+			raise( msg )
+		end
+		self.log.debug "  found: %s" % [ path ]
+
+		return path, gemname
+	end
+
+
+	### Load the specified +file+, and return any Strelka::App subclasses that are loaded
+	### as a result.
+	def self::load( file )
+		self.log.debug "Loading application/s from %p" % [ file ]
+		@loading_file = Pathname( file ).expand_path
+		self.subclasses.delete( @loading_file )
+		Kernel.load( @loading_file.to_s )
+		new_subclasses = self.subclasses[ @loading_file ]
+		self.log.debug "  loaded %d new app class/es" % [ new_subclasses.size ]
+
+		return new_subclasses
+	ensure
+		@loading_file = nil
+	end
+
+
+	### Register the given +subclass+ as having inherited a class that has been extended
+	### with Discovery.
+	def self::add_inherited_class( subclass )
+		self.log.debug "Registering discovered subclass %p" % [ subclass ]
+		self.subclasses[ self.loading_file ] << subclass
+	end
+
+
+	### Inheritance callback -- register the subclass with its parent for discovery.
+	def inherited( subclass )
+		super
+		Strelka::Discovery.log.info "%p inherited by discoverable class %p" % [ self, subclass ]
+		Strelka::Discovery.add_inherited_class( subclass )
+	end
+
+end # module Strelka::Discovery
+

data/lib/strelka/httprequest.rb

@@ -211,6 +211,7 @@ class Strelka::HTTPRequest < Mongrel2::HTTPRequest
 		when 'application/json', 'text/javascript'
 			return Yajl.load( self.body )
 		when 'text/x-yaml', 'application/x-yaml'
+			return nil if self.body.eof?
 			return YAML.load( self.body, safe: true )
 		when 'multipart/form-data'
 			boundary = self.content_type[ /\bboundary=(\S+)/, 1 ] or

data/lib/strelka/httpresponse/negotiation.rb

@@ -352,7 +352,13 @@ module Strelka::HTTPResponse::Negotiation
 	def try_content_type_callback( mimetype, callback )
 		self.log.debug "  trying content-type callback %p (%s)" % [ callback, mimetype ]
 
-		new_body = callback.call( mimetype ) or return false
+		new_body = begin
+			callback.call( mimetype )
+		rescue => err
+			self.log.error "  %p raised from the callback for %s: %s" %
+				[ err.class, mimetype, err.message ]
+			return false
+		end
 
 		self.log.debug "  successfully transformed: %p! Setting up response." % [ new_body.class ]
 		stringifiers = Strelka::HTTPResponse::Negotiation.stringifiers

data/lib/strelka/mixins.rb

@@ -2,6 +2,8 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
+require 'tempfile'
+
 require 'strelka' unless defined?( Strelka )
 require 'strelka/constants'
 
@@ -192,7 +194,8 @@ module Strelka
 			return obj if obj.class.name == 'RSpec::Mocks::Mock'
 
 			return case obj
-				when NilClass, Numeric, TrueClass, FalseClass, Symbol, Module
+				when NilClass, Numeric, TrueClass, FalseClass, Symbol,
+				     Module, Encoding, IO, Tempfile
 					obj
 
 				when Array

data/lib/strelka/paramvalidator.rb

@@ -753,7 +753,7 @@ class Strelka::ParamValidator
 	### the given +value+, and add the field to the appropriate field list based on the
 	### result.
 	def apply_constraint( constraint, value )
-		if !value.nil?
+		if !( value.nil? || value == '' )
 			result = constraint.apply( value, self.untaint_all? )
 
 			if !result.nil?

data/lib/strelka/plugins.rb

@@ -57,7 +57,7 @@ module Strelka
 			name = object.plugin_name
 			if (( deps = pluggable.loaded_plugins[name] ))
 				self.log.debug "  installing deferred deps for %p" % [ name ]
-				object.run_after( *deps )
+				object.run_inside( *deps )
 			end
 
 			self.log.debug "  adding %p (%p) to the plugin registry for %p" %
@@ -87,28 +87,30 @@ module Strelka
 
 		### Register the receiver as needing to be run before +other_plugins+ for requests, and
 		### *after* them for responses.
-		def run_before( *other_plugins )
+		def run_outside( *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 )
+				if mod.respond_to?( :run_inside )
+					mod.run_inside( name )
 				else
 					self.log.debug "%p plugin not yet loaded; setting up pending deps" % [ other_name ]
 					mod << name
 				end
 			end
 		end
+		alias_method :run_before, :run_outside
 
 
 		### Register the receiver as needing to be run after +other_plugins+ for requests, and
 		### *before* them for responses.
-		def run_after( *other_plugins )
+		def run_inside( *other_plugins )
 			self.log.debug "  %p will run after %p" % [ self, other_plugins ]
 			self.successors.merge( other_plugins )
 		end
+		alias_method :run_after, :run_inside
 
 	end # module Plugin
 
@@ -244,7 +246,7 @@ module Strelka
 
 
 		### Install the mixin part of the plugin, in the order determined by
-		### the plugin registry based on the run_before and run_after specifications
+		### the plugin registry based on the run_outside and run_inside specifications
 		### of the plugins themselves.
 		def install_plugins
 			if self.plugins_installed?