prawn 0.11.1 → 0.15.0

data/spec/document_spec.rb

@@ -1,15 +1,23 @@
 # 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
+    options = {:page_layout => :landscape}
+    Prawn::Document.new(options)
+    options.should == {:page_layout => :landscape}
+  end
+end
 
 describe "The cursor" do
-  it "should equal pdf.y - bounds.absolute_bottom" do
+  it "should == 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
@@ -19,14 +27,40 @@ describe "The cursor" do
     pdf.cursor.should == 10
     pdf.y.should == pdf.cursor + pdf.bounds.absolute_bottom
   end
-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
 
 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.kind_of(Prawn::Document)
+      e.should be_a_kind_of(Prawn::Document)
     end
   end
 
@@ -37,51 +71,51 @@ describe "when generating a document from a subclass" do
     Prawn::Document.extensions << mod1 << mod2
 
     custom_document = Class.new(Prawn::Document)
-    assert_equal [mod1, mod2], custom_document.extensions
+    custom_document.extensions.should == [mod1, mod2]
 
     # remove the extensions we added to prawn document
     Prawn::Document.extensions.delete(mod1)
     Prawn::Document.extensions.delete(mod2)
 
-    assert ! Prawn::Document.new.respond_to?(:test_extensions1)
-    assert ! Prawn::Document.new.respond_to?(:test_extensions2)
+    Prawn::Document.new.respond_to?(:test_extensions1).should be_false
+    Prawn::Document.new.respond_to?(:test_extensions2).should be_false
 
     # verify these still exist on custom class
-    assert_equal [mod1, mod2], custom_document.extensions
+    custom_document.extensions.should == [mod1, mod2]
 
-    assert custom_document.new.respond_to?(:test_extensions1)
-    assert custom_document.new.respond_to?(:test_extensions2)
+    custom_document.new.respond_to?(:test_extensions1).should be_true
+    custom_document.new.respond_to?(:test_extensions2).should be_true
   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::BASEDIR}/data/images/pigs.jpg"
+      @filename = "#{Prawn::DATADIR}/images/pigs.jpg"
       @pdf = Prawn::Document.new(:background => @filename)
     end
     it "should place a background image if it is in options block" do
@@ -94,11 +128,36 @@ 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
+  it "should restore the original y-position" do
+    create_pdf
+    orig_y = @pdf.y
+    @pdf.float { @pdf.text "Foo" }
+    @pdf.y.should == orig_y
+  end
+
+  it "should teleport across pages if necessary" do
+    create_pdf
+
+    @pdf.float do
+      @pdf.text "Foo"
+      @pdf.start_new_page
+      @pdf.text "Bar"
+    end
+    @pdf.text "Baz"
+
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+    pages.size.should == 2
+    pages[0][:strings].should == ["Foo", "Baz"]
+    pages[1][:strings].should == ["Bar"]
   end
-  
-  
 end
 
 describe "The page_number method" do
@@ -123,7 +182,7 @@ end
 
 describe "on_page_create callback" do
   before do
-    create_pdf 
+    create_pdf
   end
 
   it "should be invoked with document" do
@@ -144,34 +203,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
@@ -181,8 +240,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.stubs(:compress_stream).returns(true)
-    pdf.page.content.expects(:compress_stream).never
+    pdf.page.content.stream.stubs(:compress!).returns(true)
+    pdf.page.content.stream.expects(:compress!).never
 
     pdf.text "Hi There" * 20
     pdf.render
@@ -191,8 +250,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.stubs(:compress_stream).returns(true)
-    pdf.page.content.expects(:compress_stream).once
+    pdf.page.content.stream.stubs(:compress!).returns(true)
+    pdf.page.content.stream.expects(:compress!).once
 
     pdf.text "Hi There" * 20
     pdf.render
@@ -202,14 +261,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::BASEDIR}/data/fonts/gkai00mp.ttf"
+       pdf.font "#{Prawn::DATADIR}/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
@@ -229,11 +288,10 @@ describe "When reopening pages" do
       pdf.go_to_page 1
       pdf.text "More for page 1"
     end
-    
-    # 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)
+
+    # 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)
   end
 
   it "should insert pages after the current page when calling start_new_page" do
@@ -250,27 +308,36 @@ describe "When reopening pages" do
     pages[1][:strings].should == ["New page 2"]
     pages[2][:strings].should == ["Old page 2"]
   end
+
+  it "should update the bounding box to the new page's margin box" do
+    Prawn::Document.new do
+      start_new_page :layout => :landscape
+      lsize = [bounds.width, bounds.height]
+      go_to_page 1
+      [bounds.width, bounds.height].should == lsize.reverse
+    end
+  end
 end
 
 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 == Prawn::Document::PageGeometry::SIZES["LETTER"]    
