utopia 0.12.5 → 0.12.6

data/lib/utopia/middleware/controller.rb

@@ -18,9 +18,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'utopia/middleware'
-require 'utopia/path'
-require 'utopia/http'
+require_relative 'controller/variables'
+require_relative 'controller/action'
+require_relative 'controller/base'
 
 class Rack::Request
 	def controller(&block)
@@ -35,210 +35,7 @@ end
 module Utopia
 	module Middleware
 		class Controller
-			CONTROLLER_RB = "controller.rb"
-
-			class Variables
-				def initialize
-					@controllers = [Object.new]
-				end
-
-				def << controller
-					@controllers << controller
-				end
-
-				def fetch(key)
-					@controllers.reverse_each do |controller|
-						if controller.instance_variables.include?(key)
-							return controller.instance_variable_get(key)
-						end
-					end
-					
-					if block_given?
-						yield key
-					else
-						raise KeyError.new(key)
-					end
-				end
-
-				def to_hash
-					attributes = {}
-
-					@controllers.each do |controller|
-						controller.instance_variables.each do |name|
-							key = name[1..-1]
-							
-							# Instance variables that start with an underscore are considered private and not exposed:
-							next if key.start_with?('_')
-							
-							attributes[key] = controller.instance_variable_get(name)
-						end
-					end
-
-					return attributes
-				end
-
-				def [] key
-					fetch("@#{key}".to_sym) { nil }
-				end
-				
-				# Deprecated - to support old code:
-				def []= key, value
-					@controllers.first.instance_variable_set("@#{key}".to_sym, value)
-				end
-			end
-
-			class Base
-				def initialize(controller)
-					@_controller = controller
-					@_actions = {}
-
-					methods.each do |method_name|
-						next unless method_name.match(/on_(.*)$/)
-
-						action($1.split("_")) do |path, request|
-							# LOG.debug("Controller: #{method_name}")
-							self.send(method_name, path, request)
-							
-							# Don't pass the result back, instead use pass! or respond!
-							nil
-						end
-					end
-				end
-
-				def action(path, options = {}, &block)
-					cur = @_actions
-
-					path.reverse.each do |name|
-						cur = cur[name] ||= {}
-					end
-
-					cur[:action] = Proc.new(&block)
-				end
-
-				def lookup(path)
-					cur = @_actions
-
-					path.components.reverse.each do |name|
-						cur = cur[name]
-
-						return nil if cur == nil
-
-						if action = cur[:action]
-							return action
-						end
-					end
-				end
-
-				# Given a request, call an associated action if one exists.
-				def passthrough(path, request)
-					action = lookup(path)
-
-					if action
-						variables = request.controller
-						clone = self.dup
-						
-						variables << clone
-						
-						response = catch(:response) do
-							clone.instance_exec(path, request, &action)
-							
-							# By default give nothing - i.e. keep on processing:
-							nil
-						end
-						
-						if response
-							return clone.respond_with(*response)
-						end
-					end
-
-					return nil
-				end
-
-				def call(env)
-					@_controller.app.call(env)
-				end
-
-				def respond!(*args)
-					throw :response, args
-				end
-
-				def ignore!
-					throw :response, nil
-				end
-
-				def redirect! (target, status = 302)
-					respond! :redirect => target, :status => status
-				end
-
-				def fail!(error = :bad_request)
-					respond! error
-				end
-
-				def success!(*args)
-					respond! :success, *args
-				end
-
-				def respond_with(*args)
-					return args[0] if args[0] == nil || Array === args[0]
-
-					status = 200
-					options = nil
-
-					if Numeric === args[0] || Symbol === args[0]
-						status = args[0]
-						options = args[1] || {}
-					else
-						options = args[0]
-						status = options[:status] || status
-					end
-
-					status = Utopia::HTTP::STATUS_CODES[status] || status
-					headers = options[:headers] || {}
-
-					if options[:type]
-						headers['Content-Type'] ||= options[:type]
-					end
-
-					if options[:redirect]
-						headers["Location"] = options[:redirect]
-						status = 302 if status < 300 || status >= 400
-					end
-
-					body = []
-					if options[:body]
-						body = options[:body]
-					elsif options[:content]
-						body = [options[:content]]
-					elsif status >= 300
-						body = [Utopia::HTTP::STATUS_DESCRIPTIONS[status] || "Status #{status}"]
-					end
-
-					# Utopia::LOG.debug([status, headers, body].inspect)
-					return [status, headers, body]
-				end
-				
-				def direct?(path)
-					path.dirname == self.class.uri_path
-				end
-				
-				def process!(path, request)
-					return nil unless direct?(path)
-					
-					passthrough(path, request)
-				end
-				
-				def self.base_path
-					self.const_get(:BASE_PATH)
-				end
-				
-				def self.uri_path
-					self.const_get(:URI_PATH)
-				end
-				
-				def self.require_local(path)
-					require File.join(base_path, path)
-				end
-			end
+			CONTROLLER_RB = "controller.rb".freeze
 
 			def initialize(app, options = {})
 				@app = app
