utopia 1.9.11 → 2.0.0

data/lib/utopia/content/node.rb

@@ -20,12 +20,14 @@
 
 require_relative 'markup'
 require_relative 'links'
-require_relative 'transaction'
+
+require_relative 'document'
 
 require 'pathname'
 
 module Utopia
 	class Content
+		# Represents an immutable node within the content hierarchy.
 		class Node
 			def initialize(controller, uri_path, request_path, file_path)
 				@controller = controller
@@ -39,12 +41,16 @@ module Utopia
 			attr :uri_path
 			attr :file_path
 
+			def name
+				@uri_path.basename
+			end
+
 			def link
 				return Link.new(:file, uri_path)
 			end
 
 			def lookup_node(path)
-				@controller.lookup_node(path)
+				@controller.lookup_node(@uri_path + Path[path])
 			end
 
 			def local_path(path = '.', base = nil)
@@ -60,17 +66,6 @@ module Utopia
 				end
 			end
 
-			def lookup(tag)
-				from_path = parent_path
-				
-				# If the current node is called 'foo', we can't lookup 'foo' in the current directory or we will have infinite recursion.
-				if tag.name == @uri_path.basename
-					from_path = from_path.dirname
-				end
-				
-				return @controller.lookup_tag(tag.name, from_path)
-			end
-
 			def parent_path
 				uri_path.dirname
 			end
@@ -105,83 +100,86 @@ module Utopia
 			def sibling_links(**options)
 				return Links.index(@controller.root, siblings_path, options)
 			end
-
-			def call(transaction, state)
+			
+			# Lookup the given tag which is being rendered within the given node. Invoked by {Document}.
+			# @return [Node] The node which will be used to render the tag.
+			def lookup_tag(tag)
+				return @controller.lookup_tag(tag.name, self)
+			end
+			
+			# Invoked when the node is being rendered by {Document}.
+			def call(document, state)
 				# Load the template:
 				template = @controller.fetch_template(@file_path)
 				
 				# Evaluate the template/code:
-				context = Context.new(transaction, state)
+				context = Context.new(document, state)
 				markup = template.to_buffer(context)
 				
-				# Render the resulting markup into the transaction:
-				transaction.parse_markup(markup)
+				# Render the resulting markup into the document:
+				document.parse_markup(markup)
 			end
-
+			
 			def process!(request, attributes = {})
-				transaction = Transaction.new(request)
-				
-				output = transaction.render_node(self, attributes)
-				
-				return [200, transaction.headers, [output]]
+				Document.render(self, request, attributes).to_a
 			end
-		end
 		
-		# This is a special context in which a limited set of well defined methods are exposed in the content view.
-		Node::Context = Struct.new(:transaction, :state) do
-			def partial(*args, &block)
-				if block_given?
-					state.defer(&block)
-				else
-					state.defer do |transaction|
-						transaction.tag(*args)
+			# This is a special context in which a limited set of well defined methods are exposed in the content view.
+			Context = Struct.new(:document, :state) do
+				def partial(*args, &block)
+					if block_given?
+						state.defer(&block)
+					else
+						state.defer do |document|
+							document.tag(*args)
+						end
 					end
 				end
-			end
-			
-			alias deferred_tag partial
-			
-			def controller
-				transaction.controller
-			end
-			
-			def localization
-				transaction.localization
-			end
-			
-			def request
-				transaction.request
-			end
-			
-			def response
-				transaction
-			end
-			
-			def attributes
-				state.attributes
-			end
-			
-			def [] key
-				state.attributes.fetch(key) {transaction.attributes[key]}
-			end
-			
-			alias current state
-			
-			def content
-				transaction.content
-			end
+				
+				alias deferred_tag partial
+				
+				def controller
+					document.controller
+				end
+				
+				def localization
+					document.localization
+				end
+				
+				def request
+					document.request
+				end
+				
+				def response
+					document
+				end
+				
+				def attributes
+					state.attributes
+				end
+				
+				def [] key
+					state.attributes.fetch(key) {document.attributes[key]}
+				end
+				
+				alias current state
+				
+				def content
+					document.content
+				end
 
