prawn 1.0.0.rc2 → 1.0.0

data/spec/pdf_object_spec.rb

@@ -1,172 +0,0 @@
-# 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" 
-    # scientific notation is not valid in PDF
-    Prawn::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')"
-  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_error(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

data/spec/snapshot_spec.rb

@@ -1,186 +0,0 @@
-# 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
-
-  it "should not propagate a RollbackTransaction outside its bounds" do
-    def add_lines(pdf)
-      100.times { |i| pdf.text "Line #{i}" }
-    end
-
-    Prawn::Document.new do |pdf|
-      lambda do
-        begin
-          pdf.group { add_lines(pdf) }
-        rescue Prawn::Errors::CannotGroup
-          add_lines(pdf)
-        end
-      end.should_not raise_error#(Prawn::Document::Snapshot::RollbackTransaction)
-    end
-  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 = state.page.dictionary.identifier
-      old_page_content_id = state.page.content.identifier
-
-      transaction do
-        start_new_page
-        rollback
-      end
-
-      state.page.dictionary.identifier.should == old_page_object_id
-      state.page.content.identifier.should == old_page_content_id
-    end
-
-  end
-
-  it "page object should refer to the page_content object after restore" do
-
-    Prawn::Document.new do
-      transaction do
-        start_new_page
-        rollback
-      end
-
-      # should be the exact same object, not a clone
-      state.page.dictionary.data[:Contents].should == state.page.content
-    end
-
-  end
-
-  it "should restore bounds on rollback" do
-    Prawn::Document.new(:page_layout => :landscape) do
-      size = [bounds.width, bounds.height]
-      transaction do
-        start_new_page :layout => :portrait
-        rollback
-      end
-      [bounds.width, bounds.height].should == size
-    end
-  end
-
-  it "should set new bounding box on start_new_page with different layout" do
-    Prawn::Document.new(:page_layout => :landscape) do
-      size = [bounds.width, bounds.height]
-      transaction do
-        start_new_page
-        rollback
-      end
-
-      start_new_page :layout => :portrait
-      [bounds.width, bounds.height].should == size.reverse
-    end
-  end
-
-  it "should work with dests" do
-    Prawn::Document.new do |pdf|
-      pdf.add_dest("dest", pdf.dest_fit_horizontally(pdf.cursor, pdf.page))
-      pdf.text("Hello world")
-      lambda { pdf.transaction{} }.should_not raise_error
-    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") { draw_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") { draw_text "This is not shown", :at => [0,0] }
-
-        transaction do
-          stamp("test_stamp")
-          rollback
-        end
-      end
-      pdf.render.should_not =~ /\/Stamp1 Do/
-    end 
-
-  end
-
-  it "should restore page_number on rollback" do
-    Prawn::Document.new do
-      transaction do
-        5.times { start_new_page }
-        rollback
-      end
-
-      page_number.should == 1
-    end
-  end
-
-end
-

data/spec/template_spec.rb

