prawn 1.0.0.rc2 → 1.0.0

data/lib/prawn/document/snapshot.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-# snapshot.rb : Implements transactional rendering for Prawn
-#
-# Copyright August 2009, Brad Ediger.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-require 'delegate'
-
-module Prawn
-  class Document
-    module Snapshot
-
-      RollbackTransaction = Class.new(StandardError)
-
-      # Call this within a +transaction+ block to roll back the transaction and
-      # prevent any of its data from being rendered. You must reset the
-      # y-position yourself if you have performed any drawing operations that
-      # modify it.
-      #
-      def rollback
-        raise RollbackTransaction
-      end
-
-      # Run a block of drawing operations, to be completed atomically. If
-      # +rollback+ is called or a RollbackTransaction exception is raised
-      # inside the block, all actions taken inside the block will be rolled
-      # back (with the exception of y-position, which you must restore
-      # yourself). 
-      #
-      # Returns true on success, or false if the transaction was rolled back.
-      #
-      def transaction
-        snap = take_snapshot
-        yield
-        true
-      rescue RollbackTransaction
-        restore_snapshot(snap)
-        false
-      end
-
-      private
-      
-      # Takes a current snapshot of the document's state, sufficient to
-      # reconstruct it after it was amended.
-      #
-      def take_snapshot
-        # current_page holds a ref to the Pages dictionary which grows
-        # monotonically as data is added to the document, so we share that
-        # between the old and new copies.
-        {:page_content    => state.page.content.deep_copy,
-         :current_page    => state.page.dictionary.deep_copy(share=[:Parent]),
-         :bounds          => bounds.deep_copy,
-         :page_number     => page_number,
-         :page_kids       => state.store.pages.data[:Kids].compact.map{|kid| kid.identifier},
-         :dests           => names? && names.data[:Dests].deep_copy}
-      end
-
-      # Rolls the page state back to the state of the given snapshot.
-      #
-      def restore_snapshot(shot)
-        page = state.page
-        # Because these objects are referenced by identifier from the Pages
-        # dictionary, we can't just restore them over the current refs in
-        # page_content and current_page. We have to restore them over the old
-        # ones.
-        page.content = shot[:page_content].identifier
-        page.content.replace shot[:page_content]
-
-        page.dictionary = shot[:current_page].identifier
-        page.dictionary.replace shot[:current_page]
-        page.dictionary.data[:Contents] = page.content
-
-        self.page_number = shot[:page_number]
-
-        state.store.pages.data[:Kids] = shot[:page_kids].map{|id| state.store[id]}
-        state.store.pages.data[:Count] = shot[:page_kids].size
-
-        self.bounds = BoundingBox.restore_deep_copy(shot[:bounds], self)
-
-        if shot[:dests]
-          names.data[:Dests] = shot[:dests] 
-        end
-      end
-
-    end
-  end
-end

data/manual/manual/foreword.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-#
-# Prawn manual foreword page. 
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  header("Foreword, by Gregory Brown")
-  prose "This will be written just before 1.0, to give the" +
-        " core team something to look forward to."
-  end

data/manual/templates/full_template.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-#
-# You may load another PDF while creating a new one. Just pass the loaded PDF
-# filename to the <code>:template</code> option when creating/generating the new
-# PDF.
-#
-# The provided PDF will be loaded and the its first page will be set as the
-# current page. If you'd like to resume the document you may take advantage of
-# two helpers: <code>page_count</code> and <code>go_to_page</code>.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = "#{Prawn::DATADIR}/pdfs/multipage_template.pdf"
-
-Prawn::Example.generate("full_template.pdf", :template => filename) do
-  go_to_page(page_count)
-  
-  start_new_page
-  
-  text "Previous pages and content imported.", :align => :center
-  text "This page and content is brand new.",  :align => :center
-end

data/manual/templates/page_template.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-#
-# If you only need to load some pages from another PDF, you can accomplish it
-# with the <code>start_new_page</code> method. You may pass it a
-# <code>:template</code> option with the path for an existing pdf and a
-# <code>:template_page</code> option to specify which page to load.
-# You can also load a <code>:template</code> using a URI:
-#
-# <code>require 'open-uri'</code>
-#
-# <code>start_new_page(:template => open('url_for_your.pdf'))</code>
-#
-# The following example loads some pages from an existing PDF. If we don't
-# specify the <code>:template_page</code> option, the first page of the template
-# PDF will be loaded. That's what happens on the first load below. Then we load
-# a page by specifying the <code>:template_page</code> option and then we do it
-# again this time adding some content to the loaded page.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  text "Please scan the next 3 pages to see the page templates in action."
-  move_down 10
-  text "You also might want to look at the pdf used as a template: "
-  url = "https://github.com/prawnpdf/prawn/raw/master/data/pdfs/form.pdf"
-  move_down 10
-  
-  formatted_text [{:text => url, :link => url}]
-  
-  filename = "#{Prawn::DATADIR}/pdfs/form.pdf"
-  start_new_page(:template => filename)
-  
-  start_new_page(:template => filename, :template_page => 2)
-  
-  start_new_page(:template => filename, :template_page => 2)
-  
-  fill_color "FF8888"
-  
-  text_box "John Doe", :at => [75, cursor-75]
-  text_box "john@doe.com", :at => [75, cursor-105]
-  text_box "John Doe inc", :at => [75, cursor-135]
-  text_box "You didn't think I'd tell, did you?", :at => [75, cursor-165]
-  
-  fill_color "000000"
-end

