glyph 0.5.2 → 0.5.3.1

data/spec/lib/bookmark_spec.rb

@@ -10,55 +10,55 @@ describe Glyph::Bookmark do
 	end
 
 	it "should be initialized with at least an id" do
-		lambda { Glyph::Bookmark.new }.should raise_error
-		lambda { Glyph::Bookmark.new({:id => :test}) }.should_not raise_error
-		lambda { Glyph::Bookmark.new({:file => "test"}) }.should raise_error
-		lambda { Glyph::Bookmark.new({:id => "test", :file => "test.glyph"}) }.should_not raise_error
+		expect { Glyph::Bookmark.new }.to raise_error
+		expect { Glyph::Bookmark.new({:id => :test}) }.not_to raise_error
+		expect { Glyph::Bookmark.new({:file => "test"}) }.to raise_error
+		expect { Glyph::Bookmark.new({:id => "test", :file => "test.glyph"}) }.not_to raise_error
 	end
 
 	it "shiuld expose title, code and file" do
-		@b.file.should == "test.glyph"
-		@b.code.should == :test
-		@b.title.should == nil
-		Glyph::Bookmark.new(:id => :test2, :title => "Test 2").title.should == "Test 2"
+		expect(@b.file).to eq("test.glyph")
+		expect(@b.code).to eq(:test)
+		expect(@b.title).to eq(nil)
+		expect(Glyph::Bookmark.new(:id => :test2, :title => "Test 2").title).to eq("Test 2")
 	end
 
 	it "should convert to a string" do
 		@b.code.to_s == @b.to_s
-		"#{@b}".should == @b.to_s
+		expect("#{@b}").to eq(@b.to_s)
 	end
 
 	it "should format the link for a single output file" do
 		# Link within the same file
-		@b.link.should == "#test"
+		expect(@b.link).to eq("#test")
 		# Link to a different file file
-		@b.link('intro.glyph').should == "#test"
+		expect(@b.link('intro.glyph')).to eq("#test")
 	end
 
 	it "should format the link for multiple output files" do
 		out = Glyph['document.output']
 		Glyph['document.output'] = 'web'
 		# Link within the same file
-		@b.link("test.glyph").should == "#test"
+		expect(@b.link("test.glyph")).to eq("#test")
 		# Link to a different file file
-		@b.link("intro.glyph").should == "/test.html#test"
+		expect(@b.link("intro.glyph")).to eq("/test.html#test")
 		# Test that base directory is added correctly
 		Glyph["output.#{Glyph['document.output']}.base"] = ""
-		@b.link("intro.glyph").should == "test.html#test"
-		@b.link("test.glyph").should == "#test"
+		expect(@b.link("intro.glyph")).to eq("test.html#test")
+		expect(@b.link("test.glyph")).to eq("#test")
 		Glyph['document.output'] = out
 	end
 
 	it "should check ID validity" do
-		lambda { Glyph::Bookmark.new :id => "#test$", :file => "test.glyph"}.should raise_error(RuntimeError, "Invalid bookmark ID: #test$")		
+		expect { Glyph::Bookmark.new :id => "#test$", :file => "test.glyph"}.to raise_error(RuntimeError, "Invalid bookmark ID: #test$")		
 	end
 
 	it "should check bookmark equality" do
-		@b.should == Glyph::Bookmark.new(:id => :test, :file => 'test.glyph')
-		@b.should == Glyph::Bookmark.new(:id => :test, :file => "test.glyph")
-		@b.should == Glyph::Bookmark.new(:id => :test, :file => 'test.glyph', :level => 2)
-		@b.should_not == Glyph::Bookmark.new(:id => :test1, :file => 'test.glyph')
-		@b.should_not == Glyph::Bookmark.new(:id => :test, :file => 'test1.glyph')
+		expect(@b).to eq(Glyph::Bookmark.new(:id => :test, :file => 'test.glyph'))
+		expect(@b).to eq(Glyph::Bookmark.new(:id => :test, :file => "test.glyph"))
+		expect(@b).to eq(Glyph::Bookmark.new(:id => :test, :file => 'test.glyph', :level => 2))
+		expect(@b).not_to eq(Glyph::Bookmark.new(:id => :test1, :file => 'test.glyph'))
+		expect(@b).not_to eq(Glyph::Bookmark.new(:id => :test, :file => 'test1.glyph'))
 	end
 
 end

data/spec/lib/commands_spec.rb

@@ -19,57 +19,57 @@ describe "glyph" do
 		delete_project
 		Glyph.enable "project:create"
 		Dir.chdir Glyph::PROJECT.to_s
