glyph 0.5.2 → 0.5.3.1

data/spec/lib/node_spec.rb

@@ -9,32 +9,32 @@ describe Node do
 
 	it "should be a hash" do
 		ht = Node.new
-		ht.is_a?(Hash).should == true
-		ht.children.should == []
+		expect(ht.is_a?(Hash)).to eq(true)
+		expect(ht.children).to eq([])
 	end
 
 	it "should be generated from a hash" do
 		create_node
-		@ht.respond_to?(:children).should == true
+		expect(@ht.respond_to?(:children)).to eq(true)
 	end
 
 	it "should support child elements" do
 		create_node
-		lambda { @ht << "wrong" }.should raise_error
-		lambda { @ht << {:c => 3, :d => 4} }.should_not raise_error
-		@ht.children[0][:c].should == 3
-		lambda { @ht << {:e => 5, :f => 6}.to_node }.should_not raise_error
+		expect { @ht << "wrong" }.to raise_error
+		expect { @ht << {:c => 3, :d => 4} }.not_to raise_error
+		expect(@ht.children[0][:c]).to eq(3)
+		expect { @ht << {:e => 5, :f => 6}.to_node }.not_to raise_error
 		@ht.child(1) << {:g => 7, :h => 8}
 		@ht.child(1) << {:i => 9, :j => 10}
-		((@ht&1&1)[:j]).should == 10
+		expect((@ht&1&1)[:j]).to eq(10)
 		l = (@ht&1).length
 		orphan = @ht&1&0
-		orphan.parent.should == @ht&1
-		(@ht&1).children.include?(orphan).should == true
+		expect(orphan.parent).to eq(@ht&1)
+		expect((@ht&1).children.include?(orphan)).to eq(true)
 		(@ht&1) >> orphan
-		(@ht&1).children.length.should == l-1 
-		orphan.parent.should == nil
-		(@ht&1).children.include?(orphan).should == false
+		expect((@ht&1).children.length).to eq(l-1) 
+		expect(orphan.parent).to eq(nil)
+		expect((@ht&1).children.include?(orphan)).to eq(false)
 	end
 	
 	it "should support iteration" do
@@ -46,15 +46,15 @@ describe Node do
 		@ht.each_child do |c|
 			c.values.each { |v| sum+=v}
 		end
-		sum.should == 18
+		expect(sum).to eq(18)
 		level = 0
 		str = ""
 		@ht.descend do |c, l|
 			level = l
 			c.values.sort.each { |v| str+=v.to_s}
 		end
-		str.should == "12347856"
-		level.should == 1
+		expect(str).to eq("12347856")
+		expect(level).to eq(1)
 	end
 
 	it "should store information about parent nodes" do
@@ -63,8 +63,8 @@ describe Node do
 		@ht << {:e => 5, :f => 6}
 		@ht.child(1) << {:g => 7, :h => 8}
 		@ht.child(1).child(0) << {:i => 9, :j => 10}
-		(@ht&1&0&0).parent.should == @ht&1&0
-		(@ht&1&0&0).root.should == @ht
+		expect((@ht&1&0&0).parent).to eq(@ht&1&0)
+		expect((@ht&1&0&0).root).to eq(@ht)
 	end
 
 	it "should find child nodes" do
@@ -74,24 +74,24 @@ describe Node do
 		result = @ht.find_child do |node|
 			node[:d] == 4
 		end
-		result.to_hash.should == {:c => 3, :d => 4}
+		expect(result.to_hash).to eq({:c => 3, :d => 4})
 		result2 = @ht.find_child do |node|
 			node[:q] == 7
 		end
-		result2.should == nil
+		expect(result2).to eq(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}"
+		expect(@ht.inspect).to eq("#{@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
+		expect(@ht.to_hash).to eq({:a => 1, :b => 2})
+		expect { @ht.to_hash.children }.to raise_error
 	end
 
 	it "should check equality of children as well" do
@@ -101,9 +101,9 @@ describe Node do
 		@ht2 = {:a => 1, :b => 2}.to_node
 		@ht2 << {:c => 3, :d => 4}
 		@ht2 << {:e => 5, :f => 6}
-		(@ht==@ht2).should == true
+		expect(@ht==@ht2).to eq(true)
 		(@ht&1)[:c] = 47
-		(@ht==@ht2).should == false
+		expect(@ht==@ht2).to eq(false)
 	end
 
 end

data/spec/lib/parser_spec.rb

@@ -42,7 +42,7 @@ Contents]
 		header_1 << text_node("Another test")
 		section_1 << text_node("\nContents")
 		section_0 << text_node("\n")
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should recognize escape sequences" do
@@ -57,12 +57,12 @@ Contents]
 		macro_0 << escape_node("\\[")
 		macro_0 << text_node(" ")
 		(tree&0) << macro_0
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(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")
+		expect { puts parse_text(text).inspect }.to	raise_error(Glyph::SyntaxError, "-- [3, 4] Macro 'section' not closed")
 	end
 
 	it "should not parse macros within escaping macros" do
@@ -72,25 +72,25 @@ Contents]
 		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
