prawn 0.12.0 → 0.13.0

data/spec/outline_spec.rb

@@ -36,7 +36,7 @@ describe "Outline" do
     end
 
     it "should create a root outline dictionary item" do
-      assert_not_nil @outline_root
+      @outline_root.should_not be_nil
     end
 
     it "should set the first and last top items of the root outline dictionary item" do
@@ -46,7 +46,7 @@ describe "Outline" do
 
     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}
+        [@section_1, @page_1, @page_2].each {|item| item.should_not be_nil}
       end
     end
 
@@ -70,7 +70,7 @@ describe "Outline" do
 
       it "should add the count of all descendant items" do
         @outline_root[:Count].should == 3
-        @section_1[:Count].should.abs == 2
+        @section_1[:Count].abs.should == 2
         @page_1[:Count].should == 0
         @page_2[:Count].should == 0
       end
@@ -87,6 +87,28 @@ describe "Outline" do
 
   end
 
+  describe "adding a custom destination" do
+    before(:each) do
+      @pdf.start_new_page
+      @pdf.text "Page 3 with a destination"
+      @pdf.add_dest('customdest', @pdf.dest_xyz(200, 200))
+      pdf = @pdf
+      @pdf.outline.update do
+        page :destination => pdf.dest_xyz(200, 200), :title => 'Custom Destination'
+      end
+      render_and_find_objects
+    end
+
+    it "should create an outline item" do
+      @custom_dest.should_not be_nil
+    end
+
+    it "should reference the custom destination" do
+      referenced_object(@custom_dest[:Dest].first).should == referenced_object(@pages.last)
+    end
+
+  end
+
   describe "addding a section later with outline#section" do
     before(:each) do
       @pdf.start_new_page
@@ -100,7 +122,7 @@ describe "Outline" do
     end
 
     it "should add new outline items to document" do
-      [@section_2, @page_3].each { |item| assert_not_nil item}
+      [@section_2, @page_3].each { |item| item.should_not be_nil}
     end
 
     it "should reset the last items for root outline dictionary" do
@@ -120,11 +142,11 @@ describe "Outline" do
       @outline_root[:Count].should == 5
     end
 
-  end  
-  
-  describe "#outline.add_subsection_to" do  
+  end
+
+  describe "#outline.add_subsection_to" do
     context "positioned last" do
-    
+
       before(:each) do
         @pdf.start_new_page
         @pdf.text "Page 3. An added subsection "
@@ -133,45 +155,45 @@ describe "Outline" do
             section 'Added SubSection', :destination => 3 do
               page :destination => 3, :title => 'Added Page 3'
             end
-          end 
+          end
         end
         render_and_find_objects
       end
-    
+
       it "should add new outline items to document" do
-        [@subsection, @added_page_3].each { |item| assert_not_nil item}
+        [@subsection, @added_page_3].each { |item| item.should_not be_nil}
       end
-    
+
       it "should reset the last item for parent item dictionary" do
         referenced_object(@section_1[:First]).should == @page_1
         referenced_object(@section_1[:Last]).should == @subsection
       end
-    
+
       it "should set the prev relation for the new subsection to its parent's old last item" do
         referenced_object(@subsection[:Prev]).should == @page_2
       end
-    
-    
+
+
       it "the subsection should become the next relation for its parent's old last item" do
          referenced_object(@page_2[:Next]).should == @subsection
        end
-    
+
       it "should set the first relation for the new subsection" do
         referenced_object(@subsection[:First]).should == @added_page_3
       end
-    
+
       it "should set the correct last relation of the added to section" do
         referenced_object(@subsection[:Last]).should == @added_page_3
       end
-    
+
       it "should increase the count of root outline dictionary" do
         @outline_root[:Count].should == 5
       end
-    
-    end  
-    
+
+    end
+
     context "positioned first" do
-    
+
       before(:each) do
         @pdf.start_new_page
         @pdf.text "Page 3. An added subsection "
@@ -186,14 +208,14 @@ describe "Outline" do
       end
 
       it "should add new outline items to document" do
-        [@subsection, @added_page_3].each { |item| assert_not_nil item}
+        [@subsection, @added_page_3].each { |item| item.should_not be_nil}
       end
 
       it "should reset the first item for parent item dictionary" do
         referenced_object(@section_1[:First]).should == @subsection
         referenced_object(@section_1[:Last]).should == @page_2
       end
-    
+
       it "should set the next relation for the new subsection to its parent's old first item" do
         referenced_object(@subsection[:Next]).should == @page_1
       end
