prawn 0.11.1.pre → 0.11.1

data/spec/object_store_spec.rb

@@ -157,4 +157,14 @@ describe "Prawn::ObjectStorie#object_id_for_page" do
     store = Prawn::Core::ObjectStore.new
     store.object_id_for_page(10).should == nil
   end
+
+  it "should accept a stream instead of a filename" do
+    example = Prawn::Document.new()
+    example.text "An example doc, created in memory"
+    example.start_new_page
+    StringIO.open(example.render) do |stream|
+      @pdf = Prawn::Core::ObjectStore.new(:template => stream)
+    end
+    @pdf.page_count.should == 2
+  end
 end

data/spec/outline_spec.rb

@@ -242,14 +242,15 @@ describe "Outline" do
             page :destination => page_number, :title => "Inserted Page"
           end
         end
-        render_and_find_objects
       end
 
       it "should insert new outline items to document" do
+        render_and_find_objects
         assert_not_nil @inserted_page
       end
       
       it "should adjust the count of all ancestors" do
+        render_and_find_objects
         @outline_root[:Count].should == 4
         @section_1[:Count].should.abs == 3
       end
@@ -257,16 +258,19 @@ describe "Outline" do
       describe "#adjust_relations" do
       
         it "should reset the sibling relations of adjoining items to inserted item" do
+          render_and_find_objects
           referenced_object(@page_1[:Next]).should == @inserted_page
           referenced_object(@page_2[:Prev]).should == @inserted_page
         end
       
         it "should set the sibling relation of added item to adjoining items" do
+          render_and_find_objects
           referenced_object(@inserted_page[:Next]).should == @page_2
           referenced_object(@inserted_page[:Prev]).should == @page_1
         end
       
         it "should not affect the first and last relations of parent item" do
+          render_and_find_objects
           referenced_object(@section_1[:First]).should == @page_1
           referenced_object(@section_1[:Last]).should == @page_2
         end
@@ -361,7 +365,7 @@ context "foreign character encoding" do
         section 'La pomme croquée', :destination => 1, :closed => true
       end
     end
-    @hash = PDF::Hash.new(StringIO.new(pdf.render, 'r+'))
+    @hash = PDF::Reader::ObjectHash.new(StringIO.new(pdf.render, 'r+'))
   end
 
   it "should handle other encodings for the title" do
@@ -372,7 +376,7 @@ end
 
 def render_and_find_objects
   output = StringIO.new(@pdf.render, 'r+')
-  @hash = PDF::Hash.new(output)
+  @hash = PDF::Reader::ObjectHash.new(output)
   @outline_root = @hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Outlines}
   @pages = @hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
   @section_1 = find_by_title('Chapter 1')

data/spec/repeater_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")           
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Repeaters" do
 
@@ -10,13 +10,13 @@ describe "Repeaters" do
 
     r = repeater(doc, :all) { :do_nothing }
 
-    assert_equal orig_count + 1,  Prawn::Repeater.count 
+    assert_equal orig_count + 1,  Prawn::Repeater.count
   end
 
   it "must provide an :all filter" do
     doc = sample_document
     r = repeater(doc, :all) { :do_nothing }
-   
+
     assert (1..doc.page_count).all? { |i| r.match?(i) }
   end
 
@@ -64,23 +64,39 @@ describe "Repeaters" do
     doc.expects(:stamp).never
     repeater(doc, :odd).run(2)
   end
-  
+
   it "must not try to run a stamp if dynamic is selected" do
     doc = sample_document
 
     doc.expects(:stamp).never
     (1..10).each { |p| repeater(doc, :all, true){:do_nothing}.run(p) }
   end
-  
-  it "must render the block in context of page when dynamic is selected" do
+
+  it "must treat any block as a closure" do
     doc = sample_document
 
-    doc.repeat(:all, :dynamic => true) do 
-      draw_text page_number, :at => [500, 0]
+    @page = "Page" # ensure access to ivars
+    doc.repeat(:all, :dynamic => true) do
+      doc.draw_text "#@page #{doc.page_number}", :at => [500, 0]
+    end
+
+    text = PDF::Inspector::Text.analyze(doc.render)
+    assert_equal (1..10).to_a.map{|p| "Page #{p}"}, text.strings
+  end
+
+  it "must treat any block as a closure (Document.new instance_eval form)" do
+    doc = Prawn::Document.new(:skip_page_creation => true) do
+      10.times { start_new_page }
+
+      @page = "Page"
+      repeat(:all, :dynamic => true) do
+        # ensure self is accessible here
+        draw_text "#@page #{page_number}", :at => [500, 0]
+      end
     end
 