@@ -246,41 +43,32 @@ module Utopia
 
 				@controllers = {}
 				@cache_controllers = (UTOPIA_ENV == :production)
-
-				if options[:controller_file]
-					@controller_file = options[:controller_file]
-				else
-					@controller_file = "controller.rb"
-				end
 			end
-
+			
 			attr :app
-
-			def lookup(path)
+			
+			def lookup_controller(path)
 				if @cache_controllers
 					return @controllers.fetch(path.to_s) do |key|
-						@controllers[key] = load_file(path)
+						@controllers[key] = load_controller_file(path)
 					end
 				else
-					return load_file(path)
+					return load_controller_file(path)
 				end
 			end
-
-			def load_file(path)
-				if path.directory?
-					uri_path = path
-					base_path = File.join(@root, uri_path.components)
-				else
-					uri_path = path.dirname
-					base_path = File.join(@root, uri_path.components)
-				end
-
+			
+			def load_controller_file(path)
+				uri_path = path
+				base_path = File.join(@root, uri_path.components)
+				
 				controller_path = File.join(base_path, CONTROLLER_RB)
-
+				# puts "load_controller_file(#{path.inspect}) => #{controller_path}"
+				
 				if File.exist?(controller_path)
 					klass = Class.new(Base)
 					klass.const_set(:BASE_PATH, base_path)
 					klass.const_set(:URI_PATH, uri_path)
+					klass.const_set(:CONTROLLER, self)
 					
 					$LOAD_PATH.unshift(base_path)
 					
@@ -288,34 +76,53 @@ module Utopia
 					
 					$LOAD_PATH.delete(base_path)
 					
-					return klass.new(self)
+					return klass.new
 				else
 					return nil
 				end
 			end
-
-			def fetch_controllers(path)
-				controllers = []
-
-				path.ascend do |parent_path|
-					controllers << lookup(parent_path)
+			
+			def invoke_controllers(variables, request, done = Set.new)
+				path = Path.create(request.path_info)
+				controller_path = Path.new
+				
+				path.descend do |controller_path|
+					# puts "Invoke controller: #{controller_path}"
+					if controller = lookup_controller(controller_path)
+						# We only want to invoke controllers which have not already been invoked:
+						unless done.include? controller
+							# If we get throw :rewrite, location, the URL has been rewritten and we need to request again:
+							location = catch(:rewrite) do
+								# Invoke the controller and if it returns a result, send it back out:
+								if result = controller.process!(request, path)
+									return result
+								end
+							end
+							
+							if location
+								request.env['PATH_INFO'] = location.to_s
+								
+								return invoke_controllers(variables, request, done)
+							end
+							
+							done << controller
+						end
+					end
 				end
-
-				return controllers.compact.reverse
+				
+				# No controller gave a useful result:
+				return nil
 			end
-
+			
 			def call(env)
 				variables = (env["utopia.controller"] ||= Variables.new)
 				
 				request = Rack::Request.new(env)
