prawn 0.11.1 → 0.15.0

data/lib/prawn/core/object_store.rb

@@ -1,264 +0,0 @@
-# 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(filename, page_num)
-        @loaded_objects = {}
-        unless File.file?(filename)
-          raise ArgumentError, "#{filename} does not exist"
-        end
-
-        hash = PDF::Reader::ObjectHash.new(filename)
-        ref  = hash.page_references[page_num - 1]
-
-        ref.nil? ? nil : load_object_graph(hash, ref).identifier
-
-      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
-
-      # 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

data/lib/prawn/core/page.rb

@@ -1,213 +0,0 @@
-# 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.
-#
-
-require 'prawn/document/graphics_state'
-
-module Prawn
-  module Core
-    class Page #:nodoc:
-
-      include Prawn::Core::Page::GraphicsState
-
-      attr_accessor :document, :content, :dictionary, :margins, :stack
-
-      def initialize(document, options={})
-        @document = document
-        @margins  = options[:margins] || { :left    => 36,
-                                           :right   => 36,
-                                           :top     => 36,
-                                           :bottom  => 36  }
-        @stack = Prawn::GraphicStateStack.new(options[:graphic_state])
-        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
-        graphic_stack_size = stack.stack.size
-
-        document.save_graphics_state
-        document.send(:freeze_stamp_graphics)
-        yield if block_given?
-        
-        until graphic_stack_size == stack.stack.size
-          document.restore_graphics_state
-        end
-
-        @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]
-        document.open_graphics_state
-      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 inherited_dictionary_value(: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)
-        content << "q" << "\n"
-        @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
-
-      # some entries in the Page dict can be inherited from parent Pages dicts.
-      #
-      # Starting with the current page dict, this method will walk up the
-      # inheritance chain return the first value that is found for key
-      #
-      #     inherited_dictionary_value(:MediaBox)
-      #     => [ 0, 0, 595, 842 ]
-      #
-      def inherited_dictionary_value(key, local_dict = nil)
-        local_dict ||= dictionary.data
-
-        if local_dict.has_key?(key)
-          local_dict[key]
-        elsif local_dict.has_key?(:Parent)
-          inherited_dictionary_value(key, local_dict[:Parent].data)
-        else
-          nil
-        end
-      end
-
-    end
-
-  end
-end
-

data/lib/prawn/core/pdf_object.rb

@@ -1,108 +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.
-
-# 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

data/lib/prawn/core/reference.rb

@@ -1,112 +0,0 @@
-# encoding: utf-8
-
-# reference.rb : Implementation of PDF indirect objects
-#
-# Copyright April 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-require 'zlib'
-
-module Prawn  
-  module Core
-  
-    class Reference #:nodoc:
-
-      attr_accessor :gen, :data, :offset, :stream, :live, :identifier
-      
-      def initialize(id, data)
-        @identifier = id 
-        @gen        = 0       
-        @data       = data     
-        @compressed = false
-        @stream     = nil
-      end            
-      
-      def object 
-        output = "#{@identifier} #{gen} obj\n" <<
-                 Prawn::Core::PdfObject(data) << "\n"
-        if @stream
-          output << "stream\n" << @stream << "\nendstream\n" 
-        end
-        output << "endobj\n"
-      end  
-      
-      def <<(data)
-        raise 'Cannot add data to a stream that is compressed' if @compressed
-        (@stream ||= "") << data  
-      end  
-      
-      def to_s            
-        "#{@identifier} #{gen} R"
-      end
-
-      def compress_stream
-        @stream = Zlib::Deflate.deflate(@stream)
-        @data[:Filter] = :FlateDecode
-        @data[:Length] ||= @stream.length
-        @compressed = true
-      end
-
-      def compressed?
-        @compressed
-      end
-
-      # Creates a deep copy of this ref. If +share+ is provided, shares the
-      # given dictionary entries between the old ref and the new.
-      #
-      def deep_copy(share=[])
-        r = dup
-
-        if r.data.is_a?(Hash)
-          # Copy each entry not in +share+.
-          (r.data.keys - share).each do |k|
-            r.data[k] = Marshal.load(Marshal.dump(r.data[k]))
-          end
-        else
-          r.data = Marshal.load(Marshal.dump(r.data))
-        end
-
-        r.stream = Marshal.load(Marshal.dump(r.stream))
-        r
-      end
-      
-      # Replaces the data and stream with that of other_ref. Preserves compressed
-      # status.
-      def replace(other_ref)
-        @data       = other_ref.data
-        @stream     = other_ref.stream
-        @compressed = other_ref.compressed?
-      end
-
-      # Marks this and all referenced objects live, recursively.
-      def mark_live
-        return if @live
-        @live = true
-        referenced_objects.each { |o| o.mark_live }
-      end
-
-      private
-
-      # All objects referenced by this one. Used for GC.
-      def referenced_objects(obj=@data)
-        case obj
-        when self.class
-          []
-        when Hash
-          obj.values.map{|v| [v] + referenced_objects(v) }
-        when Array
-          obj.map{|v| [v] + referenced_objects(v) }
-        else []
-        end.flatten.grep(self.class)
-      end
-
-    end         
-
-    module_function
-    
-    def Reference(*args, &block) #:nodoc:
-      Reference.new(*args, &block)
-    end     
-  end
-end