-  end                                                                  
-  
-  (Prawn::Document::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
+    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"]
+  end
+
+  (PDF::Core::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 == Prawn::Document::PageGeometry::SIZES[k]
+      pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+      pages.first[:size].should == PDF::Core::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
 
 
@@ -279,27 +346,34 @@ 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 == Prawn::Document::PageGeometry::SIZES["LEGAL"]
+      page[:size].should == PDF::Core::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 == Prawn::Document::PageGeometry::SIZES["A4"].reverse
-  end   
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+    pages.first[:size].should == PDF::Core::PageGeometry::SIZES["A4"].reverse
+  end
 
-  it "should retain page layout  by default when starting a new page" do
+  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 == Prawn::Document::PageGeometry::SIZES["LETTER"].reverse
+      page[:size].should == PDF::Core::PageGeometry::SIZES["LETTER"].reverse
     end
   end
+
+  it "should swap the bounds when starting a new page with different layout" do
+    @pdf = Prawn::Document.new
+    size = [@pdf.bounds.width, @pdf.bounds.height]
+    @pdf.start_new_page(:layout => :landscape)
+    [@pdf.bounds.width, @pdf.bounds.height].should == size.reverse
+  end
 end
 
 describe "The mask() feature" do
@@ -309,11 +383,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
 
@@ -342,14 +416,14 @@ describe "The group() feature" do
     pages[1][:strings].should == ["Hello", "World"]
   end
 
-  it "should raise CannotGroup if the content is too tall" do
+  it "should raise_error 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(Prawn::Errors::CannotGroup)
+    }.should raise_error(Prawn::Errors::CannotGroup)
   end
 
    it "should group within individual column boxes" do
@@ -373,25 +447,23 @@ describe "The group() feature" do
 end
 
 describe "The render() feature" do
-  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
+  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
 
   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)
@@ -415,10 +487,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"
@@ -429,12 +501,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
@@ -516,32 +588,38 @@ 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 the page if the page number matches" do
+
+  it "must print each page if given the :all page_filter" do
     10.times { @pdf.start_new_page }
-    @pdf.expects(:text_box).at_least_once
+    @pdf.expects(:text_box).times(10)
     @pdf.number_pages "test", {:page_filter => :all}
   end
 
-  it "must not print the page number without a filter" do
+  it "must print each page if no :page_filter is specified" do
+    10.times { @pdf.start_new_page }
+    @pdf.expects(:text_box).times(10)
+    @pdf.number_pages "test"
+  end
+
+  it "must not print the page number if given a nil filter" do
     10.times { @pdf.start_new_page }
     @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
@@ -550,10 +628,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
@@ -567,7 +645,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 }
@@ -576,7 +654,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
@@ -621,6 +699,27 @@ 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
@@ -628,33 +727,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
-    assert ! @pdf.page_match?(:nil, 1)
+    @pdf.page_match?(:nil, 1).should be_false
   end
-  
+
   it "must provide an :all filter" do
-    assert (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }
+    (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }.should be_true
   end
 
   it "must provide an :odd filter" do
     odd, even = (1..@pdf.page_count).partition { |e| e % 2 == 1 }
-    assert odd.all? { |i| @pdf.page_match?(:odd, i) }
-    assert ! even.any? { |i| @pdf.page_match?(:odd, i) }
+    odd.all? { |i| @pdf.page_match?(:odd, i) }.should be_true
+    even.any? { |i| @pdf.page_match?(:odd, i) }.should be_false
   end
 
   it "must be able to filter by an array of page numbers" do
     fltr = [1,2,7]
-    assert_equal [1,2,7], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,2,7]
   end
 
   it "must be able to filter by a range of page numbers" do
     fltr = 2..4
-    assert_equal [2,3,4], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [2,3,4]
   end
 
   it "must be able to filter by an arbitrary proc" do
     fltr = lambda { |x| x == 1 or x % 3 == 0 }
-    assert_equal [1,3,6,9], (1..10).select { |i| @pdf.page_match?(fltr, i) }
-  end    
+    (1..10).select { |i| @pdf.page_match?(fltr, i) }.should == [1,3,6,9]
+  end
 end

data/spec/extensions/encoding_helpers.rb

@@ -0,0 +1,9 @@
+module EncodingHelpers
+  def win1252_string(str)
+    str.force_encoding(Encoding::Windows_1252)
+  end
+
+  def bin_string(str)
+    str.force_encoding(Encoding::ASCII_8BIT)
+  end
+end

data/spec/extensions/mocha.rb

@@ -11,13 +11,12 @@
 
 class ParameterChecker < Mocha::ParametersMatcher
   def initialize(&matching_block)
+    @expected_parameters = [Mocha::ParameterMatchers::AnyParameters.new]
     @matching_block = matching_block
-    @run_matching_block = false
   end
 
   def match?(actual_parameters = [])
-    @matching_block.call(*actual_parameters) unless @run_matching_block
-    @run_matching_block = true
+    @matching_block.call(*actual_parameters)
 
     true # always succeed
   end