-    text = PDF::Inspector::Text.analyze(doc.render)  
-    assert_equal (1..10).to_a.map{|p| p.to_s}, text.strings 
+    text = PDF::Inspector::Text.analyze(doc.render)
+    assert_equal (1..10).to_a.map{|p| "Page #{p}"}, text.strings
   end
 
   def sample_document
@@ -93,4 +109,36 @@ describe "Repeaters" do
     Prawn::Repeater.new(*args,&b)
   end
 
+  context "graphic state" do
+
+    it "should not alter the graphic state stack color space" do
+      create_pdf
+      starting_color_space = @pdf.state.page.graphic_state.color_space.dup
+      @pdf.repeat :all do
+        @pdf.text "Testing", :size => 24, :style => :bold
+      end
+      @pdf.state.page.graphic_state.color_space.should == starting_color_space
+    end
+
+    context "dynamic repeaters" do
+
+      it "should preserve the graphic state at creation time" do
+        create_pdf
+        @pdf.repeat :all, :dynamic => true do
+          @pdf.text "fill_color: #{@pdf.graphic_state.fill_color}"
+          @pdf.text "cap_style: #{@pdf.graphic_state.cap_style}"
+        end
+        @pdf.fill_color "666666"
+        @pdf.cap_style :round
+        text = PDF::Inspector::Text.analyze(@pdf.render)
+        text.strings.include?("fill_color: 666666").should == false
+        text.strings.include?("fill_color: 000000").should == true
+        text.strings.include?("cap_style: round").should == false
+        text.strings.include?("cap_style: butt").should == true
+      end
+      
+    end
+
+  end
+
 end

data/spec/security_spec.rb

@@ -66,6 +66,12 @@ describe "Document encryption" do
         should == 0b1111_1111_1111_1111_1111_1111_1101_1111
     end
 
+    it "should raise ArgumentError if invalid option is provided" do
+      lambda {
+        doc_with_permissions(:modify_document => false)
+      }.should.raise(ArgumentError)
+    end
+
   end
 
   describe "Encryption keys" do

data/spec/spec_helper.rb

@@ -3,24 +3,28 @@
 puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
 
 require "rubygems"
+require "bundler"
+Bundler.setup
+
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'vendor',
-                             'pdf-inspector','lib')
 require "prawn"
 
 Prawn.debug = true
 
-ruby_19 do
-  gem "test-unit", "=1.2.3"
-end
 require "test/spec"
 require "mocha"
-
-gem 'pdf-reader', ">=0.8"
-require "pdf/reader"          
+require "pdf/reader"
 require "pdf/inspector"
 
 def create_pdf(klass=Prawn::Document)
   @pdf = klass.new(:margin => 0)
 end    
 
+# Make some methods public to assist in testing
+module Prawn::Graphics
+  public :map_to_absolute
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[extensions mocha]))
+

data/spec/stamp_spec.rb

@@ -88,7 +88,7 @@ describe "Document with a stamp" do
      "stamp XObject, not the page" do
     create_pdf
     @pdf.create_stamp("MyStamp") do
-      @pdf.transparent(0.5) { @pdf.circle_at([100, 100], :radius => 10)}
+      @pdf.transparent(0.5) { @pdf.circle([100, 100], 10)}
     end
     @pdf.stamp("MyStamp")
 
@@ -105,4 +105,55 @@ describe "Document with a stamp" do
       end
     end
   end