@@ -215,9 +237,9 @@ describe "Outline" do
       end
 
     end
-    
+
     it "should require an existing title" do
-      assert_raise Prawn::Errors::UnknownOutlineTitle do
+      lambda do
         @pdf.go_to_page 1
         @pdf.start_new_page
         @pdf.text "Inserted Page"
@@ -227,9 +249,9 @@ describe "Outline" do
           end
         end
         render_and_find_objects
-      end
+      end.should raise_error(Prawn::Errors::UnknownOutlineTitle)
     end
-  end     
+  end
 
   describe "#outline.insert_section_after" do
     describe "inserting in the middle of another section" do
@@ -246,47 +268,47 @@ describe "Outline" do
 
       it "should insert new outline items to document" do
         render_and_find_objects
-        assert_not_nil @inserted_page
+        @inserted_page.should_not be_nil
       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
+        @section_1[:Count].abs.should == 3
       end
-       
+
       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
-      
-      end 
-      
-      
-      context "when adding another section afterwards" do 
+
+      end
+
+
+      context "when adding another section afterwards" do
         it "should have reset the root position so that a new section is added at the end of root sections" do
           @pdf.start_new_page
           @pdf.text "Another Inserted Page"
           @pdf.outline.update do
             section 'Added Section' do
               page :destination => page_number, :title => "Inserted Page"
-            end 
-          end 
+            end
+          end
           render_and_find_objects
           referenced_object(@outline_root[:Last]).should == @section_2
           referenced_object(@section_1[:Next]).should == @section_2
@@ -305,7 +327,7 @@ describe "Outline" do
          @pdf.outline.update do
            insert_section_after 'Page 2' do
              page :destination => page_number, :title => "Inserted Page"
-           end 
+           end
          end
          render_and_find_objects
       end
@@ -317,7 +339,7 @@ describe "Outline" do
         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[:Next]).should be_nil
           referenced_object(@inserted_page[:Prev]).should == @page_2
         end
 
@@ -329,7 +351,7 @@ describe "Outline" do
     end
 
     it "should require an existing title" do
-      assert_raise Prawn::Errors::UnknownOutlineTitle do
+      lambda do
         @pdf.go_to_page 1
         @pdf.start_new_page
         @pdf.text "Inserted Page"
@@ -339,26 +361,26 @@ describe "Outline" do
           end
         end
         render_and_find_objects
-      end
+      end.should raise_error(Prawn::Errors::UnknownOutlineTitle)
     end
 
   end
 
   describe "#page" do
     it "should require a title option to be set" do
-      assert_raise Prawn::Errors::RequiredOption do
+      lambda do
         @pdf = Prawn::Document.new() do
           text "Page 1. This is the first Chapter. "
           outline.define do
             page :destination => 1, :title => nil
           end
         end
-      end
+      end.should raise_error(Prawn::Errors::RequiredOption)
     end
   end
 end
-  
-context "foreign character encoding" do
+
+describe "foreign character encoding" do
   before(:each) do
     pdf = Prawn::Document.new() do
       outline.define do
@@ -370,7 +392,25 @@ context "foreign character encoding" do
 
   it "should handle other encodings for the title" do
     object = find_by_title('La pomme croquée')
-    object.should.not == nil
+    object.should_not == nil
+  end
+end
+
+describe "with optimize_objects option" do
+  before(:each) do
+    @pdf = Prawn::Document.new(:optimize_objects => true) do
+      outline.define do
+        section 'Chapter 1', :destination => 1, :closed => true do
+          page :destination => 1, :title => 'Page 1'
+        end
+      end
+    end
+    render_and_find_objects
+  end
+
+  it "should generate an outline" do
+    @section_1.should_not be_nil
+    @page_1.should_not be_nil
   end
 end
 
@@ -384,9 +424,10 @@ def render_and_find_objects
   @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') 
+  @inserted_page = find_by_title('Inserted Page')
   @subsection = find_by_title('Added SubSection')
   @added_page_3 = find_by_title('Added Page 3')
+  @custom_dest = find_by_title('Custom Destination')
 end
 
 # Outline titles are stored as UTF-16. This method accepts a UTF-8 outline title
@@ -405,4 +446,3 @@ end
 def referenced_object(reference)
   @hash[reference]
 end
-

data/spec/pdf_object_spec.rb

@@ -2,168 +2,170 @@
 
 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     
