prawn-core 0.5.1 → 0.6.1

data/spec/images_spec.rb

@@ -24,7 +24,7 @@ describe "the image() function" do
   it "should return the image info object" do
     info =  @pdf.image(@filename)
     
-    assert info.kind_of?(Prawn::Images::JPG)
+    info.should.be.kind_of(Prawn::Images::JPG)
     
     info.height.should == 453
   end

data/spec/name_tree_spec.rb

@@ -19,7 +19,9 @@ def tree_value(name, value)
 end
 
 class RefExposingDocument < Prawn::Document
-  attr_reader :objects
+  def object_store
+    @store
+  end
 end
 
 describe "Name Tree" do     
@@ -43,20 +45,20 @@ describe "Name Tree" do
   end
 
   it "should create a two new references when root is split" do
-    ref_count = @pdf.objects.length
+    ref_count = @pdf.object_store.length
     node = Prawn::NameTree::Node.new(@pdf, 3)
     tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    @pdf.objects.length.should.equal ref_count+2
+    @pdf.object_store.length.should.equal ref_count+2
   end
   
   it "should create a one new reference when subtree is split" do
     node = Prawn::NameTree::Node.new(@pdf, 3)
     tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
 
-    ref_count = @pdf.objects.length # save when root is split
+    ref_count = @pdf.object_store.length # save when root is split
     tree_add(node, ["five", 5], ["six", 6], ["seven", 7])
     tree_dump(node).should == "[[five=5,four=4,one=1],[seven=7,six=6],[three=3,two=2]]"
-    @pdf.objects.length.should.equal ref_count+1
+    @pdf.object_store.length.should.equal ref_count+1
   end
 
   it "should keep tree balanced when subtree split cascades to root" do
@@ -66,6 +68,13 @@ describe "Name Tree" do
     tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
   end
 
+  it "should maintain order of already properly ordered nodes" do
+    node = Prawn::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["eight", 8], ["five", 5], ["four", 4], ["one", 1])
+    tree_add(node, ['seven', 7], ['six', 6], ['three', 3], ['two', 2])
+    tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
+  end
+
   it "should emit only :Names key with to_hash if root is only node" do
     node = Prawn::NameTree::Node.new(@pdf, 3)
     tree_add(node, ["one", 1], ["two", 2], ["three", 3])

data/spec/object_store_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Prawn::ObjectStore" do
+  before(:each) do
+    @store = Prawn::ObjectStore.new
+  end
+
+  it "should create required roots by default, including info passed to new" do
+    store = Prawn::ObjectStore.new(:Test => 3)
+    store.size.should == 3 # 3 default roots
+    store.info.data[:Test].should == 3
+    store.pages.data[:Count].should == 0
+    store.root.data[:Pages].should == store.pages
+  end
+
+  it "should add to its objects when ref() is called" do
+    count = @store.size
+    @store.ref("blah")
+    @store.size.should == count + 1
+  end
+
+  it "should accept push with a Prawn::Reference" do
+    r = Prawn::Reference(123, "blah")
+    @store.push(r)
+    @store[r.identifier].should == r
+  end
+
+  it "should accept arbitrary data and use it to create a Prawn::Reference" do
+    @store.push(123, "blahblah")
+    @store[123].data.should == "blahblah"
+  end
+
+  it "should be Enumerable, yielding in order of submission" do
+    # higher IDs to bypass the default roots
+    [10, 11, 12].each do |id|
+      @store.push(id, "some data #{id}")
+    end
+    @store.map{|ref| ref.identifier}[-3..-1].should == [10, 11, 12]
+  end
+end

data/spec/pdf_object_spec.rb

@@ -34,6 +34,11 @@ describe "PDF Object Serialization" do
     s_utf16 = "\xFE\xFF" + s.unpack("U*").pack("n*")
     PDF::Inspector.parse(Prawn::PdfObject(s, false)).should == s_utf16
   end                      
+
+  it "should pass through bytes regardless of content stream status for ByteString" do
+    Prawn::PdfObject(Prawn::ByteString.new("\xDE\xAD\xBE\xEF")).upcase.
+      should == "<DEADBEEF>"
+  end
   
   it "should escape parens when converting from Ruby string to PDF" do
     s =  'I )(can has a string'      

