trenni 2.1.0 → 3.0.0

data/lib/trenni/markup.rb

@@ -18,47 +18,46 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'substitutions'
+require 'cgi'
 
 module Trenni
 	# A wrapper which indicates that `value` can be appended to the output buffer without any changes.
 	module Markup
-		# Generates a string suitable for concatenating with the output buffer.
-		def self.escape(value)
+		# Converts special characters `<`, `>`, `&`, and `"` into their equivalent entities.
+		# @return [String] May return the original string if no changes were made.
+		def self.escape_string(string)
+			CGI.escape_html(string)
+		end
+		
+		# Appends a string to the output buffer, escaping if if necessary.
+		def self.append(buffer, value)
 			if value.is_a? Markup
-				value
+				buffer << value
 			elsif value
-				MarkupString.new(value.to_s)
-			else
-				# String#<< won't accept nil, so we return an empty string, thus ensuring a fixed point function:
-				EMPTY
+				buffer << self.escape_string(value.to_s)
 			end
 		end
-		
-		def escape(value)
-			Markup.escape(value)
-		end
 	end
 	
 	# Initialized from text which is escaped to use HTML entities.
 	class MarkupString < String
 		include Markup
 		
-		# This is only casually related to HTML, it's just enough so that it would not be mis-interpreted by `Trenni::Parser`.
-		ESCAPE = Substitutions.new("&" => "&amp;", "<" => "&lt;", ">" => "&gt;", "\"" => "&quot;")
-		
-		# Convert ESCAPE characters into their corresponding entities.
+		# @param string [String] the string value itself.
+		# @param escape [Boolean] whether or not to escape the string.
 		def initialize(string = nil, escape = true)
 			if string
-				super(string)
+				if escape
+					string = Markup.escape_string(string)
+				end
 				
-				# self.replace CGI.escapeHTML(self)
-				ESCAPE.gsub!(self) if escape
+				super(string)
 			else
 				super()
 			end
 		end
 		
+		# Generate a valid MarkupString withot any escaping.
 		def self.raw(string)
 			self.new(string, false)
 		end
@@ -69,10 +68,4 @@ module Trenni
 			MarkupString.new(JSON.dump(value), false)
 		end
 	end
-	
-	def self.MarkupString(value)
-		Markup.escape(value)
-	end
-	
-	Markup::EMPTY = String.new.extend(Markup).freeze
 end

data/lib/trenni/native.rb

@@ -20,9 +20,12 @@
 
 require_relative 'parse_error'
 
+# Methods on the following classes may be replaced by native implementations:
+require_relative 'tag'
+
 begin
 	# Load native code:
 	require_relative 'trenni'
 rescue LoadError
 	warn "Could not load native implementation: #{$!}" if $VERBOSE
-end
+end unless ENV['TRENNI_PREFER_FALLBACK']

data/lib/trenni/parsers.rb

@@ -2,7 +2,7 @@
 require_relative 'native'
 require_relative 'parse_delegate'
 
-if defined? Trenni::Native and !ENV['TRENNI_PREFER_FALLBACK']
+if defined? Trenni::Native
 	Trenni::Parsers = Trenni::Native
 else
 	require_relative 'fallback/markup'

data/lib/trenni/tag.rb

