utopia 0.12.6 → 1.0.0

data/lib/utopia/mail_exceptions.rb

@@ -0,0 +1,136 @@
+# Copyright, 2013, 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 'net/smtp'
+require 'mail'
+
+module Utopia
+	# Catches all exceptions raised from the app it wraps and sends a useful email with the exception, stacktrace, and contents of the environment.
+	class MailExceptions
+		# A basic local non-authenticated SMTP server.
+		LOCAL_SMTP = [:smtp, {
+			:address => "localhost",
+			:port => 25,
+			:enable_starttls_auto => false
+		}]
+		
+		def initialize(app, config = {})
+			@app = app
+			
+			@to = config[:to] || "postmaster"
+			@from = config.fetch(:from) {(ENV['USER'] || 'rack') + "@localhost"}
+			@subject = config[:subject] || '%{exception} [PID %{pid} : %{cwd}]'
+			@delivery_method = config.fetch(:delivery_method, LOCAL_SMTP)
+			
+			@dump_environment = config.fetch(:dump_environment, false)
+		end
+
+		def call(env)
+			begin
+				return @app.call(env)
+			rescue => exception
+				send_notification exception, env
+				
+				raise
+			end
+		end
+		
+		private
+		
+		REQUEST_KEYS = [:ip, :referrer, :path, :user_agent]
+		
+		def generate_body(exception, env)
+			io = StringIO.new
+			
+			# Dump out useful rack environment variables:
+			request = Rack::Request.new(env)
+			
+			io.puts "#{request.request_method} #{request.url}"
+			
+			io.puts
+			
+			REQUEST_KEYS.each do |key|
+				value = request.send(key)
+				io.puts "request.#{key}: #{value.inspect}"
+			end
+			
+			request.params.each do |key, value|
+				io.puts "request.params.#{key}: #{value.inspect}"
+			end
+			
+			io.puts
+			
+			io.puts "#{exception.class.name}: #{exception.to_s}"
+			
+			if exception.respond_to?(:backtrace)
+				io.puts exception.backtrace
+			else
+				io.puts exception.to_s
+			end
+			
+			return io.string
+		end
+		
+		def generate_mail(exception, env)
+			attributes = {
+				exception: exception.class.name,
+				pid: $$,
+				cwd: Dir.getwd,
+			}
+			
+			mail = Mail.new(
+				:from => @from,
+				:to => @to,
+				:subject => @subject % attributes
+			)
+			
+			mail.text_part = Mail::Part.new
+			mail.text_part.body = generate_body(exception, env)
+		
+			if body = extract_body(env) and body.size > 0
+				mail.attachments['body.bin'] = body
+			end
+			
+			if @dump_environment
+				mail.attachments['environment.yaml'] = YAML::dump(env)
+			end
+
+			return mail
+		end
+
+		def send_notification(exception, env)
+			mail = generate_mail(exception, env)
+			
+			mail.delivery_method(*@delivery_method) if @delivery_method
+			
+			mail.deliver
+		rescue => mail_exception
+			$stderr.puts mail_exception.to_s
+			$stderr.puts mail_exception.backtrace
+		end
+
+		def extract_body(env)
+			if io = env['rack.input']
+				io.rewind if io.respond_to?(:rewind)
+				io.read
+			end
+		end
+	end
+end

data/lib/utopia/middleware.rb

@@ -18,34 +18,19 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'pathname'
 require 'logger'
 
-require 'utopia/http'
+require_relative 'http'
+require_relative 'path'
 
-require 'utopia/extensions/rack'
+require_relative 'extensions/rack'
 
 module Utopia
 	LOG = Logger.new($stderr)
-	LOG.level = Logger::DEBUG
 	