+		expect(parse_text(text)).to eq(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'")
+		expect  { puts parse_text(text).inspect }.to 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")
+		expect { puts parse_text(text).inspect }.to	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")
+		expect { puts parse_text(" ] test[...] dgdsg").inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 2] Macro delimiter ']' not escaped")
+		expect { puts parse_text("[ test[...] dgdsg").inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 1] Macro delimiter '[' not escaped")
+		expect { puts parse_text(" test[...] [dgdsg]").inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 12] Macro delimiter '[' not escaped")
+		expect { puts parse_text(" test[...] dgdsg [").inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 18] Macro delimiter '[' not escaped")
+		expect { puts parse_text(" test[[...]] dgdsg").inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 7] Macro delimiter '[' not escaped")
 	end
 
 	it "should parse positional parameters (parameters)" do
@@ -114,12 +114,12 @@ Contents]
 		macro_011 << text_node("...")
 		(macro_01_p1&0) << macro_011
 		macro_0 << text_node(".")
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(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")
+		expect { puts parse_text(text).inspect }.to raise_error(Glyph::SyntaxError, "-- [1, 5] Parameter delimiter '|' not allowed here")
 	end
 
 	it "should recognize escaped pipes" do
@@ -140,7 +140,7 @@ Contents]
 		test_1 << text_node("a ", :escaped => true)
 		test_1 << escape_node("\\|")
 		test_1 << text_node("test", :escaped => true)
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should parse named parameters (attributes)" do
@@ -157,12 +157,12 @@ Contents]
 		(tree&0) << macro_0
 		(tree&0) << first
 		(tree&0) << second
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(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")
+		expect { puts parse_text(text).inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 16] Parameter delimiter '|' not allowed here")
 	end
 
 	it "should parse attributes inside parameters" do
@@ -178,12 +178,12 @@ Contents]
 		par = tree.children.last&2
 		par << text_node("...")
 		test_1 << text_node(" test")
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(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")
+		expect { puts parse_text(text).inspect}.to raise_error(Glyph::SyntaxError, "-- [1, 22] Attributes cannot be nested")
 	end
 
 	it "should parse macros nested in attributes" do
@@ -199,7 +199,7 @@ Contents]
 		c = a_node :c
 		c << text_node('...')
 		(a&0) << c
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should parse parameters in nested macros" do
@@ -221,7 +221,7 @@ Contents]
 		macro_0_p2 = p_node 2
 		macro_0_p2 << text_node("...")
 		(tree&0) << macro_0_p2
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should handle escaped sequences before macro names" do
@@ -233,21 +233,21 @@ Contents]
 		macro_0 = p_node(0) 
 		macro_0 << text_node("...")
 		(tree&2) << macro_0
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should ignore parameters for empty macros" do
 		text = "toc[]"
 		tree = document_node
 		tree << macro_node(:toc)
-		parse_text(text).should == tree
+		expect(parse_text(text)).to eq(tree)
 	end
 
 	it "should allow macro composition" do
-		parse_text("test[...|a/b/c[...]]").should == parse_text("test[...|a[b[c[...]]]]")
-		parse_text(" /test[...]").should == parse_text(" test[...]")
-		parse_text(" test/[...]").should == parse_text(" test[...]")
-		parse_text("a/b/c[=test[...]=]").should == parse_text("a[b[c[=test[...]=]]]")
+		expect(parse_text("test[...|a/b/c[...]]")).to eq(parse_text("test[...|a[b[c[...]]]]"))
+		expect(parse_text(" /test[...]")).to eq(parse_text(" test[...]"))
+		expect(parse_text(" test/[...]")).to eq(parse_text(" test[...]"))
+		expect(parse_text("a/b/c[=test[...]=]")).to eq(parse_text("a[b[c[=test[...]=]]]"))
 	end
 
 end

data/spec/lib/reporter_spec.rb

@@ -30,104 +30,104 @@ describe Glyph::Reporter do
 
 	it "should be initialized with stats" do
 		stats :macros
-		lambda { rep }.should_not raise_error
+		expect { rep }.not_to raise_error
 	end
 
 	it "should display macro stats" do
 		stats :macros
 		out = stdout_for { rep.display }
-		out.should match "Total Macro Instances: 20"
-		out.should match "-- Used Macro Definitions:"
+		expect(out).to match "Total Macro Instances: 20"
+		expect(out).to match "-- Used Macro Definitions:"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "-- Used Macro Definitions:"
+		expect(out).not_to match "-- Used Macro Definitions:"
 	end
 
 	it "should display stats for a single macro" do
 		stats :macro, :section
 		out = stdout_for { rep.display }
