utopia 0.9.17

data/lib/utopia/middleware/requester.rb

@@ -0,0 +1,116 @@
+# 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 'set'
+
+module Utopia
+	module Middleware
+
+		class Requester
+			TTL_KEY = "utopia.requestor.ttl"
+			REQUESTOR_KEY = "utopia.requestor"
+			PATH_VARIABLES = Set.new
+			MAXIMUM_DEPTH = 5
+
+			class Response
+				def initialize(status, headers, body)
+					@status = status
+					@headers = headers
+					@body = body
+				end
+
+				attr :status
+				attr :headers
+
+				def body
+					unless @body_string
+						buffer = StringIO.new
+
+						@body.each do |string|
+							buffer.write(string)
+						end
+
+						@body_string = buffer.string
+					end
+
+					return @body_string
+				end
+
+				def [](key)
+					return @headers[key]
+				end
+
+				def okay?
+					@status == 200
+				end
+			end
+
+			class NoRequesterError < ArgumentError
+			end
+
+			def self.[](env)
+				requestor = env[REQUESTOR_KEY]
+				if requestor
+					return requestor
+				else
+					raise NoRequesterError
+				end
+			end
+
+			def initialize(app, env = {})
+				@app = app
+				@env = env
+				@env[TTL_KEY] = 0
+			end
+
+			attr :env, true
+
+			def call(env)
+				requestor = dup
+				env[REQUESTOR_KEY] = requestor
+				requestor.env = env.merge(@env)
+				requestor.env.delete("rack.request")
+
+				@app.call(env)
+			end
+
+			class RecursiveRequestError < StandardError
+			end
+
+			def request(env)
+				env = @env.merge(env)
+				env[TTL_KEY] += 1
+
+				if env[TTL_KEY].to_i > MAXIMUM_DEPTH
+					raise RecursiveRequestError, env["PATH_INFO"]
+				end
+
+				return Response.new(*@app.call(env))
+			end
+
+			def [](path, method = "GET", env = {})
+				path_env = {
+					"REQUEST_METHOD" => method,
+					"PATH_INFO" => path.to_s
+				}
+				request(env.merge(path_env))
+			end
+		end
+
+	end
+end
+

data/lib/utopia/middleware/static.rb

@@ -0,0 +1,186 @@
+# 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'
+
+require 'time'
+
+require 'mime/types'
+
+module Utopia
+	module Middleware
+
+		class Static
+			DEFAULT_TYPES = [
+				"html", "css", "js", "txt", "rtf", "xml",
+				"pdf", "zip", "tar", "tgz", "tar.gz", "tar.bz2", "dmg",
+				"mp3", "mp4", "wav", "aiff", ["aac", "audio/x-aac"], "mov", "avi", "wmv",
+				/^image/
+			]
+
+			private
+
+			class FileReader
+				def initialize(path)
+					@path = path
+				end
+
+				attr :path
+
+				def to_path
+					@path
+				end
+
+				def mtime_date
+					File.mtime(@path).httpdate
+				end
+
+				def size
+					File.size(@path)
+				end
+
+				def each
+					File.open(@path, "rb") do |fp|
+						while part = fp.read(8192)
+							yield part
+						end
+					end
+				end
+			end
+
+			def load_mime_types(types)
+				result = {}
+
+				extract_extensions = lambda do |mime_type|
+					mime_type.extensions.each{|ext| result["." + ext] = mime_type.content_type}
+				end
+
+				types.each do |type|
+					current_count = result.size
+					
+					begin
+						case type
+						when :defaults
+							result = load_mime_types(DEFAULT_TYPES).merge(result)
+						when Array
+							result["." + type[0]] = type[1]
+						when String
+							mt = MIME::Types.of(type).select{|mt| !mt.obsolete?}.each do |mt|
+								extract_extensions.call(mt)
+							end
+						when Regexp
+							MIME::Types[type].select{|mt| !mt.obsolete?}.each do |mt|
+								extract_extensions.call(mt)
+							end
+						when MIME::Type
+							extract_extensions.call(type)
+						end
+					rescue
+						LOG.error "#{self.class.name}: Error while processing #{type.inspect}!"
+						raise $!
+					end
+					
+					if result.size == current_count
+						LOG.warn "#{self.class.name}: Could not find any mime type for file extension #{type.inspect}"
+					end
+				end
+
+				return result
+			end
+
+			public
+			def initialize(app, options = {})
+				@app = app
+				@root = options[:root] || Utopia::Middleware::default_root
+
+				if options[:types]
+					@extensions = load_mime_types(options[:types])
+				else
+					@extensions = load_mime_types(DEFAULT_TYPES)
+				end
+				
+				LOG.info "#{self.class.name}: Running in #{@root} with #{extensions.size} filetypes"
+			end
+
+			def fetch_file(path)
+				file_path = File.join(@root, path.components)
+				if File.exist?(file_path)
+					return FileReader.new(file_path)
+				else
+					return nil
+				end
+			end
+
+			def lookup_relative_file(path)
+				file = nil
+				name = path.basename
+
+				if split = path.split("@rel@")
+					path = split[0]
+					name = split[1].components
+					
+					# Fix a problem if the browser request has multiple @rel@
+					# This normally indicates a browser bug.. :(
+					name.delete("@rel@")
+				else
+					path = path.dirname
+					
+					# Relative lookups are not done unless explicitly required by @rel@
+					# ... but they do work. This is a performance optimization.
+					return nil
+				end
+
+				# LOG.debug("Searching for #{name.inspect} starting in #{path.components}")
+
+				path.ascend do |parent_path|
+					file_path = File.join(@root, parent_path.components, name)
+					# LOG.debug("File path: #{file_path}")
+					if File.exist?(file_path)
+						return (parent_path + name).to_s
+					end
+				end
+
+				return nil
+			end
+
+			attr :extensions
+
+			def call(env)
+				request = Rack::Request.new(env)
+				ext = File.extname(request.path_info)
+				if @extensions.key? ext
+					path = Path.create(request.path_info).simplify
+					
+					if file = fetch_file(path)
+						response_headers = {
+							"Last-Modified" => file.mtime_date,
+							"Content-Type" => @extensions[ext],
+							"Content-Length" => file.size.to_s
+						}
+
+						return [200, response_headers, file]
+					elsif redirect = lookup_relative_file(path)
+						return [307, {"Location" => redirect}, []]
+					end
+				end
+
+				# else if no file was found:
+				return @app.call(env)
+			end
+		end
+
+	end
+end

