utopia 1.4.0 → 1.5.0

data/lib/utopia/content/transaction.rb

@@ -22,6 +22,7 @@ require_relative 'links'
 
 module Utopia
 	class Content
+		# This error is thrown if a tag doesn't match up when parsing the 
 		class UnbalancedTagError < StandardError
 			def initialize(tag)
 				@tag = tag
@@ -32,114 +33,47 @@ module Utopia
 			attr :tag
 		end
 		
-		# A single request through content middleware.
+		DEFERRED_TAG_NAME = "deferred".freeze
+		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
-			# The state of a single tag being rendered.
-			class State
-				def initialize(tag, node)
-					@node = node
-
-					@buffer = StringIO.new
-					@overrides = {}
-
-					@tags = []
-					@attributes = tag.to_hash
-
-					@content = nil
-					@deferred = []
-				end
-
-				attr :attributes
-				attr :overrides
-				attr :content
-				attr :node
-				attr :tags
-
-				attr :deferred
-
-				def defer(value = nil, &block)
-					@deferred << block
+			# extend Gem::Deprecate
+			
+			def initialize(request, response, attributes = {})
+				@request = request
+				@response = response
+				
+				@attributes = attributes
 				
-					Tag.closed("deferred", :id => @deferred.size - 1).to_html
-				end
-
-				def [](key)
-					@attributes[key.to_s]
-				end
-
-				def call(transaction)
-					@content = @buffer.string
-					@buffer = StringIO.new
-					
-					if node.respond_to? :call
-						node.call(transaction, self)
-					else
-						transaction.parse_xml(@content)
-					end
-
-					return @buffer.string
-				end
-
-				def lookup(tag)
-					if override = @overrides[tag.name]
-						if override.respond_to? :call
-							return override.call(tag)
-						elsif String === override
-							return Tag.new(override, tag.attributes)
-						else
-							return override
-						end
-					else
-						return tag
-					end
-				end
-
-				def cdata(text)
-					@buffer.write(text)
-				end
-
-				def markup(text)
-					cdata(text)
-				end
-
-				def tag_complete(tag)
-					tag.write_full_html(@buffer)
-				end
-
-				def tag_begin(tag)
-					@tags << tag
-					tag.write_open_html(@buffer)
-				end
-
-				def tag_end(tag)
-					raise UnbalancedTagError(tag) unless @tags.pop.name == tag.name
-
-					tag.write_close_html(@buffer)
-				end
-			end
-
-			def initialize(request, response)
 				@begin_tags = []
 				@end_tags = []
-
-				@request = request
-				@response = response
 			end
-
-			attr :request
-			attr :response
 			
 			# A helper method for accessing controller variables from view:
 			def controller
-				@request.env[VARIABLES_KEY]
+				@controller ||= Utopia::Controller[request]
+			end
+			
+			def localization
+				@localization ||= Utopia::Localization[request]
 			end
 
-			def parse_xml(xml_data)
-				Processor.parse_xml(xml_data, self)
+			def parse_markup(markup)
+				Processor.parse_markup(markup, self)
 			end
 
+			# The Rack::Request for this transaction.
+			attr :request
+
+			# The mutable Rack::Response for this transaction.
+			attr :response
+
+			# Per-transaction global attributes.
+			attr :attributes
+
 			# Begin tags represents a list from outer to inner most tag.
-			# At any point in parsing xml, begin_tags is a list of the inner most tag,
+			# At any point in parsing markup, begin_tags is a list of the inner most tag,
 			# then the next outer tag, etc. This list is used for doing dependent lookups.
 			attr :begin_tags
 
@@ -147,30 +81,6 @@ module Utopia
 			# have appeared when evaluating nodes.
 			attr :end_tags
 
-			def attributes
-				return current.attributes
-			end
-
-			def localization
-				@localization ||= Utopia::Localization[request]
-			end
-
-			def current
-				@begin_tags[-1]
-			end
-
-			def content
-				@end_tags[-1].content
-			end
-
-			def parent
-				end_tags[-2]
-			end
-
-			def first
-				@begin_tags[0]
-			end
-
 			def tag(name, attributes = {}, &block)
 				tag = Tag.new(name, attributes)
 
@@ -182,7 +92,7 @@ module Utopia
 			end
 
 			def tag_complete(tag, node = nil)
-				if tag.name == "content"
+				if tag.name == CONTENT_TAG_NAME
 					current.markup(content)
 				else
 					node ||= lookup(tag)
@@ -201,7 +111,7 @@ module Utopia
 
 				if node
 					state = State.new(tag, node)
-					@begin_tags << state
+					self.begin_tags << state
 
 					if node.respond_to? :tag_begin
 						node.tag_begin(self, state)
@@ -219,31 +129,21 @@ module Utopia
 				current.cdata(text)
 			end
 
-			def partial(*args, &block)
-				if block_given?
-					current.defer(&block)
-				else
-					current.defer do
-						tag(*args)
-					end
-				end
-			end
-
-			alias deferred_tag partial
-
 			def tag_end(tag = nil)
+				# 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)
 					end
 
-					@end_tags << top
+					self.end_tags << top
 					buffer = top.call(self)
 
-					@begin_tags.pop
-					@end_tags.pop
+					self.begin_tags.pop
+					self.end_tags.pop
 
 					if current
 						current.markup(buffer)
@@ -258,8 +158,7 @@ module Utopia
 			end
 
 			def render_node(node, attributes = {})