-			def parent
-				transaction.parent
-			end
+				def parent
+					document.parent
+				end
 
-			def first
-				transaction.first
-			end
-			
-			def links(*arguments, &block)
-				state.node.links(*arguments, &block)
+				def first
+					document.first
+				end
+				
+				def links(*arguments, &block)
+					state.node.links(*arguments, &block)
+				end
 			end
 		end
 	end
-end
+end

data/lib/utopia/content/response.rb

@@ -24,25 +24,44 @@ module Utopia
 		EXPIRES = 'Expires'.freeze
 		CACHE_CONTROL = 'Cache-Control'.freeze
 		CONTENT_TYPE = 'Content-Type'.freeze
+		NO_CACHE = 'no-cache'.freeze
 		
+		# A basic content response, including useful defaults for typical HTML5 content.
 		class Response
 			def initialize
 				@status = 200
 				@headers = {}
+				@body = []
+				
+				# The default content type:
+				self.content_type = "text/html; charset=utf-8"
 			end
 			
 			attr :status
 			attr :headers
+			attr :body
+			
+			def content
+				@body.join
+			end
+			
+			def lookup(tag)
+				return nil
+			end
+			
+			def to_a
+				[@status, @headers, @body]
+			end
 			
 			# Specifies that the content shouldn't be cached. Overrides `cache!` if already called.
 			def do_not_cache!
 				@headers[CACHE_CONTROL] = "no-cache, must-revalidate"
 				@headers[EXPIRES] = Time.now.httpdate
 			end
-
-			# Specify that the content should be cached.
+			
+			# Specify that the content could be cached.
 			def cache!(duration = 3600, access: "public")
-				unless @headers[CACHE_CONTROL] =~ /no-cache/
+				unless cache_control = @headers[CACHE_CONTROL] and cache_control.include?(NO_CACHE)
 					@headers[CACHE_CONTROL] = "#{access}, max-age=#{duration}"
 					@headers[EXPIRES] = (Time.now + duration).httpdate
 				end

data/lib/utopia/content/tags.rb

@@ -0,0 +1,66 @@
+# Copyright, 2017, 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 'namespace'
+
+module Utopia
+	class Content
+		# Tags which provide intrinsic behaviour within the content middleware.
+		module Tags
+			extend Namespace
+			
+			# Invokes a node and renders a single node to the output stream.
+			# @param path [String] The path of the node to invoke.
+			tag('node') do |document, state|
+				path = Path[state[:path]]
+				
+				node = document.lookup_node(path)
+				
+				document.render_node(node)
+			end
+			
+			# Invokes a deferred tag from the current state. Works together with {Document::State#defer}.
+			# @param id [String] The id of the deferred to invoke.
+			tag('deferred') do |document, state|
+				id = state[:id].to_i
+				
+				deferred = document.parent.deferred[id]
+				
+				deferred.call(document, state)
+			end
+			
+			# Renders the content of the parent node into the output of the document.
+			tag('content') do |document, state|
+				# We are invoking this node within a parent who has content, and we want to generate output equal to that.
+				document.write(document.parent.content)
+			end
+			
+			# Render the contents only if in the correct environment.
+			# @param only [String] A comma separated list of environments to check.
+			tag('environment') do |document, state|
+				environment = document.attributes.fetch(:environment){RACK_ENV}.to_s
+				
+				if state[:only].split(',').include?(environment)
+					document.parse_markup(state.content)
+				end
+			end
+		end
+	end
+end

data/lib/utopia/controller.rb

@@ -54,39 +54,31 @@ module Utopia
 			request.env[VARIABLES_KEY]
 		end
 		
-		def initialize(app, root: nil, cache_controllers: false, base: nil)
+		# @param root [String] The content root where controllers will be loaded from.
+		# @param base [Class] The base class for controllers.
+		def initialize(app, root: Utopia::default_root, base: Controller::Base)
 			@app = app
-			@root = root || Utopia::default_root
+			@root = root
 			
-			if cache_controllers
-				@controller_cache = Concurrent::Map.new
-			else
-				@controller_cache = nil
-			end
+			@controller_cache = Concurrent::Map.new
 			
-			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)
+			@base = base
 		end
 		
 		attr :app
 		
 		def freeze