-		run_command_successfully(['init']).should == true
+		expect(run_command_successfully(['init'])).to eq(true)
 	end
 
 	it "[config] should read configuration settings" do
 		create_project
-		run_command_with_status(["config", "-g"]).should == -10
-		run_command(["config", "document.output"]).match(/html/m).should_not == nil
+		expect(run_command_with_status(["config", "-g"])).to eq(-10)
+		expect(run_command(["config", "document.output"]).match(/html/m)).not_to eq(nil)
 	end
 
 	it "[config] should write configuration settings" do
 		create_project
-		run_command_successfully(["config", "test_setting", "true"]).should == true
-		Glyph::CONFIG.get(:test_setting).should == true
+		expect(run_command_successfully(["config", "test_setting", "true"])).to eq(true)
+		expect(Glyph::CONFIG.get(:test_setting)).to eq(true)
 		Glyph::PROJECT_CONFIG.read
-		Glyph::PROJECT_CONFIG.get('test_setting').should == true
+		expect(Glyph::PROJECT_CONFIG.get('test_setting')).to eq(true)
 		Glyph::GLOBAL_CONFIG.read
-		Glyph::GLOBAL_CONFIG.get('test_setting').should_not == true
-		run_command_successfully(["config", "-g", "another.test", "something else"]).should == true
-		(Glyph::SPEC_DIR/'.glyphrc').exist?.should == true
-		Glyph::CONFIG.get("another.test").should == "something else"
+		expect(Glyph::GLOBAL_CONFIG.get('test_setting')).not_to eq(true)
+		expect(run_command_successfully(["config", "-g", "another.test", "something else"])).to eq(true)
+		expect((Glyph::SPEC_DIR/'.glyphrc').exist?).to eq(true)
+		expect(Glyph::CONFIG.get("another.test")).to eq("something else")
 		Glyph::PROJECT_CONFIG.read
-		Glyph::PROJECT_CONFIG.get('another.test').should_not == "something else"
+		expect(Glyph::PROJECT_CONFIG.get('another.test')).not_to eq("something else")
 		Glyph::GLOBAL_CONFIG.read
-		Glyph::GLOBAL_CONFIG.get('another.test').should == "something else"
+		expect(Glyph::GLOBAL_CONFIG.get('another.test')).to eq("something else")
 		(Glyph::SPEC_DIR/'.glyphrc').unlink
 	end
 
 	it "[config] should not overwrite system settings" do
 		create_project
 		Glyph['system.test_setting'] = false
-		run_command(["config", "system.test_setting", "true"]).match(/warning.+\(system use only\)/m).should_not == nil
-		Glyph['system.test_setting'].should == false
+		expect(run_command(["config", "system.test_setting", "true"]).match(/warning.+\(system use only\)/m)).not_to eq(nil)
+		expect(Glyph['system.test_setting']).to eq(false)
 	end
 
 	it "[add] should create a new text file" do
 		create_project
-		run_command_successfully(["add", "test.textile"]).should == true
-		(Glyph::PROJECT/'text/test.textile').exist?.should == true
+		expect(run_command_successfully(["add", "test.textile"])).to eq(true)
+		expect((Glyph::PROJECT/'text/test.textile').exist?).to eq(true)
 	end
 
 	it "[compile] should compile the project" do
 		create_project
-		run_command(["compile"]).match(/test_project\.html/m).should_not == nil
-		(Glyph::PROJECT/'output/html/test_project.html').exist?.should == true
+		expect(run_command(["compile"]).match(/test_project\.html/m)).not_to eq(nil)
+		expect((Glyph::PROJECT/'output/html/test_project.html').exist?).to eq(true)
 	end
 
 	it "[compile] should support a custom source file" do
 		create_project
 		file_copy Glyph::PROJECT/'document.glyph', Glyph::PROJECT/'custom.glyph'
-		run_command(["-d", "compile", "-s", "custom.glyph"]).match(/custom\.glyph/m).should_not == nil
-		(Glyph::PROJECT/'output/html/test_project.html').exist?.should == true
+		expect(run_command(["-d", "compile", "-s", "custom.glyph"]).match(/custom\.glyph/m)).not_to eq(nil)
+		expect((Glyph::PROJECT/'output/html/test_project.html').exist?).to eq(true)
 	end
 
 	it "[compile] should not continue execution in case of macro errors" do
