strelka 0.0.1.pre129 → 0.0.1.pre148

data/lib/strelka/httpresponse/negotiation.rb

@@ -1,4 +1,6 @@
-#!usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'set'
 require 'yaml'
@@ -10,7 +12,7 @@ require 'strelka/httpresponse' unless defined?( Strelka::HTTPResponse )
 
 
 # The mixin that adds methods to Strelka::HTTPResponse for content-negotiation.
-# 
+#
 #    response = request.response
 #    response.for( 'text/html' ) {...}
 #    response.for( :json ) {...}
@@ -187,7 +189,7 @@ module Strelka::HTTPResponse::Negotiation
 		#   value of "ISO-8859-1" when received via HTTP. [RFC2616 3.7.1]
 		if charset == Encoding::ASCII_8BIT
 			return true unless self.content_type.start_with?( 'text/' )
-			charset = Encoding::ISO8859_1 
+			charset = Encoding::ISO8859_1
 		end
 
 		answer = req.accepts_charset?( charset )
@@ -214,7 +216,7 @@ module Strelka::HTTPResponse::Negotiation
 		return true if self.languages.empty?
 
 		# If any of the languages present for the body are accepted, the
-		# request is acceptable. Or at least that's what I got out of 
+		# request is acceptable. Or at least that's what I got out of
 		# reading RFC2616, Section 14.4.
 		answer = self.languages.any? {|lang| req.accepts_language?(lang) }
 		self.log.warn "Content-language %p NOT acceptable: %s" %
@@ -225,7 +227,7 @@ module Strelka::HTTPResponse::Negotiation
 	alias_method :has_acceptable_language?, :acceptable_language?
 
 
-	### Returns true if all of the receiver's #encodings were designated 
+	### Returns true if all of the receiver's #encodings were designated
 	### as acceptable by the originating request, if there was no originating
 	### request, or if no #encodings have been set.
 	def acceptable_encoding?
@@ -255,7 +257,7 @@ module Strelka::HTTPResponse::Negotiation
 	### the desired mimetype, and should return the new value for the entity
 	### body if it successfully transformed the body, or a false value if
 	### the next alternative should be tried instead.
-	### If successful, the response's body will be set to the new value, 
+	### If successful, the response's body will be set to the new value,
 	### its content_type set to the new mimetype, and its status changed
 	### to HTTP::OK.
 	def for( *mediatypes, &callback )
@@ -269,7 +271,7 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### Returns Strelka::HTTPRequest::MediaType objects for mediatypes that have 
+	### Returns Strelka::HTTPRequest::MediaType objects for mediatypes that have
 	### a higher qvalue than the current response's entity body (if any).
 	def better_mediatypes
 		req = self.request or return []
@@ -294,11 +296,11 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### Iterate over the originating request's acceptable content types in 
+	### Iterate over the originating request's acceptable content types in
 	### qvalue+listed order, looking for a content negotiation callback for
 	### each mediatype. If any are found, they are tried in declared order
 	### until one returns a true-ish value, which becomes the new entity
-	### body. If the body object is not a String, 
+	### body. If the body object is not a String,
 	def transform_content_type
 		return if self.mediatype_callbacks.empty?
 
@@ -362,7 +364,7 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### Returns Strelka::HTTPRequest::Language objects for natural languages that have 
+	### Returns Strelka::HTTPRequest::Language objects for natural languages that have
 	### a higher qvalue than the current response's entity body (if any).
 	def better_languages
 		req = self.request or return []
@@ -389,8 +391,8 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### If there are any languages that have a higher qvalue than the one/s in #languages, 
-	### look for a negotiation callback that provides that language. If any are found, they 
+	### If there are any languages that have a higher qvalue than the one/s in #languages,
+	### look for a negotiation callback that provides that language. If any are found, they
 	### are tried in declared order until one returns a true-ish value, which becomes the new
 	### entity body.
 	def transform_language
@@ -425,7 +427,7 @@ module Strelka::HTTPResponse::Negotiation
 	# :section: Charset negotiation callbacks
 	#
 
-	### Returns Strelka::HTTPRequest::Charset objects for accepted character sets that have 
+	### Returns Strelka::HTTPRequest::Charset objects for accepted character sets that have
 	### a higher qvalue than the one used by the current response.
 	def better_charsets
 		req = self.request or return []
