glyph 0.5.2 → 0.5.3.1

data/spec/lib/glyph_spec.rb

@@ -11,39 +11,39 @@ describe Glyph do
 	end
 
 	it "should initialize a rake app and tasks" do
-		Rake.application.tasks.length.should > 0
+		expect(Rake.application.tasks.length).to be > 0
 	end
 
 	it "should run rake tasks" do
 		delete_project_dir
 		create_project_dir
 		Glyph.run 'project:create', Glyph::PROJECT
-		lambda { Glyph.run! 'project:create', Glyph::PROJECT }.should raise_error
+		expect { Glyph.run! 'project:create', Glyph::PROJECT }.to raise_error
 		delete_project_dir
 		create_project_dir
-		lambda { Glyph.run! 'project:create', Glyph::PROJECT }.should_not raise_error
+		expect { Glyph.run! 'project:create', Glyph::PROJECT }.not_to raise_error
 		delete_project_dir
 	end
 
 	it "should define macros" do
-		lambda { define_em_macro }.should_not raise_error
-		lambda { define_ref_macro }.should_not raise_error
-		Glyph::MACROS.include?(:em).should == true
-		Glyph::MACROS.include?(:ref).should == true
+		expect { define_em_macro }.not_to raise_error
+		expect { define_ref_macro }.not_to raise_error
+		expect(Glyph::MACROS.include?(:em)).to eq(true)
+		expect(Glyph::MACROS.include?(:ref)).to eq(true)
 	end
 
 	it "should support macro aliases" do
 		define_ref_macro
 		define_em_macro
-		lambda { Glyph.macro_alias("->" => :ref)}.should_not raise_error
-		Glyph::MACROS[:"->"].should == Glyph::MACROS[:ref]
+		expect { Glyph.macro_alias("->" => :ref)}.not_to raise_error
+		expect(Glyph::MACROS[:"->"]).to eq(Glyph::MACROS[:ref])
 		Glyph.macro_alias :em => :ref
-		Glyph::MACROS[:em].should == Glyph::MACROS[:ref]
+		expect(Glyph::MACROS[:em]).to eq(Glyph::MACROS[:ref])
 	end
 
 	it "should provide a filter method to convert raw text into HTML" do
 		Glyph['document.title'] = "Test"
-		Glyph.filter("title[]").gsub(/\n|\t/, '').should == "<h1>Test</h1>"
+		expect(Glyph.filter("title[]").gsub(/\n|\t/, '')).to eq("<h1>Test</h1>")
 	end
 
 	it "should provide a compile method to compile files in lite mode" do
@@ -53,32 +53,32 @@ describe Glyph do
 			Glyph.debug_mode = true
 			Glyph.compile Glyph::PROJECT/'article.glyph' 
 		#}.should_not raise_error
-		(Glyph::PROJECT/'article.html').exist?.should == true
+		expect((Glyph::PROJECT/'article.html').exist?).to eq(true)
 	end
 
 	it "should provide a reset method to remove config overrides, reenable tasks, clear macros and reps" do
 		Glyph['test_setting'] = true
 		Glyph.reset
-		Glyph::MACROS.length.should == 0
-		Glyph::REPS.length.should == 0
-		Glyph['test_setting'].should == nil
+		expect(Glyph::MACROS.length).to eq(0)
+		expect(Glyph::REPS.length).to eq(0)
+		expect(Glyph['test_setting']).to eq(nil)
 	end
 
 	it "should not allow certain macros to be expanded in safe mode" do
 		create_project
 		Glyph.run! "load:all"
 		Glyph.safe_mode = true
-		lambda { output_for("include[test.glyph]")}.should raise_error Glyph::MacroError
-		lambda {output_for("config:[test|true]")}.should raise_error Glyph::MacroError
-		lambda { output_for("ruby[Time.now]")}.should raise_error Glyph::MacroError
-		lambda { output_for("def:[a|section[{{0}}]]")}.should raise_error Glyph::MacroError
+		expect { output_for("include[test.glyph]")}.to raise_error Glyph::MacroError
+		expect {output_for("config:[test|true]")}.to raise_error Glyph::MacroError
+		expect { output_for("ruby[Time.now]")}.to raise_error Glyph::MacroError
+		expect { output_for("def:[a|section[{{0}}]]")}.to raise_error Glyph::MacroError
 		Glyph.safe_mode = false
 	end
 
 	it "should define macros using Glyph syntax" do
 		define_em_macro
 		Glyph.define :test_def_macro, %{em[{{0}} -- {{a}}]}
