prawn-graph 0.0.2 → 0.0.3

data/vendor/prawn-core/lib/prawn/object_store.rb

@@ -1,93 +0,0 @@
-# encoding: utf-8
-
-# object_store.rb : Implements PDF object repository for Prawn
-#
-# Copyright August 2009, Brad Ediger.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-module Prawn
-  class ObjectStore #:nodoc:
-    include Enumerable
-    BASE_OBJECTS = %w[info pages root]
-
-    def initialize(info={})
-      @objects = {}
-      @identifiers = []
-      
-      # Create required PDF roots
-      @info    = ref(info).identifier
-      @pages   = ref(:Type => :Pages, :Count => 0, :Kids => []).identifier
-      @root    = ref(:Type => :Catalog, :Pages => pages).identifier
-    end
- 
-    def ref(data, &block)
-      push(size + 1, data, &block)
-    end                                               
-
-    %w[info pages root].each do |name|
-      define_method(name) do
-        @objects[instance_variable_get("@#{name}")]
-      end
-    end
-
-    # Adds the given reference to the store and returns the reference object.
-    # If the object provided is not a Prawn::Reference, one is created from the
-    # arguments provided.
-    def push(*args, &block)
-      reference = if args.first.is_a?(Prawn::Reference)
-              args.first
-            else
-              Prawn::Reference.new(*args, &block)
-            end
-      @objects[reference.identifier] = reference
-      @identifiers << reference.identifier
-      reference
-    end
-    alias_method :<<, :push
-
-    def each
-      @identifiers.each do |id|
-        yield @objects[id]
-      end
-    end
-
-    def [](id)
-      @objects[id]
-    end
-
-    def size
-      @identifiers.size
-    end
-    alias_method :length, :size
-
-    def compact
-      # Clear live markers
-      each { |o| o.live = false }
-
-      # Recursively mark reachable objects live, starting from the roots
-      # (the only objects referenced in the trailer)
-      root.mark_live
-      info.mark_live
-
-      # Renumber live objects to eliminate gaps (shrink the xref table)
-      if @objects.any?{ |_, o| !o.live }
-        new_id = 1
-        new_objects = {}
-        new_identifiers = []
-
-        each do |obj|
-          if obj.live
-            obj.identifier = new_id
-            new_objects[new_id] = obj
-            new_identifiers << new_id
-            new_id += 1
-          end
-        end
-
-        @objects = new_objects
-        @identifiers = new_identifiers
-      end
-    end
-
-  end
-end

data/vendor/prawn-core/lib/prawn/outline.rb

