utopia 1.7.1 → 1.8.0

data/lib/utopia/content/tag.rb

@@ -56,52 +56,49 @@ module Utopia
 			def [](key)
 				@attributes[key]
 			end
-
-			def to_html(content = nil, buffer = StringIO.new)
-				write_full_html(buffer, content)
-				
-				return buffer.string
-			end
 			
 			def to_hash
 				@attributes
 			end
 			
 			def to_s(content = nil)
-				buffer = StringIO.new
+				buffer = String.new
+				
 				write_full_html(buffer, content)
-				return buffer.string
+				
+				return buffer
 			end
 			
+			alias to_html to_s
+			
 			def write_open_html(buffer, terminate = false)
-				buffer ||= StringIO.new 
-				buffer.write "<#{name}"
+				buffer << "<#{name}"
 
 				@attributes.each do |key, value|
 					if value
-						buffer.write " #{key}=\"#{value}\""
+						buffer << " #{key}=\"#{value}\""
 					else
-						buffer.write " #{key}"
+						buffer << " #{key}"
 					end
 				end
 				
 				if terminate
-					buffer.write "/>"
+					buffer << "/>"
 				else
-					buffer.write ">"
+					buffer << ">"
 				end
 			end
 			
 			def write_close_html(buffer)
-				buffer.write "</#{name}>"
+				buffer << "</#{name}>"
 			end
 			
 			def write_full_html(buffer, content = nil)
-				if @closed && content == nil
+				if @closed and content.nil?
 					write_open_html(buffer, true)
 				else
 					write_open_html(buffer)
-					buffer.write(content)
+					buffer << content if content
 					write_close_html(buffer)
 				end
 			end

data/lib/utopia/content/transaction.rb

@@ -20,6 +20,8 @@
 
 require_relative 'links'
 
+require_relative 'response'
+
 module Utopia
 	class Content
 		# This error is thrown if a tag doesn't match up when parsing the 
@@ -37,19 +39,21 @@ module Utopia
 		CONTENT_TAG_NAME = "content".freeze
 		
 		# A single request through content middleware. We use a struct to hide instance varibles since we instance_exec within this context.
-		class Transaction
-			# extend Gem::Deprecate
-			
-			def initialize(request, response, attributes = {})
+		class Transaction < Response
+			def initialize(request, attributes = {})
 				@request = request
-				@response = response
 				
 				@attributes = attributes
 				
 				@begin_tags = []
 				@end_tags = []
+				
+				super()
 			end
 			
+			attr :status
+			attr :headers
+			
 			# A helper method for accessing controller variables from view:
 			def controller
 				@controller ||= Utopia::Controller[request]
@@ -66,9 +70,6 @@ module Utopia
 			# The Rack::Request for this transaction.
 			attr :request
 
-			# The mutable Rack::Response for this transaction.
-			attr :response
-
 			# Per-transaction global attributes.
 			attr :attributes
 
@@ -133,7 +134,6 @@ module Utopia
 				# Get the current tag which we are completing/ending:
 				top = current
 				
-				
 				if top.tags.empty?
 					if top.node.respond_to? :tag_end
 						top.node.tag_end(self, top)
@@ -156,7 +156,7 @@ module Utopia
 
 				return nil
 			end
-
+			
 			def render_node(node, attributes = {})
 				self.begin_tags << State.new(attributes, node)
 
@@ -206,8 +206,10 @@ module Utopia
 		class Transaction::State
 			def initialize(tag, node, attributes = tag.to_hash)
 				@node = node
-
-				@buffer = StringIO.new
+				
+				# The contents of the output
+				@buffer = String.new
+				
 				@overrides = {}
 
 				@tags = []
@@ -228,7 +230,7 @@ module Utopia
 			def defer(value = nil, &block)
 				@deferred << block
 				
-				Tag.closed(DEFERRED_TAG_NAME, :id => @deferred.size - 1).to_html
+				Tag.closed(DEFERRED_TAG_NAME, :id => @deferred.size - 1).to_s
 			end
 			
 			def [](key)
@@ -250,8 +252,8 @@ module Utopia
 			end
 
 			def call(transaction)
-				@content = @buffer.string
-				@buffer = StringIO.new
+				@content = @buffer
+				@buffer = String.new
 				
 				if node.respond_to? :call
 					node.call(transaction, self)
@@ -259,11 +261,11 @@ module Utopia
 					transaction.parse_markup(@content)
 				end
 				
-				return @buffer.string
+				return @buffer
 			end
 
 			def cdata(text)
-				@buffer.write(text)
+				@buffer << text
 			end
 
 			def markup(text)

data/lib/utopia/controller.rb

@@ -22,15 +22,16 @@ require_relative 'path'
 
 require_relative 'middleware'
 require_relative 'controller/variables'
-require_relative 'controller/action'
 require_relative 'controller/base'
 
 require_relative 'controller/rewrite'
 require_relative 'controller/respond'