@@ -0,0 +1,130 @@
+# Copyright, 2012, 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 'markup'
+
+module Trenni
+	# This represents an individual SGML tag, e.g. <a>, </a> or <a />, with attributes. Attribute values must be escaped.
+	Tag = Struct.new(:name, :closed, :attributes) do
+		include Trenni::Markup
+		
+		def self.split(qualified_name)
+			if i = qualified_name.index(':')
+				return qualified_name.slice(0...i), qualified_name.slice(i+1..-1)
+			else
+				return nil, qualified_name
+			end
+		end
+		
+		def self.closed(name, **attributes)
+			self.new(name, true, attributes)
+		end
+		
+		def self.opened(name, **attributes)
+			self.new(name, false, attributes)
+		end
+		
+		def [] key
+			attributes[key]
+		end
+		
+		alias to_hash attributes
+		
+		def to_s(content = nil)
+			self.class.format_tag(name, attributes, content || !closed)
+		end
+		
+		alias to_str to_s
+		
+		def self_closed?
+			closed
+		end
+		
+		def write_opening_tag(buffer)
+			buffer << '<' << name
+			
+			self.class.append_attributes(buffer, attributes, nil)
+			
+			if self_closed?
+				buffer << '/>'
+			else
+				buffer << '>'
+			end
+		end
+		
+		def write_closing_tag(buffer)
+			buffer << '</' << name << '>'
+		end
+		
+		def write(buffer, content = nil)
+			self.class.append_tag(buffer, name, attributes, content || !closed)
+		end
+		
+		def self.format_tag(name, attributes, content)
+			buffer = String.new.force_encoding(name.encoding)
+			
+			self.append_tag(buffer, name, attributes, content)
+			
+			return buffer
+		end
+		
+		def self.append_tag(buffer, name, attributes, content)
+			buffer << '<' << name.to_s
+			
+			self.append_attributes(buffer, attributes, nil)
+			
+			if !content
+				buffer << '/>'
+			else
+				buffer << '>'
+				unless content == true
+					Markup.append(buffer, content)
+				end
+				buffer << '</' << name.to_s << '>'
+			end
+			
+			return nil
+		end
+		
+		# Convert a set of attributes into a string suitable for use within a <tag>.
+		def self.append_attributes(buffer, attributes, prefix)
+			attributes.each do |key, value|
+				next unless value
+				
+				attribute_key = prefix ? "#{prefix}-#{key}" : key
+				
+				case value
+				when Hash
+					self.append_attributes(buffer, value, attribute_key)
+				when Array
+					self.append_attributes(buffer, value, attribute_key)
+				when TrueClass
+					buffer << ' ' << attribute_key.to_s
+				else
+					buffer << ' ' << attribute_key.to_s << '="'
+					Markup.append(buffer, value)
+					buffer << '"'
+				end
+			end
+			
+			return nil
+		end
+	end
+end

data/lib/trenni/template.rb

@@ -59,9 +59,8 @@ module Trenni
 		end
 		
 		class Assembler
-			def initialize(filter: String, encoding: Encoding::UTF_8)
+			def initialize(encoding: Encoding::UTF_8)
 				@code = String.new.force_encoding(encoding)
-				@filter = filter
 			end
 
 			attr :code
@@ -83,20 +82,27 @@ module Trenni
 			# Output a string interpolation.
 			def expression(text)
 				# Double brackets are required here to handle expressions like #{foo rescue "bar"}.
-				@code << "#{OUT}<<#{@filter}((#{text}));"
+				@code << "#{OUT}<<String(#{text});"
 			end
 		end
 		
-		def self.load_file(path, **options)
-			self.new(FileBuffer.new(path), **options)
+		def self.load_file(path, *args)
+			self.new(FileBuffer.new(path), *args).freeze
 		end
 
-		def initialize(buffer, filter: String)
+		def initialize(buffer)
 			@buffer = buffer
-			@filter = filter
 		end
-
-		def to_string(scope = Object.new, output = output_buffer)
+		
+		def freeze
+			return self if frozen?
+			
+			to_proc
+			
+			super
+		end
+		
+		def to_string(scope = Object.new, output = nil)
 			output ||= output_buffer
 			
 			scope.instance_exec(output, &to_proc)
@@ -105,9 +111,9 @@ module Trenni
 		def to_buffer(scope)
 			Buffer.new(to_string(scope), path: @buffer.path)
 		end
-
+		
 		def to_proc(scope = nil)
-			@compiled_proc ||= eval("proc{|#{OUT}|;#{code};#{OUT}}", scope, @buffer.path)
+			@compiled_proc ||= eval("proc{|#{OUT}|;#{code};#{OUT}}", scope, @buffer.path).freeze
 		end
 		
 		protected
@@ -120,8 +126,12 @@ module Trenni
 			@code ||= compile!
 		end
 		
+		def make_assembler
+			Assembler.new
+		end
+		
 		def compile!
-			assembler = Assembler.new(filter: @filter)
+			assembler = make_assembler
 			
 			Parsers.parse_template(@buffer, assembler)
 			
@@ -130,11 +140,21 @@ module Trenni
 	end
 	
 	class MarkupTemplate < Template