@@ -84,10 +84,10 @@ describe "glyph" do
 		}
 		file_write Glyph::PROJECT/'document.glyph', text
 		res = run_command(["compile"])
-		res.match(/Bookmark 'invalid1' does not exist/).should_not == nil
-		res.match(/Bookmark 'invalid2' does not exist/).should_not == nil
-		res.match(/Bookmark 'valid' does not exist/).should == nil
-		res.match(/Snippet 'invalid3' does not exist/).should_not == nil
+		expect(res.match(/Bookmark 'invalid1' does not exist/)).not_to eq(nil)
+		expect(res.match(/Bookmark 'invalid2' does not exist/)).not_to eq(nil)
+		expect(res.match(/Bookmark 'valid' does not exist/)).to eq(nil)
+		expect(res.match(/Snippet 'invalid3' does not exist/)).not_to eq(nil)
 	end
 
 	it "[compile] should regenerate output with auto switch set" do
@@ -122,17 +122,17 @@ describe "glyph" do
 		compile_thread.join
 
 		output2 = file_load output_file
-		output.should_not == output2
-		output2.match(/<p>This is another test.<\/p>/).should_not == nil
+		expect(output).not_to eq(output2)
+		expect(output2.match(/<p>This is another test.<\/p>/)).not_to eq(nil)
 
-		res.match(/Auto-regeneration enabled/).should_not == nil
-		res.match(/Regeneration started: 1 files changed/).should_not == nil
+		expect(res.match(/Auto-regeneration enabled/)).not_to eq(nil)
+		expect(res.match(/Regeneration started: 1 files changed/)).not_to eq(nil)
 		reset_quiet
 	end
 
 	it "[compile] should not compile the project in case of an unknown output format" do
 		reset_quiet
-		run_command_successfully(["compile", "-f", "wrong"]).should == false
+		expect(run_command_successfully(["compile", "-f", "wrong"])).to eq(false)
 	end
 
 	it "[compile] should compile a single source file" do
@@ -140,14 +140,13 @@ describe "glyph" do
 		Dir.chdir Glyph::PROJECT
 		file_copy "#{Glyph::PROJECT}/../files/article.glyph", "#{Glyph::PROJECT}/article.glyph"
 		file_copy "#{Glyph::PROJECT}/../files/ligature.jpg", "#{Glyph::PROJECT}/ligature.jpg"
-		run_command_successfully(["compile", "article.glyph"]).should == true
-		Pathname.new('article.html').exist?.should == true
-		compact_html(file_load('article.html')).should == compact_html(%{
-      <?xml version="1.0"?>
+		expect(run_command_successfully(["compile", "article.glyph"])).to eq(true)
+		expect(Pathname.new('article.html').exist?).to eq(true)
+		expect(compact_html(file_load('article.html'))).to eq(compact_html(%{
 			<div class="section">
-			  &#x6539;&#x5584; Test -- Test Snippet
+			  改善 Test -- Test Snippet
 			</div>
-		})
+		}))
 		(Glyph::PROJECT/'article.html').unlink
 		Glyph['document.output'] = 'pdf'
 		src = Glyph::PROJECT/'article.html'
@@ -155,9 +154,9 @@ describe "glyph" do
     Glyph.enable 'generate:html'
     Glyph.enable 'generate:pdf'
     Glyph.enable 'generate:pdf_through_html'
-    run_command_successfully(["compile", "article.glyph"]).should == true
-    src.exist?.should == true
-    out.exist?.should == true
+    expect(run_command_successfully(["compile", "article.glyph"])).to eq(true)
+    expect(src.exist?).to eq(true)
+    expect(out.exist?).to eq(true)
     out.unlink
 		Glyph.lite_mode = false
 	end	
@@ -167,9 +166,9 @@ describe "glyph" do
 		Dir.chdir Glyph::PROJECT
 		file_copy "#{Glyph::PROJECT}/../files/article.glyph", "#{Glyph::PROJECT}/article.glyph"
 		file_copy "#{Glyph::PROJECT}/../files/ligature.jpg", "#{Glyph::PROJECT}/ligature.jpg"
-		run_command_successfully(["compile", "article.glyph", "out/article.htm"]).should == true
+		expect(run_command_successfully(["compile", "article.glyph", "out/article.htm"])).to eq(true)
 		Glyph.lite_mode = false
-		Pathname.new('out/article.htm').exist?.should == true 
+		expect(Pathname.new('out/article.htm').exist?).to eq(true) 
 	end
 
 	it "[compile] should finalize the document in case of errors in included files" do
