utopia 0.12.6 → 1.0.0

data/lib/utopia/redirector.rb

@@ -0,0 +1,152 @@
+# 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 Utopia
+	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 Redirector
+		# This redirects directories to the directory + 'index' 
+		DIRECTORY_INDEX = [/^(.*)\/$/, lambda{|prefix| [307, {"Location" => "#{prefix}index"}, []]}]
+		
+		# Redirects a whole source tree to a destination tree, given by the roots.
+		def self.moved(source_root, destination_root)
+			return [
+				/^#{Regexp.escape(source_root)}(.*)$/,
+				lambda do |match|
+					[301, {"Location" => (destination_root + match[1]).to_s}, []]
+				end
+			]
+		end
+		
+		def self.starts_with(source_root, destination_uri)
+			return [
+				/^#{Regexp.escape(source_root)}/,
+				destination_uri
+			]
+		end
+		
+		private
+		
+		def normalize_strings(strings)
+			normalized = {}
+			
+			strings.each_pair do |key, value|
+				if Array === key
+					key.each { |s| normalized[s] = value }
+				else
+					normalized[key] = value
+				end
+			end
+			
+			return normalized
+		end
+
+		def normalize_patterns(patterns)
+			normalized = []
+			
+			patterns.each do |pattern|
+				uri = pattern.pop
+				
+				pattern.each do |key|
+					normalized.push([key, uri])
+				end
+			end
+			
+			return normalized
+		end
+
+		public
+		
+		def initialize(app, options = {})
+			@app = app
+
+			@strings = options[:strings] || {}
+			@patterns = options[:patterns] || []
+
+			@patterns.collect! do |rule|
+				if Symbol === rule[0]
+					self.class.send(*rule)
+				else
+					rule
+				end
+			end
+
+			@strings = normalize_strings(@strings)
+			@patterns = normalize_patterns(@patterns)
+
+			@errors = options[:errors]
+		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 = pattern.match(base_path)
+					result = redirect(uri, match_data)
+
+					return result if result != nil
+				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

data/lib/utopia/{extensions/hash.rb → session.rb}

@@ -1,4 +1,4 @@
-# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 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
@@ -18,10 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-class Hash
-	def symbolize_keys
-		inject({}) do |options, (key, value)|
-			options[(key.to_sym rescue key) || key] = value; options
-		end
+module Utopia
+	module Session
+		RACK_SESSION = "rack.session"
 	end
 end

data/lib/utopia/session/encrypted_cookie.rb

@@ -21,19 +21,20 @@
 require 'openssl'
 require 'digest/sha2'
 
+require_relative 'lazy_hash'
+require_relative '../session'
+
 module Utopia
 	module Session
-
+		# Stores all session data client side using a private symmetric encrpytion key.
 		class EncryptedCookie
-			RACK_SESSION = "rack.session"
-			RACK_SESSION_OPTIONS = "rack.session.options"
-
-			def initialize(app, options={})
+			def initialize(app, options = {})
 				@app = app
-				@cookie = options[:cookie] || (RACK_SESSION + ".encrypted")
-				@secret = Digest::SHA256.digest(options[:secret])
+				@cookie_name = options.delete(:cookie_name) || (RACK_SESSION + ".encrypted")
+
+				@secret = options.delete(:secret)
 