-				state = State.new(attributes, node)
-				@begin_tags << state
+				self.begin_tags << State.new(attributes, node)
 
 				return tag_end
 			end
@@ -269,29 +168,121 @@ module Utopia
 				result = tag
 				node = nil
 
-				@begin_tags.reverse_each do |state|
+				self.begin_tags.reverse_each do |state|
 					result = state.lookup(result)
 					
 					node ||= state.node if state.node.respond_to? :lookup
 
-					return result if Node === result
+					return result if result.is_a?(Node)
 				end
 
-				@end_tags.reverse_each do |state|
+				self.end_tags.reverse_each do |state|
 					return state.node.lookup(result) if state.node.respond_to? :lookup
 				end
 
 				return nil
 			end
+			
+			# The current tag being processed/rendered. Prefer to access state directly.
+			def current
+				@begin_tags.last
+			end
+
+			# The content of the node 
+			def content
+				@end_tags.last.content
+			end
+
+			def parent
+				@end_tags[-2]
+			end
+
+			def first
+				@begin_tags.first
+			end
+		end
+		
+		# The state of a single tag being rendered within a Transaction instance.
+		class Transaction::State
+			def initialize(tag, node, attributes = tag.to_hash)
+				@node = node
+
+				@buffer = StringIO.new
+				@overrides = {}
+
+				@tags = []
+				@attributes = attributes
+
+				@content = nil
+				@deferred = []
+			end
+
+			attr :attributes
+			attr :overrides
+			attr :content
+			attr :node
+			attr :tags
+
+			attr :deferred
+
+			def defer(value = nil, &block)
+				@deferred << block
+				
+				Tag.closed(DEFERRED_TAG_NAME, :id => @deferred.size - 1).to_html
+			end
+			
+			def [](key)
+				@attributes[key]
+			end
 
-			def method_missing(name, *args)
-				@begin_tags.reverse_each do |state|
-					if state.node.respond_to? name
-						return state.node.send(name, *args)
+			def lookup(tag)
+				if override = @overrides[tag.name]
+					if override.respond_to? :call
+						return override.call(tag)
+					elsif String === override
+						return Tag.new(override, tag.attributes)
+					else
+						return override
 					end
+				else
+					return tag
 				end
+			end
+
+			def call(transaction)
+				@content = @buffer.string
+				@buffer = StringIO.new
+				
+				if node.respond_to? :call
+					node.call(transaction, self)
+				else
+					transaction.parse_markup(@content)
+				end
+				
+				return @buffer.string
+			end
+
+			def cdata(text)
+				@buffer.write(text)
+			end
+
+			def markup(text)
+				cdata(text)
+			end
+
+			def tag_complete(tag)
+				tag.write_full_html(@buffer)
+			end
+
+			def tag_begin(tag)
+				@tags << tag
+				tag.write_open_html(@buffer)
+			end
+
+			def tag_end(tag)
+				raise UnbalancedTagError(tag) unless @tags.pop.name == tag.name
 
-				super
+				tag.write_close_html(@buffer)
 			end
 		end
 	end

data/lib/utopia/content_length.rb

@@ -0,0 +1,50 @@
+# 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 'middleware'
+
+module Utopia
+	# A faster implementation of Rack::ContentLength which doesn't rewrite body, but does expect it to either be an Array or an object that responds to #bytesize.
+	class ContentLength
+		def initialize(app)
+			@app = app
+		end
+		
+		def content_length_of(body)
+			if body.is_a? Array
+				return body.map(&:bytesize).reduce(0, :+)
+			else
+				return body.bytesize
+			end
+		end
+		
+		def call(env)
+			response = @app.call(env)
+			
+			unless response[2].empty? or response[1].include?(Rack::CONTENT_LENGTH)
+				if content_length = self.content_length_of(response[2])
+					response[1][Rack::CONTENT_LENGTH] = content_length
+				end
+			end
+			
+			return response
+		end
+	end
+end

data/lib/utopia/controller.rb

@@ -47,6 +47,10 @@ module Utopia
 	class Controller
 		CONTROLLER_RB = 'controller.rb'.freeze
 		
+		def self.[] request
+			request.env[VARIABLES_KEY]
+		end
+		
 		def initialize(app, root: nil, cache_controllers: false)
 			@app = app
 			@root = root || Utopia::default_root

data/lib/utopia/controller/variables.rb

@@ -62,7 +62,7 @@ module Utopia
 				
 				if controller = self.top
 					controller.instance_variables.each do |name|
-						key = name[1..-1]
+						key = name[1..-1].to_sym
 						
 						attributes[key] = controller.instance_variable_get(name)
 					end

data/lib/utopia/http.rb

@@ -45,6 +45,7 @@ module Utopia
 			:unsupported_method => 405,
 			:gone => 410,
 			:teapot => 418,
+			:unprocessible => 422, # The best status code for a client-side ArgumentError.
 			:error => 500,
 			:unimplemented => 501,
 			:unavailable => 503
@@ -79,6 +80,7 @@ module Utopia
 			409 => 'Request Conflict'.freeze,
 			410 => 'Resource Removed'.freeze,
 			416 => 'Byte range unsatisfiable'.freeze,
+			422 => 'Unprocessible Entity'.freeze,
 			500 => 'Internal Server Error'.freeze,
 			501 => 'Not Implemented'.freeze,
 			503 => 'Service Unavailable'.freeze