-
-				path = Path.create(request.path_info)
-				fetch_controllers(path).each do |controller|
-					if result = controller.process!(path, request)
-						return result
-					end
+				
+				if result = invoke_controllers(variables, request)
+					return result
 				end
-
+				
 				return @app.call(env)
 			end
 		end

data/lib/utopia/middleware/directory_index.rb

@@ -23,7 +23,6 @@ require 'utopia/path'
 
 module Utopia
 	module Middleware
-
 		class DirectoryIndex
 			def initialize(app, options = {})
 				@app = app
@@ -52,6 +51,5 @@ module Utopia
 				end
 			end
 		end
-
 	end
 end

data/lib/utopia/middleware/exception_handler.rb

@@ -0,0 +1,80 @@
+# Copyright, 2014, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'utopia/middleware'
+require 'utopia/extensions/string'
+
+module Utopia
+	module Middleware
+		class ExceptionHandler
+			def initialize(app, location)
+				@app = app
+
+				@location = location
+			end
+
+			def fatal_error(env, ex)
+				body = StringIO.new
+
+				body.puts "<!DOCTYPE html><html><head><title>Fatal Error</title></head><body>"
+				body.puts "<h1>Fatal Error</h1>"
+				body.puts "<p>While requesting resource #{env['PATH_INFO'].to_html}, a fatal error occurred.</p>"
+				body.puts "<blockquote><strong>#{ex.class.name.to_html}</strong>: #{ex.to_s.to_html}</blockquote>"
+				body.puts "<p>There is nothing more we can do to fix the problem at this point.</p>"
+				body.puts "<p>We apologize for the inconvenience.</p>"
+				body.puts "</body></html>"
+				body.rewind
+
+				return [400, {"Content-Type" => "text/html"}, body]
+			end
+
+			def redirect(env, ex)
+				return @app.call(env.merge('PATH_INFO' => @location, 'REQUEST_METHOD' => 'GET'))
+			end
+
+			def call(env)
+				begin
+					return @app.call(env)
+				rescue Exception => ex
+					log = ::Logger.new(env['rack.errors'])
+					
+					log.error "Exception #{ex.to_s.dump}!"
+					
+					ex.backtrace.each do |bt|
+						log.error bt
+					end
+					
+					if env['PATH_INFO'] == @location
+						return fatal_error(env, ex)
+					else
+
+						# If redirection fails
+						begin
+							return redirect(env, ex)
+						rescue
+							return fatal_error(env, ex)
+						end
+
+					end
+				end
+			end
+		end
+	end
+end

data/lib/utopia/middleware/redirector.rb

@@ -38,63 +38,6 @@ module Utopia
 				"Requested resource #{@resource_path} resulted in a #{@resource_status} error. Requested error handler #{@error_path} resulted in a #{@error_status} error."
 			end
 		end
-		
-		class ExceptionHandler
-			def initialize(app, location)
-				@app = app
-
-				@location = location
-			end
-
-			def fatal_error(env, ex)
-				body = StringIO.new
-
-				body.puts "<!DOCTYPE html><html><head><title>Fatal Error</title></head><body>"
-				body.puts "<h1>Fatal Error</h1>"
-				body.puts "<p>While requesting resource #{env['PATH_INFO'].to_html}, a fatal error occurred.</p>"
-				body.puts "<blockquote><strong>#{ex.class.name.to_html}</strong>: #{ex.to_s.to_html}</blockquote>"
-				body.puts "<p>There is nothing more we can do to fix the problem at this point.</p>"
-				body.puts "<p>We apologize for the inconvenience.</p>"
-				body.puts "</body></html>"
-				body.rewind
-
-				return [400, {"Content-Type" => "text/html"}, body]
-			end
-
-			def redirect(env, ex)
-				return @app.call(env.merge('PATH_INFO' => @location, 'REQUEST_METHOD' => 'GET'))
-			end
-
-			def call(env)
-				begin
-					return @app.call(env)
-				rescue Exception => ex
-					log = ::Logger.new(env['rack.errors'])
-					
-					log.error "Exception #{ex.to_s.dump}!"
-					
-					ex.backtrace.each do |bt|
-						log.error bt
-					end
-					
-					if env['PATH_INFO'] == @location
-						return fatal_error(env, ex)
-					else
-
-						# If redirection fails
-						begin
-							return redirect(env, ex)
-						rescue
-							return fatal_error(env, ex)
-						end
-
-					end
-				end
-			end
-		end
-
-		# Legacy Support
-		ExceptionRedirector = ExceptionHandler
 
 		class Redirector
 			# Redirects a whole source tree to a destination tree, given by the roots.