-				@default_options = {
+				@options = {
 					:domain => nil,
 					:path => "/",
 					:expires_after => nil
@@ -41,80 +42,77 @@ module Utopia
 			end
 
 			def call(env)
-				original_session = load_session(env).dup
+				session_hash = prepare_session(env)
 
 				status, headers, body = @app.call(env)
 
-				if original_session != env[RACK_SESSION]
-					commit_session(env, status, headers, body)
+				if session_hash.changed?
+					commit(session_hash.values, headers)
 				end
 
 				return [status, headers, body]
 			end
-
-			private
-
-			def load_session(env)
-				session = {}
-
+			
+			protected
+			
+			def prepare_session(env)
+				env[RACK_SESSION] = LazyHash.new do
+					self.load_session_values(env)
+				end
+			end
+			
+			# Load session
+			def load_session_values(env)
+				values = {}
+				
 				request = Rack::Request.new(env)
-				data = request.cookies[@cookie]
-
+				data = request.cookies[@cookie_name]
+				
 				if data
-					session = decrypt(data) rescue session
+					values = decrypt(data) rescue values
 				end
-
-				env[RACK_SESSION] = session
-				env[RACK_SESSION_OPTIONS] = @default_options.dup
-
-				return session
+				
+				return values
 			end
 			
-			def commit_session(env, status, headers, body)
-				session = env[RACK_SESSION]
-
-				data = encrypt(session)
-
-				if data.size > (1024 * 4)
-					env["rack.errors"].puts "Error: #{self.class.name} data exceeds 4K. Content Dropped!"
-				else
-					options = env[RACK_SESSION_OPTIONS]
-					cookie = {:value => data}
-					cookie[:expires] = Time.now + options[:expires_after] unless options[:expires_after].nil?
-
-					Rack::Utils.set_cookie_header!(headers, @cookie, cookie.merge(options))
-				end
+			def commit(values, headers)
+				data = encrypt(values)
+				
+				cookie = {:value => data}
+				
+				cookie[:expires] = Time.now + @options[:expires_after] unless @options[:expires_after].nil?
+				
+				Rack::Utils.set_cookie_header!(headers, @cookie_name, cookie.merge(@options))
 			end
 			
 			def encrypt(hash)
 				c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
 				c.encrypt
-
+				
 				# your pass is what is used to encrypt/decrypt
 				c.key = @secret
 				c.iv = iv = c.random_iv
-
+				
 				e = c.update(Marshal.dump(hash))
 				e << c.final
-
+				
 				return [iv, e].pack("m16m*")
 			end
-
+			
 			def decrypt(data)
 				iv, e = data.unpack("m16m*")
-
+				
 				c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
 				c.decrypt
-
+				
 				c.key = @secret
 				c.iv = iv
-
+				
 				d = c.update(e)
 				d << c.final
-
+				
 				return Marshal.load(d)
 			end
 		end
-		
 	end
 end

data/lib/utopia/{middleware/directory_index.rb → session/lazy_hash.rb}

@@ -1,4 +1,4 @@
-# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 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
@@ -18,37 +18,54 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'utopia/middleware'
-require 'utopia/path'
+require_relative '../session'
 
 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"])
+	module Session
+		# A simple hash table which fetches it's values only when required.
+		class LazyHash
+			def initialize(&block)
+				@changed = false
+				@values = nil
 				
-				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))
-							return [307, {"Location" => (path + file).to_s}, []]
-						end
-					end
+				@loader = block
+			end
+			
+			attr :values
+			
+			def [] key
+				load![key]
+			end
+			
+			def []= key, value
+				values = load!
 				
-					# Use the default path
-					return [307, {"Location" => (path + @default).to_s}, []]
-				else
-					return @app.call(env)
+				if values[key] != value
+					values[key] = value
+					@changed = true
 				end
+				
+				return value
+			end
+			
+			def include?(key)
+				load!.include?(key)
+			end
+			
+			def delete(key)
+				load!
+				
+				@changed = true if @values.include? key
+				
+				@values.delete(key)
+			end
+			
+			def changed?
+				@changed
+			end
+			
+			def load!
+				@values ||= @loader.call
 			end
 		end
 	end

data/lib/utopia/static.rb

