nurettin-prawn 1.0.0.rc1

data/lib/prawn/core/byte_string.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module Prawn
+  module Core
+    # This is used to differentiate strings that must be encoded as
+    # a byte string, such as binary data from encrypted strings.
+    class ByteString < String #:nodoc:
+    end
+  end
+end

data/lib/prawn/core/destinations.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+# prawn/core/destinations.rb : Implements destination support for PDF
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Core
+    module Destinations #:nodoc:
+      
+      # The maximum number of children to fit into a single node in the Dests tree.
+      NAME_TREE_CHILDREN_LIMIT = 20 #:nodoc:
+      
+      # The Dests name tree in the Name dictionary (see Prawn::Document::Internal#names).
+      # This name tree is used to store named destinations (PDF spec 8.2.1).
+      # (For more on name trees, see section 3.8.4 in the PDF spec.)
+      #
+      def dests
+        names.data[:Dests] ||= ref!(Prawn::Core::NameTree::Node.new(self, NAME_TREE_CHILDREN_LIMIT))
+      end
+
+      # Adds a new destination to the dests name tree (see #dests). The
+      # +reference+ parameter will be converted into a Prawn::Reference if
+      # it is not already one.
+      #
+      def add_dest(name, reference)
+        reference = ref!(reference) unless reference.is_a?(Prawn::Core::Reference)
+        dests.data.add(name, reference)
+      end
+
+      # Return a Dest specification for a specific location (and optional zoom
+      # level).
+      #
+      def dest_xyz(left, top, zoom=nil, dest_page=page)
+        [dest_page.dictionary, :XYZ, left, top, zoom]
+      end
+
+      # Return a Dest specification that will fit the given page into the
+      # viewport.
+      #
+      def dest_fit(dest_page=page)
+        [dest_page.dictionary, :Fit]
+      end
+
+      # Return a Dest specification that will fit the given page horizontally
+      # into the viewport, aligned vertically at the given top coordinate.
+      #
+      def dest_fit_horizontally(top, dest_page=page)
+        [dest_page.dictionary, :FitH, top]
+      end
+
+      # Return a Dest specification that will fit the given page vertically
+      # into the viewport, aligned horizontally at the given left coordinate.
+      #
+      def dest_fit_vertically(left, dest_page=page)
+        [dest_page.dictionary, :FitV, left]
+      end
+
+      # Return a Dest specification that will fit the given rectangle into the
+      # viewport, for the given page.
+      #
+      def dest_fit_rect(left, bottom, right, top, dest_page=page)
+        [dest_page.dictionary, :FitR, left, bottom, right, top]
+      end
+
+      # Return a Dest specfication that will fit the given page's bounding box
+      # into the viewport.
+      #
+      def dest_fit_bounds(dest_page=page)
+        [dest_page.dictionary, :FitB]
+      end
+
+      # Same as #dest_fit_horizontally, but works on the page's bounding box
+      # instead of the entire page.
+      #
+      def dest_fit_bounds_horizontally(top, dest_page=page)
+        [dest_page.dictionary, :FitBH, top]
+      end
+
+      # Same as #dest_fit_vertically, but works on the page's bounding box
+      # instead of the entire page.
+      #
+      def dest_fit_bounds_vertically(left, dest_page=page)
+        [dest_page.dictionary, :FitBV, left]
+      end
+    end
+  end
+end

data/lib/prawn/core/document_state.rb

