prawn 0.12.0 → 0.13.0

data/lib/{prawn → pdf}/core/page.rb

@@ -7,15 +7,13 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
 
-require 'prawn/document/graphics_state'
+require_relative 'graphics_state'
 
-module Prawn
+module PDF
   module Core
     class Page #:nodoc:
-
-      include Prawn::Core::Page::GraphicsState
-
-      attr_accessor :document, :content, :dictionary, :margins, :stack
+      attr_accessor :document, :margins, :stack
+      attr_writer :content, :dictionary
 
       def initialize(document, options={})
         @document = document
@@ -23,7 +21,7 @@ module Prawn
                                            :right   => 36,
                                            :top     => 36,
                                            :bottom  => 36  }
-        @stack = Prawn::GraphicStateStack.new(options[:graphic_state])
+        @stack = GraphicStateStack.new(options[:graphic_state])
         if options[:object_id]
           init_from_object(options)
         else
@@ -31,8 +29,12 @@ module Prawn
         end
       end
 
+      def graphic_state
+        stack.current_state
+      end
+
       def layout
-        return @layout if @layout
+        return @layout if defined?(@layout) && @layout
 
         mb = dictionary.data[:MediaBox]
         if mb[3] > mb[2]
@@ -43,7 +45,7 @@ module Prawn
       end
 
       def size
-        @size || dimensions[2,2]
+        defined?(@size) && @size || dimensions[2,2]
       end
 
       def in_stamp_stream?
@@ -63,7 +65,6 @@ module Prawn
           document.restore_graphics_state
         end
 
-        @stamp_dictionary.data[:Length] = @stamp_stream.length + 1
         @stamp_dictionary << @stamp_stream
 
         @stamp_stream      = nil
@@ -84,13 +85,13 @@ module Prawn
         unless dictionary.data[:Contents].is_a?(Array)
           dictionary.data[:Contents] = [content]
         end
-        @content    = document.ref(:Length => 0)
+        @content    = document.ref({})
         dictionary.data[:Contents] << document.state.store[@content]
         document.open_graphics_state
       end
 
       def dictionary
-        @stamp_dictionary || document.state.store[@dictionary]
+        defined?(@stamp_dictionary) && @stamp_dictionary || document.state.store[@dictionary]
       end
 
       def resources
@@ -128,12 +129,10 @@ module Prawn
       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
+            stream.stream.compress! if document.compression_enabled?
           end
         else
-          content.compress_stream if document.compression_enabled?
-          content.data[:Length] = content.stream.size
+          content.stream.compress! if document.compression_enabled?
         end
       end
 
@@ -144,14 +143,14 @@ module Prawn
       def dimensions
         return inherited_dictionary_value(:MediaBox) if imported_page?
 
-        coords = Prawn::Document::PageGeometry::SIZES[size] || size
+        coords = PDF::Core::PageGeometry::SIZES[size] || size
         [0,0] + case(layout)
         when :portrait
           coords
         when :landscape
           coords.reverse
         else
-          raise Prawn::Errors::InvalidPageLayout,
+          raise PDF::Core::Errors::InvalidPageLayout,
             "Layout must be either :portrait or :landscape"
         end
       end
@@ -160,7 +159,7 @@ module Prawn
 
       def init_from_object(options)
         @dictionary = options[:object_id].to_i
-        dictionary.data[:Parent] = document.state.store.pages
+        dictionary.data[:Parent] = document.state.store.pages if options[:page_template]
 
         unless dictionary.data[:Contents].is_a?(Array) # content only on leafs
           @content    = dictionary.data[:Contents].identifier
@@ -175,7 +174,11 @@ module Prawn
         @size     = options[:size]    ||  "LETTER"
         @layout   = options[:layout]  || :portrait
 