@@ -180,8 +179,8 @@ describe "glyph" do
 		err = "Document cannot be finalized due to previous errors"
 		res = run_command(["compile"])
 		out = file_load Glyph::PROJECT/'output/html/test_project.html'
-		compact_html(out).should == %{<?xml version="1.0"?><div class="section"><h2 id="h_1" class="toc">Test</h2></div>}
-		res.match("error: #{err}").should == nil
+		expect(compact_html(out)).to eq(%{<div class="section"><h2 id="h_1" class="toc">Test</h2></div>})
+		expect(res.match("error: #{err}")).to eq(nil)
 	end
 
 	it "[outline] should display the document outline" do
@@ -199,25 +198,25 @@ test_project - Outline
 		i_id = "[#h_2]"
 		m_id = "[#md]"
 		file_write Glyph::PROJECT/'document.glyph', "document[#{file_load(Glyph::PROJECT/'document.glyph')}]"
-		run_command(["-d", "outline"]).should == %{#{start}
+		expect(run_command(["-d", "outline"])).to eq(%{#{start}
   #{c_title}
     #{i_title}
   #{m_title}
-}
+})
 		reset_quiet
-		run_command(["outline", "-l", "1"]).should == %{#{start}
+		expect(run_command(["outline", "-l", "1"])).to eq(%{#{start}
   #{c_title}
   #{m_title}
-}
+})
 		reset_quiet
-		run_command(["outline", "-ift"]).should == %{#{start}
+		expect(run_command(["outline", "-ift"])).to eq(%{#{start}
 #{c_file}
   #{c_title}#{c_id}
 #{i_file}
     #{i_title}#{i_id}
 #{m_file}
   #{m_title}#{m_id}
-}
+})
 	end
 
 	it "[stats] should display project statistics" do
@@ -225,14 +224,14 @@ test_project - Outline
 		create_project
 		out = run_command(["stats", "-ms"])
 		total_macros = (Glyph::MACROS.keys - Glyph::ALIASES[:by_alias].keys).uniq.length
-		out.should match "-- Total Macro Definitions: #{total_macros}" 
+		expect(out).to match "-- Total Macro Definitions: #{total_macros}" 
 		out = run_command(["stats"])
-		out.should match "-- Total Macro Definitions: #{total_macros}" 
-		out.should match "-- Total Unreferenced Bookmarks: 3"
+		expect(out).to match "-- Total Macro Definitions: #{total_macros}" 
+		expect(out).to match "-- Total Unreferenced Bookmarks: 3"
 		out = run_command(["stats", "-lb", "--bookmark=md"])
-		out.should match "-- Unreferenced Bookmarks: h_1, h_2, md" 
-		out.should match "-- Defined in: text/a/b/c/markdown.markdown"
-		out.should_not match "-- Total Macro Definitions: 19"
+		expect(out).to match "-- Unreferenced Bookmarks: h_1, h_2, md" 
+		expect(out).to match "-- Defined in: text/a/b/c/markdown.markdown"
+		expect(out).not_to match "-- Total Macro Definitions: 19"
 	end
 
 end

data/spec/lib/config_spec.rb

@@ -19,34 +19,34 @@ describe Glyph::Config do
 
 	it "should load a YAML configuration file" do
 		@write_config_file.call @invalid
-		lambda { @cfg.read }.should raise_error
+		expect { @cfg.read }.to raise_error
 		@write_config_file.call @valid
-		@cfg.read.should == {:test => true}
+		expect(@cfg.read).to eq({:test => true})
 	end
 
 	it "should get and set configuration data through dot notation" do
 		@write_config_file.call @valid
 		@cfg.read
-		lambda { @cfg.set :test, false }.should_not raise_error
-		lambda { @cfg.set "test.wrong", true}.should raise_error
-		lambda { @cfg.set "test2.value", true}.should_not raise_error
-		@cfg.get("test2.value").should == true
-		lambda { @cfg.set "test2.value", "false"}.should_not raise_error
-		@cfg.get("test2.value").should == false
-		@cfg.get("test2.value2").should == nil
-		@cfg.to_hash.should == {:test => false, :test2 => {:value => false}}
+		expect { @cfg.set :test, false }.not_to raise_error
+		expect { @cfg.set "test.wrong", true}.to raise_error
+		expect { @cfg.set "test2.value", true}.not_to raise_error
+		expect(@cfg.get("test2.value")).to eq(true)
+		expect { @cfg.set "test2.value", "false"}.not_to raise_error
+		expect(@cfg.get("test2.value")).to eq(false)
+		expect(@cfg.get("test2.value2")).to eq(nil)
+		expect(@cfg.to_hash).to eq({:test => false, :test2 => {:value => false}})
 	end
 
 	it "can be resetted with a Hash, if resettable" do