-		out.should match "text/a/b/c/markdown.markdown \\(1\\)"
-		out.should match "-- Total Instances: 4"
+		expect(out).to match "text/a/b/c/markdown.markdown \\(1\\)"
+		expect(out).to match "-- Total Instances: 4"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "text/a/b/c/markdown.markdown \\(1\\)"
+		expect(out).not_to match "text/a/b/c/markdown.markdown \\(1\\)"
 		stats :macro, :"=>"
 		out = stdout_for { rep.display }
-		out.should match "alias for: link"
+		expect(out).to match "alias for: link"
 	end
 
 	it "should display bookmark stats" do
 		stats :bookmarks
 		out = stdout_for { rep.display }
-		out.should match "-- Total Bookmarks: 6"
-		out.should match "h_1    h_2    md     refs   toc"
-		out.should match "   - h_1 \\(1\\)"
+		expect(out).to match "-- Total Bookmarks: 6"
+		expect(out).to match "h_1    h_2    md     refs   toc"
+		expect(out).to match "   - h_1 \\(1\\)"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "-- Occurrences:"
+		expect(out).not_to match "-- Occurrences:"
 	end
 
 	it "should display stats for a single bookmark" do
 		stats :bookmark, 'refs'
 		out = stdout_for { rep.display }
-		out.should match "===== Bookmark 'refs' \\(header\\)"
-		out.should match "   - text/references.glyph \\(1\\)"
+		expect(out).to match "===== Bookmark 'refs' \\(header\\)"
+		expect(out).to match "   - text/references.glyph \\(1\\)"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "-- Referenced in:"
+		expect(out).not_to match "-- Referenced in:"
 	end
 
 	it "should display snippet stats" do
 		stats :snippets
 		out = stdout_for { rep.display }
-		out.should match "-- Total Snippets: 2"
+		expect(out).to match "-- Total Snippets: 2"
 	end
 
 	it "should display stats for a single snippet" do
 		stats :snippets
 		stats :snippet, :test
 		out = stdout_for { rep.display }
-		out.should match "-- Total Used Instances: 2"
-		out.should match "   - text/references.glyph \\(1\\)"
+		expect(out).to match "-- Total Used Instances: 2"
+		expect(out).to match "   - text/references.glyph \\(1\\)"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "-- Usage Details:"
+		expect(out).not_to match "-- Usage Details:"
 	end
 
 	it "should display link stats" do
 		stats :links
 		out = stdout_for { rep.display }
-		out.should match "http://www.h3rald.com"
-		out.should match "-- Total Internal Links: 2"
+		expect(out).to match "http://www.h3rald.com"
+		expect(out).to match "-- Total Internal Links: 2"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "     - text/references.glyph (1)"
+		expect(out).not_to match "     - text/references.glyph (1)"
 	end
 
 	it "should display stats for a single link" do
 		stats :link, 'h3'
 		out = stdout_for { rep.display }
-		out.should match "===== Links matching \\/h3\\/"
-		out.should match "   - http://www.h3rald.com \\(1\\)"
+		expect(out).to match "===== Links matching \\/h3\\/"
+		expect(out).to match "   - http://www.h3rald.com \\(1\\)"
 		@r.detailed = false
 		out = stdout_for { @r.display }
-		out.should_not match "   - http://www.h3rald.com \\(1\\)"
+		expect(out).not_to match "   - http://www.h3rald.com \\(1\\)"
 	end
 
 	it "should display files stats" do
 		stats :files
 		out = stdout_for { rep.display }
-		out.should match "-- Total Files: 6"
-		out.should match "-- /text    -- 4"
+		expect(out).to match "-- Total Files: 6"
+		expect(out).to match "-- /text    -- 4"
 	end
 
 	it "should display global stats" do
 		stats :global
 		out = stdout_for { rep.display }
-		out.should match "-- Total Files: 6"
-		out.should match "   - http://www.h3rald.com"
-		out.should match "Total Macro Instances: 20"
-		out.should match "-- Total Snippets: 2"
-		out.should match "h_1    h_2    md     refs   toc"
+		expect(out).to match "-- Total Files: 6"
+		expect(out).to match "   - http://www.h3rald.com"
+		expect(out).to match "Total Macro Instances: 20"
+		expect(out).to match "-- Total Snippets: 2"
+		expect(out).to match "h_1    h_2    md     refs   toc"
 	end
 end

data/spec/lib/syntax_node_spec.rb

@@ -6,18 +6,18 @@ describe Glyph::SyntaxNode do
 	it "should evaluate" do
 		t = text_node("test")
 		t.evaluate({})