-		output_for("test_def_macro[@a[!]?]").should == "<em>? -- !</em>"
+		expect(output_for("test_def_macro[@a[!]?]")).to eq("<em>? -- !</em>")
 	end
 
 	it "should store alias information" do
@@ -86,13 +86,13 @@ describe Glyph do
 		create_project_dir
 		Glyph.run! 'project:create', Glyph::PROJECT
 		Glyph.run 'load:all'
-		Glyph::ALIASES[:by_def][:snippet].should == [:&]
-		Glyph::ALIASES[:by_alias][:"?"].should == :condition
-		Glyph.macro_aliases_for(:link).should == [:"=>"]
-		Glyph.macro_aliases_for(:"=>").should == nil
-		Glyph.macro_definition_for(:"=>").should == :link
-		Glyph.macro_definition_for(:link).should == nil
-		Glyph.macro_alias?(:"#").should == true
+		expect(Glyph::ALIASES[:by_def][:snippet]).to eq([:&])
+		expect(Glyph::ALIASES[:by_alias][:"?"]).to eq(:condition)
+		expect(Glyph.macro_aliases_for(:link)).to eq([:"=>"])
+		expect(Glyph.macro_aliases_for(:"=>")).to eq(nil)
+		expect(Glyph.macro_definition_for(:"=>")).to eq(:link)
+		expect(Glyph.macro_definition_for(:link)).to eq(nil)
+		expect(Glyph.macro_alias?(:"#")).to eq(true)
 	end
 
 	it "should store macro representations" do
@@ -104,15 +104,15 @@ describe Glyph do
 		Glyph.rep :test_rep do |data|
 			"TEST - #{data[:a]}"
 		end
-		Glyph::REPS[:test_rep].call(:a => 1).should == "TEST - 1" 
-		Glyph::REPS[:test_rep_alias].call(:a => 1).should == "TEST - 1" 
+		expect(Glyph::REPS[:test_rep].call(:a => 1)).to eq("TEST - 1") 
+		expect(Glyph::REPS[:test_rep_alias].call(:a => 1)).to eq("TEST - 1") 
 	end
 
 	it "should load reps for a given output" do
 		Glyph.reps_for(:html)
-		Glyph::REPS[:section].should_not be_blank
-		Glyph::REPS[:link].should_not be_blank
-		Glyph::REPS[:"=>"].should_not be_blank
+		expect(Glyph::REPS[:section]).not_to be_blank
+		expect(Glyph::REPS[:link]).not_to be_blank
+		expect(Glyph::REPS[:"=>"]).not_to be_blank
 	end
 
 end

data/spec/lib/interpreter_spec.rb

@@ -18,16 +18,16 @@ describe Glyph::Interpreter do
 	it "should process text and run simple macros" do
 		define_em_macro
 		text = "This is a em[test]. It em[should] work."
-		output_for(text).should == "This is a <em>test</em>. It <em>should</em> work."
+		expect(output_for(text)).to eq("This is a <em>test</em>. It <em>should</em> work.")
 		text2 = "This is pointless, but valid: em[]. This em[will] though."
-		output_for(text2).should == "This is pointless, but valid: <em></em>. This <em>will</em> though."
+		expect(output_for(text2)).to eq("This is pointless, but valid: <em></em>. This <em>will</em> though.")
 	end
 
 	it "should process and run complex macros" do
 		define_ref_macro
 		text = "This is a ref[http://www.h3rald.com|test]."
 		interpret text
-		@p.document.output.should == "This is a <a href=\"http://www.h3rald.com\">test</a>."
+		expect(@p.document.output).to eq("This is a <a href=\"http://www.h3rald.com\">test</a>.")
 	end
 
 	it "should support multiline macros" do
