prawn 0.15.0 → 1.0.0.rc1

data/spec/cell_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
 
 module CellHelpers
 
@@ -10,6 +10,10 @@ module CellHelpers
     Prawn::Table::Cell::Text.new(@pdf, at, options)
   end
 
+  def close?(actual, expected, epsilon=0.01)
+    (actual - expected).abs < epsilon
+  end
+
 end
 
 describe "Prawn::Table::Cell" do
@@ -26,18 +30,13 @@ describe "Prawn::Table::Cell" do
     end
 
     it "should return a Cell" do
-      @pdf.cell(:content => "text").should be_a_kind_of Prawn::Table::Cell
-    end
-
-    it "accepts :content => nil in a hash" do
-      @pdf.cell(:content => nil).should be_a_kind_of(Prawn::Table::Cell::Text)
-      @pdf.make_cell(:content => nil).should be_a_kind_of(Prawn::Table::Cell::Text)
+      @pdf.cell(:content => "text").should.be.a.kind_of Prawn::Table::Cell
     end
 
     it "should convert nil, Numeric, and Date values to strings" do
       [nil, 123, 123.45, Date.today].each do |value|
         c = @pdf.cell(:content => value)
-        c.should be_a_kind_of Prawn::Table::Cell::Text
+        c.should.be.a.kind_of Prawn::Table::Cell::Text
         c.content.should == value.to_s
       end
     end
@@ -46,7 +45,7 @@ describe "Prawn::Table::Cell" do
       # used for table([[{:text => "...", :font_style => :bold, ...}, ...]])
       c = Prawn::Table::Cell.make(@pdf,
                                   {:content => 'hello', :font_style => :bold})
-      c.should be_a_kind_of Prawn::Table::Cell::Text
+      c.should.be.a.kind_of Prawn::Table::Cell::Text
       c.content.should == "hello"
       c.font.name.should == 'Helvetica-Bold'
     end
@@ -57,22 +56,22 @@ describe "Prawn::Table::Cell" do
       @pdf.expects(:move_down)
       @pdf.expects(:draw_text!).with { |text, options| text == "hello world" }
 