-              
+# 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"
+    PDF::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"
+    PDF::Core::PdfObject(true).should  == "true"
+    PDF::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" 
+    PDF::Core::PdfObject(1).should == "1"
+    PDF::Core::PdfObject(1.214112421).should == "1.214112421"
+    # scientific notation is not valid in PDF
+    PDF::Core::PdfObject(0.000005).should == "0.000005"
   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')"
+    PDF::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       
+
+  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                      
+    PDF::Inspector.parse(PDF::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       
+  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                      
+    PDF::Inspector.parse(PDF::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>"
+    PDF::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.
+    PDF::Core::PdfObject(PDF::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               
-  
+    s =  'I )(can has a string'
+    PDF::Inspector.parse(PDF::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      
+    PDF::Inspector.parse(PDF::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 = PDF::Core::LiteralString.new("abc")
+    PDF::Core::PdfObject(ls).should == "(abc)"
 
-    ls = Prawn::Core::LiteralString.new("abc\x0Ade") # should escape \n
-    Prawn::Core::PdfObject(ls).should == "(abc\x5C\x0Ade)"
+    ls = PDF::Core::LiteralString.new("abc\x0Ade") # should escape \n
+    PDF::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 = PDF::Core::LiteralString.new("abc\x0Dde") # should escape \r
+    PDF::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 = PDF::Core::LiteralString.new("abc\x09de") # should escape \t
+    PDF::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 = PDF::Core::LiteralString.new("abc\x08de") # should escape \b
+    PDF::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 = PDF::Core::LiteralString.new("abc\x0Cde") # should escape \f
+    PDF::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 = PDF::Core::LiteralString.new("abc(de") # should escape \(
+    PDF::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 = PDF::Core::LiteralString.new("abc)de") # should escape \)
+    PDF::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
+    ls = PDF::Core::LiteralString.new("abc\x5Cde") # should escape \\
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x5Cde)"
+    PDF::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)"
+    ls = PDF::Core::LiteralString.new(data)
+    PDF::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 ==
+    PDF::Core::PdfObject(:my_symbol).should == "/my_symbol"
+    PDF::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
-  
+    PDF::Core::PdfObject(:"my symbol").should == "/my#20symbol"
+    PDF::Core::PdfObject(:"my#symbol").should == "/my#23symbol"
+    PDF::Core::PdfObject(:"my/symbol").should == "/my#2Fsymbol"
+    PDF::Core::PdfObject(:"my(symbol").should == "/my#28symbol"
+    PDF::Core::PdfObject(:"my)symbol").should == "/my#29symbol"
+    PDF::Core::PdfObject(:"my<symbol").should == "/my#3Csymbol"
+    PDF::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 ==  
+    PDF::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(PDF::Core::PdfObject([[1,2],:foo,"Bar"], true)).should ==
       [[1,2],:foo, "Bar"]
-  end  
+  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 ==  
+    PDF::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(PDF::Core::PdfObject([[1,2],:foo,"Bar"], false)).should ==
       [[1,2],:foo, bar]
-  end  
- 
+  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 )     
+    dict = PDF::Core::PdfObject( {:foo  => :bar,
+                              "baz" => [1,2,3],
+                              :bang => {:a => "what", :b => [:you, :say] }}, true )
 
-    res = PDF::Inspector.parse(dict)           
+    res = PDF::Inspector.parse(dict)
 
     res[:foo].should == :bar
     res[:baz].should == [1,2,3]
     res[:bang].should == { :a => "what", :b => [:you, :say] }
 
-  end      
+  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], 
+    dict = PDF::Core::PdfObject( {:foo  => :bar,
+                              "baz" => [1,2,3],
                               :bang => {:a => "what", :b => [:you, :say] }}, false )
 
-    res = PDF::Inspector.parse(dict)           
+    res = PDF::Inspector.parse(dict)
 
     res[:foo].should == :bar
     res[:baz].should == [1,2,3]
     res[:bang].should == { :a => what, :b => [:you, :say] }
 
-  end      
-  
+  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  
-  
+    lambda { PDF::Core::PdfObject(:foo => :bar, :baz => :bang, 1 => 4) }.
+      should raise_error(PDF::Core::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
+    ref = PDF::Core::Reference(1,true)
+    PDF::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 = PDF::Core::NameTree::Node.new(Prawn::Document.new, 10)
     node.add "hello", 1.0
     node.add "world", 2.0
-    data = Prawn::Core::PdfObject(node)
+    data = PDF::Core::PdfObject(node)
     res = PDF::Inspector.parse(data)
     res.should == {:Names => ["hello", 1.0, "world", 2.0]}
   end