utopia 0.9.17

data/lib/utopia/middleware/directory_index.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'utopia/middleware'
+require 'utopia/path'
+
+module Utopia
+	module Middleware
+
+		class DirectoryIndex
+			def initialize(app, options = {})
+				@app = app
+				@root = options[:root] || Utopia::Middleware::default_root
+				
+				@files = ["index.html"]
+				
+				@default = "index"
+			end
+
+			def call(env)
+				path = Path.create(env["PATH_INFO"])
+				
+				if path.directory?
+					# Check to see if one of the files exists in the requested directory
+					@files.each do |file|
+						if File.exist?(File.join(@root, path.components, file))
+							env["PATH_INFO"] = (path + file).to_s
+							return @app.call(env)
+						end
+					end
+				
+					# Use the default path
+					env["PATH_INFO"] = (path + @default).to_s
+					return @app.call(env)
+				else
+					return @app.call(env)
+				end
+			end
+		end
+
+	end
+end

data/lib/utopia/middleware/localization.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'utopia/middleware'
+require 'utopia/response_helper'
+require 'utopia/middleware/localization/name'
+
+module Rack
+	class Request
+		def current_locale
+			env["utopia.current_locale"]
+		end
+		
+		def all_locales
+			localization.all_locales
+		end
+		
+		def localization
+			env["utopia.localization"]
+		end
+	end
+end
+
+module Utopia
+	module Middleware
+
+		class Localization
+			def initialize(app, options = {})
+				@app = app
+
+				@default_locale = options[:default] || "en"
+				@all_locales = options[:all] || ["en"]
+			end
+
+			def named_locale(resource_name)
+				Name.extract_locale(resource_name, @all_locales)
+			end
+			
+			def current_locale(env, resource_name)
+				Rack::Request.new(env).GET["locale"] || named_locale(resource_name) || @default_locale
+			end
+
+			attr :all_locales
+			attr :default_locale
+
+			def call(env)
+				path = Path.create(env["PATH_INFO"])
+
+				request_locale = current_locale(env, path.basename)
+				resource_name = Name.nonlocalized(path.basename, @all_locales).join(".")
+
+				env["utopia.current_locale"] = request_locale
+				env["utopia.localization"] = self
+
+				localized_name = Name.localized(resource_name, request_locale, @all_locales).join(".")
+
+				localization_probe = env.dup
+				localization_probe["REQUEST_METHOD"] = "HEAD"
+				localization_probe["PATH_INFO"] = (path.dirname + localized_name).to_s
+
+				response = @app.call(localization_probe)
+
+				if response[0] < 300
+					if path.basename == localized_name
+						return @app.call(env)
+					else
+						return [307, {"Location" => localization_probe["PATH_INFO"]}, []]
+					end
+				elsif response[0] < 400
+					return response
+				else
+					if path.basename == resource_name
+						return @app.call(env)
+					else
+						return [307, {"Location" => (path.dirname + resource_name).to_s}, []]
+					end
+				end
+			end
+		end
+
+	end
+end

data/lib/utopia/middleware/localization/name.rb

@@ -0,0 +1,64 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Utopia
+	module Middleware
+		class Localization
+			
+			module Name
+				def self.nonlocalized(resource_name, all_locales)
+					resource_name = resource_name.split(".") unless resource_name.kind_of? Array
+
+					# We either have a file extension or an existing locale
+					if all_locales.include?(resource_name[-1])
+						resource_name.delete_at(-1)
+					elsif all_locales.include?(resource_name[-2])
+						resource_name.delete_at(-2)
+					end
+
+					resource_name
+				end
+
+				def self.extract_locale(resource_name, all_locales)
+					resource_name = resource_name.split(".") unless resource_name.kind_of? Array
+
+					# We either have a file extension or an existing locale
+					if all_locales.include?(resource_name[-1])
+						return resource_name[-1]
+					elsif all_locales.include?(resource_name[-2])
+						return resource_name[-2]
+					end
+					
+					return nil
+				end
+
+				def self.localized(resource_name, locale, all_locales)
+					nonlocalized_name = nonlocalized(resource_name, all_locales)
+
+					if locale == nil
+						return nonlocalized_name
+					end
+
+					if nonlocalized_name.size == 1
+						return nonlocalized_name.push(locale)
+					else
+						return nonlocalized_name.insert(-2, locale)
+					end
+				end
+			end
+			
+		end
+	end
+end