@@ -1,351 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Document built from a template" do
-  it "should have the same page count as the source document" do
-    filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-    @pdf = Prawn::Document.new(:template => filename)
-    page_counter = PDF::Inspector::Page.analyze(@pdf.render)
-
-    page_counter.pages.size.should == 1
-  end
-
-  it "should not set the template page's parent to the document pages catalog (especially with nested pages)" do
-    filename = "#{Prawn::DATADIR}/pdfs/nested_pages.pdf"
-    @pdf = Prawn::Document.new(:template => filename, :skip_page_creation => true)
-    @pdf.state.page.dictionary.data[:Parent].should_not == @pdf.state.store.pages
-  end
-
-
-  it "should have start with the Y cursor at the top of the document" do
-    filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    (@pdf.y == nil).should == false
-  end
-
-  it "should respect margins set by Prawn" do
-    filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename, :margin => 0)
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 0,
-                                  :top    => 0,
-                                  :bottom => 0 }
-
-    @pdf = Prawn::Document.new(:template => filename, :left_margin => 0)
-
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 36,
-                                  :top    => 36,
-                                  :bottom => 36 }
-
-    @pdf.start_new_page(:right_margin => 0)
-
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 0,
-                                  :top    => 36,
-                                  :bottom => 36 }
-
-
-
-  end
-
-  it "should not add an extra restore_graphics_state operator to the end of any content stream" do
-    filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    hash.each_value do |obj|
-      next unless obj.kind_of?(PDF::Reader::Stream)
-
-      data = obj.data.tr(" \n\r","")
-      data.include?("QQ").should == false
-    end
-  end
-
-  it "should have a single page object if importing a single page template" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    pages = hash.values.select { |obj| obj.kind_of?(Hash) && obj[:Type] == :Page }
-
-    pages.size.should == 1
-  end
-
-  it "should have two content streams if importing a single page template" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
-
-    streams.size.should == 2
-  end
-
-  it "should not die if using this PDF as a template" do
-    filename = "#{Prawn::DATADIR}/pdfs/complex_template.pdf"
-
-    lambda {
-      @pdf = Prawn::Document.new(:template => filename)
-    }.should_not raise_error
-  end
-
-
-  it "should have balance q/Q operators on all content streams" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
-
-    streams.each do |stream|
-      data = stream.unfiltered_data
-      data.scan("q").size.should == 1
-      data.scan("Q").size.should == 1
-    end
-  end
-
-  it "should allow text to be added to a single page template" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-
-    @pdf.text "Adding some text"
-
-    text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings.first.should == "Adding some text"
-  end
-
-  it "should allow PDFs with page resources behind an indirect object to be used as templates" do
-    filename = "#{Prawn::DATADIR}/pdfs/resources_as_indirect_object.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-
-    @pdf.text "Adding some text"
-
-    text = PDF::Inspector::Text.analyze(@pdf.render)
-    all_text = text.strings.join
-    all_text.include?("Adding some text").should == true
-  end
-
-  it "should copy the PDF version from the template file" do
-    filename = "#{Prawn::DATADIR}/pdfs/version_1_6.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    str = @pdf.render
-    str[0,8].should == "%PDF-1.6"
-  end
-
-  it "should correctly add a TTF font to a template that has existing fonts" do
-    filename = "#{Prawn::DATADIR}/pdfs/contains_ttf_font.pdf"
-    @pdf = Prawn::Document.new(:template => filename)
-    @pdf.font "#{Prawn::DATADIR}/fonts/Chalkboard.ttf"
-    @pdf.move_down(40)
-    @pdf.text "Hi There"
-
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    page_dict = hash.values.detect{ |obj| obj.is_a?(Hash) && obj[:Type] == :Page }
-    resources = page_dict[:Resources]
-    fonts = resources[:Font]
-    fonts.size.should == 2
-  end
-
-  it "should correctly import a template file that is missing a MediaBox entry" do
-    filename = "#{Prawn::DATADIR}/pdfs/page_without_mediabox.pdf"
-
-    @pdf = Prawn::Document.new(:template => filename)
-    str = @pdf.render
-    str[0,4].should == "%PDF"
-  end
-
-  context "with the template as a stream" do
-    it "should correctly import a template file from a stream" do
-      filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-      io = StringIO.new(File.binread(filename))
-      @pdf = Prawn::Document.new(:template => io)
-      str = @pdf.render
-      str[0,4].should == "%PDF"
-    end
-  end
-
-  it "merges metadata info" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-    info = { :Title => "Sample METADATA",
-             :Author => "Me",
-             :Subject => "Not Working",
-             :CreationDate => Time.now }
-
-    @pdf = Prawn::Document.new(:template => filename, :info => info)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-    info.keys.each { |k| hash[hash.trailer[:Info]].keys.include?(k).should == true }
-  end
-
-end
-
-describe "Document#start_new_page with :template option" do
-  filename = "#{Prawn::BASEDIR}/spec/data/curves.pdf"
-
-  it "should set the imported page's parent to the document pages catalog" do
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-    @pdf.state.page.dictionary.data[:Parent].should == @pdf.state.store.pages
-  end
-
-  it "should set start the Y cursor at the top of the page" do
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-    (@pdf.y == nil).should == false
-  end
-
-  it "should respect margins set by Prawn" do
-    @pdf = Prawn::Document.new(:margin => 0)
-    @pdf.start_new_page(:template => filename)
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 0,
-                                  :top    => 0,
-                                  :bottom => 0 }
-
-    @pdf = Prawn::Document.new(:left_margin => 0)
-    @pdf.start_new_page(:template => filename)
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 36,
-                                  :top    => 36,
-                                  :bottom => 36 }
-    @pdf.start_new_page(:template => filename, :right_margin => 0)
-    @pdf.page.margins.should == { :left   => 0,
-                                  :right  => 0,
-                                  :top    => 36,
-                                  :bottom => 36 }
-  end
-
-  it "should not add an extra restore_graphics_state operator to the end of any content stream" do
-    @pdf = Prawn::Document.new
-    @pdf.start_new_page(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    hash.each_value do |obj|
-      next unless obj.kind_of?(PDF::Reader::Stream)
-
-      data = obj.data.tr(" \n\r","")
-      data.include?("QQ").should == false
-    end
-  end
-
-  it "should have two content streams if importing a single page template" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
-    template_page = hash[pages[1]]
-    template_page[:Contents].size.should == 2
-  end
-
-  it "should have balance q/Q operators on all content streams" do
-    filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-
-    streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
-
-    streams.each do |stream|
-      data = stream.unfiltered_data
-      data.scan("q").size.should == 1
-      data.scan("Q").size.should == 1
-    end
-  end
-
-  it "should allow text to be added to a single page template" do
-
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-
-    @pdf.text "Adding some text"
-
-    text = PDF::Inspector::Text.analyze(@pdf.render)
-    text.strings.first.should == "Adding some text"
-  end
-
-  it "should allow PDFs with page resources behind an indirect object to be used as templates" do
-    filename = "#{Prawn::DATADIR}/pdfs/resources_as_indirect_object.pdf"
-
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-
-    @pdf.text "Adding some text"
-
-    text = PDF::Inspector::Text.analyze(@pdf.render)
-    all_text = text.strings.join
-    all_text.include?("Adding some text").should == true
-  end
-
-  it "should correctly add a TTF font to a template that has existing fonts" do
-    filename = "#{Prawn::DATADIR}/pdfs/contains_ttf_font.pdf"
-    @pdf = Prawn::Document.new()
-    @pdf.start_new_page(:template => filename)
-    @pdf.font "#{Prawn::DATADIR}/fonts/Chalkboard.ttf"
-    @pdf.move_down(40)
-    @pdf.text "Hi There"
-
-    output = StringIO.new(@pdf.render)
-    hash = PDF::Reader::ObjectHash.new(output)
-    hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
-    template_page = hash[pages[1]]
-    resources = template_page[:Resources]
-    fonts = resources[:Font]
-    fonts.size.should == 2
-  end
-
-  it "indexes template pages when used multiple times" do
-    filename = "#{Prawn::DATADIR}/pdfs/multipage_template.pdf"
-    @repeated_pdf = Prawn::Document.new()
-    3.times { @repeated_pdf.start_new_page(:template => filename) }
-    repeated_hash = PDF::Reader::ObjectHash.new(StringIO.new(@repeated_pdf.render))
-    @sequential_pdf = Prawn::Document.new()
-    (1..3).each { |p| @sequential_pdf.start_new_page(:template => filename, :template_page => p ) }
-    sequential_hash = PDF::Reader::ObjectHash.new(StringIO.new(@sequential_pdf.render))
-    (repeated_hash.size < sequential_hash.size).should == true
-  end
-
-  context "with the template as a stream" do
-    it "should correctly import a template file from a stream" do
-      filename = "#{Prawn::DATADIR}/pdfs/hexagon.pdf"
-      io = StringIO.new(File.binread(filename))
-
-      @pdf = Prawn::Document.new()
-      @pdf.start_new_page(:template => io)
-
-      str = @pdf.render
-      str[0,4].should == "%PDF"
-    end
-  end
-
-  context "using template_page option" do
-    it "uses the specified page option" do
-      filename = "#{Prawn::DATADIR}/pdfs/multipage_template.pdf"
-      @pdf = Prawn::Document.new()
-      @pdf.start_new_page(:template => filename, :template_page => 2)
-      text = PDF::Inspector::Text.analyze(@pdf.render)
-      text.strings.first.should == "This is template page 2"
-    end
-  end
-
-end