-      @pdf.cell(:content => "hello world",
+      @pdf.cell(:content => "hello world", 
                 :at => [10, 20],
                 :padding => [30, 40],
-                :size => 7,
+                :size => 7, 
                 :font_style => :bold)
     end
   end
-
+  
   describe "Prawn::Document#make_cell" do
     it "should not draw the cell" do
       Prawn::Table::Cell::Text.any_instance.expects(:draw).never
       @pdf.make_cell("text")
     end
-
+    
     it "should return a Cell" do
-      @pdf.make_cell("text", :size => 7).should be_a_kind_of Prawn::Table::Cell
+      @pdf.make_cell("text", :size => 7).should.be.a.kind_of Prawn::Table::Cell
     end
   end
 
@@ -87,12 +86,6 @@ describe "Prawn::Table::Cell" do
 
       c.style(:padding => 50, :size => 7)
     end
-
-    it "ignores unknown properties" do
-      c = cell(:content => 'text')
-
-      c.style(:foobarbaz => 'frobnitz')
-    end
   end
 
   describe "cell width" do
@@ -110,7 +103,7 @@ describe "Prawn::Table::Cell" do
 
     it "should incorporate padding when specified" do
       c = cell(:content => "text", :padding => [1, 2, 3, 4])
-      c.width.should be_within(0.01).of(@pdf.width_of("text") + 6)
+      c.width.should.be.close(@pdf.width_of("text") + 6, 0.01)
     end
 
     it "should allow width to be reset after it has been calculated" do
@@ -124,7 +117,7 @@ describe "Prawn::Table::Cell" do
     it "should return proper width with size set" do
       text = "text " * 4
       c = cell(:content => text, :size => 7)
-      c.width.should ==
+      c.width.should == 
         @pdf.width_of(text, :size => 7) + c.padding[1] + c.padding[3]
     end
 
@@ -135,14 +128,17 @@ describe "Prawn::Table::Cell" do
 
     it "content_width should exclude padding even with manual :width" do
       c = cell(:content => "text", :padding => 10, :width => 400)
-      c.content_width.should be_within(0.01).of(380)
+      c.content_width.should.be.close(380, 0.01)
     end
 
     it "should have a reasonable minimum width that can fit @content" do
       c = cell(:content => "text", :padding => 10)
       min_content_width = c.min_width - c.padding[1] - c.padding[3]
 
-      @pdf.height_of("text", :width => min_content_width).should be <
+      lambda { @pdf.height_of("text", :width => min_content_width) }.
+        should.not.raise(Prawn::Errors::CannotFit)
+
+      @pdf.height_of("text", :width => min_content_width).should.be <
         (5 * @pdf.height_of("text"))
     end
 
@@ -151,14 +147,14 @@ describe "Prawn::Table::Cell" do
       c.padding = 0
 
       # Make sure we use the new value of padding in calculating min_width
-      c.min_width.should be < 100
+      c.min_width.should.be < 100
     end
 
     it "should defer min_width's evaluation of size" do
       c = cell(:content => "text", :size => 50)
       c.size = 8
       c.padding = 0
-      c.min_width.should be < 10
+      c.min_width.should.be < 10
     end
 
   end
@@ -168,7 +164,7 @@ describe "Prawn::Table::Cell" do
 
     it "should be calculated for text" do
       c = cell(:content => "text")
-      c.height.should ==
+      c.height.should == 
         @pdf.height_of("text", :width => @pdf.width_of("text")) +
         c.padding[0] + c.padding[3]
     end
@@ -180,8 +176,8 @@ describe "Prawn::Table::Cell" do
 
     it "should incorporate :padding when specified" do
       c = cell(:content => "text", :padding => [1, 2, 3, 4])
-      c.height.should be_within(0.01).of(1 + 3 +
-        @pdf.height_of("text", :width => @pdf.width_of("text")))
+      c.height.should.be.close(1 + 3 +
+        @pdf.height_of("text", :width => @pdf.width_of("text")), 0.01)
     end
 
     it "should allow height to be reset after it has been calculated" do
@@ -215,10 +211,10 @@ describe "Prawn::Table::Cell" do
       c = cell(:content => "text", :padding => 10)
       c.content_height.should == @pdf.height_of("text")
     end
-
+    
     it "content_height should exclude padding even with manual :height" do
       c = cell(:content => "text", :padding => 10, :height => 400)
-      c.content_height.should be_within(0.01).of(380)
+      c.content_height.should.be.close(380, 0.01)
     end
   end
 
@@ -239,7 +235,7 @@ describe "Prawn::Table::Cell" do
       c = cell(:content => "text", :padding => [20, 30])
       c.padding.should == [20, 30, 20, 30]
     end
-
+    
     it "should accept [t,h,b]" do
       c = cell(:content => "text", :padding => [10, 20, 30])
       c.padding.should == [10, 20, 30, 20]
@@ -253,7 +249,7 @@ describe "Prawn::Table::Cell" do
     it "should reject other formats" do
       lambda{
         cell(:content => "text", :padding => [10])
-      }.should raise_error(ArgumentError)
+      }.should.raise(ArgumentError)
     end
   end
 
@@ -267,10 +263,10 @@ describe "Prawn::Table::Cell" do
       @pdf.stubs(:fill_color)
       @pdf.expects(:fill_color).with('123456')
       @pdf.expects(:fill_rectangle).checking do |(x, y), w, h|
-        x.should be_within(0.01).of(0)
-        y.should be_within(0.01).of(@pdf.cursor)
-        w.should be_within(0.01).of(29.344)
-        h.should be_within(0.01).of(23.872)
+        x.should.be.close(0, 0.01)
+        y.should.be.close(@pdf.cursor, 0.01)
+        w.should.be.close(29.344, 0.01)
+        h.should.be.close(23.872, 0.01)
       end
       @pdf.cell(:content => "text", :background_color => '123456')
     end