+  
+  it "stamp stream should be wrapped in a graphic state" do
+    create_pdf
+    @pdf.create_stamp("MyStamp") do
+      @pdf.text "This should have a 'q' before it and a 'Q' after it"
+    end
+    @pdf.stamp("MyStamp")
+    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
+    stamps.xobject_streams[:Stamp1].data.chomp.should =~ /q(.|\s)*Q\Z/
+  end
+  
+  it "should not add to the page graphic state stack " do
+    create_pdf
+    @pdf.state.page.stack.stack.size.should == 1
+    
+    @pdf.create_stamp("MyStamp") do
+      @pdf.save_graphics_state
+      @pdf.save_graphics_state
+      @pdf.save_graphics_state
+      @pdf.text "This should have a 'q' before it and a 'Q' after it"
+      @pdf.restore_graphics_state
+    end
+    @pdf.state.page.stack.stack.size.should == 1
+  end
+  
+  it "should be able to change fill and stroke colors within the stamp stream" do
+    create_pdf
+    @pdf.create_stamp("MyStamp") do
+      @pdf.fill_color(100, 100, 20, 0)
+      @pdf.stroke_color(100, 100, 20, 0)
+    end
+    @pdf.stamp("MyStamp")
+    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
+    stamp_stream = stamps.xobject_streams[:Stamp1].data
+    stamp_stream.should.include "/DeviceCMYK cs\n1.000 1.000 0.200 0.000 scn"
+    stamp_stream.should.include "/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN"
+  end
+  
+  it "should save the color space even when same as current page color space" do
+    create_pdf
+    @pdf.stroke_color(100, 100, 20, 0)
+    @pdf.create_stamp("MyStamp") do
+      @pdf.stroke_color(100, 100, 20, 0)
+    end
+    @pdf.stamp("MyStamp")
+    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
+    stamp_stream = stamps.xobject_streams[:Stamp1].data
+    stamp_stream.should.include "/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN"
+  end
+    
+
 end

data/spec/stroke_styles_spec.rb

@@ -159,5 +159,35 @@ describe "Dashes" do
     dashes.stroke_dash_count.should == 2
     dashes.stroke_dash.should == [[2, 2], 0]
   end
+  
+  describe "#dashed?" do
+    
+    it "an initial document should not be dashed" do
+      @pdf.dashed?.should == false
+    end
+    
+    it "should return true if any of the currently active settings are dashed" do
+      @pdf.dash(2)
+      @pdf.save_graphics_state
+      @pdf.dashed?.should == true
+    end
+    
+    it "should return false if the document was most recently undashed" do
+      @pdf.dash(2)
+      @pdf.save_graphics_state
+      @pdf.undash
+      @pdf.save_graphics_state
+      @pdf.dashed?.should == false
+    end
+    
+    it "should return true when restoring to a state that was dashed" do
+      @pdf.dash(2)
+      @pdf.save_graphics_state
+      @pdf.undash
+      @pdf.restore_graphics_state
+      @pdf.dashed?.should == true
+    end
+    
+  end
 
 end

data/spec/table_spec.rb

@@ -32,6 +32,10 @@ describe "Prawn::Table" do
       }.should.not.raise
     end   
 
+    it "should allow a table with a header but no body" do
+      lambda { @pdf.table([["Header"]], :header => true) }.should.not.raise
+    end
+
     # TODO: pending colspan
     xit "should accurately count columns from data" do
       # First data row may contain colspan which would hide true column count
@@ -99,6 +103,15 @@ describe "Prawn::Table" do
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
+    it "should allow negative row selectors" do
+      Set.new(@table.row(-1).map { |c| c.content }).should ==
+        Set.new(%w[R1C0 R1C1])
+      Set.new(@table.rows(-2..-1).map { |c| c.content }).should ==
+        Set.new(%w[R0C0 R0C1 R1C0 R1C1])
+      Set.new(@table.rows(0..-1).map { |c| c.content }).should ==
+        Set.new(%w[R0C0 R0C1 R1C0 R1C1])
+    end
+
     it "should select columns by number or range" do
       Set.new(@table.column(0).map { |c| c.content }).should == 
         Set.new(%w[R0C0 R1C0])
@@ -106,6 +119,15 @@ describe "Prawn::Table" do
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
+    it "should allow negative column selectors" do
+      Set.new(@table.column(-1).map { |c| c.content }).should ==
+        Set.new(%w[R0C1 R1C1])
+      Set.new(@table.columns(-2..-1).map { |c| c.content }).should ==
+        Set.new(%w[R0C0 R0C1 R1C0 R1C1])
+      Set.new(@table.columns(0..-1).map { |c| c.content }).should ==
+        Set.new(%w[R0C0 R0C1 R1C0 R1C1])
+    end
+
     it "should allow rows and columns to be combined" do
       @table.row(0).column(1).map { |c| c.content }.should == ["R0C1"]
     end
@@ -137,6 +159,11 @@ describe "Prawn::Table" do
       @table.cells[1, 0].width.should == 100
     end
 
+    it "style method should accept a block, passing each cell to be styled" do
+      @table.cells.style { |c| c.height = 200 }
+      @table.cells[0, 1].height.should == 200
+    end
+
     it "should return the width of selected columns for #width" do
       c0_width = @table.column(0).map{ |c| c.width }.max
       c1_width = @table.column(1).map{ |c| c.width }.max