@@ -1,278 +0,0 @@
-# encoding: utf-8
-#
-# generates outline dictionary and items for document
-#
-# Author Jonathan Greenberg
-
-require 'forwardable'
-
-module Prawn
-  
-  class Document
-
-    # See Outline#define below for documentation
-    def define_outline(&block)
-      outline.define(&block)
-    end
-
-    # The Outline dictionary (12.3.3) for this document.  It is
-    # lazily initialized, so that documents that do not have an outline
-    # do not incur the additional overhead.
-    def outline_root(outline_root)
-      @store.root.data[:Outlines] ||= ref!(outline_root)
-    end
-
-    # Lazily instantiates an Outline object for document. This is used as point of entry
-    # to methods to build the outline tree.
-    def outline
-      @outline ||= Outline.new(self)
-    end
-
-  end
-  
-  # The Outline class organizes the outline tree items for the document.
-  # Note that the prev and parent instance variables are adjusted while navigating 
-  # through the nested blocks. These variables along with the presence or absense 
-  # of blocks are the primary means by which the relations for the various
-  # OutlineItems and the OutlineRoot are set. Unfortunately, the best way to
-  # understand how this works is to follow the method calls through a real example.
-  #
-  # Some ideas for the organization of this class were gleaned from name_tree. In 
-  # particular the way in which the OutlineItems are finally rendered into document 
-  # objects in PdfObject through a hash.
-  #
-  class Outline
-    
-    extend Forwardable
-    def_delegator :@document, :page_number
-    
-    attr_accessor :parent
-    attr_accessor :prev
-    attr_accessor :document
-    attr_accessor :outline_root
-    attr_accessor :items
-    
-    def initialize(document)
-      @document = document
-      @outline_root = document.outline_root(OutlineRoot.new)
-      @parent = outline_root
-      @prev = nil
-      @items = {}
-    end
-    
-    # Defines an outline for the document.
-    # The outline is an optional nested index that appears on the side of a PDF 
-    # document usually with direct links to pages. The outline DSL is defined by nested 
-    # blocks involving two methods: section and page.
-    #
-    # section(title, options{}, &block)
-    #   title: the outline text that appears for the section.
-    #   options: page - optional integer defining the page number for a destination link.
-    #                 - currently only :FIT destination supported with link to top of page.
-    #            closed - whether the section should show its nested outline elements.
-    #                   - defaults to false.
-    # page(page, options{})
-    #   page: integer defining the page number for the destination link.
-    #         currently only :FIT destination supported with link to top of page.
-    #         set to nil if destination link is not desired.
-    #   options: title - the outline text that appears for the section.
-    #            closed - whether the section should show its nested outline elements.
-    #                   - defaults to false.
-    #
-    # The syntax is best illustrated with an example:
-    #
-    # Prawn::Document.generate(outlined document) 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
-    # 
-    # It should be noted that not defining a title for a page element will raise
-    # a RequiredOption error
-    #
-    def define(&block)
-      if block
-        block.arity < 1 ? instance_eval(&block) : block[self]
-      end
-    end
-     
-    # Adds an outine section to the outline tree (see define_outline).
-    # Although you will probably choose to exclusively use define_outline so 
-    # that your outline tree is contained and easy to manage, this method
-    # gives you the option to add sections to the outline tree at any point
-    # during document generation. Note that the section will be added at the 
-    # top level at the end of the outline. For more a more flexible API try
-    # using outline.insert_section_after.
-    #
-    # block uses the same DSL syntax as define_outline, for example: 
-    #
-    #   outline.add_section do
-    #     section 'Added Section', :page => 3 do
-    #       page 3, :title => 'Page 3'
-    #     end
-    #   end
-    def add_section(&block)
-      @parent = outline_root
-      @prev = outline_root.data.last
-      if block
-        block.arity < 1 ? instance_eval(&block) : block[self]
-      end      
-    end
-    
-    # Inserts an outline section to the outline tree (see define_outline).
-    # Although you will probably choose to exclusively use define_outline so 
-    # that your outline tree is contained and easy to manage, this method
-    # gives you the option to insert sections to the outline tree at any point
-    # during document generation. Unlike outline.add_section, this method allows 
-    # you to enter a section after any other item at any level in the outline tree. 
-    # Currently the only way to locate the place of entry is with the title for the 
-    # item. If your titles names are not unique consider using define_outline.
-    #
-    # block uses the same DSL syntax as define_outline, for example: 
-    # 
-    #   go_to_page 2
-    #   start_new_page
-    #   text "Inserted Page"
-    #   outline.insert_section_after :title => 'Page 2' do 
-    #     page page_number, :title => "Inserted Page"
-    #   end
-    #
-    def insert_section_after(title, &block)
-      @prev = items[title]
-      if @prev
-        @parent = @prev.data.parent
-        nxt = @prev.data.next
-        if block
-          block.arity < 1 ? instance_eval(&block) : block[self]
-        end
-        adjust_relations(nxt)
-      else
-        raise Prawn::Errors::UnknownOutlineTitle, 
-          "\n No outline item with title: '#{title}' exists in the outline tree"
-      end
-    end
-
-  private
-    
-    def section(title, options = {}, &block)
-      add_outline_item(title, options, &block)
-    end 
-    
-    def page(page = nil, options = {})
-      if options[:title]
-        title = options[:title] 
-        options[:page] = page
-      else
-        raise Prawn::Errors::RequiredOption, 
-          "\nTitle is a required option for page"
-      end
-      add_outline_item(title, options)
-    end
-     
-    def add_outline_item(title, options, &block)
-      outline_item = create_outline_item(title, options)
-      set_relations(outline_item)
-      increase_count
-      set_variables_for_block(outline_item, block)
-      block.call if block
-      reset_parent(outline_item)
-    end
-    
-    def create_outline_item(title, options)
-      outline_item = OutlineItem.new(title, parent, options)
-
-      if options[:page]
-        page_index = options[:page] - 1
-        outline_item.dest = [document.pages[page_index].dictionary, :Fit] 
-      end
-
-      outline_item.prev = prev if @prev
-      items[title] = document.ref!(outline_item)
-    end
-    
-    def set_relations(outline_item)
-      prev.data.next = outline_item if prev
-      parent.data.first = outline_item unless prev
-      parent.data.last = outline_item
-    end
-    
-    def increase_count
-      counting_parent = parent
-      while counting_parent
-        counting_parent.data.count += 1
-        if counting_parent == outline_root
-          counting_parent = nil
-        else
-          counting_parent = counting_parent.data.parent
-        end
-      end
-    end
-    
-    def set_variables_for_block(outline_item, block)
-      self.prev = block ? nil : outline_item
-      self.parent = outline_item if block
-    end
-    
-    def reset_parent(outline_item)
-      if parent == outline_item
-        self.prev = outline_item
-        self.parent = outline_item.data.parent
-      end
-    end
-    
-    def adjust_relations(nxt)
-      if nxt 
-        nxt.data.prev = @prev
-        @prev.data.next = nxt
-        @parent.data.last = nxt
-      else 
-        @parent.data.last = @prev
-      end
-    end
-    
-  end
-  
-  class OutlineRoot #:nodoc:
-    attr_accessor :count, :first, :last
-    
-    def initialize
-      @count = 0
-    end
-        
-    def to_hash
-      {:Type => :Outlines, :Count => count, :First => first, :Last => last}
-    end
-  end
-  
-  class OutlineItem #:nodoc:
-    attr_accessor :count, :first, :last, :next, :prev, :parent, :title, :dest, :closed
-  
-    def initialize(title, parent, options)
-      @closed = options[:closed]
-      @title = title
-      @parent = parent
-      @count = 0
-    end
-  
-    def to_hash
-      hash = { :Title => Prawn::LiteralString.new(title),
-               :Parent => parent,
-               :Count => closed ? -count : count }
-      [{:First => first}, {:Last => last}, {:Next => @next}, 
-       {:Prev => prev}, {:Dest => dest}].each do |h|
-        unless h.values.first.nil?
-          hash.merge!(h)
-        end
-      end
-      hash 
-    end
-  end    
-end
-     