-		lambda { @cfg.reset }.should raise_error
+		expect { @cfg.reset }.to raise_error
 		cfg2 = Glyph::Config.new :resettable => true
 		cfg2.reset :test => "reset!"
-		cfg2.to_hash.should == {:test => "reset!"}	
+		expect(cfg2.to_hash).to eq({:test => "reset!"})	
 	end
 
 	it "should be set to an empty Hash by default" do
 		cfg2 = Glyph::Config.new
-		cfg2.to_hash.should == {}
+		expect(cfg2.to_hash).to eq({})
 	end
 
 	it "should write a YAML configuration file" do
@@ -58,7 +58,7 @@ describe Glyph::Config do
 		@cfg.write
 		cfg2 = Glyph::Config.new :file => @config_path
 		cfg2.read
-		cfg2.to_hash.should == @cfg.to_hash
+		expect(cfg2.to_hash).to eq(@cfg.to_hash)
 	end
 
 	it "should merge with another Config without data loss" do
@@ -70,9 +70,9 @@ describe Glyph::Config do
 		cfg2 = Glyph::Config.new :file => @config_path
 		@cfg.update cfg2
 		updated = {:a =>1, :b => {:b1 => 1111, :b2 => 2222, :b3 => {:b11 => 1, :b12 =>2222}, :b4 => 4}, :c=> 3}
-		@cfg.to_hash.should == updated
+		expect(@cfg.to_hash).to eq(updated)
 		hash1.merge! hash2
-		hash1.should == {:a =>1, :b => {:b1 => 1111, :b2 => 2222, :b3 => {:b12 =>2222}}, :c=> 3}
+		expect(hash1).to eq({:a =>1, :b => {:b1 => 1111, :b2 => 2222, :b3 => {:b12 =>2222}}, :c=> 3})
 	end
 
 

data/spec/lib/document_spec.rb

@@ -16,30 +16,30 @@ describe Glyph::Document do
 	end
 
 	it "should expose document data" do
-		@doc.bookmarks.should == {}
-		@doc.headers.should == {}
-		@doc.styles.should == []
-		@doc.placeholders.should == {}
-		@doc.new?.should == true
+		expect(@doc.bookmarks).to eq({})
+		expect(@doc.headers).to eq({})
+		expect(@doc.styles).to eq([])
+		expect(@doc.placeholders).to eq({})
+		expect(@doc.new?).to eq(true)
 	end
 
 	it "should store bookmarks" do
-		lambda { @doc.bookmark(:id => "test", :title => "Test Bookmark #1", :file => 'test.glyph')}.should_not raise_error
-		lambda { @doc.bookmark(:id => :test, :title => "Test Bookmark #1", :file => 'test.glyph')}.should raise_error
-		lambda { @doc.bookmark(:id => :test, :title => "Test Bookmark #2", :file => 'test2.glyph')}.should raise_error
-		@doc.bookmarks.length.should == 1
-		@doc.bookmarks[:test].should == Glyph::Bookmark.new(:id => :test, :title => "Test Bookmark #1", :file => "test.glyph")
+		expect { @doc.bookmark(:id => "test", :title => "Test Bookmark #1", :file => 'test.glyph')}.not_to raise_error
+		expect { @doc.bookmark(:id => :test, :title => "Test Bookmark #1", :file => 'test.glyph')}.to raise_error
+		expect { @doc.bookmark(:id => :test, :title => "Test Bookmark #2", :file => 'test2.glyph')}.to raise_error
+		expect(@doc.bookmarks.length).to eq(1)
+		expect(@doc.bookmarks[:test]).to eq(Glyph::Bookmark.new(:id => :test, :title => "Test Bookmark #1", :file => "test.glyph"))
 	end
 
 	it "should store placeholders" do
 		p = lambda { "test" }
-		lambda { @doc.placeholder &p }.should_not raise_error
-		@doc.placeholders["‡‡‡‡‡PLACEHOLDER¤1‡‡‡‡‡".to_sym].should == p
+		expect { @doc.placeholder &p }.not_to raise_error
+		expect(@doc.placeholders["‡‡‡‡‡PLACEHOLDER¤1‡‡‡‡‡".to_sym]).to eq(p)
 	end
 
 	it "should store styles" do