+require_relative 'controller/actions'
 
 require 'concurrent/map'
 
 module Utopia
+	# A container for controller classes which are loaded from disk.
 	module Controllers
 		def self.class_name_for_controller(controller)
 			controller.uri_path.to_a.collect{|_| _.capitalize}.join + "_#{controller.object_id}"
@@ -44,14 +45,16 @@ module Utopia
 		end
 	end
 	
+	# A middleware which loads controller classes and invokes functionality based on the requested path.
 	class Controller
+		# The controller filename.
 		CONTROLLER_RB = 'controller.rb'.freeze
 		
 		def self.[] request
 			request.env[VARIABLES_KEY]
 		end
 		
-		def initialize(app, root: nil, cache_controllers: false)
+		def initialize(app, root: nil, cache_controllers: false, base: nil)
 			@app = app
 			@root = root || Utopia::default_root
 			
@@ -60,6 +63,10 @@ module Utopia
 			else
 				@controller_cache = nil
 			end
+			
+			warn "Controller middleware is automatically prepending Actions! Will be deprecated in 2.x" if $VERBOSE and base.nil?
+			
+			@base = base || Controller::Base.dup.prepend(Controller::Actions)
 		end
 		
 		attr :app
@@ -67,9 +74,13 @@ module Utopia
 		def freeze
 			@root.freeze
 			
+			# Should we freeze the base class?
+			# @base.freeze
+			
 			super
 		end
 		
+		# Fetch the controller for the given relative path. May be cached.
 		def lookup_controller(path)
 			if @controller_cache
 				@controller_cache.fetch_or_store(path.to_s) do
@@ -80,6 +91,7 @@ module Utopia
 			end
 		end
 		
+		# Loads the controller file for the given relative url_path.
 		def load_controller_file(uri_path)
 			base_path = File.join(@root, uri_path.components)
 			
@@ -87,7 +99,7 @@ module Utopia
 			# puts "load_controller_file(#{path.inspect}) => #{controller_path}"
 			
 			if File.exist?(controller_path)
-				klass = Class.new(Base)
+				klass = Class.new(@base)
 				
 				# base_path is expected to be a string representing a filesystem path:
 				klass.const_set(:BASE_PATH, base_path.freeze)
@@ -112,13 +124,22 @@ module Utopia
 			end
 		end
 		
+		# Invoke the controller layer for a given request. The request path may be rewritten.
 		def invoke_controllers(request)
-			relative_path = Path[request.path_info]
+			request_path = Path.from_string(request.path_info)
+			
+			# The request path must be absolute. We could handle this internally but it is probably better for this to be an error:
+			raise ArgumentError.new("Invalid request path #{request_path}") unless request_path.absolute?
+			
+			# The controller path contains the current complete path being evaluated:
 			controller_path = Path.new
+			
+			# Controller instance variables which eventually get processed by the view:
 			variables = request.env[VARIABLES_KEY]
 			
-			while relative_path.components.any?
-				controller_path.components << relative_path.components.shift
+			while request_path.components.any?
+				# We copy one path component from the relative path to the controller path at a time. The controller, when invoked, can modify the relative path (by assigning to relative_path.components). This allows for controller-relative rewrites, but only the remaining path postfix can be modified.
+				controller_path.components << request_path.components.shift
 				
 				if controller = lookup_controller(controller_path)
 					# Don't modify the original controller:
@@ -127,13 +148,13 @@ module Utopia
 					# Append the controller to the set of controller variables, updates the controller with all current instance variables.
 					variables << controller
 					
-					if result = controller.process!(request, relative_path)
+					if result = controller.process!(request, request_path)
 						return result
 					end
 				end
 			end
 			
-			# The controllers may have rewriten the path so we update the path info:
+			# Controllers can directly modify relative_path, which is copied into controller_path. The controllers may have rewriten the path so we update the path info:
 			request.env[Rack::PATH_INFO] = controller_path.to_s
 			
 			# No controller gave a useful result:

data/lib/utopia/controller/actions.rb