data/vendor/prawn-core/lib/prawn/pdf_object.rb

@@ -1,83 +0,0 @@
-# encoding: utf-8
-#
-# pdf_object.rb : Handles Ruby to PDF object serialization
-#
-# Copyright April 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-require 'prawn/byte_string'
-
-# Top level Module
-#
-module Prawn 
-                                             
-  module_function
-    
-  # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
-  # will work as expected, but please note that Name objects are represented 
-  # by Ruby Symbol objects and Dictionary objects are represented by Ruby hashes
-  # (keyed by symbols)   
-  #
-  #  Examples:
-  #
-  #     PdfObject(true)      #=> "true"
-  #     PdfObject(false)     #=> "false" 
-  #     PdfObject(1.2124)    #=> "1.2124"
-  #     PdfObject("foo bar") #=> "(foo bar)"  
-  #     PdfObject(:Symbol)   #=> "/Symbol"
-  #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
-  # 
-  def PdfObject(obj, in_content_stream = false)
-    case(obj)        
-    when NilClass   then "null" 
-    when TrueClass  then "true"
-    when FalseClass then "false"
-    when Numeric    then String(obj)
-    when Array
-      "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
-    when Prawn::LiteralString
-      obj = obj.gsub(/[\\\n\(\)]/) { |m| "\\#{m}" }
-      "(#{obj})"
-    when Time
-      obj = obj.strftime("D:%Y%m%d%H%M%S%z").chop.chop + "'00'"
-      obj = obj.gsub(/[\\\n\(\)]/) { |m| "\\#{m}" }
-      "(#{obj})"
-    when Prawn::ByteString
-      "<" << obj.unpack("H*").first << ">"
-    when String
-      obj = "\xFE\xFF" + obj.unpack("U*").pack("n*") unless in_content_stream
-      "<" << obj.unpack("H*").first << ">"
-     when Symbol                                                         
-       if (obj = obj.to_s) =~ /\s/
-         raise Prawn::Errors::FailedObjectConversion, 
-           "A PDF Name cannot contain whitespace"  
-       else
-         "/" << obj   
-       end 
-    when Hash           
-      output = "<< "
-      obj.each do |k,v|  
-        unless String === k || Symbol === k
-          raise Prawn::Errors::FailedObjectConversion, 
-            "A PDF Dictionary must be keyed by names"
-        end                          
-        output << PdfObject(k.to_sym, in_content_stream) << " " << 
-                  PdfObject(v, in_content_stream) << "\n"
-      end  
-      output << ">>"  
-    when Prawn::Reference
-      obj.to_s      
-    when Prawn::NameTree::Node
-      PdfObject(obj.to_hash)
-    when Prawn::NameTree::Value
-      PdfObject(obj.name) + " " + PdfObject(obj.value)
-    when Prawn::OutlineRoot, Prawn::OutlineItem
-      PdfObject(obj.to_hash)
-    else
-      raise Prawn::Errors::FailedObjectConversion, 
-        "This object cannot be serialized to PDF"
-    end     
-  end   
-  
-end