@@ -39,7 +39,7 @@ describe Glyph::Interpreter do
 		
 		] macro.}
 		interpret text
-		@p.document.output.should == %{This is a test containing a <a href="http://www.h3rald.com">multiline</a> macro.}
+		expect(@p.document.output).to eq(%{This is a test containing a <a href="http://www.h3rald.com">multiline</a> macro.})
 	end
 
 	it "should support escape characters" do
@@ -47,7 +47,7 @@ describe Glyph::Interpreter do
 		text = %{This text contains em[
 			some escaped em\\[content\\]... etc.].}
 		interpret text
-		@p.document.output.should == %{This text contains <em>some escaped em[content]... etc.</em>.}
+		expect(@p.document.output).to eq(%{This text contains <em>some escaped em[content]... etc.</em>.})
 	end
 
 	it "should support nested macros" do
@@ -55,7 +55,7 @@ describe Glyph::Interpreter do
 		define_ref_macro
 		text = %{This is an ref[#test|em[emphasized] link]}
 		interpret text
-		@p.document.output.should == %{This is an <a href="#test"><em>emphasized</em> link</a>}
+		expect(@p.document.output).to eq(%{This is an <a href="#test"><em>emphasized</em> link</a>})
 	end
 
 	it "should store syntax node information in context" do
@@ -66,12 +66,12 @@ describe Glyph::Interpreter do
 		end
 		text = %{Test em[test_node[em[test_node[---]]]].}
 		interpret text
-		@p.document.output.should == "Test <em>em</em>."
+		expect(@p.document.output).to eq("Test <em>em</em>.")
 	end
 
 	it "should provide diagnostic information on errors" do
 		failure = "-- [1, 12] Macro 'section' not closed"
-		lambda { interpret("section[em[]").document }.should raise_error(Glyph::SyntaxError, failure)
+		expect { interpret("section[em[]").document }.to raise_error(Glyph::SyntaxError, failure)
 	end
 
 end

data/spec/lib/macro_spec.rb

@@ -18,11 +18,11 @@ describe Glyph::Macro do
 	end
 
 	it "should raise macro errors" do
-		lambda { @macro.macro_error "Error!" }.should raise_error(Glyph::MacroError)
+		expect { @macro.macro_error "Error!" }.to raise_error(Glyph::MacroError)
 	end
 
 	it "should interpret strings" do
-		@macro.interpret("test[--]").should == "Test: --"
+		expect(@macro.interpret("test[--]")).to eq("Test: --")
 	end
 
 	it "should not interpret escaped macros" do
@@ -36,33 +36,33 @@ describe Glyph::Macro do
 		text2 = "int_1[=int_2[Test]=]"
 		text3 = "int_1[=int_2\\[Test\\]=]"
 		text4 = "int_2[int_1[=int_1[wrong_macro[Test]]=]]"
-		@macro.interpret(text1).should == "->=>Test<=<-"
-		@macro.interpret(text2).should == "->int_2\\[Test\\]<-"
-		@macro.interpret(text3).should == "->int_2\\[Test\\]<-"
-		@macro.interpret(text4).should == "=>->int_1\\[wrong_macro\\[Test\\]\\]<-<="
+		expect(@macro.interpret(text1)).to eq("->=>Test<=<-")
+		expect(@macro.interpret(text2)).to eq("->int_2\\[Test\\]<-")
+		expect(@macro.interpret(text3)).to eq("->int_2\\[Test\\]<-")
+		expect(@macro.interpret(text4)).to eq("=>->int_1\\[wrong_macro\\[Test\\]\\]<-<=")
 	end
 
 	it "should store and check bookmarks" do
 		h = { :id => "test2", :title => "Test 2", :file => 'test.glyph' }
 		@macro.bookmark h
-		@doc.bookmark?(:test2).should == Glyph::Bookmark.new(h)
-		@macro.bookmark?(:test2).should == Glyph::Bookmark.new(h)
+		expect(@doc.bookmark?(:test2)).to eq(Glyph::Bookmark.new(h))
+		expect(@macro.bookmark?(:test2)).to eq(Glyph::Bookmark.new(h))
 	end
 
 	it "should store and check headers" do
 		h = { :level => 2, :id => "test3", :title => "Test 3", :file => "test.glyph"}
 		@macro.header h
-		@doc.header?("test3").should == Glyph::Bookmark.new(h)
-		@macro.header?("test3").should == Glyph::Bookmark.new(h)
+		expect(@doc.header?("test3")).to eq(Glyph::Bookmark.new(h))
+		expect(@macro.header?("test3")).to eq(Glyph::Bookmark.new(h))
 	end
 
 	it "should store placeholders" do
 		@macro.placeholder { |document| }
-		@doc.placeholders.length.should == 1
+		expect(@doc.placeholders.length).to eq(1)
 	end
 
 	it "should expand" do
-		@macro.expand.should == "Test: Testing..."
+		expect(@macro.expand).to eq("Test: Testing...")
 	end
 
 	it "should support rewriting" do
@@ -88,8 +88,9 @@ describe Glyph::Macro do
 				]
 			]
 		}