data/spec/reference_spec.rb

@@ -39,4 +39,44 @@ describe "A Reference object" do
       "compressed stream expected to be smaller than source but wasn't"
     cref.data[:Filter].should == :FlateDecode
   end
+
+  it "should copy the data and stream from another ref on #replace" do
+    from = Prawn::Reference(3, {:foo => 'bar'})
+    from << "has a stream too"
+
+    to = Prawn::Reference(4, {:foo => 'baz'})
+    to.replace from
+
+    # should preserve identifier but copy data and stream
+    to.identifier.should == 4
+    to.data.should == from.data
+    to.stream.should == from.stream
+  end
+
+  it "should copy a compressed stream from a compressed ref on #replace" do
+    from = Prawn::Reference(5, {:foo => 'bar'})
+    from << "has a stream too " * 20
+    from.compress_stream
+
+    to = Prawn::Reference(6, {:foo => 'baz'})
+    to.replace from
+
+    to.identifier.should == 6
+    to.data.should == from.data
+    to.stream.should == from.stream
+    to.compressed?.should == true
+  end
+
+  describe "generated via Prawn::Document" do
+    it "should return a proper reference on ref!" do
+      pdf = Prawn::Document.new
+      pdf.ref!({}).is_a?(Prawn::Reference).should == true
+    end
+
+    it "should return an identifier on ref" do
+      pdf = Prawn::Document.new
+      r = pdf.ref({})
+      r.is_a?(Integer).should == true
+    end
+  end
 end

data/spec/snapshot_spec.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Prawn::Document#transaction" do
+
+  it "should properly commit if no error is raised" do
+    pdf = Prawn::Document.new do
+      transaction do
+        text "This is shown"
+      end
+    end
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    text.strings.should == ["This is shown"]
+  end
+
+  it "should not display text if transaction is rolled back" do
+    pdf = Prawn::Document.new do
+      transaction do
+        text "This is not shown"
+        rollback
+      end
+    end
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    text.strings.should == []
+  end 
+
+  it "should return true/false value indicating success of the transaction" do
+    Prawn::Document.new do
+      success = transaction { }
+      success.should == true
+
+      success = transaction { rollback }
+      success.should == false
+    end
+  end
+  
+  it "should support nested transactions" do
+    pdf = Prawn::Document.new do
+      transaction do
+        text "This is shown"
+        transaction do
+          text "and this is not"
+          rollback
+        end
+        text "and this is"
+      end
+    end
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    text.strings.should == ["This is shown", "and this is"]
+  end
+
+  it "should allow rollback of multiple pages" do
+    pdf = Prawn::Document.new do
+      transaction do
+        5.times { start_new_page }
+        text "way out there and will never be shown"
+        rollback
+      end
+      text "This is the real text, only one page"
+    end
+
+    pages = PDF::Inspector::Page.analyze(pdf.render).pages
+    pages.size.should == 1
+  end
+
+  # Because the Pages object, when restored, points to the snapshotted pages
+  # by identifier, we have to restore the snapshot into the same page objects,
+  # or else old pages will appear in the post-rollback document.
+  it "should restore the pages into the same objects" do
+    Prawn::Document.new do
+      old_page_object_id = current_page.identifier
+      old_page_content_id = page_content.identifier
+
+      transaction do
+        start_new_page
+        rollback
+      end
+
+      current_page.identifier.should == old_page_object_id
+      page_content.identifier.should == old_page_content_id
+    end
+
+
+  end
+
+  
+  describe "with a stamp dictionary present" do
+
+    it "should properly commit if no error is raised" do
+      pdf = Prawn::Document.new do
+        create_stamp("test_stamp") { text "This is shown", :at => [0,0] }
+        transaction do
+          stamp("test_stamp")
+        end
+      end
+      pdf.render.should =~ /\/Stamp1 Do/
+    end
+
+    it "should properly rollback when #rollback is called" do
+      pdf = Prawn::Document.new do
+        create_stamp("test_stamp") { text "This is not shown", :at => [0,0] }
+
+        transaction do
+          stamp("test_stamp")
+          rollback
+        end
+      end
+      pdf.render.should.not =~ /\/Stamp1 Do/
+    end 
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -16,8 +16,5 @@ require "pdf/reader"
 require "pdf/inspector"
 
 def create_pdf(klass=Prawn::Document)