-	module Middleware
-		def self.default_root(subdir = "pages")
-			Pathname.new(Dir.pwd).join(subdir).cleanpath.to_s
-		end
-		
-		def self.failure(status = 500, message = "Non-specific error")
-			body = "#{HTTP::STATUS_DESCRIPTIONS[status] || status.to_s}: #{message}"
-			
-			return [status, {
-				"Content-Type" => "text/plain",
-				"Content-Length" => body.size.to_s,
-				"X-Cascade" => "pass"
-			}, [body]]
-		end
+	PAGES_PATH = 'pages'.freeze
+	
+	def self.default_root(subdirectory = PAGES_PATH, pwd = Dir.pwd)
+		File.expand_path(subdirectory, pwd)
 	end
 end
-
-require 'utopia/path'
-require 'utopia/tag'
-

data/lib/utopia/path.rb

@@ -19,19 +19,88 @@
 # THE SOFTWARE.
 
 module Utopia
+	class Basename
+		# A basename represents a file name with an optional extension. You can specify a specific extension to identify or specify true to select any extension after the last trailing dot.
+		def initialize(name, extension = false)
+			if extension
+				if extension == true
+					offset = name.rindex('.')
+				else
+					offset = name.rindex(extension) - 1
+				end
+				
+				@name = name[0...offset]
+				@extension = name[offset+1..-1]
+			else
+				@name = name
+				@extension = nil
+			end
+		end
+		
+		def rename(name)
+			copy = self.dup
+			
+			copy.send(:instance_variable_set, :@name, name)
+			
+			return copy
+		end
+		
+		attr :name
+		attr :extension
+		
+		def parts
+			@parts ||= @name.split('.')
+		end
+		
+		def variant
+			parts.last if parts.size > 1
+		end
+		
+		def to_str
+			"#{name}#{extension}"
+		end
+		
+		def to_s
+			to_str
+		end
+	end
+	
 	class Path
 		SEPARATOR = "/"
 
 		include Comparable
 
 		def initialize(components = [])
-			# To ensure we don't do anything stupid we freeze the components
-			@components = components.dup.freeze
+			@components = components
 		end
 
-		# Shorthand constructor
-		def self.[](path)
-			create(path)
+		def freeze
+			@components.freeze
+			
+			super
+		end
+		
+		# Returns the length of the prefix which is shared by two strings.
+		def self.prefix_length(a, b)
+			[a.size, b.size].min.times{|i| return i if a[i] != b[i]}
+		end
+		
+		# Return the shortest relative path to get to path from root:
+		def self.shortest_path(path, root)
+			path = self.create(path)
+			root = self.create(root).dirname
+			
+			# Find the common prefix:
+			i = prefix_length(path.components, root.components) || 0
+			
+			# The difference between the root path and the required path, taking into account the common prefix:
+			up = root.components.size - i
+			
+			return self.create([".."] * up + path.components[i..-1])
+		end
+
+		def shortest_path(root)
+			self.class.shortest_path(self, root)
 		end
 
 		def self.unescape(string)
@@ -40,22 +109,20 @@ module Utopia
 			}
 		end
 
+		def self.[] path
+			self.create(path)
+		end
+
 		def self.create(path)
 			case path
 			when Path
 				return path
 			when Array
-				return Path.new(path)
+				return self.new(path)
 			when String
-				path = unescape(path)
-				# Ends with SEPARATOR
-				if path[-1,1] == SEPARATOR
-					return Path.new(path.split(SEPARATOR) << "")
-				else
-					return Path.new(path.split(SEPARATOR))
-				end
+				return self.new(unescape(path).split(SEPARATOR, -1))
 			when Symbol
-				return Path.new([path])
+				return self.new([path])
 			end
 		end
 
@@ -81,7 +148,7 @@ module Utopia
 			if absolute?
 				return self
 			else
-				return Path.new([""] + @components)
+				return self.class.new([""] + @components)
 			end
 		end
 
@@ -97,12 +164,12 @@ module Utopia
 			to_str
 		end
 
-		def [] index
-			@components[index]
+		def join(other)
+			self.class.new(@components + other).simplify
 		end
 