-		output_for(text).gsub(/\n|\t/, '').should == 
+		expect(output_for(text).gsub(/\n|\t/, '')).to eq( 
 			"ReleaseFeatures: a-2b-3c-4-1"
+		)
 		test = 0
 		Glyph.macro :test do
 			interpret "#{value}-#{test+=1}"
@@ -103,8 +104,9 @@ describe Glyph::Macro do
 		Glyph.macro :feature do
 			interpret "test[#{value}]\n"
 		end
-		output_for(text).gsub(/\n|\t/, '').should == 
+		expect(output_for(text).gsub(/\n|\t/, '')).to eq( 
 			"ReleaseFeatures: a-1b-2c-3-4"
+		)
 	end
 
 	it "should support access to parameters and attributes" do
@@ -116,13 +118,13 @@ describe Glyph::Macro do
 		end
 		node = Glyph::Parser.new("test[@a[test1[...]]test1[...]|test1[---]]").parse
 		m = Glyph::Macro.new(node&0)
-		m.parameters.should == ["test1: ...", "test1: ---"]
-		m.attributes.should == {:a => "test1: ..."}
-		m.parameter(0).should == "test1: ..."
-		m.parameter(1).should == "test1: ---"
-		m.parameter(2).should == nil
-		m.attribute(:a).should == "test1: ..."
-		m.attribute(:b).should == nil
+		expect(m.parameters).to eq(["test1: ...", "test1: ---"])
+		expect(m.attributes).to eq({:a => "test1: ..."})
+		expect(m.parameter(0)).to eq("test1: ...")
+		expect(m.parameter(1)).to eq("test1: ---")
+		expect(m.parameter(2)).to eq(nil)
+		expect(m.attribute(:a)).to eq("test1: ...")
+		expect(m.attribute(:b)).to eq(nil)
 	end
 
 	it "should not evaluate attributes unless specifically requested" do
@@ -142,12 +144,12 @@ describe Glyph::Macro do
 		p10 = p_node 0
 		(p1&0) << p10
 		p10 << text_node("---")
-		m.node.parameters.should == [p0, p1]
-		m.node.parameters[0][:value].should == nil
-		m.node.parameters[1][:value].should == nil
-		m.parameter(0).should == "<em>...</em>"
-		m.node.parameters[0][:value].should == "<em>...</em>"
-		m.node.parameters[1][:value].should == nil
+		expect(m.node.parameters).to eq([p0, p1])
+		expect(m.node.parameters[0][:value]).to eq(nil)
+		expect(m.node.parameters[1][:value]).to eq(nil)
+		expect(m.parameter(0)).to eq("<em>...</em>")
+		expect(m.node.parameters[0][:value]).to eq("<em>...</em>")
+		expect(m.node.parameters[1][:value]).to eq(nil)
 	end
 
 	it "should not evaluate parameters unless specifically requested" do
@@ -167,12 +169,12 @@ describe Glyph::Macro do
 		p10 = p_node 0
 		(p1&0) << p10
 		p10 << text_node("---")
