utopia 0.12.6 → 1.0.0

data/lib/utopia/controller/base.rb

@@ -0,0 +1,174 @@
+# 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_relative '../http'
+
+module Utopia
+	class Controller
+		class Base
+			def self.base_path
+				self.const_get(:BASE_PATH)
+			end
+		
+			def self.uri_path
+				self.const_get(:URI_PATH)
+			end
+		
+			def self.controller
+				self.const_get(:CONTROLLER)
+			end
+			
+			class << self
+				def require_local(path)
+					require File.join(base_path, path)
+				end
+				
+				def direct?(path)
+					path.dirname == uri_path
+				end
+				
+				def actions
+					@actions ||= Action.new
+				end
+				
+				def on(path, options = {}, &block)
+					if Symbol === path
+						path = ['**', path]
+					end
+					
+					actions.define(Path.create(path).components, options, &block)
+				end
+				
+				def lookup(path)
+					possible_actions = actions.select((path - uri_path).components)
+				end
+			end
+			
+			# Given a path, look up all matched actions.
+			def lookup(path)
+				self.class.lookup(path)
+			end
+			
+			# Given a request, call associated actions if at least one exists.
+			def passthrough(request, path)
+				actions = lookup(path)
+				
+				if actions.size > 0
+					variables = request.controller
+					controller_clone = self.clone
+					
+					variables << controller_clone
+					
+					response = catch(:response) do
+						# By default give nothing - i.e. keep on processing:
+						actions.each do |action|
+							action.invoke!(controller_clone, request, path)
+						end and nil
+					end
+					
+					if response
+						return controller_clone.respond_with(*response)
+					end
+				end
+				
+				return nil
+			end
+
+			# Copy the instance variables from the previous controller to the next controller (usually only a few). This allows controllers to share effectively the same instance variables while still being separate classes/instances.
+			def copy_instance_variables(from)
+				from.instance_variables.each do |name|
+					instance_variable_set(name, from.instance_variable_get(name))
+				end
+			end
+
+			def call(env)
+				self.class.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.to_str, :status => status
+			end
+
+			def rewrite! location
+				throw :rewrite, location.to_str
+			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
+
+				return [status, headers, body]
+			end
+			
+			# Return nil if this controller didn't do anything. Request will keep on processing. Return a valid rack response if the controller can do so.
+			def process!(request, path)
+				# puts "process! #{request} #{path}"
+				passthrough(request, path)
+			end
+		end
+	end
+end

data/lib/utopia/{middleware/controller → controller}/variables.rb

@@ -19,53 +19,51 @@
 # THE SOFTWARE.
 
 module Utopia
-	module Middleware
-		class Controller
-			class Variables
-				def initialize
-					@controllers = []
-				end
+	class Controller
+		class Variables
+			def initialize
+				@controllers = []
+			end
 
-				def << controller
-					top = @controllers.last
-					
-					@controllers << controller
-					
-					# This ensures that most variables will be at the top and controllers can naturally interactive with instance variables.
-					controller.copy_instance_variables(top) if top
-				end
+			def << controller
+				top = @controllers.last
+				
+				@controllers << controller
+				
+				# This ensures that most variables will be at the top and controllers can naturally interactive with instance variables.
+				controller.copy_instance_variables(top) if top
+			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)
+			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 = {}
+			def to_hash
+				attributes = {}
 
-					@controllers.each do |controller|
-						controller.instance_variables.each do |name|
-							key = name[1..-1]
-							
-							attributes[key] = controller.instance_variable_get(name)
-						end
+				@controllers.each do |controller|
+					controller.instance_variables.each do |name|
+						key = name[1..-1]
+						
+						attributes[key] = controller.instance_variable_get(name)
 					end
-
-					return attributes
 				end
 
-				def [] key
-					fetch("@#{key}".to_sym) { nil }
-				end
+				return attributes
+			end
+
+			def [] key
+				fetch("@#{key}".to_sym) { nil }
 			end
 		end
 	end

data/lib/utopia/exception_handler.rb

@@ -0,0 +1,79 @@
+# 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_relative 'middleware'
+
+require 'trenni/strings'
+
+module Utopia
+	class ExceptionHandler
+		def initialize(app, location)
+			@app = app
+
+			@location = location
+		end
+
+		def fatal_error(env, exception)
+			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 #{Trenni::Strings::to_html env['PATH_INFO']}, a fatal error occurred.</p>"
+			body.puts "<blockquote><strong>#{Trenni::Strings::to_html exception.class.name}</strong>: #{Trenni::Strings::to_html exception.to_s}</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 => exception
+				# An error has occurred, log it:
+				log = ::Logger.new(env['rack.errors'] || $stderr)
+				
+				log.error "Exception #{exception.to_s.dump}!"
+				
+				ex.backtrace.each do |bt|
+					log.error bt
+				end
+				
+				# If the error occurred while accessing the error handler, we finish with a fatal error:
+				if env['PATH_INFO'] == @location
+					return fatal_error(env, ex)
+				else
+					# If redirection fails, we also finish with a fatal error:
+					begin
+						return redirect(env, ex)
+					rescue
+						return fatal_error(env, ex)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/utopia/extensions/array.rb