-        @content    = document.ref(:Length      => 0)
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+        @imported_page     = false
+
+        @content    = document.ref({})
         content << "q" << "\n"
         @dictionary = document.ref(:Type        => :Page,
                                    :Parent      => document.state.store.pages,
@@ -183,9 +186,6 @@ module Prawn
                                    :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.
@@ -207,9 +207,6 @@ module Prawn
           nil
         end
       end
-
     end
-
   end
 end
-

data/lib/{prawn/document → pdf/core}/page_geometry.rb

@@ -1,32 +1,21 @@
 # encoding: utf-8
 
-# page_geometry.rb : Describes PDF page geometries
+# Describes PDF page geometries
 #
 # Copyright April 2008, Gregory Brown.  All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-module Prawn
-  class Document
-    
+module PDF
+  module Core
+
     # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
-    # 
-    # All of these dimensions are in PDF Points, see Prawn::Measurements for
-    # conversion utilities.
-    # 
-    # Additionally, if the size you are after is not listed below, you can always
-    # specify your size by passing an array of width and height to Prawn::Document.new
-    # like:
-    # 
-    #  Prawn::Document.new(:page_size => [1000, 20000])
     #
-    # The sizes below can be used by passing the appropriate string to :size:
-    # 
-    #  Prawn::Document.new(:page_size => '2A0')
-    # 
+    # All of these dimensions are in PDF Points (1/72 inch)
+    #
     # ===Inbuilt Sizes:
-    # 
-    # 
+    #
+    #
     # 4A0:: => 4767.87 x 6740.79
     # 2A0:: => 3370.39 x 4767.87
     # A0:: => 2383.94 x 3370.39
@@ -76,7 +65,7 @@ module Prawn
     # FOLIO:: => 612.00 x 936.00
     # LEGAL:: => 612.00 x 1008.00
     # LETTER:: => 612.00 x 792.00
-    # TABLOID:: => 792.00 x 1224.00 
+    # TABLOID:: => 792.00 x 1224.00
     #
     module PageGeometry
 
@@ -131,6 +120,7 @@ module Prawn
              "LETTER" => [612.00, 792.00],
             "TABLOID" => [792.00, 1224.00] }
 
-   end
+    end
   end
 end
+

data/lib/{prawn → pdf}/core/pdf_object.rb

@@ -8,9 +8,8 @@
 
 # Top level Module
 #
-module Prawn 
-  module Core #:nodoc:
-                                             
+module PDF
+  module Core
     module_function
 
     if "".respond_to?(:encode)
@@ -18,12 +17,19 @@ module Prawn
       def utf8_to_utf16(str)
         "\xFE\xFF".force_encoding("UTF-16BE") + str.encode("UTF-16BE")
       end
+
+      # encodes any string into a hex representation. The result is a string
+      # with only 0-9 and a-f characters. That result is valid ASCII so tag
+      # it as such to account for behaviour of different ruby VMs
+      def string_to_hex(str)
+        str.unpack("H*").first.force_encoding("ascii")
+      end
     else
       # Ruby 1.8
       def utf8_to_utf16(str)
         utf16 = "\xFE\xFF"
 
-        str.unpack("U*").each do |cp|
+        str.codepoints do |cp|
           if cp < 0x10000 # Basic Multilingual Plane
             utf16 << [cp].pack("n")
           else
@@ -36,43 +42,53 @@ module Prawn
 
         utf16
       end
+
+      def string_to_hex(str)
+        str.unpack("H*").first
+      end
     end
-      
+
     # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
-    # will work as expected, but please note that Name objects are represented 
+    # 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)   
+    # (keyed by symbols)
     #
     #  Examples:
     #
     #     PdfObject(true)      #=> "true"
-    #     PdfObject(false)     #=> "false" 
+    #     PdfObject(false)     #=> "false"
     #     PdfObject(1.2124)    #=> "1.2124"
-    #     PdfObject("foo bar") #=> "(foo bar)"  
+    #     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" 
+      case(obj)
+      when NilClass   then "null"
       when TrueClass  then "true"
       when FalseClass then "false"
-      when Numeric    then String(obj)
+      when Numeric
+        if (str = String(obj)) =~ /e/i
+          # scientific notation is not supported in PDF
+          sprintf("%.16f", obj).gsub(/\.?0+\z/, "")
+        else
+          str
+        end
       when Array
         "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