@@ -0,0 +1,79 @@
+module Prawn
+  module Core
+    class DocumentState #:nodoc:
+      def initialize(options)
+        normalize_metadata(options)
+
+        if options[:template]
+          @store = Prawn::Core::ObjectStore.new(:template => options[:template])
+          @store.info.data.merge!(options[:info]) if options[:info]
+        else
+          @store = Prawn::Core::ObjectStore.new(:info => options[:info])
+        end
+
+        @version                 = 1.3
+        @pages                   = []
+        @page                    = nil
+        @trailer                 = {}
+        @compress                = options.fetch(:compress, false)
+        @encrypt                 = options.fetch(:encrypt, false)
+        @encryption_key          = options[:encryption_key]
+        @optimize_objects        = options.fetch(:optimize_objects, false)
+        @skip_encoding           = options.fetch(:skip_encoding, false)
+        @before_render_callbacks = []
+        @on_page_create_callback = nil
+      end
+
+      attr_accessor :store, :version, :pages, :page, :trailer, :compress,
+        :encrypt, :encryption_key, :optimize_objects, :skip_encoding,
+        :before_render_callbacks, :on_page_create_callback
+
+      def populate_pages_from_store(document)
+        return 0 if @store.page_count <= 0 || @pages.size > 0
+
+        count = (1..@store.page_count)
+        @pages = count.map do |index|
+          orig_dict_id = @store.object_id_for_page(index)
+          Prawn::Core::Page.new(document, :object_id => orig_dict_id)
+        end
+
+      end
+
+      def normalize_metadata(options)
+        options[:info] ||= {}
+        options[:info][:Creator] ||= "Prawn"
+        options[:info][:Producer] ||= "Prawn"
+
+        info = options[:info]
+      end
+
+      def insert_page(page, page_number)
+        pages.insert(page_number, page)
+        store.pages.data[:Kids].insert(page_number, page.dictionary)
+        store.pages.data[:Count] += 1
+      end
+
+      def on_page_create_action(doc)
+        on_page_create_callback[doc] if on_page_create_callback
+      end
+
+      def before_render_actions(doc)
+        before_render_callbacks.each{ |c| c.call(self) }
+      end
+
+      def page_count
+        pages.length
+      end
+
+      def render_body(output)
+        store.compact if optimize_objects
+        store.each do |ref|
+          ref.offset = output.size
+          output << (@encrypt ? ref.encrypted_object(@encryption_key) : 
+                                ref.object)
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/core/literal_string.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Prawn
+  module Core
+    # This is used to differentiate strings that must be encoded as
+    # a *literal* string, versus those that can be encoded in
+    # the PDF hexadecimal format.
+    #
+    # Some features of the PDF format appear to require that literal
+    # strings be used. One such feature is the /Dest key of a link
+    # annotation; if a hex encoded string is used there, the links
+    # do not work (as tested in Mac OS X Preview, and Adobe Acrobat
+    # Reader).
+    class LiteralString < String #:nodoc:
+    end
+  end
+end

data/lib/prawn/core/name_tree.rb

@@ -0,0 +1,177 @@
+# encoding: utf-8
+
+# name_tree.rb : Implements NameTree for PDF
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Core
+    module NameTree #:nodoc:
+      class Node #:nodoc:
+        attr_reader :children
+        attr_reader :limit
+        attr_reader :document
+        attr_accessor :parent
+        attr_accessor :ref
+
+        def initialize(document, limit, parent=nil)
+          @document = document
+          @children = []
+          @limit = limit
+          @parent = parent
+          @ref = nil
+        end
+
+        def empty?
+          children.empty?
+        end
+
+        def size
+          leaf? ? children.size : children.inject(0) { |sum, child| sum + child.size }
+        end
+
+        def leaf?
+          children.empty? || children.first.is_a?(Value)
+        end
+
+        def add(name, value)
+          self << Value.new(name, value)
+        end
+
+        def to_hash
+          hash = {}
+
+          hash[:Limits] = [least, greatest] if parent
+          if leaf?
+            hash[:Names] = children if leaf?
+          else
+            hash[:Kids] = children.map { |child| child.ref }
+          end
+
+          return hash
+        end
+
+        def least
+          if leaf?
+            children.first.name
+          else
+            children.first.least
+          end
+        end
+
+        def greatest
+          if leaf?
+            children.last.name
+          else
+            children.last.greatest
+          end
+        end
+
+        def <<(value)
+          if children.empty?
+            children << value
+          elsif leaf?
+            children.insert(insertion_point(value), value)
+            split! if children.length > limit
+          else
+            fit = children.detect { |child| child >= value }
+            fit = children.last unless fit
+            fit << value
+          end
+
+          value
+        end
+
+        def >=(value)
+          children.empty? || children.last >= value
+        end
+
+        def split!
+          if parent
+            parent.split(self)
+          else
+            left, right = new_node(self), new_node(self)
+            split_children(self, left, right)
+            children.replace([left, right])
+          end
+        end
+
+        # Returns a deep copy of this node, without copying expensive things
+        # like the ref to @document.
+        #
+        def deep_copy
+          node = dup
+          node.instance_variable_set("@children",
+                                     Marshal.load(Marshal.dump(children)))
+          node.instance_variable_set("@ref",
+                                     node.ref ? node.ref.deep_copy : nil)
+          node
+        end
+
+        protected
+
+          def split(node)
+            new_child = new_node(self)
+            split_children(node, node, new_child)
+            index = children.index(node)
+            children.insert(index+1, new_child)
+            split! if children.length > limit
+          end
+
+        private
+
+          def new_node(parent=nil)
+            node = Node.new(document, limit, parent)
+            node.ref = document.ref!(node)
+            return node
+          end
+
+          def split_children(node, left, right)
+            half = (node.limit+1)/2
+
+            left_children, right_children = node.children[0...half], node.children[half..-1]
+
+            left.children.replace(left_children)
+            right.children.replace(right_children)
+
+            unless node.leaf?
+              left_children.each { |child| child.parent = left }
+              right_children.each { |child| child.parent = right }
+            end
+          end
+
+          def insertion_point(value)
+            children.each_with_index do |child, index|
+              return index if child >= value
+            end
+            return children.length
+          end
+      end
+
+      class Value #:nodoc:
+        include Comparable
+
+        attr_reader :name
+        attr_reader :value
+
+        def initialize(name, value)
+          @name, @value = Prawn::Core::LiteralString.new(name), value
+        end
+
+        def <=>(leaf)
+          name <=> leaf.name
+        end
+
+        def inspect
+          "#<Value: #{name.inspect} : #{value.inspect}>"
+        end
+
+        def to_s
+          "#{name} : #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/prawn/core/object_store.rb