-		t[:value].should == "test"
+		expect(t[:value]).to eq("test")
 		e = escape_node("\\.")
 		e.evaluate({})
-		e[:value].should == "\\."
+		expect(e[:value]).to eq("\\.")
 		p = p_node(0)
 		a = a_node(:a)
 		a << e
 		p << t
 		p.evaluate({}, :params => true)
-		p[:value].should == "test"
+		expect(p[:value]).to eq("test")
 		a.evaluate({}, :attrs => true)
-		a[:value].should == "\\."
+		expect(a[:value]).to eq("\\.")
 		Glyph.macro :test do
 			attribute(:a)+param(0)
 		end
@@ -25,41 +25,41 @@ describe Glyph::SyntaxNode do
 		m << p
 		m << a
 		m.evaluate({})
-		m[:value].should == "\\.test"
+		expect(m[:value]).to eq("\\.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
+		expect(node.parent_macro).to eq(nil)
+		expect((node&0).parent_macro).to eq(nil)
+		expect((node&0&0).parent_macro).to eq(node&0)
+		expect((node&0&1).parent_macro).to eq(node&0)
+		expect((node&0&0&0).parent_macro).to eq(node&0)
+		expect((node&0&1&0).parent_macro).to eq(node&0)
 	end
 
 	it "should convert to a string implicitly" do
-		"#{text_node("test")}".should == "test"
-		"#{escape_node("\\.")}".should == "\\."
-		"#{document_node}".should == ""
+		expect("#{text_node("test")}").to eq("test")
+		expect("#{escape_node("\\.")}").to eq("\\.")
+		expect("#{document_node}").to eq("")
 		p0 = p_node(0)
 		p0 << text_node("p0")
 		p1 = p_node(1)
 		p1 << text_node("p1")
-		"#{p0}".should == "p0"
-		"#{p1}".should == "p1"
+		expect("#{p0}").to eq("p0")
+		expect("#{p1}").to eq("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]"
+		expect("#{a}").to eq("@a[a]")
+		expect("#{b}").to eq("@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=]"
+		expect("#{m}").to eq("test[=@a[a]@b[b]p0|p1=]")
 	end
 
 end
@@ -80,34 +80,34 @@ describe Glyph::MacroNode do
 	end
 
 	it "should expand the corresponding macro" do
-		@n.expand({}).should == "--test:test--"
+		expect(@n.expand({})).to eq("--test:test--")
 	end
 
 	it "should retrieve parameter nodes easily" do
-		@n.parameter(0).should == @p
-		@n.parameters.should == [@p]
+		expect(@n.parameter(0)).to eq(@p)
+		expect(@n.parameters).to eq([@p])
 	end
 
 	it "should retrieve attribute nodes easily" do
-		@n.attribute(:a).should == @a
-		@n.attributes.should == [@a]
+		expect(@n.attribute(:a)).to eq(@a)
+		expect(@n.attributes).to eq([@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=]"
+		expect(@a.to_s).to eq("@a[=test=]")
+		expect(@a.contents).to eq(".[=test=]")
 		@p.parent[:escape] = true
-		@p.to_s.should == "test"
-		@p.contents.should == ".[=test=]"
+		expect(@p.to_s).to eq("test")
+		expect(@p.contents).to eq(".[=test=]")
 		###
 		n = macro_node(:test)
 		a = a_node(:a)
 		a[:escape] = true
 		a << text_node("alias[test\\|test1]")
 		n << a
-		a.to_s.should == "@a[=alias[test\\|test1]=]"
-		a.contents.should == ".[=alias[test\\|test1]=]"
+		expect(a.to_s).to eq("@a[=alias[test\\|test1]=]")
+		expect(a.contents).to eq(".[=alias[test\\|test1]=]")
 	end
 
 	it "should perform macro dispatching" do
@@ -124,7 +124,7 @@ describe Glyph::MacroNode do
 		m = macro_node :test_macro
 		p << m
 		d << p
-		m.expand({}).should == "dispatched: test_macro"
+		expect(m.expand({})).to eq("dispatched: test_macro")
 		# Parent dispatcher via attribute
 		d = macro_node :dispatcher
 		d[:dispatch] = dispatch_proc
@@ -132,14 +132,14 @@ describe Glyph::MacroNode do
 		m = macro_node :test_macro
 		a << m
 		d << a
-		m.expand({}).should == "dispatched: test_macro"
+		expect(m.expand({})).to eq("dispatched: test_macro")
 		# No dispatcher
 		d = macro_node :no_dispatcher
 		a = a_node :attr1
 		m = macro_node :test_macro
 		a << m
 		d << a
-		m.expand({}).should == "--test macro--"
+		expect(m.expand({})).to eq("--test macro--")
 	end
 	
 end