-      when Prawn::Core::LiteralString
+      when PDF::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
+      when PDF::Core::ByteString
         "<" << obj.unpack("H*").first << ">"
       when String
         obj = utf8_to_utf16(obj) unless in_content_stream
-        "<" << obj.unpack("H*").first << ">"
-       when Symbol                                                         
+        "<" << string_to_hex(obj) << ">"
+       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
@@ -80,29 +96,29 @@ module Prawn
             [n].pack("C*")
           end
          }.join
-      when Hash           
+      when ::Hash
         output = "<< "
-        obj.each do |k,v|  
+        obj.each do |k,v|
           unless String === k || Symbol === k
-            raise Prawn::Errors::FailedObjectConversion, 
+            raise PDF::Core::Errors::FailedObjectConversion,
               "A PDF Dictionary must be keyed by names"
-          end                          
-          output << PdfObject(k.to_sym, in_content_stream) << " " << 
+          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
+        end
+        output << ">>"
+      when PDF::Core::Reference
+        obj.to_s
+      when PDF::Core::NameTree::Node
         PdfObject(obj.to_hash)
-      when Prawn::Core::NameTree::Value
+      when PDF::Core::NameTree::Value
         PdfObject(obj.name) + " " + PdfObject(obj.value)
-      when Prawn::OutlineRoot, Prawn::OutlineItem
+      when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
         PdfObject(obj.to_hash)
       else
-        raise Prawn::Errors::FailedObjectConversion, 
+        raise PDF::Core::Errors::FailedObjectConversion,
           "This object cannot be serialized to PDF (#{obj.inspect})"
-      end     
-    end   
+      end
+    end
   end
 end

data/lib/{prawn → pdf}/core/reference.rb

@@ -6,50 +6,38 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-require 'zlib'
 
-module Prawn  
+module PDF
   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" 
+        @identifier = id
+        @gen        = 0
+        @data       = data
+        @stream     = Stream.new
+      end
+
+      def object
+        output = "#{@identifier} #{gen} obj\n"
+        unless @stream.empty?
+          output << PDF::Core::PdfObject(data.merge @stream.data) << "\n" << @stream.object
+        else
+          output << PDF::Core::PdfObject(data) << "\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
+      def <<(io)
+        raise "Cannot attach stream to non-dictionary object" unless @data.is_a?(::Hash)
+        (@stream ||= Stream.new) << io
       end
 
-      def compressed?
-        @compressed
+      def to_s
+        "#{@identifier} #{gen} R"
       end
 
       # Creates a deep copy of this ref. If +share+ is provided, shares the
@@ -58,11 +46,14 @@ module Prawn
       def deep_copy(share=[])
         r = dup
 
-        if r.data.is_a?(Hash)
+        case r.data
+        when ::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
+        when PDF::Core::NameTree::Node
+          r.data = r.data.deep_copy
         else
           r.data = Marshal.load(Marshal.dump(r.data))
         end
@@ -70,18 +61,16 @@ module Prawn
         r.stream = Marshal.load(Marshal.dump(r.stream))
         r
       end
-      
-      # Replaces the data and stream with that of other_ref. Preserves compressed
-      # status.
+
+      # Replaces the data and stream with that of other_ref.
       def replace(other_ref)
-        @data       = other_ref.data
-        @stream     = other_ref.stream
-        @compressed = other_ref.compressed?
+        @data   = other_ref.data
+        @stream = other_ref.stream
       end
 
       # Marks this and all referenced objects live, recursively.
       def mark_live
-        return if @live
+        return if defined?(@live) && @live
         @live = true
         referenced_objects.each { |o| o.mark_live }
       end
@@ -93,20 +82,22 @@ module Prawn
         case obj
         when self.class
           []
-        when Hash
+        when ::Hash
           obj.values.map{|v| [v] + referenced_objects(v) }
         when Array
           obj.map{|v| [v] + referenced_objects(v) }
+        when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
+          referenced_objects(obj.to_hash)
         else []
         end.flatten.grep(self.class)
       end
 
-    end         
+    end
 
     module_function
-    
+
     def Reference(*args, &block) #:nodoc:
       Reference.new(*args, &block)
-    end     
+    end
   end
 end