@@ -453,7 +455,7 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### Iterate over the originating request's acceptable charsets in 
+	### Iterate over the originating request's acceptable charsets in
 	### qvalue+listed order, attempting to transcode the current entity body
 	### if it
 	def transform_charset
@@ -522,7 +524,7 @@ module Strelka::HTTPResponse::Negotiation
 	end
 
 
-	### Returns Strelka::HTTPRequest::Encoding objects for accepted encodings that have 
+	### Returns Strelka::HTTPRequest::Encoding objects for accepted encodings that have
 	### a higher qvalue than the one used by the current response.
 	def better_encoding
 		req = self.request or return []

data/lib/strelka/httpresponse/session.rb

@@ -0,0 +1,101 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'strelka/constants'
+require 'strelka/exceptions'
+require 'strelka/httpresponse' unless defined?( Strelka::HTTPResponse )
+
+
+# The mixin that adds methods to Strelka::HTTPResponse for session persistance.
+# If you create a response via the Request#response method, the session will
+# added to the response as well, and automatically saved after the handler and
+# all plugins have run. Or you can do so manually:
+#
+#    response = request.response
+#    response.save_session
+#
+# You can also clear the session with #destroy_session.
+#
+#
+#
+module Strelka::HTTPResponse::Session
+	include Strelka::Constants
+
+
+	### Initialize instance variables for session data in the response.
+	def initialize( * )
+		super
+		@session = nil
+		@session_namespace = nil
+	end
+
+
+	######
+	public
+	######
+
+	# The current session namespace
+	attr_reader :session_namespace
+
+
+	### The namespace that will be used when creating a session for this response
+	def session_namespace=( namespace )
+		self.log.debug "Setting session namespace to %p" % [ namespace ]
+		@session_namespace = namespace
+
+		# If the session has already been created, switch its current namespace
+		@session.namespace = namespace if @session
+	end
+
+
+	### Return the session associated with the response, creating it if necessary.
+	def session
+		unless @session
+			# Load the session from the associated request if there is one.
+			# If there isn't an associated request, this will just create a
+			# new blank session.
+			if self.request.session?
+				self.log.debug "Getting the request's session."
+				@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
+			end
+		end
+
+		return @session
+	end
+
+
+	### Set the request's session object.
+	def session=( new_session )
+		new_session.namespace = self.session_namespace
+		@session = new_session
+		request.session = new_session
+	end
+
+
+	### Returns +true+ if the response already has an associated session object.
+	def session?
+		return @session || self.request.session?
+	end
+
+
+	### 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 )
+		else
+			self.log.debug "No session to save."
+		end
+	end
+
+end # module Strelka::HTTPResponse::Session
+

data/lib/strelka/httpresponse.rb

@@ -1,7 +1,10 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'mongrel2/httpresponse'
 require 'strelka' unless defined?( Strelka )
+require 'strelka/cookieset'
 
 # An HTTP response class.
 class Strelka::HTTPResponse < Mongrel2::HTTPResponse
@@ -16,9 +19,10 @@ class Strelka::HTTPResponse < Mongrel2::HTTPResponse
 
 	### Add some instance variables to new HTTPResponses.
 	def initialize( * ) # :notnew:
-		@charset = nil
+		@charset   = nil
 		@languages = []
 		@encodings = []
+		@cookies   = nil
 
 		super
 	end
@@ -58,6 +62,7 @@ class Strelka::HTTPResponse < Mongrel2::HTTPResponse
 		self.add_content_type_charset( headers )
 		headers.content_encoding ||= self.encodings.join(', ') unless self.encodings.empty?
 		headers.content_language ||= self.languages.join(', ') unless self.languages.empty?
+		self.add_cookie_headers( headers )
 
 		return headers
 	end
@@ -73,6 +78,14 @@ class Strelka::HTTPResponse < Mongrel2::HTTPResponse
 	end
 
 
+	### Returns a Strelka::CookieSet that can be used to manipulate the cookies that are
+	### sent with the response, creating it if necessary.
+	def cookies
+		@cookies = Strelka::CookieSet.new unless @cookies
+		return @cookies
+	end
+
+
 
 	#########
 	protected
@@ -94,9 +107,9 @@ class Strelka::HTTPResponse < Mongrel2::HTTPResponse
 	### associated with the entity body, then the default external encoding (if it's set). If
 	### none of those are found, this method returns ISO-8859-1.
 	def find_header_charset