-		lambda {@doc.style "test.css"}.should_not raise_error
-		@doc.styles.include?(Pathname.new('test.css')).should == true
+		expect {@doc.style "test.css"}.not_to raise_error
+		expect(@doc.styles.include?(Pathname.new('test.css'))).to eq(true)
 	end
 
 	it "can inherit data from another document" do
@@ -50,33 +50,33 @@ describe Glyph::Document do
 		@doc.header :id => :test3, :title => "Test #3", :level => 3, :file => "test.glyph"
 		@doc.toc[:contents] = "TOC goes here..."
 		doc2 = create_doc @tree
-		doc2.bookmarks.length.should == 0
-		doc2.placeholders.length.should == 0
+		expect(doc2.bookmarks.length).to eq(0)
+		expect(doc2.placeholders.length).to eq(0)
 		doc2.bookmark :id => :test4, :title => "Test #4", :file => "test.glyph"
 		doc2.inherit_from @doc
-		doc2.bookmarks.length.should == 3
-		doc2.placeholders.length.should == 1
-		doc2.headers.length.should == 1
-		doc2.styles.length.should == 1
+		expect(doc2.bookmarks.length).to eq(3)
+		expect(doc2.placeholders.length).to eq(1)
+		expect(doc2.headers.length).to eq(1)
+		expect(doc2.styles.length).to eq(1)
 		doc2.toc[:contents] = "TOC goes here..."
-		doc2.bookmarks[0].should_not == Glyph::Bookmark.new(:id => :test4, :title => "Test #4", :file => "test.glyph")
+		expect(doc2.bookmarks[0]).not_to eq(Glyph::Bookmark.new(:id => :test4, :title => "Test #4", :file => "test.glyph"))
 	end
 
 	it "should analyze the syntax tree and finalize the document" do
-		lambda { @doc.output }.should raise_error
-		lambda { @doc.finalize }.should raise_error
-		lambda { @doc.analyze }.should_not raise_error
-		lambda { @doc.analyze }.should raise_error
-		@doc.analyzed?.should == true
-		lambda { @doc.output }.should raise_error
-		lambda { @doc.finalize }.should_not raise_error
-		@doc.output.should == "Test: Test: Test: Test|]..."
+		expect { @doc.output }.to raise_error
+		expect { @doc.finalize }.to raise_error
+		expect { @doc.analyze }.not_to raise_error
+		expect { @doc.analyze }.to raise_error
+		expect(@doc.analyzed?).to eq(true)
+		expect { @doc.output }.to raise_error
+		expect { @doc.finalize }.not_to raise_error
+		expect(@doc.output).to eq("Test: Test: Test: Test|]...")
 	end
 
 	it "should expose document structure" do
-		lambda { @doc.structure }.should raise_error
+		expect { @doc.structure }.to raise_error
 		@doc.analyze
-		@doc.structure.is_a?(Node).should == true
+		expect(@doc.structure.is_a?(Node)).to eq(true)
 	end
 
 	it "should substitute placeholders when finalizing" do
@@ -105,7 +105,7 @@ describe Glyph::Document do
 		doc = create_doc tree
 		doc.analyze
 		doc.finalize
-		doc.output.gsub(/\n|\t/, '')[0..14].should == "Total: 4 tests."
+		expect(doc.output.gsub(/\n|\t/, '')[0..14]).to eq("Total: 4 tests.")
 	end
 
 	it "should substitute escaped pipes only when finalizing the document" do
@@ -119,7 +119,7 @@ describe Glyph::Document do
 		doc = create_doc tree
 		doc.analyze
 		doc.finalize
-		doc.output.should == result
+		expect(doc.output).to eq(result)
 	end
 
 	it "should store the Table of Contents" do
@@ -145,7 +145,7 @@ describe Glyph::Document do
 		doc = create_doc tree
 		doc.analyze
 		doc.finalize
-		doc.toc[:contents].match(%{<div class="contents">}).blank?.should == false
+		expect(doc.toc[:contents].match(%{<div class="contents">}).blank?).to eq(false)
 		reset_quiet
 	end
 
@@ -155,7 +155,7 @@ describe Glyph::Document do
 		Glyph.run! "load:all"
 		doc = create_doc create_tree("testing ##[frag1|fragments!] -- ##[frag2|another fragment]")
 		doc.analyze
-		doc.fragments.should == {:frag1 => "fragments!", :frag2 => "another fragment"}
+		expect(doc.fragments).to eq({:frag1 => "fragments!", :frag2 => "another fragment"})
 		reset_quiet
 	end