@@ -0,0 +1,320 @@
+# encoding: utf-8
+
+# prawn/core/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.
+
+
+require 'pdf/reader'
+
+module Prawn
+  module Core
+    class ObjectStore #:nodoc:
+      include Enumerable
+
+      attr_reader :min_version
+
+      BASE_OBJECTS = %w[info pages root]
+
+      def initialize(opts = {})
+        @objects = {}
+        @identifiers = []
+
+        load_file(opts[:template]) if opts[:template]
+
+        @info  ||= ref(opts[:info] || {}).identifier
+        @root  ||= ref(:Type => :Catalog).identifier
+        if pages.nil?
+          root.data[:Pages] = ref(:Type => :Pages, :Count => 0, :Kids => [])
+        end
+      end
+
+      def ref(data, &block)
+        push(size + 1, data, &block)
+      end
+
+      def info
+        @objects[@info]
+      end
+
+      def root
+        @objects[@root]
+      end
+
+      def pages
+        root.data[:Pages]
+      end
+
+      def page_count
+        pages.data[:Count]
+      end
+
+      # Adds the given reference to the store and returns the reference object.
+      # If the object provided is not a Prawn::Core::Reference, one is created from the
+      # arguments provided.
+      #
+      def push(*args, &block)
+        reference = if args.first.is_a?(Prawn::Core::Reference)
+          args.first
+        else
+          Prawn::Core::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
+
+      # returns the object ID for a particular page in the document. Pages
+      # are indexed starting at 1 (not 0!).
+      #
+      #   object_id_for_page(1)
+      #   => 5
+      #   object_id_for_page(10)
+      #   => 87
+      #   object_id_for_page(-11)
+      #   => 17
+      #
+      def object_id_for_page(k)
+        k -= 1 if k > 0
+        flat_page_ids = get_page_objects(pages).flatten
+        flat_page_ids[k]
+      end
+
+      # imports all objects required to render a page from another PDF. The
+      # objects are added to the current object store, but NOT linked
+      # anywhere.
+      #
+      # The object ID of the root Page object is returned, it's up to the
+      # calling code to link that into the document structure somewhere. If
+      # this isn't done the imported objects will just be removed when the
+      # store is compacted.
+      #
+      # Imports nothing and returns nil if the requested page number doesn't
+      # exist. page_num is 1 indexed, so 1 indicates the first page.
+      #
+      def import_page(input, page_num)
+        @loaded_objects = {}
+        if template_id = indexed_template(input, page_num)
+          return template_id
+        end
+
+        io = if input.respond_to?(:seek) && input.respond_to?(:read)
+               input
+             elsif File.file?(input.to_s)
+               StringIO.new(File.binread(input.to_s))
+             else
+               raise ArgumentError, "input must be an IO-like object or a filename"
+             end
+
+                # unless File.file?(filename)
+        #   raise ArgumentError, "#{filename} does not exist"
+        # end
+
+        hash = indexed_hash(input, io)
+        ref  = hash.page_references[page_num - 1]
+
+        if ref.nil?
+          nil
+        else
+          index_template(input, page_num, load_object_graph(hash, ref).identifier)
+        end
+
+      rescue PDF::Reader::MalformedPDFError, PDF::Reader::InvalidObjectError
+        msg = "Error reading template file. If you are sure it's a valid PDF, it may be a bug."
+        raise Prawn::Errors::TemplateError, msg
+      rescue PDF::Reader::UnsupportedFeatureError
+        msg = "Template file contains unsupported PDF features"
+        raise Prawn::Errors::TemplateError, msg
+      end
+
+      private
+
+      # An index for page templates so that their loaded object graph
+      # can be reused without multiple loading
+      def template_index
+        @template_index ||= {}
+      end
+
+      # An index for the read object hash of a pdf template so that the
+      # object hash does not need to be parsed multiple times when using
+      # different pages of the pdf as page templates
+      def hash_index
+        @hash_index ||= {}
+      end
+
+      # returns the indexed object graph identifier for a template page if
+      # it exists
+      def indexed_template(input, page_number)
+        key = indexing_key(input)
+        template_index[key] && template_index[key][page_number]
+      end
+
+      # indexes the identifier for a page from a template
+      def index_template(input, page_number, id)
+        (template_index[indexing_key(input)] ||= {})[page_number] ||= id
+      end
+
+      # reads and indexes a new IO for a template
+      # if the IO has been indexed already then the parsed object hash
+      # is returned directly
+      def indexed_hash(input, io)
+        hash_index[indexing_key(input)] ||= PDF::Reader::ObjectHash.new(io)
+      end
+
+      # the index key for the input.
+      # uses object_id so that both a string filename or an IO stream can be
+      # indexed and reused provided the same object gets used in multiple page
+      # template calls.
+      def indexing_key(input)
+        input.object_id
+      end
+
+      # returns a nested array of object IDs for all pages in this object store.
+      #
+      def get_page_objects(obj)
+        if obj.data[:Type] == :Page
+          obj.identifier
+        elsif obj.data[:Type] == :Pages
+          obj.data[:Kids].map { |kid| get_page_objects(kid) }
+        end
+      end
+
+      # takes a source PDF and uses it as a template for this document.
+      #
+      def load_file(template)
+        unless (template.respond_to?(:seek) && template.respond_to?(:read)) ||
+               File.file?(template)
+          raise ArgumentError, "#{template} does not exist"
+        end
+
+        hash = PDF::Reader::ObjectHash.new(template)
+        src_info = hash.trailer[:Info]
+        src_root = hash.trailer[:Root]
+        @min_version = hash.pdf_version.to_f
+
+        if hash.trailer[:Encrypt]
+          msg = "Template file is an encrypted PDF, it can't be used as a template"
+          raise Prawn::Errors::TemplateError, msg
+        end
+
+        if src_info
+          @info = load_object_graph(hash, src_info).identifier
+        end
+
+        if src_root
+          @root = load_object_graph(hash, src_root).identifier
+        end
+      rescue PDF::Reader::MalformedPDFError, PDF::Reader::InvalidObjectError
+        msg = "Error reading template file. If you are sure it's a valid PDF, it may be a bug."
+        raise Prawn::Errors::TemplateError, msg
+      rescue PDF::Reader::UnsupportedFeatureError
+        msg = "Template file contains unsupported PDF features"
+        raise Prawn::Errors::TemplateError, msg
+      end
+
+      # recurse down an object graph from a source PDF, importing all the
+      # indirect objects we find.
+      #
+      # hash is the PDF::Reader::ObjectHash to extract objects from, object is
+      # the object to extract.
+      #
+      def load_object_graph(hash, object)
+        @loaded_objects ||= {}
+        case object
+        when ::Hash then
+          object.each { |key,value| object[key] = load_object_graph(hash, value) }
+          object
+        when Array then
+          object.map { |item| load_object_graph(hash, item)}
+        when PDF::Reader::Reference then
+          unless @loaded_objects.has_key?(object.id)
+            @loaded_objects[object.id] = ref(nil)
+            new_obj = load_object_graph(hash, hash[object])
+          if new_obj.kind_of?(PDF::Reader::Stream)
+            stream_dict = load_object_graph(hash, new_obj.hash)
+            @loaded_objects[object.id].data = stream_dict
+            @loaded_objects[object.id] << new_obj.data
+            else
+              @loaded_objects[object.id].data = new_obj
+            end
+          end
+          @loaded_objects[object.id]
+        when PDF::Reader::Stream
+          # Stream is a subclass of string, so this is here to prevent the stream
+          # being wrapped in a LiteralString
+          object
+        when String
+          is_utf8?(object) ? object : Prawn::Core::ByteString.new(object)
+        else
+          object
+        end
+      end
+
+      ruby_18 do
+        def is_utf8?(str)
+          begin
+            str.unpack("U*")
+            true
+          rescue
+            false
+          end
+        end
+      end
+      ruby_19 do
+        def is_utf8?(str)
+          str.force_encoding("utf-8")
+          str.valid_encoding?
+        end
+      end
+    end
+  end
+end