alphasights-prawn 0.10.0

data/lib/prawn/core/object_store.rb

@@ -0,0 +1,236 @@
+# 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
+
+      private
+
+      # 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(filename)
+        unless File.file?(filename)
+          raise ArgumentError, "#{filename} does not exist"
+        end
+
+        unless PDF.const_defined?("Hash")
+          raise "PDF::Hash not found. Is PDF::Reader > 0.8?"
+        end
+
+        hash = PDF::Hash.new(filename)
+        src_info = hash.trailer[:Info]
+        src_root = hash.trailer[:Root]
+        @min_version = hash.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::Hash 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

data/lib/prawn/core/page.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+# prawn/core/page.rb : Implements low-level representation of a PDF page
+#
+# Copyright February 2010, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Core
+    class Page #:nodoc:
+      attr_accessor :document, :content, :dictionary, :margins
+
+      def initialize(document, options={})
+        @document = document
+        @margins  = options[:margins] || { :left    => 36,
+                                           :right   => 36,
+                                           :top     => 36,
+                                           :bottom  => 36  }
+
+        if options[:object_id]
+          init_from_object(options)
+        else
+          init_new_page(options)
+        end
+      end
+
+      def layout
+        return @layout if @layout
+
+        mb = dictionary.data[:MediaBox]
+        if mb[3] > mb[2]
+          :portrait
+        else
+          :landscape
+        end
+      end
+
+      def size
+        @size || dimensions[2,2]
+      end
+
+      def in_stamp_stream?
+        !!@stamp_stream
+      end
+
+      def stamp_stream(dictionary)
+        @stamp_stream     = ""
+        @stamp_dictionary = dictionary
+
+        document.send(:update_colors)
+        yield if block_given?
+        document.send(:update_colors)
+
+        @stamp_dictionary.data[:Length] = @stamp_stream.length + 1
+        @stamp_dictionary << @stamp_stream
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+      end
+
+      def content
+        @stamp_stream || document.state.store[@content]
+      end
+
+      # As per the PDF spec, each page can have multiple content streams. This will
+      # add a fresh, empty content stream this the page, mainly for use in loading
+      # template files.
+      #
+      def new_content_stream
+        return if in_stamp_stream?
+
+        unless dictionary.data[:Contents].is_a?(Array)
+          dictionary.data[:Contents] = [content]
+        end
+        @content    = document.ref(:Length => 0)
+        dictionary.data[:Contents] << document.state.store[@content]
+      end
+
+      def dictionary
+        @stamp_dictionary || document.state.store[@dictionary]
+      end
+
+      def resources
+        if dictionary.data[:Resources]
+          document.deref(dictionary.data[:Resources])
+        else
+          dictionary.data[:Resources] = {}
+        end
+      end
+
+      def fonts
+        if resources[:Font]
+          document.deref(resources[:Font])
+        else
+          resources[:Font] = {}
+        end
+      end
+
+      def xobjects
+        if resources[:XObject]
+          document.deref(resources[:XObject])
+        else
+          resources[:XObject] = {}
+        end
+      end
+
+      def ext_gstates
+        if resources[:ExtGState]
+          document.deref(resources[:ExtGState])
+        else
+          resources[:ExtGState] = {}
+        end
+      end
+
+      def finalize
+        if dictionary.data[:Contents].is_a?(Array)
+          dictionary.data[:Contents].each do |stream|
+            stream.compress_stream if document.compression_enabled?
+            stream.data[:Length] = stream.stream.size
+          end
+        else
+          content.compress_stream if document.compression_enabled?
+          content.data[:Length] = content.stream.size
+        end
+      end
+
+      def imported_page?
+        @imported_page
+      end
+
+      def dimensions
+        return dictionary.data[:MediaBox] if imported_page?
+
+        coords = Prawn::Document::PageGeometry::SIZES[size] || size
+        [0,0] + case(layout)
+        when :portrait
+          coords
+        when :landscape
+          coords.reverse
+        else
+          raise Prawn::Errors::InvalidPageLayout,
+            "Layout must be either :portrait or :landscape"
+        end
+      end
+
+      private
+
+      def init_from_object(options)
+        @dictionary = options[:object_id].to_i
+        unless dictionary.data[:Contents].is_a?(Array) # content only on leafs
+          @content    = dictionary.data[:Contents].identifier
+        end
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+        @imported_page     = true
+      end
+
+      def init_new_page(options)
+        @size     = options[:size]    ||  "LETTER" 
+        @layout   = options[:layout]  || :portrait         
+        
+        @content    = document.ref(:Length      => 0)
+        @dictionary = document.ref(:Type        => :Page,
+                                   :Parent      => document.state.store.pages,
+                                   :MediaBox    => dimensions,
+                                   :Contents    => content)
+
+        resources[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+      end
+
+    end
+  end
+end
+

data/lib/prawn/core/pdf_object.rb

@@ -0,0 +1,108 @@
+# 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.
+
+# Top level Module
+#
+module Prawn 
+  module Core #:nodoc:
+                                             
+    module_function
+
+    ruby_18 do
+      def utf8_to_utf16(str)
+        utf16 = "\xFE\xFF"
+
+        str.unpack("U*").each do |cp|
+          if cp < 0x10000 # Basic Multilingual Plane
+            utf16 << [cp].pack("n")
+          else
+            # pull out high/low 10 bits
+            hi, lo = (cp - 0x10000).divmod(2**10)
+            # encode a surrogate pair
+            utf16 << [0xD800 + hi, 0xDC00 + lo].pack("n*")
+          end
+        end
+
+        utf16
+      end
+    end
+
+    ruby_19 do
+      def utf8_to_utf16(str)
+        "\xFE\xFF".force_encoding("UTF-16BE") + str.encode("UTF-16BE")
+      end
+    end
+      
+    # 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::Core::LiteralString
+        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
+        "(#{obj})"
+      when Time
+        obj = obj.strftime("D:%Y%m%d%H%M%S%z").chop.chop + "'00'"
+        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
+        "(#{obj})"
+      when Prawn::Core::ByteString
+        "<" << obj.unpack("H*").first << ">"
+      when String
+        obj = utf8_to_utf16(obj) unless in_content_stream
+        "<" << obj.unpack("H*").first << ">"
+       when Symbol                                                         
+         "/" + obj.to_s.unpack("C*").map { |n|
+          if n < 33 || n > 126 || [35,40,41,47,60,62].include?(n)
+            "#" + n.to_s(16).upcase
+          else
+            [n].pack("C*")
+          end
+         }.join
+      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::Core::Reference
+        obj.to_s      
+      when Prawn::Core::NameTree::Node
+        PdfObject(obj.to_hash)
+      when Prawn::Core::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 (#{obj.inspect})"
+      end     
+    end   
+  end
+end