-  @pdf = klass.new(:left_margin   => 0,
-                   :right_margin  => 0,
-                   :top_margin    => 0,
-                   :bottom_margin => 0)
+  @pdf = klass.new(:margin => 0)
 end    

data/spec/stamp_spec.rb

@@ -0,0 +1,98 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
+
+describe "Document with a stamp" do
+  it "should raise NameTaken error when attempt to create stamp "+
+     "with same name as an existing stamp" do
+    create_pdf
+    @pdf.create_stamp("MyStamp")
+    lambda {
+      @pdf.create_stamp("MyStamp")
+    }.should.raise(Prawn::Errors::NameTaken)
+  end
+  
+  it "should raise InvalidName error when attempt to create "+
+     "stamp with a blank name" do
+    create_pdf
+    lambda {
+      @pdf.create_stamp("")
+    }.should.raise(Prawn::Errors::InvalidName)
+  end
+  
+  it "a new XObject should be defined for each stamp created" do
+    create_pdf
+    @pdf.create_stamp("MyStamp")
+    @pdf.create_stamp("AnotherStamp")
+    @pdf.stamp("MyStamp")
+    @pdf.stamp("AnotherStamp")
+    
+    inspector = PDF::Inspector::XObject.analyze(@pdf.render)
+    xobjects = inspector.page_xobjects.last
+    xobjects.length.should == 2
+  end
+
+  it "calling stamp with a name that does not match an existing stamp "+
+     "should raise UndefinedObjectName" do
+    create_pdf
+    @pdf.create_stamp("MyStamp")
+    lambda {
+      @pdf.stamp("OtherStamp")
+    }.should.raise(Prawn::Errors::UndefinedObjectName)
+  end
+
+  it "stamp should be drawn into the document each time stamp is called" do
+    create_pdf
+    @pdf.create_stamp("MyStamp")
+    @pdf.stamp("MyStamp")
+    @pdf.stamp("MyStamp")
+    @pdf.stamp("MyStamp")
+    # I had modified PDF::Inspector::XObject to receive the
+    # invoke_xobject message and count the number of times it was
+    # called, but it was only called once, so I reverted checking the
+    # output with a regular expression
+    @pdf.render.should =~ /(\/Stamp1 Do.*?){3}/m
+  end
+
+  it "resources added during stamp creation should be added to the "+
+     "stamp XObject, not the page" do
+    create_pdf
+    @pdf.create_stamp("MyStamp") do
+      @pdf.transparent(0.5) { @pdf.circle_at([100, 100], :radius => 10)}
+    end
+    @pdf.stamp("MyStamp")
+
+    # Inspector::XObject does not give information about resources, so
+    # resorting to string matching
+
+    output = @pdf.render
+    objects = output.split("endobj")
+    objects.each do |object|
+      if object =~ /\/Type \/Page$/
+        object.should.not =~ /\/ExtGState/
+      elsif object =~ /\/Type \/XObject$/
+        object.should =~ /\/ExtGState/
+      end
+    end
+  end
+
+  it "if ProcSet changes are made, they should be added to the Page "+
+     "object, not the stamp XObject" do
+    create_pdf
+    @pdf.create_stamp("MyStamp") do
+      @pdf.text("hello")
+    end
+    @pdf.stamp("MyStamp")
+
+    # Inspector::XObject does not give information about ProcSet, so
+    # resorting to string matching
+
+    output = @pdf.render
+    objects = output.split("endobj")
+    objects.each do |object|
+      if object =~ /\/Type \/Page$/
+        object.should =~ /\/ProcSet/
+      elsif object =~ /\/Type \/XObject$/
+        object.should.not =~ /\/ProcSet/
+      end
+    end
+  end
+end

