utopia 1.8.3 → 1.9.0

data/documentation/tasks/utopia.rake

@@ -0,0 +1,38 @@
+
+desc 'Run by git post-update hook when deployed to a web server'
+task :deploy do
+	# This task is typiclly run after the site is updated but before the server is restarted.
+end
+
+desc 'Restart the application server'
+task :restart do
+	# This task is run after the deployment task above.
+	if passenger_config = `which passenger-config`.chomp!
+		sh(passenger_config, 'restart-app', '--ignore-passenger-not-running', File.dirname(__dir__))
+	end
+end
+
+desc 'Set up the environment for running your web application'
+task :environment do
+	require_relative '../config/environment'
+end
+
+desc 'Run a server for testing your web application'
+task :server => :environment do
+	port = ENV.fetch('SERVER_PORT', 9292).to_s
+	exec('puma', '-v', '-p', port)
+end
+
+desc 'Start an interactive console for your web application'
+task :console => :environment do
+	require 'pry'
+	require 'rack/test'
+	
+	include Rack::Test::Methods
+	
+	def app
+		@app ||= Rack::Builder.parse_file(File.expand_path("../config.ru", __dir__)).first
+	end
+	
+	Pry.start
+end

data/lib/utopia/content.rb

@@ -60,10 +60,10 @@ module Utopia
 		def fetch_template(path)
 			if @template_cache
 				@template_cache.fetch_or_store(path.to_s) do
-					Trenni::Template.load_file(path)
+					Trenni::MarkupTemplate.load_file(path)
 				end
 			else
-				Trenni::Template.load_file(path)
+				Trenni::MarkupTemplate.load_file(path)
 			end
 		end
 		

data/lib/utopia/content/link.rb

@@ -21,6 +21,8 @@
 require 'yaml'
 require 'trenni/builder'
 
+require 'trenni/strings'
+
 require_relative '../path'
 require_relative '../locale'
 
@@ -86,7 +88,7 @@ module Utopia
 				@info.fetch(:title, @title)
 			end
 
-			def to_href(**options)
+			def to_anchor(**options)
 				Trenni::Builder.fragment(options[:builder]) do |builder|
 					if href?
 						relative_href(options[:base])
@@ -102,6 +104,8 @@ module Utopia
 				end
 			end
 			
+			alias to_href to_anchor
+			
 			def to_s
 				"\#<#{self.class}(#{self.kind}) title=#{title.inspect} href=#{href.inspect}>"
 			end

data/lib/utopia/content/markup.rb

@@ -18,7 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'trenni/parser'
+require 'trenni/parsers'
+require 'trenni/entities'
 require 'trenni/strings'
 
 require_relative 'tag'
@@ -48,106 +49,125 @@ module Utopia
 			end
 		end
 		
-		class Markup
-			def self.parse!(markup, delegate)
-				# This is for compatibility with the existing API which passes in a string:
-				markup = Trenni::Buffer.new(markup) if markup.is_a? String
+		class MarkupParser
+			class ParsedTag
+				def initialize(name, offset)
+					@offset = offset
+					@tag = Tag.new(name, false, SymbolicHash.new)
+				end
+				
+				attr :tag
+				attr :offset
 				
-				self.new(markup, delegate).parse!
+				def to_s
+					@tag.to_s
+				end
 			end
-
+			
 			class UnbalancedTagError < StandardError
-				def initialize(scanner, start_position, current_tag, closing_tag)
-					@scanner = scanner
-					@start_position = start_position
-					@current_tag = current_tag
+				def initialize(buffer, opening_tag, closing_tag = nil)
+					@buffer = buffer
+					@opening_tag = current_tag
 					@closing_tag = closing_tag
-					
-					@starting_line = Trenni::Location.new(@scanner.string, @start_position)
-					@ending_line = Trenni::Location.new(@scanner.string, @scanner.pos)
 				end
 
-				attr :scanner
-				attr :start_position
+				attr :buffer
 				attr :current_tag
 				attr :closing_tag
-
+				
+				def start_location
+					Trenni::Location.new(@buffer.read, current_tag.offset)
+				end
+				
+				def end_location
+					if closing_tag and closing_tag.respond_to? :offset
+						Trenni::Location.new(@buffer.read, closing_tag.offset)
+					end
+				end
+				
 				def to_s
-					"Unbalanced Tag Error. Line #{@starting_line}: #{@current_tag} has been closed by #{@closing_tag} on line #{@ending_line}!"
+					if @closing_tag
+						"#{start_location}: #{@opening_tag} was not closed!"
+					else
+						"#{start_location}: #{@opening_tag} was closed by #{@closing_tag}!"
+					end
 				end
 			end
-
-			def initialize(buffer, delegate)
+			
+			def self.parse(buffer, delegate, entities = Trenni::Entities::HTML5)
+				# This is for compatibility with the existing API which passes in a string:
+				buffer = Trenni::Buffer(buffer)
+				
+				self.new(buffer, delegate).parse!
+			end
+			
+			def initialize(buffer, delegate, entities = Trenni::Entities::HTML5)
 				@buffer = buffer
+				
 				@delegate = delegate
