alphasights-prawn 0.10.0

data/spec/object_store_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Prawn::ObjectStore" do
+  before(:each) do
+    @store = Prawn::Core::ObjectStore.new
+  end
+
+  it "should create required roots by default, including info passed to new" do
+    store = Prawn::Core::ObjectStore.new(:info => {: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 import objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.size.should == 5
+  end
+
+  it "should point to existing roots when importing objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.info.class.should == Prawn::Core::Reference
+    store.root.class.should == Prawn::Core::Reference
+  end
+
+  it "should initialize with pages when importing objects from an existing PDF" do
+    filename = "#{Prawn::BASEDIR}/reference_pdfs/curves.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.pages.data[:Count].should == 1
+  end
+
+  it "should import all objects from a PDF that has an indirect reference in a stream dict" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/indirect_reference.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.size.should == 8
+  end
+
+  it "should raise ArgumentError when given a file that doesn exist as a template" do
+    filename = "not_really_there.pdf"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(ArgumentError)
+  end
+
+  it "should raise Prawn::Errors::TemplateError when given a non PDF as a template" do
+    filename = "#{Prawn::BASEDIR}/data/images/dice.png"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(Prawn::Errors::TemplateError)
+  end
+
+  it "should raise Prawn::Errors::TemplateError when given an encrypted PDF as a template" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/encrypted.pdf"
+
+    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should.raise(Prawn::Errors::TemplateError)
+  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::Core::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
+
+describe "Prawn::ObjectStore#compact" do
+  it "should do nothing to an ObjectStore with all live refs" do
+    store = Prawn::Core::ObjectStore.new
+    store.info.data[:Blah] = store.ref(:some => "structure")
+    old_size = store.size
+    store.compact
+
+    store.size.should == old_size
+  end
+
+  it "should remove dead objects, renumbering live objects from 1" do
+    store = Prawn::Core::ObjectStore.new
+    store.ref(:some => "structure")
+    old_size = store.size
+    store.compact
+    
+    store.size.should.be < old_size
+    store.map{ |o| o.identifier }.should == (1..store.size).to_a
+  end
+
+  it "should detect and remove dead objects that were once live" do
+    store = Prawn::Core::ObjectStore.new
+    store.info.data[:Blah] = store.ref(:some => "structure")
+    store.info.data[:Blah] = :overwritten
+    old_size = store.size
+    store.compact
+    
+    store.size.should.be < old_size
+    store.map{ |o| o.identifier }.should == (1..store.size).to_a
+  end
+end
+
+describe "Prawn::ObjectStorie#object_id_for_page" do
+  it "should return the object ID of an imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/hexagon.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(0).should == 4
+  end
+
+  it "should return the object ID of the first imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/two_hexagons.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(1).should == 4
+  end
+
+  it "should return the object ID of the last imported template page" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/two_hexagons.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(-1).should == 6
+  end
+
+  it "should return the object ID of the first page of a template that uses nested Pages" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/nested_pages.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(1).should == 5
+  end
+
+  it "should return the object ID of the last page of a template that uses nested Pages" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/nested_pages.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(-1).should == 8
+  end
+
+  it "should return nil if given an invalid page number" do
+    filename = "#{Prawn::BASEDIR}/data/pdfs/hexagon.pdf"
+    store = Prawn::Core::ObjectStore.new(:template => filename)
+    store.object_id_for_page(10).should == nil
+  end
+
+  it "should return nil if given an invalid page number" do
+    store = Prawn::Core::ObjectStore.new
+    store.object_id_for_page(10).should == nil
+  end
+end

data/spec/outline_spec.rb

@@ -0,0 +1,269 @@
+# encoding: utf-8
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Outline" do
+  before(:each) do
+    @pdf = Prawn::Document.new() do
+      text "Page 1. This is the first Chapter. "
+      start_new_page
+      text "Page 2. More in the first Chapter. "
+      start_new_page
+      define_outline do
+        section 'Chapter 1', :page => 1, :closed => true do
+          page 1, :title => 'Page 1'
+          page 2, :title => 'Page 2'
+        end
+      end
+    end
+  end
+  if RUBY_VERSION >= "1.9"
+    describe "outline encoding" do
+      it "should store all outline titles as UTF-16" do
+        render_and_find_objects
+        @hash.values.each do |obj|
+          if obj.is_a?(Hash) && obj[:Title]
+            title = obj[:Title].dup
+            title.force_encoding("UTF-16LE")
+            title.valid_encoding?.should == true
+          end
+        end
+      end
+    end
+  end
+  describe "#generate_outline" do
+    before(:each) do
+      render_and_find_objects
+    end
+
+    it "should create a root outline dictionary item" do
+      assert_not_nil @outline_root
+    end
+
+    it "should set the first and last top items of the root outline dictionary item" do
+      referenced_object(@outline_root[:First]).should == @section_1
+      referenced_object(@outline_root[:Last]).should == @section_1
+    end
+
+    describe "#create_outline_item" do
+      it "should create outline items for each section and page" do
+        [@section_1, @page_1, @page_2].each {|item| assert_not_nil item}
+      end
+    end
+
+    describe "#set_relations, #set_variables_for_block, and #reset_parent" do
+      it "should link sibling items" do
+        referenced_object(@page_1[:Next]).should == @page_2
+        referenced_object(@page_2[:Prev]).should == @page_1
+      end
+
+      it "should link child items to parent item" do
+        [@page_1, @page_2].each {|page| referenced_object(page[:Parent]).should == @section_1 }
+      end
+
+      it "should set the first and last child items for parent item" do
+        referenced_object(@section_1[:First]).should == @page_1
+        referenced_object(@section_1[:Last]).should == @page_2
+      end
+    end
+
+    describe "#increase_count" do
+
+      it "should add the count of all descendant items" do
+        @outline_root[:Count].should == 3
+        @section_1[:Count].should.abs == 2
+        @page_1[:Count].should == 0
+        @page_2[:Count].should == 0
+      end
+
+    end
+
+    describe "closed option" do
+
+      it "should set the item's integer count to negative" do
+        @section_1[:Count].should == -2
+      end
+
+    end
+
+  end
+
+  describe "#outline.add_section" do
+    before(:each) do
+      @pdf.start_new_page
+      @pdf.text "Page 3. An added section "
+      @pdf.outline.add_section do
+        section 'Added Section', :page => 3 do
+          page 3, :title => 'Page 3'
+        end
+      end
+      render_and_find_objects
+    end
+
+    it "should add new outline items to document" do
+      [@section_2, @page_3].each { |item| assert_not_nil item}
+    end
+
+    it "should reset the last items for root outline dictionary" do
+      referenced_object(@outline_root[:First]).should == @section_1
+      referenced_object(@outline_root[:Last]).should == @section_2
+    end
+
+    it "should reset the next relation for the previous last top level item" do
+      referenced_object(@section_1[:Next]).should == @section_2
+    end
+
+    it "should set the previous relation of the addded to section" do
+      referenced_object(@section_2[:Prev]).should == @section_1
+    end
+
+    it "should increase the count of root outline dictionary" do
+      @outline_root[:Count].should == 5
+    end
+
+  end
+
+  describe "#outline.insert_section_after" do
+    describe "inserting in the middle of another section" do
+      before(:each) do
+        @pdf.go_to_page 1
+        @pdf.start_new_page
+        @pdf.text "Inserted Page"
+        @pdf.outline.insert_section_after 'Page 1' do
+          page page_number, :title => "Inserted Page"
+        end
+        render_and_find_objects
+      end
+
+      it "should insert new outline items to document" do
+        assert_not_nil @inserted_page
+      end
+
+      it "should adjust the count of all ancestors" do
+        @outline_root[:Count].should == 4
+        @section_1[:Count].should.abs == 3
+      end
+
+      describe "#adjust_relations" do
+
+        it "should reset the sibling relations of adjoining items to inserted item" do
+          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
+          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
+          referenced_object(@section_1[:First]).should == @page_1
+          referenced_object(@section_1[:Last]).should == @page_2
+        end
+
+      end
+
+    end
+
+    describe "inserting at the end of another section" do
+      before(:each) do
+        @pdf.go_to_page 2
+         @pdf.start_new_page
+         @pdf.text "Inserted Page"
+         @pdf.outline.insert_section_after 'Page 2' do
+           page page_number, :title => "Inserted Page"
+         end
+         render_and_find_objects
+      end
+
+      describe "#adjust_relations" do
+
+        it "should reset the sibling relations of adjoining item to inserted item" do
+           referenced_object(@page_2[:Next]).should == @inserted_page
+        end
+
+        it "should set the sibling relation of added item to adjoining items" do
+          assert_nil referenced_object(@inserted_page[:Next])
+          referenced_object(@inserted_page[:Prev]).should == @page_2
+        end
+
+        it "should adjust the last relation of parent item" do
+          referenced_object(@section_1[:Last]).should == @inserted_page
+        end
+
+      end
+    end
+
+    it "should require an existing title" do
+      assert_raise Prawn::Errors::UnknownOutlineTitle do
+        @pdf.go_to_page 1
+        @pdf.start_new_page
+        @pdf.text "Inserted Page"
+        @pdf.outline.insert_section_after 'Wrong page' do
+          page page_number, :title => "Inserted Page"
+        end
+        render_and_find_objects
+      end
+    end
+
+  end
+
+  describe "#page" do
+    it "should require a title option to be set" do
+      assert_raise Prawn::Errors::RequiredOption do
+        @pdf = Prawn::Document.new() do
+          text "Page 1. This is the first Chapter. "
+          define_outline do
+            page 1, :title => nil
+          end
+        end
+      end
+    end
+  end
+end
+  
+context "foreign character encoding" do
+  before(:each) do
+    pdf = Prawn::Document.new() do
+      define_outline do
+        section 'La pomme croquée', :page => 1, :closed => true
+      end
+    end
+    @hash = PDF::Hash.new(StringIO.new(pdf.render, 'r+'))
+  end
+
+  it "should handle other encodings for the title" do
+    object = find_by_title('La pomme croquée')
+    object.should.not == nil
+  end
+end
+
+def render_and_find_objects
+  output = StringIO.new(@pdf.render, 'r+')
+  @hash = PDF::Hash.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')
+  @page_1 = find_by_title('Page 1')
+  @page_2 = find_by_title('Page 2')
+  @section_2 = find_by_title('Added Section')
+  @page_3 = find_by_title('Page 3')
+  @inserted_page = find_by_title('Inserted Page')
+end
+
+# Outline titles are stored as UTF-16. This method accepts a UTF-8 outline title
+# and returns the PDF Object that contains an outline with that name
+def find_by_title(title)
+  @hash.values.find {|obj|
+    if obj.is_a?(Hash) && obj[:Title]
+      title_codepoints = obj[:Title].unpack("n*")
+      title_codepoints.shift
+      utf8_title = title_codepoints.pack("U*")
+      utf8_title == title ? obj : nil
+    end
+  }
+end
+
+def referenced_object(reference)
+  @hash[reference]
+end
+

data/spec/pdf_object_spec.rb

@@ -0,0 +1,170 @@
+# encoding: ASCII-8BIT
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+# See PDF Reference, Sixth Edition (1.7) pp51-60 for details 
+describe "PDF Object Serialization" do     
+              
+  it "should convert Ruby's nil to PDF null" do
+    Prawn::Core::PdfObject(nil).should == "null"
+  end
+  
+  it "should convert Ruby booleans to PDF booleans" do
+    Prawn::Core::PdfObject(true).should  == "true"
+    Prawn::Core::PdfObject(false).should == "false"
+  end
+                                          
+  it "should convert a Ruby number to PDF number" do
+    Prawn::Core::PdfObject(1).should == "1"
+    Prawn::Core::PdfObject(1.214112421).should == "1.214112421" 
+  end
+  
+  it "should convert a Ruby time object to a PDF timestamp" do
+    t = Time.now
+    Prawn::Core::PdfObject(t).should == t.strftime("(D:%Y%m%d%H%M%S%z").chop.chop + "'00')"
+  end
+  
+  it "should convert a Ruby string to PDF string when inside a content stream" do       
+    s = "I can has a string"
+    PDF::Inspector.parse(Prawn::Core::PdfObject(s, true)).should == s
+  end                      
+
+  it "should convert a Ruby string to a UTF-16 PDF string when outside a content stream" do       
+    s = "I can has a string"
+    s_utf16 = "\xFE\xFF" + s.unpack("U*").pack("n*")
+    PDF::Inspector.parse(Prawn::Core::PdfObject(s, false)).should == s_utf16
+  end                      
+
+  it "should convert a Ruby string with characters outside the BMP to its " +
+     "UTF-16 representation with a BOM" do
+    # U+10192 ROMAN SEMUNCIA SIGN
+    semuncia = [65938].pack("U")
+    Prawn::Core::PdfObject(semuncia, false).upcase.should == "<FEFFD800DD92>"
+  end
+
+  it "should pass through bytes regardless of content stream status for ByteString" do
+    Prawn::Core::PdfObject(Prawn::Core::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'      
+    PDF::Inspector.parse(Prawn::Core::PdfObject(s, true)).should == s
+  end               
+  
+  it "should handle ruby escaped parens when converting to PDF string" do
+    s = 'I can \\)( has string'
+    PDF::Inspector.parse(Prawn::Core::PdfObject(s, true)).should == s  
+  end      
+
+  it "should escape various strings correctly when converting a LiteralString" do
+    ls = Prawn::Core::LiteralString.new("abc")
+    Prawn::Core::PdfObject(ls).should == "(abc)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x0Ade") # should escape \n
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x0Ade)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x0Dde") # should escape \r
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x0Dde)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x09de") # should escape \t
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x09de)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x08de") # should escape \b
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x08de)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x0Cde") # should escape \f
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x0Cde)"
+
+    ls = Prawn::Core::LiteralString.new("abc(de") # should escape \(
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C(de)"
+
+    ls = Prawn::Core::LiteralString.new("abc)de") # should escape \)
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C)de)"
+
+    ls = Prawn::Core::LiteralString.new("abc\x5Cde") # should escape \\
+    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x5Cde)"
+    Prawn::Core::PdfObject(ls).size.should == 9
+  end
+
+  it "should escape strings correctly when converting a LiteralString that is not utf-8" do
+    data = "\x43\xaf\xc9\x7f\xef\xf\xe6\xa8\xcb\x5c\xaf\xd0"
+    ls = Prawn::Core::LiteralString.new(data)
+    Prawn::Core::PdfObject(ls).should == "(\x43\xaf\xc9\x7f\xef\xf\xe6\xa8\xcb\x5c\x5c\xaf\xd0)"
+  end
+
+  it "should convert a Ruby symbol to PDF name" do
+    Prawn::Core::PdfObject(:my_symbol).should == "/my_symbol"
+    Prawn::Core::PdfObject(:"A;Name_With-Various***Characters?").should ==
+     "/A;Name_With-Various***Characters?"
+  end
+ 
+  it "should convert a whitespace or delimiter containing Ruby symbol to a PDF name" do
+    Prawn::Core::PdfObject(:"my symbol").should == "/my#20symbol"
+    Prawn::Core::PdfObject(:"my#symbol").should == "/my#23symbol"
+    Prawn::Core::PdfObject(:"my/symbol").should == "/my#2Fsymbol"
+    Prawn::Core::PdfObject(:"my(symbol").should == "/my#28symbol"
+    Prawn::Core::PdfObject(:"my)symbol").should == "/my#29symbol"
+    Prawn::Core::PdfObject(:"my<symbol").should == "/my#3Csymbol"
+    Prawn::Core::PdfObject(:"my>symbol").should == "/my#3Esymbol"
+  end
+  
+  it "should convert a Ruby array to PDF Array when inside a content stream" do
+    Prawn::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(Prawn::Core::PdfObject([[1,2],:foo,"Bar"], true)).should ==  
+      [[1,2],:foo, "Bar"]
+  end  
+
+  it "should convert a Ruby array to PDF Array when outside a content stream" do
+    bar = "\xFE\xFF" + "Bar".unpack("U*").pack("n*")
+    Prawn::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(Prawn::Core::PdfObject([[1,2],:foo,"Bar"], false)).should ==  
+      [[1,2],:foo, bar]
+  end  
+ 
+  it "should convert a Ruby hash to a PDF Dictionary when inside a content stream" do
+    dict = Prawn::Core::PdfObject( {:foo  => :bar, 
+                              "baz" => [1,2,3], 
+                              :bang => {:a => "what", :b => [:you, :say] }}, true )     
+
+    res = PDF::Inspector.parse(dict)           
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => "what", :b => [:you, :say] }
+
+  end      
+
+  it "should convert a Ruby hash to a PDF Dictionary when outside a content stream" do
+    what = "\xFE\xFF" + "what".unpack("U*").pack("n*")
+    dict = Prawn::Core::PdfObject( {:foo  => :bar, 
+                              "baz" => [1,2,3], 
+                              :bang => {:a => "what", :b => [:you, :say] }}, false )
+
+    res = PDF::Inspector.parse(dict)           
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => what, :b => [:you, :say] }
+
+  end      
+  
+  it "should not allow keys other than strings or symbols for PDF dicts" do
+    lambda { Prawn::Core::PdfObject(:foo => :bar, :baz => :bang, 1 => 4) }.
+      should.raise(Prawn::Errors::FailedObjectConversion) 
+  end  
+  
+  it "should convert a Prawn::Reference to a PDF indirect object reference" do
+    ref = Prawn::Core::Reference(1,true)
+    Prawn::Core::PdfObject(ref).should == ref.to_s
+  end
+
+  it "should convert a NameTree::Node to a PDF hash" do
+    node = Prawn::Core::NameTree::Node.new(Prawn::Document.new, 10)
+    node.add "hello", 1.0
+    node.add "world", 2.0
+    data = Prawn::Core::PdfObject(node)
+    res = PDF::Inspector.parse(data)
+    res.should == {:Names => ["hello", 1.0, "world", 2.0]}
+  end
+end