data/lib/utopia/middleware/logger.rb

@@ -0,0 +1,68 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'utopia/middleware'
+require 'utopia/time_store'
+
+module Utopia
+	module Middleware
+
+		class Logger
+			ACCESS_LOG = "access_log"
+			HEADER = [:ip, :agent, :method, :url, :status, :location, :length]
+
+			def write_log(env, response)
+				request = Rack::Request.new(env)
+
+				record = {
+					:ip => request.ip,
+					:host => request.host,
+					:url => request.url,
+					:agent => env['HTTP_USER_AGENT'],
+					:status => response[0],
+					:method => request.request_method,
+					:user => env['REMOTE_USER'],
+					:version => env['HTTP_VERSION']
+				}
+
+				if response[1].key? "Location"
+					record[:location] = response[1]["Location"]
+				end
+				
+				if response[1].key? "Content-Length"
+					record[:length] = response[1]["Content-Length"]
+				end
+
+				@log << record
+			end
+
+			def initialize(app, options = {})
+				@app = app
+				
+				@log = options[:log] || TimeStore.new(options[:path] || ACCESS_LOG, options[:header] || HEADER)
+			end
+
+			def call(env)
+				response = @app.call(env)
+
+				Thread.new do
+					write_log(env, response)
+				end
+
+				return response
+			end
+		end
+	end
+end

data/lib/utopia/middleware/redirector.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'utopia/middleware'
+
+module Utopia
+	module Middleware
+
+		class FailedRequestError < StandardError
+			def initialize(resource_path, resource_status, error_path, error_status)
+				@resource_path = resource_path
+				@resource_status = resource_status
+
+				@error_path = error_path
+				@error_status = error_status
+			end
+
+			def to_s
+				"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
+					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
+			private
+			def normalize_keys(redirects)
+				redirects.each do |key, value|
+					result = nil
+
+					case value
+					when String
+						result = @strings
+					when Regexp
+						result = @patterns
+					else
+						$stderr.puts "Warning, could not process redirect #{key.inspect} to #{value.inspect}!"
+						next
+					end
+
+					if key.kind_of? Array
+						key.each do |subkey|
+							result[subkey]  = value
+						end
+					else
+						result[key] = value
+					end
+				end
+			end
+
+			public
+			def initialize(app, options = {})
+				@app = app
+
+				@strings = {}
+				@patterns = {}
+
+				normalize_keys(options[:redirects]) if options[:redirects]
+
+				@errors = options[:errors]
+
+				LOG.info "#{self.class.name}: Running with #{@strings.size + @patterns.size} rules"
+			end
+
+			def redirect(uri, match_data)
+				if uri.respond_to? :call
+					return uri.call(match_data)
+				else
+					return [301, {"Location" => uri.to_s}, []]
+				end
+			end
+
+			def call(env)
+				base_path = env['PATH_INFO']
+
+				if uri = @strings[base_path]
+					return redirect(@strings[base_path], base_path)
+				end
+
+				@patterns.each do |pattern, uri|
+					if match_data = base_path.match(pattern)
+						return redirect(uri, match_data)
+					end
+				end
+
+				response = @app.call(env)
+
+				if @errors && response[0] >= 400 && uri = @errors[response[0]]
+					error_request = env.merge("PATH_INFO" => uri, "REQUEST_METHOD" => "GET")
+					error_response = @app.call(error_request)
+
+					if error_response[0] >= 400
+						raise FailedRequestError.new(env['PATH_INFO'], response[0], uri, error_response[0])
+					else
+						# Feed the error code back with the error document
+						error_response[0] = response[0]
+						return error_response
+					end
+				else
+					return response
+				end
+			end
+		end
+
+	end
+end