@@ -283,10 +279,10 @@ describe "Prawn::Table::Cell" do
       @pdf.stubs(:fill_color)
       @pdf.expects(:fill_color).with('123456')
       @pdf.expects(:fill_rectangle).checking do |(x, y), w, h|
-        x.should be_within(0.01).of(12.0)
-        y.should be_within(0.01).of(34.0)
-        w.should be_within(0.01).of(29.344)
-        h.should be_within(0.01).of(23.872)
+        x.should.be.close(12.0, 0.01)
+        y.should.be.close(34.0, 0.01)
+        w.should.be.close(29.344, 0.01)
+        h.should.be.close(23.872, 0.01)
       end
       c = @pdf.make_cell(:content => "text", :background_color => '123456')
       c.draw([12.0, 34.0])
@@ -412,34 +408,8 @@ describe "Prawn::Table::Cell" do
         :border_width => [2, 3, 4, 5])
       c.border_widths.should == [2, 3, 4, 5]
     end
-
-    it "should set default border lines to :solid" do
-      c = @pdf.cell(:content => "text")
-      c.border_top_line.should == :solid
-      c.border_right_line.should == :solid
-      c.border_bottom_line.should == :solid
-      c.border_left_line.should == :solid
-      c.border_lines.should == [:solid] * 4
-    end
-
-    it "should set border line with :border_..._line" do
-      c = @pdf.cell(:content => "text", :border_bottom_line => :dotted)
-      c.border_bottom_line.should == :dotted
-      c.border_lines[2].should == :dotted
-    end
-
-    it "should set border lines with :border_lines" do
-      c = @pdf.cell(:content => "text",
-        :border_lines => [:solid, :dotted, :dashed, :solid])
-      c.border_lines.should == [:solid, :dotted, :dashed, :solid]
-    end
   end
 
-
-
-
-
-
   describe "Text cell attributes" do
     include CellHelpers
 
@@ -469,47 +439,6 @@ describe "Prawn::Table::Cell" do
       c.draw
     end
 
-    it "supports variant styles of the current font" do
-      font_path = "#{Prawn::BASEDIR}/data/fonts/Action Man.dfont"
-      @pdf.font_families.merge!("Action Man" => {
-        :normal    => { :file => font_path, :font => "ActionMan" },
-        :bold      => { :file => font_path, :font => "ActionMan-Bold" },
-      })
-      @pdf.font "Action Man"
-
-      c = cell(:content => "text", :font_style => :bold)
-
-      box = Prawn::Text::Box.new("text", :document => @pdf)
-      Prawn::Text::Box.expects(:new).checking do |text, options|
-        text.should == "text"
-        options[:style].should == :bold
-        @pdf.font.family.should == 'Action Man'
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
-
-    it "uses the style of the current font if none given" do
-      font_path = "#{Prawn::BASEDIR}/data/fonts/Action Man.dfont"
-      @pdf.font_families.merge!("Action Man" => {
-        :normal    => { :file => font_path, :font => "ActionMan" },
-        :bold      => { :file => font_path, :font => "ActionMan-Bold" },
-      })
-      @pdf.font "Action Man", :style => :bold
-
-      c = cell(:content => "text")
-
-      box = Prawn::Text::Box.new("text", :document => @pdf)
-      Prawn::Text::Box.expects(:new).checking do |text, options|
-        text.should == "text"
-        @pdf.font.family.should == 'Action Man'
-        @pdf.font.options[:style].should == :bold
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
     it "should allow inline formatting in cells" do
       c = cell(:content => "foo <b>bar</b> baz", :inline_format => true)
 
@@ -569,6 +498,7 @@ describe "Prawn::Table::Cell" do
       c.content_width.should == font.compute_width_of("text")
     end
   end
+
 end
 
 describe "Image cells" do
@@ -579,11 +509,11 @@ describe "Image cells" do
   describe "with default options" do
     before(:each) do
       @cell = Prawn::Table::Cell.make(@pdf,
-        :image => "#{Prawn::DATADIR}/images/prawn.png")
+        :image => "#{Prawn::BASEDIR}/data/images/prawn.png")
     end
 
     it "should create a Cell::Image" do
