glyph 0.2.0 → 0.3.0

data/spec/lib/macro_validators_spec.rb

@@ -4,13 +4,19 @@ require File.join(File.dirname(__FILE__), "..", "spec_helper")
 describe Glyph::Macro::Validators do
 
 	before do
+		create_project
 		Glyph.run! 'load:all'
 		Glyph.macro :validated_test do
-			validate("Invalid Macro"){	@value == "valid" }
-			"Validated Test: #{@value}"
+			validate("Invalid Macro"){	value == "valid" }
+			"Validated Test: #{value}"
 		end
 	end
 
+	after do
+		reset_quiet
+		delete_project
+	end
+
 	it "should provide custom validation" do
 		lambda { interpret("section[validated_test[invalid]]").document.output }.should raise_error Glyph::MacroError
 		lambda { interpret("chapter[validated_test[valid]]").document.output }.should_not raise_error
@@ -18,16 +24,32 @@ describe Glyph::Macro::Validators do
 
 	it "should validate the number of parameters" do
 		# exact
-		lambda { interpret("table[]").document.output }.should raise_error Glyph::MacroError
+		lambda { interpret("section[sfsdg|saf]").document.output }.should raise_error Glyph::MacroError
 		# none
-		lambda { interpret("toc[test]").document.output }.should raise_error Glyph::MacroError
+		lambda { interpret("title[test]").document.output }.should raise_error Glyph::MacroError
 		# min
-		lambda { interpret("img[]").document.output }.should raise_error Glyph::MacroError
+		lambda { interpret("?[]").document.output }.should raise_error Glyph::MacroError
 		# max
 		lambda { interpret("not[a|b|c]").document.output }.should raise_error Glyph::MacroError
 		# correct
 		lambda { interpret("chapter[fmi[something|#something]]").document.output }.should_not raise_error Glyph::MacroError
 	end
 
+	it "should check for mutual inclusion" do
+		Glyph::SNIPPETS[:inc] = "Test &[inc]"
+		lambda {interpret("&[inc] test").document}.should raise_error(Glyph::MutualInclusionError)
+	end
+
+	it "should validate XML elements" do
+		language 'xml'
+		lambda { interpret("<test[test]").document}.should raise_error
+		lambda { interpret("_test[test]").document}.should_not raise_error
+	end
+
+	it "should validate XML attributes" do
+		language 'xml'
+		output_for("test[test @.test[test]]").should == "<test>test</test>"
+	end
+
 end
 

data/spec/lib/node_spec.rb

@@ -74,11 +74,36 @@ describe Node do
 		result = @ht.find_child do |node|
 			node[:d] == 4
 		end
-		result.should == {:c => 3, :d => 4}
+		result.to_hash.should == {:c => 3, :d => 4}
 		result2 = @ht.find_child do |node|
 			node[:q] == 7
 		end
 		result2.should == nil
 	end
 
+	it "should expose a dedicated inspect method" do
+		create_node
+		@ht << {:c => 3, :d => 4}
+		@ht << {:e => 5, :f => 6}
+		@ht.inspect.should == "#{@ht.to_hash.inspect}\n  #{(@ht&0).to_hash.inspect}\n  #{(@ht&1).to_hash.inspect}"
+	end
+
+	it "should be convertable into a hash" do
+		create_node
+		@ht.to_hash.should == {:a => 1, :b => 2}
+		lambda { @ht.to_hash.children }.should raise_error
+	end
+
+	it "should check equality of children as well" do
+		create_node
+		@ht << {:c => 3, :d => 4}
+		@ht << {:e => 5, :f => 6}
+		@ht2 = {:a => 1, :b => 2}.to_node
+		@ht2 << {:c => 3, :d => 4}
+		@ht2 << {:e => 5, :f => 6}
+		(@ht==@ht2).should == true
+		(@ht&1)[:c] = 47
+		(@ht==@ht2).should == false
+	end
+
 end