@@ -0,0 +1,148 @@
+# Copyright, 2016, 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
+		module Actions
+			def self.prepended(base)
+				base.extend(ClassMethods)
+			end
+			
+			class Action < Hash
+				def initialize(options = {}, &block)
+					@options = options
+					@callback = block
+					
+					super()
+				end
+				
+				attr_accessor :callback, :options
+				
+				def callback?
+					@callback != nil
+				end
+				
+				def eql? other
+					super and @callback.eql? other.callback and @options.eql? other.options
+				end
+				
+				def hash
+					[super, @callback, @options].hash
+				end
+				
+				def == other
+					super and @callback == other.callback and @options == other.options
+				end
+				
+				WILDCARD_GREEDY = '**'.freeze
+				WILDCARD = '*'.freeze
+				
+				# Given a path, iterate over all actions that match. Actions match from most specific to most general.
+				# @return nil if nothing matched, or true if something matched.
+				def apply(path, index = -1, &block)
+					# ** is greedy, it always matches if possible and matches all remaining input.
+					if match_all = self[WILDCARD_GREEDY] and match_all.callback?
+						matched = true; yield(match_all)
+					end
+					
+					if name = path[index]
+						# puts "Matching #{name} in #{self.keys.inspect}"
+						
+						if match_name = self[name]
+							# puts "Matched against exact name #{name}: #{match_name}"
+							matched = match_name.apply(path, index-1, &block) || matched
+						end
+						
+						if match_one = self[WILDCARD]
+							# puts "Match against #{WILDCARD}: #{match_one}"
+							matched = match_one.apply(path, index-1, &block) || matched
+						end
+					elsif self.callback?
+						# Got to end, matched completely:
+						matched = true; yield(self)
+					end
+					
+					return matched
+				end
+				
+				def matching(path, &block)
+					to_enum(:apply, path).to_a
+				end
+				
+				def define(path, **options, &callback)
+					# puts "Defining path: #{path.inspect}"
+					current = self
+					
+					path.reverse_each do |name|
+						current = (current[name] ||= Action.new)
+					end
+					
+					current.options = options
+					current.callback = callback
+					
+					return current
+				end
+				
+				def inspect
+					if callback?
+						"<action " + super + ":#{callback.source_location}(#{options})>"
+					else
+						"<action " + super + ">"
+					end
+				end
+			end
+			
+			module ClassMethods
+				def actions
+					@actions ||= Action.new
+				end
+				
+				def on(first, *path, **options, &block)
+					if first.is_a? Symbol
+						first = ['**', first.to_s]
+					end
+					
+					actions.define(Path.split(first) + path, options, &block)
+				end
+				
+				def dispatch(controller, request, path)
+					if @actions
+						@actions.apply(path.components) do |action|
+							controller.instance_exec(request, path, &action.callback)
+						end || controller.otherwise(request, path)
+					end
+				end
+			end
+			
+			def otherwise(request, path)
+			end
+			
+			# Given a request, call associated actions if at least one exists.
+			def process!(request, path)
+				# puts "Actions\#process!(..., #{path.inspect})"
+				catch_response do
+					self.class.dispatch(self, request, path)
+				end || super
+			end
+		end
+	end
+end

data/lib/utopia/controller/base.rb

@@ -23,14 +23,17 @@ require_relative '../http'
 module Utopia
 	class Controller
 		class Base
+			# A string which is the full path to the directory which contains the controller.
 			def self.base_path
 				self.const_get(:BASE_PATH)
 			end
-		
+			
+			# A relative path to the controller directory relative to the controller root directory.
 			def self.uri_path
 				self.const_get(:URI_PATH)
 			end
-		
+			
+			# The controller middleware itself.
 			def self.controller
 				self.const_get(:CONTROLLER)
 			end
@@ -48,32 +51,6 @@ module Utopia
 				def direct?(path)
 					path.dirname == uri_path
 				end
-				
-				def actions
-					@actions ||= Action.new
-				end
-				
-				def on(first, *path, **options, &block)
-					if first.is_a? Symbol
-						first = ['**', first]
-					end
-					
-					actions.define(Path.split(first) + path, options, &block)
-				end
-				
-				def lookup(path)
-					if @actions
-						relative_path = (path - uri_path).to_a
-						return @actions.select(relative_path)
-					else
-						[]
-					end
-				end
-			end
-			
-			# Given a path, look up all matched actions.
-			def actions_for_request(request, path)
-				self.class.lookup(path)
 			end
 			
 			def catch_response
@@ -82,18 +59,8 @@ module Utopia
 				end
 			end
 			
-			# Given a request, call associated actions if at least one exists.
-			def passthrough(request, path)
-				actions = actions_for_request(request, path)
-				
-				unless actions.empty?
-					return catch_response do
-						actions.each do |action|
-							action.call(self, request, path)
-						end
-					end
-				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, relative_path)
 				return nil
 			end
 
@@ -114,7 +81,7 @@ module Utopia
 				throw :response, response
 			end
 
-				# This will cause the controller middleware to pass on the request.
+			# This will cause the controller middleware to pass on the request.
 			def ignore!
 				throw :response, nil
 			end
@@ -140,6 +107,7 @@ module Utopia
 				respond! [status.to_i, {}, [message]]
 			end
 			
+			# Succeed the request and immediately respond.
 			def succeed!(status: 200, headers: {}, **options)
 				status = HTTP::Status.new(status, 200...300)
 				
@@ -159,14 +127,6 @@ module Utopia
 					return [content]
 				end
 			end
-			
-			# Legacy method name:
-			alias success! succeed!
-			
-			# 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)
-				passthrough(request, path)
-			end
 		end
 	end
 end