+				@entities = entities
+				
+				@current = nil
 				@stack = []
 			end
-
+			
 			def parse!
-				Trenni::Parser.new(@buffer, self).parse!
+				Trenni::Parsers.parse_markup(@buffer, self, @entities)
 				
-				unless @stack.empty?
-					current_tag, current_position = @stack.pop
-					
-					raise UnbalancedTagError.new(@scanner, current_position, current_tag.name, 'EOF')
+				if tag = @stack.pop
+					raise UnbalancedTagError.new(@buffer, tag)
 				end
 			end
 
-			def begin_parse(scanner)
-				@scanner = scanner
-			end
-			
-			def doctype(attributes)
-				@delegate.cdata("<!DOCTYPE #{attributes}>")
+			def open_tag_begin(name, offset)
+				@current = ParsedTag.new(name, offset)
 			end
 
-			def text(text)
-				@delegate.cdata(text)
+			def attribute(key, value)
+				@current.tag.attributes[key] = value
 			end
 
-			def cdata(text)
-				@delegate.cdata("<![CDATA[#{text}]]>")
+			def open_tag_end(self_closing)
+				if self_closing
+					@current.tag.closed = true
+					@delegate.tag_complete(@current.tag)
+				else
+					@stack << @current
+					@delegate.tag_begin(@current.tag)
+				end
+				
+				@current = nil
 			end
 
-			def comment(text)
-				@delegate.cdata("<!--#{text}-->")
+			def close_tag(name, offset)
+				@current = @stack.pop
+				tag = @current.tag
+				
+				if tag.name != name
+					raise UnbalancedTagError.new(@buffer, tag, ParsedTag.new(name, offset))
+				end
+				
+				@delegate.tag_end(tag)
 			end
-
-			def begin_tag(tag_name, begin_tag_type)
-				if begin_tag_type == :opened
-					@stack << [Tag.new(tag_name, SymbolicHash.new), @scanner.pos]
-				else
-					current_tag, current_position = @stack.pop
-			
-					if tag_name != current_tag.name
-						raise UnbalancedTagError.new(@scanner, current_position, current_tag.name, tag_name)
-					end
 			
-					@delegate.tag_end(current_tag)
-				end
+			def doctype(string)
+				@delegate.write(string)
 			end
 
-			def finish_tag(begin_tag_type, end_tag_type)
-				if begin_tag_type == :opened # <...
-					if end_tag_type == :closed # <.../>
-						cur, pos = @stack.pop
-						cur.closed = true
-
-						@delegate.tag_complete(cur)
-					elsif end_tag_type == :opened # <...>
-						cur, pos = @stack.last
+			def comment(string)
+				@delegate.write(string)
+			end
 
-						@delegate.tag_begin(cur)
-					end
-				end
+			def instruction(string)
+				@delegate.write(string)
 			end
 
-			def attribute(name, value)
-				@stack.last[0].attributes[name.to_sym] = value
+			def cdata(string)
+				@delegate.write(string)
 			end
 
-			def instruction(content)
-				cdata("<?#{content}?>")
+			def text(string)
+				@delegate.text(string)
 			end
 		end
 	end

data/lib/utopia/content/tag.rb

@@ -18,63 +18,46 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'trenni/markup'
+
 module Utopia
 	class Content
 		# This represents an individual SGML tag, e.g. <a>, </a> or <a />, with attributes. Attribute values must be escaped.
-		class Tag
-			def == other
-				if Tag === other
-					[@name, @attributes, @closed] == [other.name, other.attributes, other.closed]
-				end
-			end
+		Tag = Struct.new(:name, :closed, :attributes) do
+			include Trenni::Markup
 			
-			def self.closed(name, attributes = {})
-				tag = Tag.new(name, attributes)
-				tag.closed = true
-				
-				return tag
+			def self.closed(name, **attributes)
+				self.new(name, true, attributes)
 			end
 			
-			def initialize(name, attributes = {})
-				@name = name
-				@attributes = attributes
-				@closed = false
-			end
-
-			def freeze
-				@name.freeze
-				@attributes.freeze
-				@closed.freeze
-				
-				super
-			end
-
-			attr_accessor :name
-			attr_accessor :attributes
-			attr_accessor :closed
-
-			def [](key)
-				@attributes[key]
+			def self.opened(name, **attributes)
+				self.new(name, false, attributes)
 			end
 			
-			def to_hash
-				@attributes
+			def [] key
+				attributes[key]
 			end
 			
+			alias to_hash attributes
+			
 			def to_s(content = nil)
-				buffer = String.new
+				buffer = String.new.force_encoding(name.encoding)
 				
-				write_full_html(buffer, content)
+				write(buffer, content)
 				
 				return buffer
 			end
 			
-			alias to_html to_s
+			alias to_str to_s
+			
+			def self_closed?
+				closed
+			end
 			
-			def write_open_html(buffer, terminate = false)
+			def write_opening_tag(buffer, self_closing = false)
 				buffer << "<#{name}"
 
-				@attributes.each do |key, value|
+				attributes.each do |key, value|
 					if value
 						buffer << " #{key}=\"#{value}\""
 					else