data/spec/stroke_styles_spec.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "When stroking with default settings" do
+  before(:each) { create_pdf }
+  it "cap_style should be :butt" do
+    @pdf.cap_style.should == :butt
+  end
+  
+  it "join_style should be :miter" do
+    @pdf.join_style.should == :miter
+  end
+
+  it "dashed? should be false" do
+    @pdf.should.not.be.dashed
+  end
+end
+
+describe "Cap styles" do
+  before(:each) { create_pdf }
+  
+  it "should be able to use assignment operator" do
+    @pdf.cap_style = :round
+    @pdf.cap_style.should == :round
+  end
+  
+  describe "#cap_style(:butt)" do
+    it "rendered PDF should include butt style cap" do
+      @pdf.cap_style(:butt)
+      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
+      cap_style.should == 0
+    end
+  end
+
+  describe "#cap_style(:round)" do
+    it "rendered PDF should include round style cap" do
+      @pdf.cap_style(:round)
+      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
+      cap_style.should == 1
+    end
+  end
+
+  describe "#cap_style(:projecting_square)" do
+    it "rendered PDF should include projecting_square style cap" do
+      @pdf.cap_style(:projecting_square)
+      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
+      cap_style.should == 2
+    end
+  end
+end
+
+describe "Join styles" do
+  before(:each) { create_pdf }
+  
+  it "should be able to use assignment operator" do
+    @pdf.join_style = :round
+    @pdf.join_style.should == :round
+  end
+  
+  describe "#join_style(:miter)" do
+    it "rendered PDF should include miter style join" do
+      @pdf.join_style(:miter)
+      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
+      join_style.should == 0
+    end
+  end
+
+  describe "#join_style(:round)" do
+    it "rendered PDF should include round style join" do
+      @pdf.join_style(:round)
+      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
+      join_style.should == 1
+    end
+  end
+
+  describe "#join_style(:bevel)" do
+    it "rendered PDF should include bevel style join" do
+      @pdf.join_style(:bevel)
+      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
+      join_style.should == 2
+    end
+  end
+end
+
+describe "Dashes" do
+  before(:each) { create_pdf }
+  
+   it "should be able to use assignment operator" do
+     @pdf.dash = 2
+     @pdf.should.be.dashed
+  end
+
+  describe "setting a dash" do
+    it "dashed? should be true" do
+      @pdf.dash(2)
+      @pdf.should.be.dashed
+    end
+    it "rendered PDF should include a stroked dash" do
+      @pdf.dash(2)
+      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+      dashes.stroke_dash.should == [[2, 2], 0]
+    end
+  end
+
+  describe "setting a dash by passing a single argument" do
+    it "space between dashes should be the same length as the dash in the rendered PDF" do
+      @pdf.dash(2)
+      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+      dashes.stroke_dash.should == [[2, 2], 0]
+    end
+  end
+
+  describe "with a space option that differs from the first argument" do
+    it "space between dashes in the rendered PDF should be different length than the length of the dash" do
+      @pdf.dash(2, :space => 3)
+      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+      dashes.stroke_dash.should == [[2, 3], 0]
+    end
+  end
+
+  describe "with a non-zero phase option" do
+    it "rendered PDF should include a non-zero phase" do
+      @pdf.dash(2, :phase => 1)
+      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+      dashes.stroke_dash.should == [[2, 2], 1]
+    end
+  end
+
+  describe "clearing stroke dash" do
+    it "should restore solid line" do
+      @pdf.dash(2)
+      @pdf.undash
+      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+      dashes.stroke_dash.should == [[], 0]
+    end
+  end
+
+  it "should reset the stroke dash on each new page if it has been defined" do
+    @pdf.start_new_page
+    @pdf.dash(2)
+    dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+    dashes.stroke_dash_count.should == 1
+
+    @pdf.start_new_page
+    dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
+    dashes.stroke_dash_count.should == 2
+    dashes.stroke_dash.should == [[], 0]
+    @pdf.dash.should == { :dash => nil, :space => nil, :phase => 0 }
+  end
+
+end

data/spec/text_box_spec.rb

@@ -20,6 +20,32 @@ describe "A text box" do
     @box.text.should == "Oh hai\ntext box.\n" * 5
   end
 