data/lib/utopia/path.rb

@@ -0,0 +1,193 @@
+# 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 'rack/utils'
+
+module Utopia
+	
+	class Path
+		SEPARATOR = "/"
+
+		def initialize(components)
+			# To ensure we don't do anything stupid we freeze the components
+			@components = components.dup.freeze
+		end
+
+		# Shorthand constructor
+		def self.[](path)
+			create(path)
+		end
+
+		def self.create(path)
+			case path
+			when Path
+				return path
+			when Array
+				return Path.new(path)
+			when String
+				path = Rack::Utils.unescape(path)
+				# Ends with SEPARATOR
+				if path[-1,1] == SEPARATOR
+					return Path.new(path.split(SEPARATOR) << "")
+				else
+					return Path.new(path.split(SEPARATOR))
+				end
+			end
+		end
+
+		attr :components
+
+		def directory?
+			return @components.last == ""
+		end
+
+		def to_directory
+			if directory?
+				return self
+			else
+				return join([""])
+			end
+		end
+
+		def absolute?
+			return @components.first == ""
+		end
+
+		def to_absolute
+			if absolute?
+				return self
+			else
+				return Path.new([""] + @components)
+			end
+		end
+
+		def to_s
+			if @components == [""]
+				SEPARATOR
+			else
+				@components.join(SEPARATOR)
+			end
+		end
+
+		def join(other)
+			Path.new(@components + other).simplify
+		end
+
+		def +(other)
+			if other.kind_of? Array
+				return join(other)
+			elsif other.kind_of? Path
+				if other.absolute?
+					return other
+				else
+					return join(other.components)
+				end
+			else
+				return join([other.to_s])
+			end
+		end
+
+		def simplify
+			result = absolute? ? [""] : []
+
+			components.each do |bit|
+				if bit == ".."
+					result.pop
+				elsif bit != "." && bit != ""
+					result << bit
+				end
+			end
+
+			result << "" if directory?
+			return Path.new(result)
+		end
+
+		def basename(ext = nil)
+			if ext
+				File.basename(components.last, ext)
+			else
+				components.last
+			end
+		end
+
+		def dirname(count = 1)
+			path = Path.new(components[0...-count])
+
+			return absolute? ? path.to_absolute : path
+		end
+
+		def to_local_path
+			components.join(File::SEPARATOR)
+		end
+
+		def ascend(&block)
+			paths = []
+			
+			next_parent = self
+
+			begin
+				parent = next_parent
+				
+				yield parent if block_given?
+				paths << parent
+				
+				next_parent = parent.dirname
+			end until next_parent.eql?(parent)
+			
+			return paths
+		end
+
+		def split(at)
+			if at.kind_of? String
+				at = @components.index(at)
+			end
+			
+			if at
+				return [Path.new(@components[0...at]), Path.new(@components[at+1..-1])]
+			else
+				return nil
+			end
+		end
+
+		def dup
+			return Path.new(components.dup)
+		end
+
+		def <=> other
+			@components <=> other.components
+		end
+
+		def eql? other
+			if self.class == other.class
+				return @components.eql?(other.components)
+			else
+				return false
+			end
+		end
+
+		def == other
+			other.components.each_with_index do |part, index|
+				return false if @components[index] != part
+			end
+			
+			return true
+		end
+
+		def hash
+			@components.hash
+		end
+	end
+	
+end