@@ -82,24 +65,24 @@ module Utopia
 					end
 				end
 				
-				if terminate
+				if self_closing
 					buffer << "/>"
 				else
 					buffer << ">"
 				end
 			end
 			
-			def write_close_html(buffer)
+			def write_closing_tag(buffer)
 				buffer << "</#{name}>"
 			end
 			
-			def write_full_html(buffer, content = nil)
-				if @closed and content.nil?
-					write_open_html(buffer, true)
+			def write(buffer, content = nil)
+				if closed and content.nil?
+					write_opening_tag(buffer, true)
 				else
-					write_open_html(buffer)
+					write_opening_tag(buffer)
 					buffer << content if content
-					write_close_html(buffer)
+					write_closing_tag(buffer)
 				end
 			end
 		end

data/lib/utopia/content/transaction.rb

@@ -29,7 +29,7 @@ module Utopia
 			def initialize(tag)
 				@tag = tag
 				
-				super("Unbalanced tag #{tag.name}")
+				super "Unbalanced tag #{tag.name}"
 			end
 			
 			attr :tag
@@ -48,12 +48,13 @@ module Utopia
 				@begin_tags = []
 				@end_tags = []
 				
+				# TODO: Provide way to set encoding and content type.
+				#@encoding = Encoding::UTF_8
+				#self.content_type = "text/html; charset=#{@encoding.name}"
+				
 				super()
 			end
 			
-			attr :status
-			attr :headers
-			
 			# A helper method for accessing controller variables from view:
 			def controller
 				@controller ||= Utopia::Controller[request]
@@ -64,7 +65,7 @@ module Utopia
 			end
 
 			def parse_markup(markup)
-				Markup.parse!(markup, self)
+				MarkupParser.parse(markup, self)
 			end
 
 			# The Rack::Request for this transaction.
@@ -83,7 +84,8 @@ module Utopia
 			attr :end_tags
 
 			def tag(name, attributes = {}, &block)
-				tag = Tag.new(name, attributes)
+				# If we provide a block which can give inner data, we are not self-closing.
+				tag = Tag.new(name, !block_given?, attributes)
 
 				node = tag_begin(tag)
 
@@ -94,7 +96,7 @@ module Utopia
 
 			def tag_complete(tag, node = nil)
 				if tag.name == CONTENT_TAG_NAME
-					current.markup(content)
+					current.write(content)
 				else
 					node ||= lookup(tag)
 
@@ -125,9 +127,15 @@ module Utopia
 
 				return nil
 			end
+			
+			def write(string)
+				current.write(string)
+			end
+			
+			alias cdata write
 
-			def cdata(text)
-				current.cdata(text)
+			def text(string)
+				current.text(string)
 			end
 
 			def tag_end(tag = nil)
@@ -146,7 +154,7 @@ module Utopia
 					self.end_tags.pop
 
 					if current
-						current.markup(buffer)
+						current.write(buffer)
 					end
 
 					return buffer
@@ -188,7 +196,7 @@ module Utopia
 				@begin_tags.last
 			end
 
-			# The content of the node 
+			# The content of the node
 			def content
 				@end_tags.last.content
 			end
@@ -207,14 +215,13 @@ module Utopia
 			def initialize(tag, node, attributes = tag.to_hash)
 				@node = node
 				
-				# The contents of the output
-				@buffer = String.new
+				@buffer = Trenni::MarkupString.new.force_encoding(Encoding::UTF_8)
 				
 				@overrides = {}
-
+				
 				@tags = []
 				@attributes = attributes
-
+				
 				@content = nil
 				@deferred = []
 			end
@@ -230,7 +237,7 @@ module Utopia
 			def defer(value = nil, &block)
 				@deferred << block
 				
-				Tag.closed(DEFERRED_TAG_NAME, :id => @deferred.size - 1).to_s
+				Tag.closed(DEFERRED_TAG_NAME, :id => @deferred.size - 1)
 			end
 			
 			def [](key)
@@ -253,7 +260,7 @@ module Utopia
 
 			def call(transaction)
 				@content = @buffer
-				@buffer = String.new
+				@buffer = Trenni::MarkupString.new.force_encoding(Encoding::UTF_8)
 				
 				if node.respond_to? :call
 					node.call(transaction, self)
@@ -264,27 +271,26 @@ module Utopia
 				return @buffer
 			end
 
-			def cdata(text)
-				@buffer << text
+			def write(string)
+				@buffer << string
 			end
 
-			def markup(text)
-				cdata(text)
+			def text(string)
+				@buffer << Trenni::MarkupString(string)
 			end
 
 			def tag_complete(tag)
-				tag.write_full_html(@buffer)
+				tag.write(@buffer)
 			end
 
 			def tag_begin(tag)
 				@tags << tag
-				tag.write_open_html(@buffer)
+				tag.write_opening_tag(@buffer)
 			end
 
 			def tag_end(tag)
 				raise UnbalancedTagError(tag) unless @tags.pop.name == tag.name
-
-				tag.write_close_html(@buffer)
+				tag.write_closing_tag(@buffer)
 			end
 		end
 	end