data/lib/utopia/path.rb

@@ -19,7 +19,6 @@
 # THE SOFTWARE.
 
 module Utopia
-	
 	class Path
 		SEPARATOR = "/"
 
@@ -55,6 +54,8 @@ module Utopia
 				else
 					return Path.new(path.split(SEPARATOR))
 				end
+			when Symbol
+				return Path.new([path])
 			end
 		end
 
@@ -84,7 +85,7 @@ module Utopia
 			end
 		end
 
-		def to_s
+		def to_str
 			if @components == [""]
 				SEPARATOR
 			else
@@ -92,6 +93,14 @@ module Utopia
 			end
 		end
 
+		def to_s
+			to_str
+		end
+
+		def [] index
+			@components[index]
+		end
+
 		def join(other)
 			Path.new(@components + other).simplify
 		end
@@ -168,21 +177,30 @@ module Utopia
 			components.join(File::SEPARATOR)
 		end
 
+		def descend(&block)
+			return to_enum(:descend) unless block_given?
+			
+			parent_path = []
+			
+			components.each do |component|
+				parent_path << component
+				
+				yield self.class.new(parent_path)
+			end
+		end
+
 		def ascend(&block)
-			paths = []
+			return to_enum(:ascend) unless block_given?
 			
 			next_parent = self
-
+			
 			begin
 				parent = next_parent
 				
-				yield parent if block_given?
-				paths << parent
+				yield parent
 				
 				next_parent = parent.dirname
 			end until next_parent.eql?(parent)
-			
-			return paths
 		end
 
 		def split(at)
@@ -247,5 +265,4 @@ module Utopia
 			return Path.locale(last, extension)
 		end
 	end
-	
-end
+end

data/lib/utopia/setup/config.ru

@@ -3,7 +3,7 @@
 UTOPIA_ENV = (ENV['UTOPIA_ENV'] || ENV['RACK_ENV'] || :development).to_sym
 $LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
 
-require 'utopia/middleware/all'
+require 'utopia'
 
 # Utopia relies heavily on a local cache:
 require 'rack/cache'
@@ -16,7 +16,6 @@ else
 end
 
 use Rack::ContentLength
-use Utopia::Middleware::Logger
 
 use Utopia::Middleware::Redirector, {
 	:strings => {

data/lib/utopia/tags/all.rb

@@ -20,6 +20,8 @@
 
 require 'pathname'
 
+warn "require 'utopia/tags/all' is deprecated. Require specific tags instead."
+
 Pathname.new(__FILE__).dirname.entries.each do |path|
 	next unless /\.rb$/ === path.to_s
 	

data/lib/utopia/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Utopia
-	VERSION = "0.12.5"
+	VERSION = "0.12.6"
 end

data/lib/utopia.rb

@@ -20,5 +20,12 @@
 
 require 'utopia/version'
 
-module Utopia
-end
+require 'utopia/middleware/content'
+require 'utopia/middleware/controller'
+require 'utopia/middleware/directory_index'
+require 'utopia/middleware/exception_handler'
+require 'utopia/middleware/localization'
+require 'utopia/middleware/mail_exceptions'
+require 'utopia/middleware/redirector'
+require 'utopia/middleware/requester'
+require 'utopia/middleware/static'