-      @cell.should be_a_kind_of(Prawn::Table::Cell::Image)
+      @cell.should.be.a.kind_of(Prawn::Table::Cell::Image)
     end
 
     it "should pull the natural width and height from the image" do
@@ -595,7 +525,7 @@ describe "Image cells" do
   describe "hash syntax" do
     before(:each) do
       @table = @pdf.make_table([[{
-        :image => "#{Prawn::DATADIR}/images/prawn.png",
+        :image => "#{Prawn::BASEDIR}/data/images/prawn.png",
         :scale => 2,
         :fit => [100, 200],
         :image_width => 123,
@@ -608,7 +538,7 @@ describe "Image cells" do
 
 
     it "should create a Cell::Image" do
-      @cell.should be_a_kind_of(Prawn::Table::Cell::Image)
+      @cell.should.be.a.kind_of(Prawn::Table::Cell::Image)
     end
 
     it "should pass through image options" do

data/spec/destinations_spec.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "When creating destinations" do
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
 
+describe "When creating destinations" do 
+ 
   before(:each) { create_pdf }
-
-  it "should add entry to Dests name tree" do
+  
+  it "should add entry to Dests name tree" do 
     @pdf.dests.data.empty?.should == true
     @pdf.add_dest "candy", "chocolate"
     @pdf.dests.data.size.should == 1

data/spec/document_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require "tempfile"
 
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
 
 describe "Prawn::Document.new" do
   it "should not modify its argument" do
@@ -12,12 +12,12 @@ describe "Prawn::Document.new" do
 end
 
 describe "The cursor" do
-  it "should == pdf.y - bounds.absolute_bottom" do
+  it "should equal pdf.y - bounds.absolute_bottom" do
     pdf = Prawn::Document.new
     pdf.cursor.should == pdf.bounds.top
-
+    
     pdf.y = 300
-    pdf.cursor.should == pdf.y - pdf.bounds.absolute_bottom
+    pdf.cursor.should == pdf.y - pdf.bounds.absolute_bottom 
   end
 
   it "should be able to move relative to the bottom margin" do
@@ -27,40 +27,14 @@ describe "The cursor" do
     pdf.cursor.should == 10
     pdf.y.should == pdf.cursor + pdf.bounds.absolute_bottom
   end
-end
-
-describe "when generating a document with a custom text formatter" do
-  it "should use the provided text formatter" do
-    class TestTextFormatter
-      def self.format(string)
-        [
-          {
-            text: string.gsub("Dr. Who?", "Just 'The Doctor'."),
-            styles: [],
-            color: nil,
-            link: nil,
-            anchor: nil,
-            local: nil,
-            font: nil,
-            size: nil,
-            character_spacing: nil
-          }
-        ]
-      end
-    end
-    pdf = Prawn::Document.new text_formatter: TestTextFormatter
-    pdf.text "Dr. Who?", inline_format: true
-    text = PDF::Inspector::Text.analyze(pdf.render)
-    text.strings.first.should == "Just 'The Doctor'."
-  end
-end
+end 
 
 describe "when generating a document from a subclass" do
   it "should be an instance of the subclass" do
     custom_document = Class.new(Prawn::Document)
-    custom_document.generate(Tempfile.new("generate_test").path) do |e|
+    custom_document.generate(Tempfile.new("generate_test").path) do |e| 
       e.class.should == custom_document
-      e.should be_a_kind_of(Prawn::Document)
+      e.should.be.kind_of(Prawn::Document)
     end
   end
 
@@ -71,51 +45,51 @@ describe "when generating a document from a subclass" do
     Prawn::Document.extensions << mod1 << mod2
 
     custom_document = Class.new(Prawn::Document)
-    custom_document.extensions.should == [mod1, mod2]
+    assert_equal [mod1, mod2], custom_document.extensions
 
     # remove the extensions we added to prawn document
     Prawn::Document.extensions.delete(mod1)
     Prawn::Document.extensions.delete(mod2)
 
-    Prawn::Document.new.respond_to?(:test_extensions1).should be_false
-    Prawn::Document.new.respond_to?(:test_extensions2).should be_false
+    assert ! Prawn::Document.new.respond_to?(:test_extensions1)
+    assert ! Prawn::Document.new.respond_to?(:test_extensions2)
 
     # verify these still exist on custom class
-    custom_document.extensions.should == [mod1, mod2]
+    assert_equal [mod1, mod2], custom_document.extensions
 
-    custom_document.new.respond_to?(:test_extensions1).should be_true
-    custom_document.new.respond_to?(:test_extensions2).should be_true
+    assert custom_document.new.respond_to?(:test_extensions1)
+    assert custom_document.new.respond_to?(:test_extensions2)
   end
 
 end
 
-
-describe "When creating multi-page documents" do
-
+                               
+describe "When creating multi-page documents" do 
+ 
   before(:each) { create_pdf }
-
-  it "should initialize with a single page" do
+  
+  it "should initialize with a single page" do 
     page_counter = PDF::Inspector::Page.analyze(@pdf.render)
-
-    page_counter.pages.size.should == 1
-    @pdf.page_count.should == 1
+    
+    page_counter.pages.size.should == 1            
+    @pdf.page_count.should == 1  
   end
-
+  
   it "should provide an accurate page_count" do
-    3.times { @pdf.start_new_page }
+    3.times { @pdf.start_new_page }           
     page_counter = PDF::Inspector::Page.analyze(@pdf.render)
-
+    
     page_counter.pages.size.should == 4
     @pdf.page_count.should == 4
-  end
-
-end
+  end                 
+  
+end   
 
 describe "When beginning each new page" do
 
   describe "Background template feature" do
     before(:each) do
-      @filename = "#{Prawn::DATADIR}/images/pigs.jpg"
+      @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg"
       @pdf = Prawn::Document.new(:background => @filename)
     end
     it "should place a background image if it is in options block" do
@@ -128,11 +102,11 @@ describe "When beginning each new page" do
       @pdf.instance_variable_defined?(:@background).should == true
       @pdf.instance_variable_get(:@background).should == @filename
     end
-
-
+    
+    
   end
-
-
+  
+  
 end
 
 describe "Prawn::Document#float" do
@@ -145,7 +119,7 @@ describe "Prawn::Document#float" do
 
   it "should teleport across pages if necessary" do
     create_pdf
-
+    
     @pdf.float do
       @pdf.text "Foo"
       @pdf.start_new_page
@@ -182,7 +156,7 @@ end
 
 describe "on_page_create callback" do
   before do
-    create_pdf
+    create_pdf 
   end
 
   it "should be invoked with document" do
@@ -203,34 +177,34 @@ describe "on_page_create callback" do
 
     5.times { @pdf.start_new_page }
   end
-
+  
   it "should be replaceable" do
       trigger1 = mock()
       trigger1.expects(:fire).times(1)
-
+      
       trigger2 = mock()
       trigger2.expects(:fire).times(1)
 
       @pdf.on_page_create { trigger1.fire }
-
+      
       @pdf.start_new_page
-
+      
       @pdf.on_page_create { trigger2.fire }
-
+      
       @pdf.start_new_page
   end
-
+  
   it "should be clearable by calling on_page_create without a block" do
       trigger = mock()
       trigger.expects(:fire).times(1)
 
       @pdf.on_page_create { trigger.fire }
 
-      @pdf.start_new_page
-
+      @pdf.start_new_page 
+      
       @pdf.on_page_create
-
-      @pdf.start_new_page
+      
+      @pdf.start_new_page 
   end
 
 end
@@ -240,8 +214,8 @@ describe "Document compression" do
   it "should not compress the page content stream if compression is disabled" do
 
     pdf = Prawn::Document.new(:compress => false)
-    pdf.page.content.stream.stubs(:compress!).returns(true)
-    pdf.page.content.stream.expects(:compress!).never
+    pdf.page.content.stubs(:compress_stream).returns(true)
+    pdf.page.content.expects(:compress_stream).never
 
     pdf.text "Hi There" * 20
     pdf.render
@@ -250,8 +224,8 @@ describe "Document compression" do
   it "should compress the page content stream if compression is enabled" do
 
     pdf = Prawn::Document.new(:compress => true)
-    pdf.page.content.stream.stubs(:compress!).returns(true)
-    pdf.page.content.stream.expects(:compress!).once
+    pdf.page.content.stubs(:compress_stream).returns(true)
+    pdf.page.content.expects(:compress_stream).once
 
     pdf.text "Hi There" * 20
     pdf.render
@@ -261,14 +235,14 @@ describe "Document compression" do
     doc_uncompressed = Prawn::Document.new
     doc_compressed   = Prawn::Document.new(:compress => true)
     [doc_compressed, doc_uncompressed].each do |pdf|
-       pdf.font "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+       pdf.font "#{Prawn::BASEDIR}/data/fonts/gkai00mp.ttf"
        pdf.text "更可怕的是，同质化竞争对手可以按照URL中后面这个ID来遍历" * 10
     end
 
-    doc_compressed.render.length.should be < doc_uncompressed.render.length
-  end
+    doc_compressed.render.length.should.be < doc_uncompressed.render.length
+  end 
 
-end
+end                                 
 
 describe "Document metadata" do
   it "should output strings as UTF-16 with a byte order mark" do
@@ -288,10 +262,11 @@ describe "When reopening pages" do
       pdf.go_to_page 1
       pdf.text "More for page 1"
     end
-
-    # Indirectly verify that the actual length does not match dictionary length.
-    # If it isn't, a MalformedPDFError will be raised
-    PDF::Inspector::Page.analyze(@pdf.render)
+    
+    # MalformedPDFError raised if content stream actual length does not match
+    # dictionary length
+    lambda{ PDF::Inspector::Page.analyze(@pdf.render) }.
+      should.not.raise(PDF::Reader::MalformedPDFError)
   end
 
   it "should insert pages after the current page when calling start_new_page" do
@@ -323,21 +298,21 @@ describe "When setting page size" do
   it "should default to LETTER" do
     @pdf = Prawn::Document.new
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"]
-  end
-
-  (PDF::Core::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
+    pages.first[:size].should == Prawn::Document::PageGeometry::SIZES["LETTER"]    
+  end                                                                  
+  
+  (Prawn::Document::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
     it "should provide #{k} geometry" do
       @pdf = Prawn::Document.new(:page_size => k)
-      pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-      pages.first[:size].should == PDF::Core::PageGeometry::SIZES[k]
+      pages = PDF::Inspector::Page.analyze(@pdf.render).pages   
+      pages.first[:size].should == Prawn::Document::PageGeometry::SIZES[k]
     end
   end
-
-  it "should allow custom page size" do
+  
+  it "should allow custom page size" do 
     @pdf = Prawn::Document.new(:page_size => [1920, 1080] )
-    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == [1920, 1080]
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages   
+    pages.first[:size].should == [1920, 1080]   
   end
 
 
@@ -346,25 +321,25 @@ describe "When setting page size" do
     @pdf.start_new_page
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
     pages.each do |page|
-      page[:size].should == PDF::Core::PageGeometry::SIZES["LEGAL"]
+      page[:size].should == Prawn::Document::PageGeometry::SIZES["LEGAL"]
     end
   end
 
-end
+end       
 
 describe "When setting page layout" do
   it "should reverse coordinates for landscape" do
     @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
-    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
-    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["A4"].reverse
-  end
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages    
+    pages.first[:size].should == Prawn::Document::PageGeometry::SIZES["A4"].reverse
+  end   
 
   it "should retain page layout by default when starting a new page" do
     @pdf = Prawn::Document.new(:page_layout => :landscape)
     @pdf.start_new_page(:trace => true)
     pages = PDF::Inspector::Page.analyze(@pdf.render).pages
     pages.each do |page|
-      page[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"].reverse
+      page[:size].should == Prawn::Document::PageGeometry::SIZES["LETTER"].reverse
     end
   end
 
@@ -383,11 +358,11 @@ describe "The mask() feature" do
     @pdf.mask(:y, :line_width) do
       @pdf.y = y + 1
       @pdf.line_width = line_width + 1
-      @pdf.y.should_not == y
-      @pdf.line_width.should_not == line_width
+      @pdf.y.should.not == y
+      @pdf.line_width.should.not == line_width
     end
     @pdf.y.should == y
-    @pdf.line_width.should == line_width
+    @pdf.line_width.should == line_width 
   end
 end
 
@@ -416,14 +391,14 @@ describe "The group() feature" do
     pages[1][:strings].should == ["Hello", "World"]
   end
 
-  it "should raise_error CannotGroup if the content is too tall" do
+  it "should raise CannotGroup if the content is too tall" do
     lambda {
       Prawn::Document.new do
         group do
           100.times { text "Too long" }
         end
       end.render
-    }.should raise_error(Prawn::Errors::CannotGroup)
+    }.should.raise(Prawn::Errors::CannotGroup)
   end
 
    it "should group within individual column boxes" do
@@ -447,23 +422,25 @@ describe "The group() feature" do
 end
 
 describe "The render() feature" do
-  it "should return a 8 bit encoded string on a m17n aware VM" do
-    @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
-    @pdf.line [100,100], [200,200]
-    str = @pdf.render
-    str.encoding.to_s.should == "ASCII-8BIT"
+  if "spec".respond_to?(:encode!)
+    it "should return a 8 bit encoded string on a m17n aware VM" do
+      @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
+      @pdf.line [100,100], [200,200]
+      str = @pdf.render
+      str.encoding.to_s.should == "ASCII-8BIT"
+    end
   end
 
   it "should trigger before_render callbacks just before rendering" do
     pdf = Prawn::Document.new
-
+    
     seq = sequence("callback_order")
 
     # Verify the order: finalize -> fire callbacks -> render body
     pdf.expects(:finalize_all_page_contents).in_sequence(seq)
     trigger = mock()
     trigger.expects(:fire).in_sequence(seq)
-
+    
     # Store away the render_body method to be called below
     render_body = pdf.method(:render_body)
     pdf.expects(:render_body).in_sequence(seq)
@@ -487,10 +464,10 @@ end
 describe "The :optimize_objects option" do
   before(:all) do
     @wasteful_doc = lambda do |pdf|
-      pdf.transaction do
+      pdf.transaction do 
         pdf.start_new_page
         pdf.text "Hidden text"
-        pdf.rollback
+        pdf.rollback 
       end
 
       pdf.text "Hello world"
@@ -501,12 +478,12 @@ describe "The :optimize_objects option" do
     wasteful_pdf = Prawn::Document.new(&@wasteful_doc)
     frugal_pdf   = Prawn::Document.new(:optimize_objects => true,
                                        &@wasteful_doc)
-    frugal_pdf.render.size.should be < wasteful_pdf.render.size
+    frugal_pdf.render.size.should.be < wasteful_pdf.render.size
   end
 
   it "should default to :false" do
     default_pdf  = Prawn::Document.new(&@wasteful_doc)
-    wasteful_pdf = Prawn::Document.new(:optimize_objects => false,
+    wasteful_pdf = Prawn::Document.new(:optimize_objects => false, 
                                        &@wasteful_doc)
     default_pdf.render.size.should == wasteful_pdf.render.size
   end
@@ -588,25 +565,25 @@ describe "The number_pages method" do
   before do
     @pdf = Prawn::Document.new(:skip_page_creation => true)
   end
-
+  
   it "replaces the '<page>' string with the proper page number" do
     @pdf.start_new_page
     @pdf.expects(:text_box).with("1, test", { :height => 50 })
     @pdf.number_pages "<page>, test", {:page_filter => :all}
   end
-
+  
   it "replaces the '<total>' string with the total page count" do
     @pdf.start_new_page
     @pdf.expects(:text_box).with("test, 1", { :height => 50 })
     @pdf.number_pages "test, <total>", {:page_filter => :all}
   end
-
+ 
   it "must print each page if given the :all page_filter" do
     10.times { @pdf.start_new_page }
     @pdf.expects(:text_box).times(10)
     @pdf.number_pages "test", {:page_filter => :all}
   end
-
+  
   it "must print each page if no :page_filter is specified" do
     10.times { @pdf.start_new_page }
     @pdf.expects(:text_box).times(10)
@@ -618,8 +595,8 @@ describe "The number_pages method" do
     @pdf.expects(:text_box).never
     @pdf.number_pages "test", {:page_filter => nil}
   end
-
-  context "start_count_at option" do
+  
+  context "start_count_at option" do    
     [1, 2].each do |startat|
       context "equal to #{startat}" do
         it "increments the pages" do
@@ -628,10 +605,10 @@ describe "The number_pages method" do
           @pdf.expects(:text_box).with("#{startat} 2", { :height => 50 })
           @pdf.expects(:text_box).with("#{startat+1} 2", { :height => 50 })
           @pdf.number_pages "<page> <total>", options
-        end
+        end  
       end
     end
-
+      
     [0, nil].each do |val|
       context "equal to #{val}" do
         it "defaults to start at page 1" do
@@ -645,7 +622,7 @@ describe "The number_pages method" do
       end
     end
   end
-
+  
   context "total_pages option" do
     it "allows the total pages count to be overridden" do
       2.times { @pdf.start_new_page }
@@ -654,7 +631,7 @@ describe "The number_pages method" do
       @pdf.number_pages "<page> <total>", :page_filter => :all, :total_pages => 10
     end
   end
-
+  
   context "special page filter" do
     context "such as :odd" do
       it "increments the pages" do
@@ -699,27 +676,6 @@ describe "The number_pages method" do
       end
     end
   end
-
-  context "height option" do
-    before do
-      @pdf.start_new_page
-    end
-
-    it "with 10 height" do
-      @pdf.expects(:text_box).with("1 1", { :height => 10 })
-      @pdf.number_pages "<page> <total>", :height => 10
-    end
-
-    it "with nil height" do
-      @pdf.expects(:text_box).with("1 1", { :height => nil })
-      @pdf.number_pages "<page> <total>", :height => nil
-    end
-
-    it "with no height" do
-      @pdf.expects(:text_box).with("1 1", { :height => 50 })
-      @pdf.number_pages "<page> <total>"
-    end
-  end
 end
 
 describe "The page_match? method" do
@@ -727,33 +683,33 @@ describe "The page_match? method" do
     @pdf = Prawn::Document.new(:skip_page_creation => true)
     10.times {@pdf.start_new_page}
   end
-
+  
   it "returns nil given no filter" do
-    @pdf.page_match?(:nil, 1).should be_false
+    assert ! @pdf.page_match?(:nil, 1)
   end
-
+  
   it "must provide an :all filter" do
-    (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }.should be_true
+    assert (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }
   end
 
   it "must provide an :odd filter" do
     odd, even = (1..@pdf.page_count).partition { |e| e % 2 == 1 }
-    odd.all? { |i| @pdf.page_match?(:odd, i) }.should be_true
-    even.any? { |i| @pdf.page_match?(:odd, i) }.should be_false
+    assert odd.all? { |i| @pdf.page_match?(:odd, i) }
+    assert ! even.any? { |i| @pdf.page_match?(:odd, i) }
   end
 
   it "must be able to filter by an array of page numbers" do
     fltr = [1,2,7]
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,2,7]
+    assert_equal [1,2,7], (1..10).select { |i| @pdf.page_match?(fltr, i) }
   end
 
   it "must be able to filter by a range of page numbers" do
     fltr = 2..4
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [2,3,4]
+    assert_equal [2,3,4], (1..10).select { |i| @pdf.page_match?(fltr, i) }
   end
 
   it "must be able to filter by an arbitrary proc" do
     fltr = lambda { |x| x == 1 or x % 3 == 0 }
-    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,3,6,9]
-  end
+    assert_equal [1,3,6,9], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+  end    
 end