data/spec/lib/parser_spec.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Glyph::Parser do
+
+	def parse_text(text)
+		Glyph::Parser.new(text).parse
+	end
+
+	it "should parse macros" do
+		text = %{
+test #1
+section[header[Testing...]
+	=>[#something]
+	Test.
+	section[
+		header[Another test]
+Contents]
+]}
+		tree = document_node
+		tree << text_node("\ntest #1\n")
+		tree << macro_node(:section)
+		(tree&1) << p_node(0)
+		section_0 = tree&1&0
+		section_0 << macro_node(:header)
+		section_0.children.last << p_node(0)
+		header_0 = section_0&0&0
+		header_0 << text_node("Testing...")
+		section_0 << text_node("\n\t")
+		section_0 << macro_node(:"=>")
+		section_0.children.last << p_node(0)
+		link_0 = section_0.children.last&0
+		link_0 << text_node("#something")
+		section_0 << text_node("\n\tTest.\n\t")
+		section_0 << macro_node(:section)
+		section_0.children.last << p_node(0)
+		section_1 = section_0.children.last&0
+		section_1 << text_node("\n\t\t")
+		section_1 << macro_node(:header)
+		section_1.children.last << p_node(0)
+		header_1 = section_1.children.last&0
+		header_1 << text_node("Another test")
+		section_1 << text_node("\nContents")
+		section_0 << text_node("\n")
+		parse_text(text).should == tree
+	end
+
+	it "should recognize escape sequences" do
+		text = "section[This is a test test\\[\\]\\]\\[ ]"
+		tree = document_node
+		tree << macro_node(:section)
+		macro_0 = p_node( 0)
+	 	macro_0	<< text_node("This is a test test")
+		macro_0 << escape_node("\\[")
+		macro_0 << escape_node("\\]")
+		macro_0 << escape_node("\\]")
+		macro_0 << escape_node("\\[")
+		macro_0 << text_node(" ")
+		(tree&0) << macro_0
+		parse_text(text).should == tree
+	end
+
+	it "should raise an error if a standard macro is not closed" do
+		text = "test\nsection[test\\]\ntest"
+		lambda { puts parse_text(text).inspect }.should	raise_error(Glyph::SyntaxError, "-- [3, 4] Macro 'section' not closed")
+	end
+
+	it "should not parse macros within escaping macros" do
+		text = "test1[= abc test2[This macro is escaped]\n cde=]"
+		tree = document_node
+		tree << macro_node(:test1, :escape => true)
+		macro_0 = p_node(0) 
+		macro_0 << text_node(" abc test2[This macro is escaped]\n cde", :escaped => true)
+		(tree&0) << macro_0
+		parse_text(text).should == tree
+	end
+
+	it "should raise an error if escaped contents are nested" do
+		text = "test1[= abc test2[=This macro is escaped=]\n cde=]"
+		lambda  { puts parse_text(text).inspect }.should raise_error(Glyph::SyntaxError, "-- [1, 41] Cannot nest escaping macro 'test2' within escaping macro 'test1'")
+	end
+	
+	it "should raise an error if an escaping macro is not closed" do
+		text = "test1[= abc test2[This macro is escaped]\n cde] test"
+		lambda { puts parse_text(text).inspect }.should	raise_error(Glyph::SyntaxError, "-- [2, 10] Escaping macro 'test1' not closed")
+	end
+
+	it "should raise errors if unescaped brackets are found" do
+		lambda { puts parse_text(" ] test[...] dgdsg").inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 2] Macro delimiter ']' not escaped")
+		lambda { puts parse_text("[ test[...] dgdsg").inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 1] Macro delimiter '[' not escaped")
+		lambda { puts parse_text(" test[...] [dgdsg]").inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 12] Macro delimiter '[' not escaped")
+		lambda { puts parse_text(" test[...] dgdsg [").inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 18] Macro delimiter '[' not escaped")
+		lambda { puts parse_text(" test[[...]] dgdsg").inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 7] Macro delimiter '[' not escaped")
+	end
+
+	it "should parse positional parameters (parameters)" do
+		text = "test[aaa =>[test2[...]|test3[...]].]"
+		tree = document_node
+		tree << macro_node(:test)
+		macro_0 = p_node 0
+		macro_0 << text_node('aaa ')
+		macro_0 << macro_node("=>")
+		(tree&0) << macro_0
+		macro_01_p0 = p_node 0
+		macro_01_p0 << macro_node(:test2)
+		(macro_0&1) << macro_01_p0
+		macro_010 = p_node 0
+		macro_010 << text_node("...")
+		(macro_01_p0&0) << macro_010
+		macro_01_p1 = p_node 1
+		macro_01_p1 << macro_node(:test3)
+		(macro_0&1) << macro_01_p1
+		macro_011 = p_node 0
+		macro_011 << text_node("...")
+		(macro_01_p1&0) << macro_011
+		macro_0 << text_node(".")
+		parse_text(text).should == tree
+	end
+
+	it "should not allow parameters outside macros" do
+		text = "... | test[...]"
+		lambda { puts parse_text(text).inspect }.should raise_error(Glyph::SyntaxError, "-- [1, 5] Parameter delimiter '|' not allowed here")
+	end
+
+	it "should recognize escaped pipes" do
+		text = "\\| test \\| test[=this \\| is|a \\|test=]"
+		tree = document_node
+		tree << escape_node("\\|")
+		tree << text_node(" test ")
+		tree << escape_node("\\|")
+		tree << text_node(" ")
+		tree << macro_node(:test, :escape => true)
+		tree.children.last << p_node(0)
+		test_0 = tree.children.last&0
+		test_0 << text_node("this ", :escaped => true)
+		test_0 << escape_node("\\|")
+		test_0 << text_node(" is", :escaped => true)
+		tree.children.last << p_node(1)
+		test_1 = tree.children.last&1
+		test_1 << text_node("a ", :escaped => true)
+		test_1 << escape_node("\\|")
+		test_1 << text_node("test", :escaped => true)
+		parse_text(text).should == tree
+	end
+
+	it "should parse named parameters (attributes)" do
+		text = "test[@first[test1] @second[=test2[...]=].]"
+		tree = document_node
+		tree << macro_node(:test)
+		first = a_node :first
+		first << text_node("test1")
+		macro_0 = p_node(0)
+		macro_0 << text_node(" ")
+		macro_0 << text_node(".")
+		second = a_node :second, :escape=> true
+		second << text_node("test2[...]", :escaped => true)
+		(tree&0) << macro_0
+		(tree&0) << first
+		(tree&0) << second
+		parse_text(text).should == tree
+	end
+
+	it "should not parse parameters inside attributes" do
+		text = "test[@attr[test|...]]"
+		lambda { puts parse_text(text).inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 16] Parameter delimiter '|' not allowed here")
+	end
+
+	it "should parse attributes inside parameters" do
+		text = "test[parameter 1|@par[...] test]"
+		tree = document_node
+		tree << macro_node(:test)
+		tree.children.last << p_node(0)
+		test_0 = tree.children.last&0
+		test_0 << text_node("parameter 1")
+		tree.children.last << p_node(1)
+		tree.children.last << a_node(:par)
+		test_1 = tree.children.last&1
+		par = tree.children.last&2
+		par << text_node("...")
+		test_1 << text_node(" test")
+		parse_text(text).should == tree
+	end
+
+	it "should not allow attribute nesting" do
+		text = "... test[@par1[@par2[...]...]]"
+		lambda { puts parse_text(text).inspect}.should raise_error(Glyph::SyntaxError, "-- [1, 22] Attributes cannot be nested")
+	end
+
+	it "should parse macros nested in attributes" do
+		text = "test[@a[test1[@b[...]@c[...]]]]"
+		tree = document_node
+		tree << macro_node(:test)
+		a = a_node :a
+		a << macro_node(:test1)
+		(tree&0) << a
+		b = a_node :b
+		b << text_node('...')
+		(a&0) << b
+		c = a_node :c
+		c << text_node('...')
+		(a&0) << c
+		parse_text(text).should == tree
+	end
+
+	it "should parse parameters in nested macros" do
+		text = "test[...|test1[a|b]|...]"
+		tree = document_node
+		tree << macro_node(:test)
+		macro_0_p0 = p_node 0
+		macro_0_p0 << text_node("...")
+		(tree&0) << macro_0_p0
+		macro_0_p1 = p_node 1
+		macro_0_p1 << macro_node(:test1)
+		(tree&0) << macro_0_p1
+		macro_01_p0 = p_node 0
+		macro_01_p0 << text_node('a')
+		(macro_0_p1&0) << macro_01_p0
+		macro_01_p1 = p_node 1
+		macro_01_p1 << text_node('b')
+		(macro_0_p1&0) << macro_01_p1
+		macro_0_p2 = p_node 2
+		macro_0_p2 << text_node("...")
+		(tree&0) << macro_0_p2
+		parse_text(text).should == tree
+	end
+
+	it "should handle escaped sequences before macro names" do
+		text = "abc\\.test[...]"
+		tree = document_node
+		tree << text_node("abc")
+		tree << escape_node("\\.")
+		tree << macro_node(:test)
+		macro_0 = p_node(0) 
+		macro_0 << text_node("...")
+		(tree&2) << macro_0
+		parse_text(text).should == tree
+	end
+
+	it "should ignore parameters for empty macros" do
+		text = "toc[]"
+		tree = document_node
+		tree << macro_node(:toc)
+		parse_text(text).should == tree
+	end
+
+end

data/spec/lib/syntax_node_spec.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Glyph::SyntaxNode do
+
+	it "should evaluate" do
+		t = text_node("test")
+		t.evaluate({})
+		t[:value].should == "test"
+		e = escape_node("\\.")
+		e.evaluate({})
+		e[:value].should == "\\."
+		p = p_node(0)
+		a = a_node(:a)
+		a << e
+		p << t
+		p.evaluate({}, :params => true)
+		p[:value].should == "test"
+		a.evaluate({}, :attrs => true)
+		a[:value].should == "\\."
+		Glyph.macro :test do
+			attribute(:a)+param(0)
+		end
+		m = macro_node(:test)
+		m << p
+		m << a
+		m.evaluate({})
+		m[:value].should == "\\.test"
+	end
+
+	it "should return its parent macro" do
+		node = Glyph::Parser.new("test[@a[a].|test]").parse
+		node.parent_macro.should == nil
+		(node&0).parent_macro.should == nil
+		(node&0&0).parent_macro.should == node&0
+		(node&0&1).parent_macro.should == node&0
+		(node&0&0&0).parent_macro.should == node&0
+		(node&0&1&0).parent_macro.should == node&0
+	end
+
+	it "should convert to a string implicitly" do
+		"#{text_node("test")}".should == "test"
+		"#{escape_node("\\.")}".should == "\\."
+		"#{document_node}".should == ""
+		p0 = p_node(0)
+		p0 << text_node("p0")
+		p1 = p_node(1)
+		p1 << text_node("p1")
+		"#{p0}".should == "p0"
+		"#{p1}".should == "p1"
+		a = a_node(:a)
+		a << text_node("a")
+		b = a_node(:b)
+		b << text_node("b")
+		"#{a}".should == "@a[a]"
+		"#{b}".should == "@b[b]"
+		m = macro_node(:test, :escape => true)
+		m << a
+		m << b
+		m << p0
+		m << p1
+		"#{m}".should == "test[=@a[a]@b[b]p0|p1=]"
+	end
+
+end
+
+describe Glyph::MacroNode do
+
+	before do
+		@n = macro_node(:test)
+		@p = p_node(0)
+		@a = a_node(:a)
+		@p << text_node("test")
+		@a << text_node("test")
+		@n << @p
+		@n << @a
+		Glyph.macro :test do
+			"--#{param(0)}:#{attr(:a)}--"
+		end
+	end
+
+	it "should expand the corresponding macro" do
+		@n.expand({}).should == "--test:test--"
+	end
+
+	it "should resolve to an XML element" do
+		reset_quiet
+		@n.expand({}) rescue nil # |xml| macro not defined
+		@n[:element].should == "test"
+	end
+
+	it "should retrieve parameter nodes easily" do
+		@n.parameter(0).should == @p
+		@n.parameters.should == [@p]
+	end
+
+	it "should retrieve attribute nodes easily" do
+		@n.attribute(:a).should == @a
+		@n.attributes.should == [@a]
+	end
+
+	it "should convert escaping attributes and parameters to strings properly" do
+		@a[:escape] = true
+		@a.to_s.should == "@a[=test=]"
+		@a.contents.should == ".[=test=]"
+		@p.parent[:escape] = true
+		@p.to_s.should == "test"
+		@p.contents.should == ".[=test=]"
+	end
+	
+end