-		def join(other)
-			Path.new(@components + other).simplify
+		def expand(root)
+			root + self
 		end
 
 		def +(other)
@@ -131,13 +198,13 @@ module Utopia
 				i += 1
 			end
 			
-			return Path.create(@components[i,@components.size])
+			return self.class.new(@components[i,@components.size])
 		end
 
 		def simplify
 			result = absolute? ? [""] : []
 
-			components.each do |bit|
+			@components.each do |bit|
 				if bit == ".."
 					result.pop
 				elsif bit != "." && bit != ""
@@ -146,35 +213,22 @@ module Utopia
 			end
 
 			result << "" if directory?
-			return Path.new(result)
-		end
-
-		def basename(ext = nil)
-			if ext == true
-				File.basename(components.last, extension)
-			elsif String === ext
-				File.basename(components.last, ext)
-			else
-				components.last
-			end
+			
+			return self.class.new(result)
 		end
 
-		def extension
-			if components.last
-				components.last.split(".").last
-			else
-				nil
-			end
+		def basename(*args)
+			Basename.new(@components.last, *args)
 		end
-
+		
 		def dirname(count = 1)
-			path = Path.new(components[0...-count])
+			path = self.class.new(@components[0...-count])
 
 			return absolute? ? path.to_absolute : path
 		end
 
-		def to_local_path
-			components.join(File::SEPARATOR)
+		def to_local_path(separator = File::SEPARATOR)
+			@components.join(separator)
 		end
 
 		def descend(&block)
@@ -182,10 +236,10 @@ module Utopia
 			
 			parent_path = []
 			
-			components.each do |component|
+			@components.each do |component|
 				parent_path << component
 				
-				yield self.class.new(parent_path)
+				yield self.class.new(parent_path.dup)
 			end
 		end
 
@@ -209,7 +263,7 @@ module Utopia
 			end
 			
 			if at
-				return [Path.new(@components[0...at]), Path.new(@components[at+1..-1])]
+				return [self.class.new(@components[0...at]), self.class.new(@components[at+1..-1])]
 			else
 				return nil
 			end
@@ -231,38 +285,74 @@ module Utopia
 			end
 		end
 
-		def starts_with? other
+		def start_with? other
 			other.components.each_with_index do |part, index|
 				return false if @components[index] != part
 			end
 			
 			return true
 		end
-
+		
 		def hash
 			@components.hash
 		end
-
+		
+		def [] index
+			return @components[component_offset(index)]
+		end
+		
+		# Replaces a named component, indexing as per 
+		def []= index, value
+			return @components[component_offset(index)] = value
+		end
+		
+		def delete_at(index)
+			@components.delete_at(component_offset(index))
+		end
+		
+		def first
+			if absolute?
+				@components[1]
+			else
+				@components[0]
+			end
+		end
+		
 		def last
 			if directory?
-				components[-2]
+				@components[-2]
 			else
-				components[-1]
+				@components[-1]
 			end
 		end
-
-		def self.locale(name, extension = false)
-			if String === extension
-				name = File.basename(name, extension)
-			elsif extension
-				name = name.split
+		
+		def extension
+			basename(true).extension
+		end
+		
+		private
+		
+		# We adjust the index slightly so that indices reference path components rather than the directory markers at the start and end of the path components array.
+		def component_offset(index)
+			if Range === index
+				Range.new(adjust_index(index.first), adjust_index(index.last), index.exclude_end?)
+			else
+				adjust_index(index)
 			end
-			
-			name.split(".")[1..-1].join(".")
 		end
 		
-		def locale (extension = false)
-			return Path.locale(last, extension)
+		def adjust_index(index)
+			if index < 0
+				index -= 1 if directory?
+			else
+				index += 1 if absolute?
+			end
+			
+			return index
 		end
 	end
+	
+	def Path(path)
+		Path.create(path)
+	end
 end