@@ -19,8 +19,8 @@
 # THE SOFTWARE.
 
 class Array
-	def split_at(&block)
-		if middle = index(&block)
+	def split_at(*args, &block)
+		if middle = index(*args, &block)
 			[self[0...middle], self[middle], self[middle+1..-1]]
 		else
 			[[], nil, []]

data/lib/utopia/localization.rb

@@ -0,0 +1,143 @@
+# Copyright, 2012, 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_relative 'middleware'
+
+module Rack
+	class Request
+		def current_locale
+			env[Utopia::Localization::CURRENT_LOCALE_KEY]
+		end
+		
+		def default_locale
+			localization.default_locale
+		end
+		
+		def all_locales
+			localization.all_locales
+		end
+		
+		def localization
+			env[Utopia::Localization::LOCALIZATION_KEY]
+		end
+	end
+end
+
+module Utopia
+	# If you request a URL which has localized content, a localized redirect would be returned based on the content requested.
+	class Localization
+		RESOURCE_NOT_FOUND = [400, {}, []].freeze
+		
+		HTTP_ACCEPT_LANGUAGE = 'HTTP_ACCEPT_LANGUAGE'.freeze
+		LOCALIZATION_KEY = 'utopia.localization'.freeze
+		CURRENT_LOCALE_KEY = 'utopia.localization.current_locale'.freeze
+		
+		def initialize(app, options = {})
+			@app = app
+
+			@default_locale = options[:default_locale] || "en"
+			@all_locales = options[:locales] || ["en"]
+			
+			@nonlocalized = options.fetch(:nonlocalized, [])
+		end
+
+		attr :all_locales
+		attr :default_locale
+		
+		def preferred_locales(env)
+			request_preferred_locales(env) | browser_preferred_locales(env) | [@default_locale, nil]
+		end
+		
+		def request_preferred_locales(env)
+			path = Path[env['PATH_INFO']]
+			
+			if all_locales.include? path.first
+				request_locale = path.first
+				
+				# Remove the localization prefix.
+				path.delete_at(0)
+				env['PATH_INFO'] = path.to_s
+				
+				return [request_locale]
+			else
+				return []
+			end
+		end
+		
+		def browser_preferred_locales(env)
+			accept_languages = env[HTTP_ACCEPT_LANGUAGE]
+			
+			# No user prefered languages:
+			return [] unless accept_languages
+
+			languages = accept_languages.split(',').map { |language|
+				language.split(';q=').tap{|x| x[1] = (x[1] || 1.0).to_f}
+			}.sort{|a, b| b[1] <=> a[1]}.collect(&:first)
+			
+			# Returns languages based on the order of the first argument
+			return languages & @all_locales
+		end
+		
+		def nonlocalized?(env)
+			path_info = env['PATH_INFO']
+			
+			@nonlocalized.any? { |pattern| path_info[pattern] != nil }
+		end
+		
+		# Set the Vary: header on the response to indicate that this response should include the header in the cache key.
+		def vary(env, response)
+			headers = response[1]
+			
+			# This response was based on the Accept-Language header:
+			if headers['Vary']
+				headers['Vary'] += ',Accept-Language'
+			else
+				headers['Vary'] = 'Accept-Language'
+			end
+			
+			# Althought this header is generally not supported, we supply it anyway as it is useful for debugging:
+			if locale = env[CURRENT_LOCALE_KEY]
+				# Set the Content-Location to point to the localized URI as requested:
+				headers['Content-Location'] = "/#{locale}" + env['PATH_INFO']
+			end
+			
+			return response
+		end
+		
+		def call(env)
+			return @app.call(env) if nonlocalized?(env)
+			
+			env[LOCALIZATION_KEY] = self
+			
+			response = nil
+			
+			# We have a non-localized request, but there might be a localized resource. We return the best localization possible:
+			preferred_locales(env).each do |locale|
+				env[CURRENT_LOCALE_KEY] = locale
+				
+				response = @app.call(env)
+				
+				break unless response[0] >= 400
+			end
+			
+			return vary(env, response)
+		end
+	end
+end