data/manual/templates/templates.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-#
-# Examples for loading existing pdfs.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-Prawn::Example.generate("templates.pdf", :page_size => "FOLIO") do
-  
-  package "templates" do |p|
-    
-    p.example "full_template", :eval_source => false, :full_source => true
-    p.example "page_template"
-    
-    p.intro do
-      prose("Templates let you embed other PDF documents inside the current one.
-
-      The examples show:")
-
-      list( "How to load the whole content from another PDF",
-            "How to load single pages from another PDF"
-          )
-    end
-    
-  end
-end

data/manual/text/group.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-#
-# Sometimes free flowing text might look ugly, specially when a paragraph is
-# split between two pages. Using a positioned text box just to overcome this
-# nuisance is not the right choice.
-#
-# You probably want to use the <code>group</code> method instead. It will try
-# to render the block within the current page. If the content would fall to a
-# new page it just renders everything on the following page. If the block cannot
-# be executed on a single blank page a <code>CannotGroup</code> exception will
-# be raised.
-#
-# So if you can split your text blocks in paragraphs you can have every
-# paragraph contained on a single page.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::Example.generate(filename) do
-  move_cursor_to 80
-  text "Let's move to the end of the page so that you can see group in action."
-  
-  group do
-    text "This block of text was too big to be rendered on the bottom of the " +
-         " previous page. So it was rendered entirely on this new page. " +
-         " _ " * 200
-  end
-end

data/spec/name_tree_spec.rb

@@ -1,112 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-def tree_dump(tree)
-  if tree.is_a?(Prawn::Core::NameTree::Node)
-    "[" + tree.children.map { |child| tree_dump(child) }.join(",") + "]"
-  else
-    "#{tree.name}=#{tree.value}"
-  end
-end
-
-def tree_add(tree, *args)
-  args.each do |(name, value)|
-    tree.add(name, value)
-  end
-end
-
-def tree_value(name, value)
-  Prawn::Core::NameTree::Value.new(name, value)
-end
-
-class RefExposingDocument < Prawn::Document
-  def object_store
-    state.store
-  end
-end
-
-describe "Name Tree" do     
-  before(:each) { create_pdf(RefExposingDocument) }
-
-  it "should have no children when first initialized" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    node.children.length.should == 0
-  end
-
-  it "should have no subtrees while child limit is not reached" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
-    tree_dump(node).should == "[one=1,three=3,two=2]"
-  end
-
-  it "should split into subtrees when limit is exceeded" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_dump(node).should == "[[four=4,one=1],[three=3,two=2]]"
-  end
-
-  it "should create a two new references when root is split" do
-    ref_count = @pdf.object_store.length
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    @pdf.object_store.length.should == ref_count+2
-  end
-  
-  it "should create a one new reference when subtree is split" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-
-    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.object_store.length.should == ref_count+1
-  end
-
-  it "should keep tree balanced when subtree split cascades to root" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
-    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::Core::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::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
-    node.to_hash.should ==(
-      { :Names => [tree_value("one", 1), tree_value("three", 3), tree_value("two", 2)] }
-    )
-  end
-
-  it "should emit only :Kids key with to_hash if root has children" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.to_hash.should ==({ :Kids => node.children.map { |child| child.ref } })
-  end
-
-  it "should emit :Limits and :Names keys with to_hash for leaf node" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    node.children.first.to_hash.should ==(
-      { :Limits => %w(four one),
-        :Names => [tree_value("four", 4), tree_value("one", 1)] }
-    )
-  end
-
-  it "should emit :Limits and :Kids keys with to_hash for inner node" do
-    node = Prawn::Core::NameTree::Node.new(@pdf, 3)
-    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
-    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
-    tree_add(node, ["nine", 9], ["ten", 10], ["eleven", 11], ["twelve", 12])
-    tree_add(node, ["thirteen", 13], ["fourteen", 14], ["fifteen", 15], ["sixteen", 16])
-    node.children.first.to_hash.should ==(
-      { :Limits => %w(eight one),
-        :Kids => node.children.first.children.map { |child| child.ref } }
-    )
-  end
-end

data/spec/object_store_spec.rb

@@ -1,170 +0,0 @@
-# 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}/spec/data/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}/spec/data/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}/spec/data/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::DATADIR}/pdfs/indirect_reference.pdf"
-    store = Prawn::Core::ObjectStore.new(:template => filename)
-    store.size.should == 8
-  end
-
-  it "should raise_error 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_error(ArgumentError)
-  end
-
-  it "should raise_error Prawn::Errors::TemplateError when given a non PDF as a template" do
-    filename = "#{Prawn::DATADIR}/images/dice.png"
-
-    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should raise_error(Prawn::Errors::TemplateError)
-  end
-
-  it "should raise_error Prawn::Errors::TemplateError when given an encrypted PDF as a template" do
-    filename = "#{Prawn::DATADIR}/pdfs/encrypted.pdf"
-
-    lambda { Prawn::Core::ObjectStore.new(:template => filename) }.should raise_error(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::DATADIR}/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::DATADIR}/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::DATADIR}/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::DATADIR}/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::DATADIR}/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::DATADIR}/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
-
-  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