-		def initialize(buffer, filter: MarkupString)
-			super
+		class Assembler < Template::Assembler
+			# Output a string interpolation.
+			def expression(text)
+				@code << "Markup.append(#{OUT},(#{text}));"
+			end
+		end
+		
+		protected
+		
+		# We need an assembler which builds specific `Markup.append` sequences.
+		def make_assembler
+			Assembler.new
 		end
 		
-		# The output of the markup template is encoded markup (e.g. with entities, tags, etc)
+		# The output of the markup template is encoded markup (e.g. with entities, tags, etc).
 		def output_buffer
 			MarkupString.new.force_encoding(code.encoding)
 		end

data/lib/trenni/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Trenni
-	VERSION = "2.1.0"
+	VERSION = "3.0.0"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+
+if ENV['COVERAGE']
+	begin
+		require 'simplecov'
+		
+		SimpleCov.start do
+			add_filter "/spec/"
+		end
+		
+		if ENV['TRAVIS']
+			require 'coveralls'
+			Coveralls.wear!
+		end
+	rescue LoadError
+		warn "Could not load simplecov: #{$!}"
+	end
+end
+
+require "bundler/setup"
+require "trenni"
+
+RSpec.configure do |config|
+	# Enable flags like --only-failures and --next-failure
+	config.example_status_persistence_file_path = ".rspec_status"
+
+	config.expect_with :rspec do |c|
+		c.syntax = :expect
+	end
+end

data/spec/trenni/builder_spec.rb

@@ -23,7 +23,7 @@
 require 'trenni'
 
 module Trenni::BuilderSpec
-	describe 'Trenni::Builder#tag_attributes' do
+	describe 'Trenni::Builder#tag' do
 		subject {Trenni::Builder.new}
 		
 		it "should format nested attributes" do

data/spec/trenni/markup_parser_spec.rb

@@ -115,6 +115,11 @@ RSpec.describe "<foo bar=\"20\" baz>Hello World</foo>" do
 		expect(events[4][1].encoding).to be == subject.encoding
 		expect(events[5][1].encoding).to be == subject.encoding
 	end
+	
+	it "should track entities" do
+		expect(events[1][2]).to be_kind_of Trenni::Markup
+		expect(events[4][1]).to be_kind_of Trenni::Markup
+	end
 end
 
 RSpec.describe "<test><![CDATA[Hello World]]></test>" do
@@ -150,10 +155,25 @@ RSpec.describe "<p attr=\"foo&amp;bar\">&quot;</p>" do
 	let(:template_buffer) {Trenni::Buffer(template_text)}
 	let(:template) {Trenni::MarkupTemplate.new(template_buffer)}
 	
+	it "should parse empty attributes" do
+		expect(events).to be == [
+			[:open_tag_begin, "p", 1],
+			[:attribute, "attr", "foo&bar"],
+			[:open_tag_end, false],
+			[:text, "\""],
+			[:close_tag, "p", 30]
+		]
+	end
+	
 	it "generates same output as input" do
 		result = template.to_string(self)
 		expect(result).to be == subject
 	end
+	
+	it "should track entities" do
+		expect(events[1][2]).to_not be_kind_of Trenni::Markup
+		expect(events[3][1]).to_not be_kind_of Trenni::Markup
+	end
 end
 
 RSpec.shared_examples "valid markup file" do |base|

data/spec/trenni/markup_performance_spec.rb

@@ -0,0 +1,26 @@
+
+require 'benchmark/ips'
+require 'trenni/markup'
+
+RSpec.describe Trenni::Markup do
+	let(:code_string) {'javascript:if (foo < bar) {alert("Hello World")}'}
+	let(:general_string) {"a" * code_string.size}
+	
+	it "should be fast to parse large documents" do
+		Benchmark.ips do |x|
+			x.report("General String") do |times|
+				while (times -= 1) >= 0
+					Trenni::Markup.escape_string(general_string)
+				end
+			end
+			
+			x.report("Code String") do |times|
+				while (times -= 1) >= 0
+					Trenni::Markup.escape_string(code_string)
+				end
+			end
+			
+			x.compare!
+		end
+	end
+end

data/spec/trenni/markup_spec.rb

@@ -43,6 +43,8 @@ RSpec.describe Trenni::MarkupString do
 	end
 	
 	it "should convert nil to empty string" do
-		expect(Trenni::MarkupString(nil)).to be == ""
+		Trenni::Markup.append(subject, nil)
+		
+		expect(subject).to be_empty
 	end
 end