@@ -0,0 +1,255 @@
+# 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'
+require_relative 'localization'
+
+require 'time'
+
+require 'digest/sha1'
+require 'mime/types'
+
+module Utopia
+	# Serve static files and include recursive name resolution using @rel@ directory entries.
+	class Static
+		MIME_TYPES = {
+			:xiph => {
+				"ogx" => "application/ogg",
+				"ogv" => "video/ogg",
+				"oga" => "audio/ogg",
+				"ogg" => "audio/ogg",
+				"spx" => "audio/ogg",
+				"flac" => "audio/flac",
+				"anx" => "application/annodex",
+				"axa" => "audio/annodex",
+				"xspf" => "application/xspf+xml",
+			},
+			:media => [
+				:xiph, "mp3", "mp4", "wav", "aiff", ["aac", "audio/x-aac"], "mov", "avi", "wmv", "mpg"
+			],
+			:text => [
+				"html", "css", "js", ["map", "application/json"], "txt", "rtf", "xml", "pdf"
+			],
+			:fonts => [
+				"otf", ["eot", "application/vnd.ms-fontobject"], "ttf", "woff"
+			],
+			:archive => [
+				"zip", "tar", "tgz", "tar.gz", "tar.bz2", ["dmg", "application/x-apple-diskimage"],
+				["torrent", "application/x-bittorrent"]
+			],
+			:images => [
+				"png", "gif", "jpeg", "tiff", "svg"
+			],
+			:default => [
+				:media, :text, :archive, :images, :fonts
+			]
+		}
+
+		private
+
+		class LocalFile
+			def initialize(root, path)
+				@root = root
+				@path = path
+				@etag = Digest::SHA1.hexdigest("#{File.size(full_path)}#{mtime_date}")
+
+				@range = nil
+			end
+
+			attr :root
+			attr :path
+			attr :etag
+			attr :range
+
+			# Fit in with Rack::Sendfile
+			def to_path
+				full_path
+			end
+
+			def full_path
+				File.join(@root, @path.components)
+			end
+
+			def mtime_date
+				File.mtime(full_path).httpdate
+			end
+
+			def size
+				File.size(full_path)
+			end
+
+			def each
+				File.open(full_path, "rb") do |file|
+					file.seek(@range.begin)
+					remaining = @range.end - @range.begin+1
+
+					while remaining > 0
+						break unless part = file.read([8192, remaining].min)
+
+						remaining -= part.length
+
+						yield part
+					end
+				end
+			end
+
+			def modified?(env)
+				if modified_since = env['HTTP_IF_MODIFIED_SINCE']
+					return false if File.mtime(full_path) <= Time.parse(modified_since)
+				end
+
+				if etags = env['HTTP_IF_NONE_MATCH']
+					etags = etags.split(/\s*,\s*/)
+					return false if etags.include?(etag) || etags.include?('*')
+				end
+
+				return true
+			end
+
+			def serve(env, response_headers)
+				ranges = Rack::Utils.byte_ranges(env, size)
+				response = [200, response_headers, self]
+
+				# LOG.info("Requesting ranges: #{ranges.inspect} (#{size})")
+
+				if ranges == nil or ranges.size != 1
+					# No ranges, or multiple ranges (which we don't support).
+					# TODO: Support multiple byte-ranges, for now just send entire file:
+					response[0] = 200
+					response[1]["Content-Length"] = size.to_s
+					@range = 0..size-1
+				else
+					# Partial content:
+					@range = ranges[0]
+					response[0] = 206
+					response[1]["Content-Range"] = "bytes #{@range.begin}-#{@range.end}/#{size}"
+					response[1]["Content-Length"] = (@range.end - @range.begin+1).to_s
+					size = @range.end - @range.begin + 1
+				end
+
+				# LOG.debug {"Serving file #{full_path.inspect}, range #{@range.inspect}"}
+
+				return response
+			end
+		end
+
+		def load_mime_types(types)
+			result = {}
+
+			extract_extensions = lambda do |mime_type|
+				# LOG.info "Extracting #{mime_type.inspect}"
+				mime_type.extensions.each{|ext| result["." + ext] = mime_type.content_type}
+			end
+
+			types.each do |type|
+				current_count = result.size
+				# LOG.info "Processing #{type.inspect}"
+				
+				begin
+					case type
+					when Symbol
+						result = load_mime_types(MIME_TYPES[type]).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 #{type.inspect}"
+				end
+			end
+
+			return result
+		end
+
+		public
+
+		def initialize(app, options = {})
+			@app = app
+			@root = options[:root] || Utopia::default_root
+
+			if options[:types]
+				@extensions = load_mime_types(options[:types])
+			else
+				@extensions = load_mime_types(MIME_TYPES[:default])
+			end
+
+			@cache_control = options[:cache_control] || "public, max-age=3600"
+		end
+
+		def fetch_file(path)
+			# We need file_path to be an absolute path for X-Sendfile to work correctly.
+			file_path = File.join(@root, path.components)
+			
+			if File.exist?(file_path)
+				return LocalFile.new(@root, path)
+			else
+				return nil
+			end
+		end
+
+		attr :extensions
+
+		def call(env)
+			path_info = env['PATH_INFO']
+			extension = File.extname(path_info)
+
+			if @extensions.key? extension.downcase
+				path = Path[path_info].simplify
+				
+				if locale = env[Localization::CURRENT_LOCALE_KEY]
+					path.last.insert(path.last.rindex('.') || -1, ".#{locale}")
+				end
+				
+				if file = fetch_file(path)
+					response_headers = {
+						"Last-Modified" => file.mtime_date,
+						"Content-Type" => @extensions[extension],
+						"Cache-Control" => @cache_control,
+						"ETag" => file.etag,
+						"Accept-Ranges" => "bytes"
+					}
+
+					if file.modified?(env)
+						return file.serve(env, response_headers)
+					else
+						return [304, response_headers, []]
+					end
+				end
+			end
+
+			# else if no file was found:
+			return @app.call(env)
+		end
+	end
+end