-		return ( self.charset || 
+		return ( self.charset ||
 		         self.content_type_charset ||
-		         self.entity_body_charset || 
+		         self.entity_body_charset ||
 		         Encoding.default_external ||
 		         Encoding::ISO_8859_1 )
 	end
@@ -135,6 +148,15 @@ class Strelka::HTTPResponse < Mongrel2::HTTPResponse
 		return nil
 	end
 
+
+	### Add Set-Cookie members to +headers+ if the response has any cookies.
+	def add_cookie_headers( headers )
+		return unless @cookies
+		@cookies.each do |cookie|
+			headers.append( :set_cookie => cookie.to_s )
+		end
+	end
+
 end # class Strelka::HTTPResponse
 
 

data/lib/strelka/logging.rb

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

data/lib/strelka/mixins.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'logger'
 
@@ -118,7 +120,7 @@ module Strelka
 		end
 
 
-		### Colorize the given +string+ with the specified +attributes+ and return it, handling 
+		### Colorize the given +string+ with the specified +attributes+ and return it, handling
 		### line-endings, color reset, etc.
 		def colorize( *args )
 			string = ''
@@ -190,6 +192,176 @@ module Strelka
 	end # module AbstractClass
 
 
+	# A collection of various delegation code-generators that can be used to define
+	# delegation through other methods, to instance variables, etc.
+	module Delegation
+
+		###############
+		module_function
+		###############
+
+		### Define the given +delegated_methods+ as delegators to the like-named method
+		### of the return value of the +delegate_method+.
+		###
+		###    class MyClass
+		###      extend Strelka::Delegation
+		###
+		###      # Delegate the #bound?, #err, and #result2error methods to the connection
+		###      # object returned by the #connection method. This allows the connection
+		###      # to still be loaded on demand/overridden/etc.
+		###      def_method_delegators :connection, :bound?, :err, :result2error
+		###
+		###      def connection
+		###        @connection ||= self.connect
+		###      end
+		###    end
+		###
+		def def_method_delegators( delegate_method, *delegated_methods )
+			delegated_methods.each do |name|
+				body = make_method_delegator( delegate_method, name )
+				define_method( name, &body )
+			end
+		end
+
+
+		### Define the given +delegated_methods+ as delegators to the like-named method
+		### of the specified +ivar+. This is pretty much identical with how 'Forwardable'
+		### from the stdlib does delegation, but it's reimplemented here for consistency.
+		###
+		###    class MyClass
+		###      extend Strelka::Delegation
+		###
+		###      # Delegate the #each method to the @collection ivar
+		###      def_ivar_delegators :@collection, :each
+		###
+		###    end
+		###
+		def def_ivar_delegators( ivar, *delegated_methods )
+			delegated_methods.each do |name|
+				body = make_ivar_delegator( ivar, name )
+				define_method( name, &body )
+			end
+		end
+
+
+		#######
+		private
+		#######
+
+		### Make the body of a delegator method that will delegate to the +name+ method
+		### of the object returned by the +delegate+ method.
+		def make_method_delegator( delegate, name )
+			error_frame = caller(5)[0]
+			file, line = error_frame.split( ':', 2 )
+
+			# Ruby can't parse obj.method=(*args), so we have to special-case setters...
+			if name.to_s =~ /(\w+)=$/
+				name = $1
+				code = <<-END_CODE
+				lambda {|*args| self.#{delegate}.#{name} = *args }
+				END_CODE
+			else
+				code = <<-END_CODE
+				lambda {|*args,&block| self.#{delegate}.#{name}(*args,&block) }
+				END_CODE
+			end
+
+			return eval( code, nil, file, line.to_i )
+		end
+
+
+		### Make the body of a delegator method that will delegate calls to the +name+
+		### method to the given +ivar+.
+		def make_ivar_delegator( ivar, name )
+			error_frame = caller(5)[0]
+			file, line = error_frame.split( ':', 2 )
+
+			# Ruby can't parse obj.method=(*args), so we have to special-case setters...
+			if name.to_s =~ /(\w+)=$/
+				name = $1
+				code = <<-END_CODE
+				lambda {|*args| #{ivar}.#{name} = *args }
+				END_CODE
+			else
+				code = <<-END_CODE
+				lambda {|*args,&block| #{ivar}.#{name}(*args,&block) }
+				END_CODE
+			end
+
+			return eval( code, nil, file, line.to_i )
+		end
+
+	end # module Delegation
+
+
+	# A collection of miscellaneous functions that are useful for manipulating
+	# complex data structures.
+	module DataUtilities
+
+		###############
+		module_function
+		###############
+
+		### Recursively copy the specified +obj+ and return the result.
+		def deep_copy( obj )
+
+			# Handle mocks during testing
+			return obj if obj.class.name == 'RSpec::Mocks::Mock'
+
+			return case obj
+				when NilClass, Numeric, TrueClass, FalseClass, Symbol
+					obj
+
+				when Array
+					obj.map {|o| deep_copy(o) }
+
+				when Hash
+					newhash = {}
+					obj.each do |k,v|
+						newhash[ deep_copy(k) ] = deep_copy( v )
+					end
+					newhash
+
+				else
+					obj.clone
+				end
+		end
+
+	end # module DataUtilities
+
+
+	# A collection of methods for declaring other methods.
+	module MethodUtilities
+
+		### Creates instance variables and corresponding methods that return their
+		### values for each of the specified +symbols+ in the singleton of the
+		### declaring object (e.g., class instance variables and methods if declared
+		### in a Class).
+		def singleton_attr_reader( *symbols )
+			symbols.each do |sym|
+				singleton_class.__send__( :attr_reader, sym )
+			end
+		end
+
+		### Creates methods that allow assignment to the attributes of the singleton
+		### of the declaring object that correspond to the specified +symbols+.
+		def singleton_attr_writer( *symbols )
+			symbols.each do |sym|
+				singleton_class.__send__( :attr_writer, sym )
+			end
+		end
+
+		### Creates readers and writers that allow assignment to the attributes of
+		### the singleton of the declaring object that correspond to the specified
+		### +symbols+.
+		def singleton_attr_accessor( *symbols )
+			symbols.each do |sym|
+				singleton_class.__send__( :attr_accessor, sym )
+			end
+		end
+
+	end # module MethodUtilities
+
 end # module Strelka
 
 # vim: set nosta noet ts=4 sw=4:

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

@@ -1,4 +1,7 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
 #encoding: utf-8
 
 require 'uri'
@@ -12,7 +15,7 @@ require 'strelka/app' unless defined?( Strelka::App )
 
 
 # A validator for user parameters.
-# 
+#
 # == Usage
 #
 #   require 'strelka/app/formvalidator'
@@ -24,20 +27,20 @@ require 'strelka/app' unless defined?( Strelka::App )
 #     :filters		=> [:strip, :squeeze],
 #     :untaint_all_constraints => true,
 #     :descriptions	=> {
-#     	:email			=> "Customer Email",
-#     	:description	=> "Issue Description",
-#     	:name			=> "Customer Name",
+#       :email          => "Customer Email",
+#       :description    => "Issue Description",
+#       :name           => "Customer Name",
 #     },
-#     :constraints	=> {
-#     	:email	=> :email,
-#     	:name	=> /^[\x20-\x7f]+$/,
-#     	:description => /^[\x20-\x7f]+$/,
+#     :constraints  => {
+#       :email  => :email,
+#       :name   => /^[\x20-\x7f]+$/,
+#       :description => /^[\x20-\x7f]+$/,
 #     },
 #	}
 #
 #	# Create a validator object and pass in a hash of request parameters and the
 #	# profile hash.
-#   validator = Strelka::App::ParamValidator.new
+#   validator = Strelka::ParamValidator.new
 #	validator.validate( req_params, profile )
 #
 #	# Now if there weren't any errors, send the success page
@@ -51,7 +54,7 @@ require 'strelka/app' unless defined?( Strelka::App )
 #		return failure_template
 #	end
 #
-class Strelka::App::ParamValidator < ::FormValidator
+class Strelka::ParamValidator < ::FormValidator
 	extend Forwardable
 	include Strelka::Loggable
 
@@ -64,7 +67,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 	#
 	# RFC822 Email Address Regex
 	# --------------------------
-	# 
+	#
 	# Originally written by Cal Henderson
 	# c.f. http://iamcal.com/publish/articles/php/parsing_email/
 	#
@@ -72,7 +75,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 	#
 	# Licensed under a Creative Commons Attribution-ShareAlike 2.5 License
 	# http://creativecommons.org/licenses/by-sa/2.5/
-	# 
+	#
 	RFC822_EMAIL_ADDRESS = begin
 		qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
 		dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
@@ -134,7 +137,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 	###	I N S T A N C E   M E T H O D S
 	#################################################################
 
-	### Create a new Strelka::App::ParamValidator object.
+	### Create a new Strelka::ParamValidator object.
 	def initialize( profile, params=nil )
 		@form                = {}
 		@raw_form            = {}
@@ -215,7 +218,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 
 		if additional_profile
 			self.log.debug "Merging additional profile %p" % [additional_profile]
-			profile = @profile.merge( additional_profile ) 
+			profile = @profile.merge( additional_profile )
 		end
 
 		super( params, profile )
@@ -270,8 +273,8 @@ class Strelka::App::ParamValidator < ::FormValidator
 	### Returns +true+ if the given +field+ is one that should be untainted.
 	def untaint?( field )
 		self.log.debug "Checking to see if %p should be untainted." % [field]
-		rval = ( @untaint_all || 
-			@untaint_fields.include?(field) || 
+		rval = ( @untaint_all ||
+			@untaint_fields.include?(field) ||
 			@untaint_fields.include?(field.to_sym) )
 
 		if rval
@@ -530,7 +533,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 			when Proc, Method
 				apply_proc_constraint( key, constraint )
 			when Regexp
-				apply_regexp_constraint( key, constraint ) 
+				apply_regexp_constraint( key, constraint )
 			else
 				raise "unknown constraint type %p" % [constraint]
 			end
@@ -585,7 +588,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 	end
 
 
-	### Apply a constraint that was specified as a Proc to the value for the given 
+	### Apply a constraint that was specified as a Proc to the value for the given
 	### +key+
 	def apply_proc_constraint( key, constraint, *params )
 		value = nil
@@ -642,7 +645,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 		key.untaint
 
 		# Have to test for nil because valid values might be false.
-		if !value.nil? 
+		if !value.nil?
 			self.log.debug "Setting form value for %p to %p (constraint was %p)" %
 				[ key, value, constraint ]
 			if self.untaint?( key )
@@ -675,7 +678,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 
 	### Formvalidator hack:
 	### The formvalidator filters method has a bug where he assumes an array
-	###	 when it is in fact a string for multiple values (ie anytime you have a 
+	###	 when it is in fact a string for multiple values (ie anytime you have a
 	###	 text-area with newlines in it).
 	def filters
 		@filters_array = Array(@profile[:filters]) unless(@filters_array)
@@ -745,7 +748,7 @@ class Strelka::App::ParamValidator < ::FormValidator
 		end
 	end
 
-end # class Strelka::App::ParamValidator
+end # class Strelka::ParamValidator
 
 
 

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

@@ -1,11 +1,13 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'strelka' unless defined?( Strelka )
 require 'strelka/app' unless defined?( Strelka::App )
-require 'strelka/app/router'
+require 'strelka/router'
 
 # Simple (dumb?) request router for Strelka::App-based applications.
-class Strelka::App::DefaultRouter < Strelka::App::Router
+class Strelka::Router::Default < Strelka::Router
 	include Strelka::Loggable
 
 	### Create a new router that will route requests according to the specified
@@ -101,4 +103,4 @@ class Strelka::App::DefaultRouter < Strelka::App::Router
 
 	end
 
-end # class Strelka::App::DefaultRouter
+end # class Strelka::Router::Default

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

@@ -1,9 +1,11 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
 
 require 'strelka' unless defined?( Strelka )
 require 'strela/app' unless defined?( Strelka::App )
 
-require 'strelka/app/defaultrouter'
+require 'strelka/router/default'
 
 # Alternative (stricter) router strategy for Strelka::App::Routing plugin.
 #
@@ -21,7 +23,7 @@ require 'strelka/app/defaultrouter'
 #
 #     end # class MyApp
 #
-class Strelka::App::ExclusiveRouter < Strelka::App::DefaultRouter
+class Strelka::Router::Exclusive < Strelka::Router::Default
 	include Strelka::Loggable
 
 	######
@@ -37,4 +39,4 @@ class Strelka::App::ExclusiveRouter < Strelka::App::DefaultRouter
 		self.routes[ verb ][ re ] = route
 	end
 
-end # class Strelka::App::DefaultRouter
+end # class Strelka::Router::Default