-			@root.freeze
+			return self if frozen?
 			
-			# Should we freeze the base class?
-			# @base.freeze
+			@root.freeze
+			@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
-					load_controller_file(path)
-				end
-			else
+			@controller_cache.fetch_or_store(path.to_s) do
 				load_controller_file(path)
 			end
 		end

data/lib/utopia/controller/actions.rb

@@ -22,11 +22,17 @@ require_relative '../http'
 
 module Utopia
 	class Controller
+		# A controller layer which invokes functinality based on the request path.
+		# @example
+		# 	on '*' do |request, path|
+		# 		succeed! content: 'Hello World'
+		# 	end
 		module Actions
 			def self.prepended(base)
 				base.extend(ClassMethods)
 			end
 			
+			# A nested action lookup hash table.
 			class Action < Hash
 				def initialize(options = {}, &block)
 					@options = options
@@ -53,7 +59,10 @@ module Utopia
 					super and @callback == other.callback and @options == other.options
 				end
 				
+				# Matches 0 or more path components.
 				WILDCARD_GREEDY = '**'.freeze
+				
+				# Matches any 1 path component.
 				WILDCARD = '*'.freeze
 				
 				# Given a path, iterate over all actions that match. Actions match from most specific to most general.
@@ -112,6 +121,7 @@ module Utopia
 				end
 			end
 			
+			# Exposed to the controller class.
 			module ClassMethods
 				def self.extended(klass)
 					klass.instance_eval do

data/lib/utopia/controller/base.rb

@@ -22,6 +22,7 @@ require_relative '../http'
 
 module Utopia
 	class Controller
+		# The base implementation of a controller class.
 		class Base
 			# A string which is the full path to the directory which contains the controller.
 			def self.base_path
@@ -87,7 +88,7 @@ module Utopia
 			end
 
 			# Request relative redirect. Respond with a redirect to the given target.
-			def redirect! (target, status = 302)
+			def redirect!(target, status = 302)
 				status = HTTP::Status.new(status, 300...400)
 				location = target.to_s
 				

data/lib/utopia/controller/respond.rb

@@ -23,7 +23,7 @@ require_relative '../path/matcher'
 
 module Utopia
 	class Controller
-		# This controller layer provides a convenient way to respond to different requested content types. The order in which you add converters matters, as it determins how the incoming Accept: header is mapped, e.g. the first converter is also defined as matching the media range */*.
+		# A controller layer which provides a convenient way to respond to different requested content types. The order in which you add converters matters, as it determines how the incoming Accept: header is mapped, e.g. the first converter is also defined as matching the media range */*.
 		module Respond
 			def self.prepended(base)
 				base.extend(ClassMethods)

data/lib/utopia/controller/rewrite.rb

@@ -25,15 +25,16 @@ module Utopia
 	class Controller
 		# This controller layer rewrites the path before executing controller actions. When the rule matches, the supplied block is executed.
 		# @example
-		# prepend Rewrite
-		# rewrite.extract_prefix id: Integer do
-		#   @user = User.find(@id)
-		# end
+		# 	prepend Rewrite
+		# 	rewrite.extract_prefix id: Integer do
+		# 		@user = User.find(@id)
+		# 	end
 		module Rewrite
 			def self.prepended(base)
 				base.extend(ClassMethods)
 			end
 			
+			# A abstract rule which can match against a request path.
 			class Rule
 				def apply_match_to_context(match_data, context)
 					match_data.names.each do |name|
@@ -42,6 +43,7 @@ module Utopia
 				end
 			end
 			
+			# A rule which extracts a prefix pattern from the request path.
 			class ExtractPrefixRule < Rule
 				def initialize(patterns, block)
 					@matcher = Path::Matcher.new(patterns)
@@ -70,6 +72,7 @@ module Utopia
 				end
 			end
 			
+			# Rewrite a request path based on a set of defined rules.
 			class Rewriter
 				def initialize
 					@rules = []
@@ -94,6 +97,7 @@ module Utopia
 				end
 			end
 			
+			# Exposed to the controller class.
 			module ClassMethods
 				def rewrite
 					@rewriter ||= Rewriter.new