@@ -293,6 +320,16 @@ describe "Prawn::Table" do
         @table.column(0).width.should == @table.column(2).width
       end
 
+      it "should allow table cells to be resized in block" do
+        lambda do
+          @pdf.table([%w[1 2 3 4 5]]) do |t|
+            t.width = 40
+            t.cells.size = 8
+            t.cells.padding = 0
+          end
+        end.should.not.raise(Prawn::Errors::CannotFit)
+      end
+
       it "should be the width of the :width parameter" do
         expected_width = 300
         table = Prawn::Table.new( [%w[snake foo b apple], 
@@ -378,10 +415,11 @@ describe "Prawn::Table" do
 
         table_height = origin - @pdf.y
         font_height = @pdf.font.height
+        line_gap = @pdf.font.line_gap
 
         num_rows = data.length
         table_height.should.be.close(
-          num_rows*font_height + 2*vpad*num_rows, 0.001 )
+          num_rows * font_height + 2*vpad*num_rows, 0.001 )
       end
 
     end
@@ -392,7 +430,7 @@ describe "Prawn::Table" do
     it "should flow to the next page when hitting the bottom of the bounds" do
       Prawn::Document.new { table([["foo"]] * 30) }.page_count.should == 1
       Prawn::Document.new { table([["foo"]] * 31) }.page_count.should == 2
-      Prawn::Document.new { table([["foo"]] * 31); table([["foo"]] * 31) }.
+      Prawn::Document.new { table([["foo"]] * 31); table([["foo"]] * 35) }.
         page_count.should == 3
     end
 
@@ -403,6 +441,50 @@ describe "Prawn::Table" do
         end
       end.page_count.should == 2
     end
+
+    it "should not start a new page before finishing out a row" do
+      Prawn::Document.new do
+        table([[ (1..80).map{ |i| "Line #{i}" }.join("\n"), "Column 2" ]])
+      end.page_count.should == 1
+    end
+
+    it "should only start new page on long cells if it would gain us height" do
+      Prawn::Document.new do
+        text "Hello"
+        table([[ (1..80).map{ |i| "Line #{i}" }.join("\n"), "Column 2" ]])
+      end.page_count.should == 2
+    end
+
+    it "should not start a new page to gain height when at the top of " +
+       "a bounding box, even if stretchy" do
+      Prawn::Document.new do
+        bounding_box([bounds.left, bounds.top - 20], :width => 400) do
+          table([[ (1..80).map{ |i| "Line #{i}" }.join("\n"), "Column 2" ]])
+        end
+      end.page_count.should == 1
+    end
+
+    it "should still break to the next page if in a stretchy bounding box " +
+       "but not at the top" do
+      Prawn::Document.new do
+        bounding_box([bounds.left, bounds.top - 20], :width => 400) do
+          text "Hello"
+          table([[ (1..80).map{ |i| "Line #{i}" }.join("\n"), "Column 2" ]])
+        end
+      end.page_count.should == 2
+    end
+
+    it "should only draw first-page header if the first body row fits" do
+      pdf = Prawn::Document.new
+
+      pdf.y = 60 # not enough room for a table row
+      pdf.table [["Header"], ["Body"]], :header => true
+
+      output = PDF::Inspector::Page.analyze(pdf.render)
+      # Ensure we only drew the header once, on the second page
+      output.pages[0][:strings].should.be.empty
+      output.pages[1][:strings].should == ["Header", "Body"]
+    end
   end
 
   describe "#style" do
@@ -525,7 +607,7 @@ describe "Prawn::Table" do
     end
 
     it "should repeat headers across pages" do
-      data = [["foo","bar"]]*30
+      data = [["foo","bar"]] * 30
       headers = ["baz","foobar"]
       @pdf = Prawn::Document.new
       @pdf.table([headers] + data, :header => true)
@@ -533,6 +615,14 @@ describe "Prawn::Table" do
       output.strings.should == headers + data.flatten[0..-3] + headers +
         data.flatten[-2..-1]
     end
+
+    it "should not draw header twice when starting new page" do
+      @pdf = Prawn::Document.new
+      @pdf.y = 0
+      @pdf.table([["Header"], ["Body"]], :header => true)
+      output = PDF::Inspector::Text.analyze(@pdf.render)   
+      output.strings.should == ["Header", "Body"]
+    end
   end
 
   describe "nested tables" do