-		m.node.attributes.should == [p0, p1]
-		m.node.attribute(:a)[:value].should == nil
-		m.node.attribute(:b)[:value].should == nil
-		m.attribute(:a).should == "<em>...</em>"
-		m.node.attribute(:a)[:value].should == "<em>...</em>"
-		m.node.attribute(:b)[:value].should == nil
+		expect(m.node.attributes).to eq([p0, p1])
+		expect(m.node.attribute(:a)[:value]).to eq(nil)
+		expect(m.node.attribute(:b)[:value]).to eq(nil)
+		expect(m.attribute(:a)).to eq("<em>...</em>")
+		expect(m.node.attribute(:a)[:value]).to eq("<em>...</em>")
+		expect(m.node.attribute(:b)[:value]).to eq(nil)
 	end
 
 	it "should treat empty parameters/attributes as null" do
@@ -195,10 +197,10 @@ describe Glyph::Macro do
 			end
 			result
 		end
-		output_for("test_ap[]").should == "(!a)(!0)(!1)"
-		output_for("test_ap[@a[]|]").should == "(!a)(!0)(!1)"
-		output_for("test_ap[@a[.]|]").should == "(a)(!0)(!1)"
-		output_for("test_ap[@a[.].|.]").should == "(a)(0)(1)"
+		expect(output_for("test_ap[]")).to eq("(!a)(!0)(!1)")
+		expect(output_for("test_ap[@a[]|]")).to eq("(!a)(!0)(!1)")
+		expect(output_for("test_ap[@a[.]|]")).to eq("(a)(!0)(!1)")
+		expect(output_for("test_ap[@a[.].|.]")).to eq("(a)(0)(1)")
 	end
 
 	it "should expose a path method to determine its location" do
@@ -211,7 +213,7 @@ describe Glyph::Macro do
 		]}).parse
 		node = tree&1&1&1&0&1&0&0
 		m = Glyph::Macro.new(node)
-		m.path.should == "test1/1/b/test2/@a/x"
+		expect(m.path).to eq("test1/1/b/test2/@a/x")
 	end
 
 	it "should substitute bracket escapes properly" do
@@ -223,9 +225,9 @@ describe Glyph::Macro do
 		text2 = "em[=test\\\\\\/[...\\\\\\/]=]"  # test\\\/[\\\/]
 		text3 = "test_int[em[=test\\\\\\/[...\\\\\\/]=]]"
 		out = "<em>test\\[...\\]</em>"
-		output_for(text1).should == out
-		output_for(text2).should == out
-		output_for(text3).should == "- #{out} -"
+		expect(output_for(text1)).to eq(out)
+		expect(output_for(text2)).to eq(out)
+		expect(output_for(text3)).to eq("- #{out} -")
 	end
 
 	it "should render representations" do