+  it "render should return truncated text (NOTE: which may have had its whitespace mangled by wrap/unwrap)" do
+    @text = "Oh hai text box. " * 25
+    @overflow = :truncate
+    create_text_box
+    excess_text = @box.render
+    excess_text.should == "Oh hai text box. " * 20
+  end
+
+  it "render should attempt to preserve double newlines in excess text before returning it" do
+    line  = "Oh hai text box. "
+    @text = line * 10 + "\n\n" + line * 10
+    @overflow = :truncate
+    create_text_box
+    excess_text = @box.render
+    excess_text.should == line * 5 + "\n\n" + line * 10
+  end
+
+  it "render should attempt to preserve single newlines in excess text before returning it" do
+    line  = "Oh hai text box. "
+    @text = line * 10 + "\n" + line * 10
+    @overflow = :truncate
+    create_text_box
+    excess_text = @box.render
+    excess_text.should == line * 5 + "\n" + line * 10
+  end
+
   it "should have a height equal to @height" do
     @overflow = :truncate    
     create_text_box

data/spec/text_spec.rb

@@ -17,7 +17,8 @@ describe "when drawing text" do
      @pdf.y.should.be.close(position - 3*@pdf.font.height, 0.0001)
    end
    
-   it "should advance down the document based on font ascender only if final_gap is given" do
+   it "should advance down the document based on font ascender only "+
+      "if final_gap is given" do
      position = @pdf.y
      @pdf.text "Foo", :final_gap => false
 
@@ -28,6 +29,12 @@ describe "when drawing text" do
      @pdf.y.should.be.close(position - 2*@pdf.font.height - @pdf.font.ascender, 0.0001)
    end
 
+   it "should not accept :align alongside :at" do
+     assert_raises(ArgumentError) do
+       @pdf.text "What could this mean?", :at => [100, 100], :align => :center
+     end
+   end
+
    it "should default to 12 point helvetica" do
       @pdf.text "Blah", :at => [100,100]              
       text = PDF::Inspector::Text.analyze(@pdf.render)  

data/spec/transparency_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
+
+describe "Document with transparency" do
+  it "the PDF version should be at least 1.4" do
+    create_pdf
+    @pdf.transparent(0.5)
+    str = @pdf.render
+    str[0,8].should == "%PDF-1.4"
+  end
+  
+  it "a new extended graphics state should be created for "+
+     "each unique transparency setting" do
+    create_pdf
+    @pdf.transparent(0.5, 0.2)
+    @pdf.transparent(0.5, 0.75)
+    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
+    extgstates.length.should == 2
+  end
+  
+  it "a new extended graphics state should not be created for "+
+     "each duplicate transparency setting" do
+    create_pdf
+    @pdf.transparent(0.5, 0.75)
+    @pdf.transparent(0.5, 0.75)
+    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
+    extgstates.length.should == 1
+  end
+
+  it "setting the transparency with only one parameter sets the transparency"+
+     " for both the fill and the stroke" do
+    create_pdf
+    @pdf.transparent(0.5)
+    extgstate = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates[0]
+    extgstate[:opacity].should == 0.5
+    extgstate[:stroke_opacity].should == 0.5
+  end
+
+  it "setting the transparency with a numerical parameter and "+
+     "a :stroke should set the fill transparency to the numerical parameter "+
+     "and the stroke transparency to the option" do
+    create_pdf
+    @pdf.transparent(0.5, 0.2)
+    extgstate = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates[0]
+    extgstate[:opacity].should == 0.5
+    extgstate[:stroke_opacity].should == 0.2
+  end
+  
+  describe "with more than one page" do
+    it "the extended graphic state resource should be added to both pages" do
+      create_pdf
+      @pdf.transparent(0.5, 0.2)
+      @pdf.start_new_page
+      @pdf.transparent(0.5, 0.2)
+      extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
+      extgstate = extgstates[0]
+      extgstates.length.should == 2
+      extgstate[:opacity].should == 0.5
+      extgstate[:stroke_opacity].should == 0.2
+    end
+  end
+end

data/vendor/pdf-inspector/lib/pdf/inspector/extgstate.rb

@@ -0,0 +1,18 @@
+module PDF
+  class Inspector
+    class ExtGState < Inspector
+      attr_accessor :extgstates
+
+      def initialize
+        @extgstates = []
+      end
+
+      def resource_extgstate(*params)
+        @extgstates << {
+                        :opacity => params[1][:ca],
+                        :stroke_opacity => params[1][:CA]
+                        }
+      end
+    end
+  end
+end