@@ -236,8 +238,8 @@ describe Glyph::Macro do
 		Glyph.rep :em_with_rep do |data|
 			%{<em>!#{data[:value]}!</em>}
 		end
-		output_for("em_with_rep[testing...]").should == "<em>!testing...!</em>"
-		Glyph::Macro.new({}).render(:em_with_rep, :value => "test").should == "<em>!test!</em>"
+		expect(output_for("em_with_rep[testing...]")).to eq("<em>!testing...!</em>")
+		expect(Glyph::Macro.new({}).render(:em_with_rep, :value => "test")).to eq("<em>!test!</em>")
 	end
 
 	it "should perform dispatching" do
@@ -250,18 +252,18 @@ describe Glyph::Macro do
 			"...#{value}"
 		end
 		define_em_macro
-		output_for("dispatcher[em[test]]").should == "dispatched: em"
-		output_for("dispatcher[em[@attr[test]]]").should == "dispatched: em"
-		output_for("dispatcher[...|em[@attr[test]]]").should == "..." # Dispatcher macros should only take one parameter
-		output_for("dispatcher[another_macro[test]]").should == "...test"
-		output_for("dispatcher[another_macro[another_macro[test]]]").should == "......test"
+		expect(output_for("dispatcher[em[test]]")).to eq("dispatched: em")
+		expect(output_for("dispatcher[em[@attr[test]]]")).to eq("dispatched: em")
+		expect(output_for("dispatcher[...|em[@attr[test]]]")).to eq("...") # Dispatcher macros should only take one parameter
+		expect(output_for("dispatcher[another_macro[test]]")).to eq("...test")
+		expect(output_for("dispatcher[another_macro[another_macro[test]]]")).to eq("......test")
 	end
 
 	it "should apply text with placeholders to macro data" do
 		Glyph.macro :data do
 			apply "{{1}} {{a}} {{0}}" 
 		end
-		output_for("data[@a[is]a test|This]").should == "This is a test"
+		expect(output_for("data[@a[is]a test|This]")).to eq("This is a test")
 	end
 
 end

data/spec/lib/macro_validators_spec.rb

@@ -18,42 +18,42 @@ describe Glyph::Macro::Validators do
 	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
+		expect { interpret("section[validated_test[invalid]]").document.output }.to raise_error Glyph::MacroError
+		expect { interpret("chapter[validated_test[valid]]").document.output }.not_to raise_error
 	end
 
 	it "should validate the number of parameters" do
 		# exact
-		lambda { interpret("section[sfsdg|saf]").document.output }.should raise_error Glyph::MacroError
+		expect { interpret("section[sfsdg|saf]").document.output }.to raise_error Glyph::MacroError
 		# none
-		lambda { interpret("title[test]").document.output }.should raise_error Glyph::MacroError
+		expect { interpret("title[test]").document.output }.to raise_error Glyph::MacroError
 		# min
-		lambda { interpret("?[]").document.output }.should raise_error Glyph::MacroError
+		expect { interpret("?[]").document.output }.to raise_error Glyph::MacroError
 		# max
-		lambda { interpret("not[a|b|c]").document.output }.should raise_error Glyph::MacroError
+		expect { interpret("not[a|b|c]").document.output }.to raise_error Glyph::MacroError
 		# correct
-		lambda { interpret("chapter[fmi[something|#something]]").document.output }.should_not raise_error Glyph::MacroError
+		expect { interpret("chapter[fmi[something|#something]]").document.output }.not_to raise_error 
 	end
 
 	it "should check for mutual inclusion" do
-		interpret("&:[inc|Test &[inc]]&[inc] test").document.output.should == "Test [SNIPPET 'inc' NOT PROCESSED] test"
+		expect(interpret("&:[inc|Test &[inc]]&[inc] test").document.output).to eq("Test [SNIPPET 'inc' NOT PROCESSED] test")
 	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
+		expect { interpret("<test[test]").document}.to raise_error
+		expect { interpret("_test[test]").document}.not_to raise_error
 	end
 
 	it "should validate XML attributes" do
 		language 'xml'
-		output_for("test[test @.test[test]]").should == "<test>test </test>"
+		expect(output_for("test[test @.test[test]]")).to eq("<test>test </test>")
 	end
 
 	it "should validate required attributes" do
 		Glyph['document.output'] = 'web'
 		Glyph.run! 'load:macros'
-		lambda { output_for("section[section[@src[test]]]") }.should raise_error(Glyph::MacroError, "Macro 'section' requires a 'title' attribute")
+		expect { output_for("section[section[@src[test]]]") }.to raise_error(Glyph::MacroError, "Macro 'section' requires a 'title' attribute")
 	end
 
 	it "should validate if a macro is within another one" do
@@ -62,7 +62,7 @@ describe Glyph::Macro::Validators do
 			within :em
 			"---"
 		end
-		lambda { output_for("within_m[test]") }.should raise_error(Glyph::MacroError, "Macro 'within_m' must be within a 'em' macro")
+		expect { output_for("within_m[test]") }.to raise_error(Glyph::MacroError, "Macro 'within_m' must be within a 'em' macro")
 	end	
 
 	it "should validate if a macro is not within another one" do
@@ -71,7 +71,7 @@ describe Glyph::Macro::Validators do
 			not_within :em
 			"---"
 		end
-		lambda { output_for("em[within_m[test]]") }.should raise_error(Glyph::MacroError, "Macro 'within_m' must not be within a 'em' macro")
+		expect { output_for("em[within_m[test]]") }.to raise_error(Glyph::MacroError, "Macro 'within_m' must not be within a 'em' macro")
 	end	
 
 end