pdf-core 0.5.1 → 0.9.0

data/lib/pdf/core/page_geometry.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # Describes PDF page geometries
 #
@@ -8,7 +8,6 @@
 
 module PDF
   module Core
-
     # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
     #
     # All of these dimensions are in PDF Points (1/72 inch)
@@ -68,59 +67,58 @@ module PDF
     # TABLOID:: => 792.00 x 1224.00
     #
     module PageGeometry
-
-      SIZES = { "4A0" => [4767.87, 6740.79],
-                "2A0" => [3370.39, 4767.87],
-                 "A0" => [2383.94, 3370.39],
-                 "A1" => [1683.78, 2383.94],
-                 "A2" => [1190.55, 1683.78],
-                 "A3" => [841.89, 1190.55],
-                 "A4" => [595.28, 841.89],
-                 "A5" => [419.53, 595.28],
-                 "A6" => [297.64, 419.53],
-                 "A7" => [209.76, 297.64],
-                 "A8" => [147.40, 209.76],
-                 "A9" => [104.88, 147.40],
-                "A10" => [73.70, 104.88],
-                 "B0" => [2834.65, 4008.19],
-                 "B1" => [2004.09, 2834.65],
-                 "B2" => [1417.32, 2004.09],
-                 "B3" => [1000.63, 1417.32],
-                 "B4" => [708.66, 1000.63],
-                 "B5" => [498.90, 708.66],
-                 "B6" => [354.33, 498.90],
-                 "B7" => [249.45, 354.33],
-                 "B8" => [175.75, 249.45],
-                 "B9" => [124.72, 175.75],
-                "B10" => [87.87, 124.72],
-                 "C0" => [2599.37, 3676.54],
-                 "C1" => [1836.85, 2599.37],
-                 "C2" => [1298.27, 1836.85],
-                 "C3" => [918.43, 1298.27],
-                 "C4" => [649.13, 918.43],
-                 "C5" => [459.21, 649.13],
-                 "C6" => [323.15, 459.21],
-                 "C7" => [229.61, 323.15],
-                 "C8" => [161.57, 229.61],
-                 "C9" => [113.39, 161.57],
-                "C10" => [79.37, 113.39],
-                "RA0" => [2437.80, 3458.27],
-                "RA1" => [1729.13, 2437.80],
-                "RA2" => [1218.90, 1729.13],
-                "RA3" => [864.57, 1218.90],
-                "RA4" => [609.45, 864.57],
-               "SRA0" => [2551.18, 3628.35],
-               "SRA1" => [1814.17, 2551.18],
-               "SRA2" => [1275.59, 1814.17],
-               "SRA3" => [907.09, 1275.59],
-               "SRA4" => [637.80, 907.09],
-          "EXECUTIVE" => [521.86, 756.00],
-              "FOLIO" => [612.00, 936.00],
-              "LEGAL" => [612.00, 1008.00],
-             "LETTER" => [612.00, 792.00],
-            "TABLOID" => [792.00, 1224.00] }
-
+      SIZES = {
+        '4A0' => [4767.87, 6740.79],
+        '2A0' => [3370.39, 4767.87],
+        'A0' => [2383.94, 3370.39],
+        'A1' => [1683.78, 2383.94],
+        'A2' => [1190.55, 1683.78],
+        'A3' => [841.89, 1190.55],
+        'A4' => [595.28, 841.89],
+        'A5' => [419.53, 595.28],
+        'A6' => [297.64, 419.53],
+        'A7' => [209.76, 297.64],
+        'A8' => [147.40, 209.76],
+        'A9' => [104.88, 147.40],
+        'A10' => [73.70, 104.88],
+        'B0' => [2834.65, 4008.19],
+        'B1' => [2004.09, 2834.65],
+        'B2' => [1417.32, 2004.09],
+        'B3' => [1000.63, 1417.32],
+        'B4' => [708.66, 1000.63],
+        'B5' => [498.90, 708.66],
+        'B6' => [354.33, 498.90],
+        'B7' => [249.45, 354.33],
+        'B8' => [175.75, 249.45],
+        'B9' => [124.72, 175.75],
+        'B10' => [87.87, 124.72],
+        'C0' => [2599.37, 3676.54],
+        'C1' => [1836.85, 2599.37],
+        'C2' => [1298.27, 1836.85],
+        'C3' => [918.43, 1298.27],
+        'C4' => [649.13, 918.43],
+        'C5' => [459.21, 649.13],
+        'C6' => [323.15, 459.21],
+        'C7' => [229.61, 323.15],
+        'C8' => [161.57, 229.61],
+        'C9' => [113.39, 161.57],
+        'C10' => [79.37, 113.39],
+        'RA0' => [2437.80, 3458.27],
+        'RA1' => [1729.13, 2437.80],
+        'RA2' => [1218.90, 1729.13],
+        'RA3' => [864.57, 1218.90],
+        'RA4' => [609.45, 864.57],
+        'SRA0' => [2551.18, 3628.35],
+        'SRA1' => [1814.17, 2551.18],
+        'SRA2' => [1275.59, 1814.17],
+        'SRA3' => [907.09, 1275.59],
+        'SRA4' => [637.80, 907.09],
+        'EXECUTIVE' => [521.86, 756.00],
+        'FOLIO' => [612.00, 936.00],
+        'LEGAL' => [612.00, 1008.00],
+        'LETTER' => [612.00, 792.00],
+        'TABLOID' => [792.00, 1224.00]
+      }.freeze
     end
   end
 end
-

data/lib/pdf/core/pdf_object.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # pdf_object.rb : Handles Ruby to PDF object serialization
 #
 # Copyright April 2008, Gregory Brown.  All Rights Reserved.
@@ -13,89 +13,98 @@ module PDF
     module_function
 
     def real(num)
-      num.to_f.round(4)
+      format('%<number>.5f', number: num).sub(/((?<!\.)0)+\z/, '')
     end
 
     def real_params(array)
-      array.map { |e| real(e) }.join(" ")
+      array.map { |e| real(e) }.join(' ')
     end
 
     def utf8_to_utf16(str)
-      "\xFE\xFF".force_encoding(::Encoding::UTF_16BE) + str.encode(::Encoding::UTF_16BE)
+      (+"\xFE\xFF").force_encoding(::Encoding::UTF_16BE) +
+        str.encode(::Encoding::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(::Encoding::US_ASCII)
+      str.unpack1('H*').force_encoding(::Encoding::US_ASCII)
     end
 
+    ESCAPED_NAME_CHARACTERS = (1..32).to_a + [35, 40, 41, 47, 60, 62] + (127..255).to_a
+
     # 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)
+    # 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]]"
+    #     pdf_object(true)      #=> "true"
+    #     pdf_object(false)     #=> "false"
+    #     pdf_object(1.2124)    #=> "1.2124"
+    #     pdf_object('foo bar') #=> "(foo bar)"
+    #     pdf_object(:Symbol)   #=> "/Symbol"
+    #     pdf_object(['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"
+    def pdf_object(obj, in_content_stream = false)
+      case obj
+      when NilClass   then 'null'
+      when TrueClass  then 'true'
+      when FalseClass then 'false'
       when Numeric
-        obj = real(obj) unless obj.kind_of?(Integer)
+        obj = real(obj) unless obj.is_a?(Integer)
 
-        String(obj) # NOTE: this can fail on huge floating point numbers,
-                    # but it seems unlikely to ever happen in practice.
+        # NOTE: this can fail on huge floating point numbers, but it seems
+        # unlikely to ever happen in practice.
+        num_string = String(obj)
+
+        # Truncate trailing fraction zeroes
+        num_string.sub(/(\d*)((\.0*$)|(\.0*[1-9]*)0*$)/, '\1\4')
       when Array
-        "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
+        "[#{obj.map { |e| pdf_object(e, in_content_stream) }.join(' ')}]"
       when PDF::Core::LiteralString
-        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
+        obj = obj.gsub(/[\\\n\r\t\b\f()]/) { |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 = "#{obj.strftime('D:%Y%m%d%H%M%S%z').chop.chop}'00'"
+        obj = obj.gsub(/[\\\n\r\t\b\f()]/) { |m| "\\#{m}" }
         "(#{obj})"
       when PDF::Core::ByteString
-        "<" << obj.unpack("H*").first << ">"
+        "<#{obj.unpack1('H*')}>"
       when String
         obj = utf8_to_utf16(obj) unless in_content_stream
-        "<" << 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
-          else
-            [n].pack("C*")
-          end
-         }.join
+        "<#{string_to_hex(obj)}>"
+      when Symbol
+        name_string =
+          obj.to_s.unpack('C*').map do |n|
+            if ESCAPED_NAME_CHARACTERS.include?(n)
+              "##{n.to_s(16).upcase}"
+            else
+              [n].pack('C*')
+            end
+          end.join
+        "/#{name_string}"
       when ::Hash
-        output = "<< "
-        obj.each do |k,v|
-          unless String === k || Symbol === k
+        output = +'<< '
+        obj.each do |k, v|
+          unless k.is_a?(String) || k.is_a?(Symbol)
             raise PDF::Core::Errors::FailedObjectConversion,
-              "A PDF Dictionary must be keyed by names"
+              'A PDF Dictionary must be keyed by names'
           end
-          output << PdfObject(k.to_sym, in_content_stream) << " " <<
-                    PdfObject(v, in_content_stream) << "\n"
+          output << pdf_object(k.to_sym, in_content_stream) << ' ' <<
+            pdf_object(v, in_content_stream) << "\n"
         end
-        output << ">>"
+        output << '>>'
       when PDF::Core::Reference
         obj.to_s
       when PDF::Core::NameTree::Node
-        PdfObject(obj.to_hash)
+        pdf_object(obj.to_hash)
       when PDF::Core::NameTree::Value
-        PdfObject(obj.name) + " " + PdfObject(obj.value)
+        "#{pdf_object(obj.name)} #{pdf_object(obj.value)}"
       when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
-        PdfObject(obj.to_hash)
+        pdf_object(obj.to_hash)
       else
         raise PDF::Core::Errors::FailedObjectConversion,
           "This object cannot be serialized to PDF (#{obj.inspect})"

data/lib/pdf/core/reference.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # reference.rb : Implementation of PDF indirect objects
 #
@@ -6,13 +6,19 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
+require 'pdf/core/utils'
 
 module PDF
   module Core
     class Reference #:nodoc:
-
       attr_accessor :gen, :data, :offset, :stream, :identifier
 
+      class CannotAttachStream < StandardError
+        def initialize(message = 'Cannot attach stream to a non-dictionary object')
+          super
+        end
+      end
+
       def initialize(id, data)
         @identifier = id
         @gen        = 0
@@ -21,18 +27,22 @@ module PDF
       end
 
       def object
-        output = "#{@identifier} #{gen} obj\n"
-        unless @stream.empty?
-          output << PDF::Core::PdfObject(data.merge @stream.data) << "\n" << @stream.object
+        output = +"#{@identifier} #{gen} obj\n"
+        if @stream.empty?
+          output << PDF::Core.pdf_object(data) << "\n"
         else
-          output << PDF::Core::PdfObject(data) << "\n"
+          output << PDF::Core.pdf_object(data.merge(@stream.data)) <<
+            "\n" << @stream.object
         end
 
         output << "endobj\n"
       end
 
       def <<(io)
-        raise "Cannot attach stream to non-dictionary object" unless @data.is_a?(::Hash)
+        unless @data.is_a?(::Hash)
+          raise CannotAttachStream
+        end
+
         (@stream ||= Stream.new) << io
       end
 
@@ -43,22 +53,22 @@ module PDF
       # 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=[])
+      def deep_copy(share = [])
         r = dup
 
         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]))
+            r.data[k] = Utils.deep_clone(r.data[k])
           end
         when PDF::Core::NameTree::Node
           r.data = r.data.deep_copy
         else
-          r.data = Marshal.load(Marshal.dump(r.data))
+          r.data = Utils.deep_clone(r.data)
         end
 
-        r.stream = Marshal.load(Marshal.dump(r.stream))
+        r.stream = Utils.deep_clone(r.stream)
         r
       end
 
@@ -68,11 +78,5 @@ module PDF
         @stream = other_ref.stream
       end
     end
-
-    module_function
-
-    def Reference(*args, &block) #:nodoc:
-      Reference.new(*args, &block)
-    end
   end
 end

data/lib/pdf/core/renderer.rb

@@ -1,4 +1,6 @@
-require "stringio"
+# frozen_string_literal: true
+
+require 'stringio'
 
 module PDF
   module Core
@@ -6,7 +8,7 @@ module PDF
       def initialize(state)
         @state = state
         @state.populate_pages_from_store(self)
-        
+
         min_version(state.store.min_version) if state.store.min_version
 
         @page_number = 0
@@ -14,8 +16,8 @@ module PDF
 
       attr_reader :state
 
-      # Creates a new Reference and adds it to the Document's object
-      # list.  The +data+ argument is anything that Prawn::PdfObject() can convert.
+      # Creates a new Reference and adds it to the Document's object list.  The
+      # +data+ argument is anything that Prawn.pdf_object() can convert.
       #
       # Returns the identifier which points to the reference in the ObjectStore
       #
@@ -50,7 +52,7 @@ module PDF
       #
       #  pdf.add_content("#{PDF::Core.real_params([x1, y1])} m")   # move
       #  pdf.add_content("#{PDF::Core.real_params([ x2, y2 ])} l") # draw path
-      #  pdf.add_content("S") # stroke
+      #  pdf.add_content('S') # stroke
       #
       def add_content(str)
         save_graphics_state if graphic_state.nil?
@@ -62,7 +64,7 @@ module PDF
       # dictionary do not incur the additional overhead.
       #
       def names
-        state.store.root.data[:Names] ||= ref!(:Type => :Names)
+        state.store.root.data[:Names] ||= ref!(Type: :Names)
       end
 
       # Returns true if the Names dictionary is in use for this document.
@@ -80,29 +82,36 @@ module PDF
       # Defines a block to be called just before a new page is started.
       #
       def on_page_create(&block)
-         if block_given?
-            state.on_page_create_callback = block
-         else
-            state.on_page_create_callback = nil
-         end
+        state.on_page_create_callback =
+          if block_given?
+            block
+          end
       end
 
       def start_new_page(options = {})
-        if last_page = state.page
+        last_page = state.page
+        if last_page
           last_page_size    = last_page.size
           last_page_layout  = last_page.layout
           last_page_margins = last_page.margins
         end
 
-        page_options = {:size => options[:size] || last_page_size,
-                        :layout  => options[:layout] || last_page_layout,
-                        :margins => last_page_margins}
+        page_options = {
+          size: options[:size] || last_page_size,
+          layout: options[:layout] || last_page_layout,
+          margins: last_page_margins
+        }
         if last_page
-          new_graphic_state = last_page.graphic_state.dup  if last_page.graphic_state
+          if last_page.graphic_state
+            new_graphic_state = last_page.graphic_state.dup
+          end
 
-          #erase the color space so that it gets reset on new page for fussy pdf-readers
-          new_graphic_state.color_space = {} if new_graphic_state
-          page_options.merge!(:graphic_state => new_graphic_state)
+          # Erase the color space so that it gets reset on new page for fussy
+          # pdf-readers
+          if new_graphic_state
+            new_graphic_state.color_space = {}
+          end
+          page_options[:graphic_state] = new_graphic_state
         end
 
         state.page = PDF::Core::Page.new(self, page_options)
@@ -121,10 +130,10 @@ module PDF
       # draw on it.
       #
       # See Prawn::Document#number_pages for a sample usage of this capability.
-      
-      def go_to_page(k)
-        @page_number = k
-        state.page = state.pages[k-1]
+
+      def go_to_page(page_number)
+        @page_number = page_number
+        state.page = state.pages[page_number - 1]
       end
 
       def finalize_all_page_contents
@@ -161,18 +170,16 @@ module PDF
         if output.instance_of?(StringIO)
           str = output.string
           str.force_encoding(::Encoding::ASCII_8BIT)
-          return str
-        else
-          return nil
+          str
         end
       end
 
       # Renders the PDF document to file.
       #
-      #   pdf.render_file "foo.pdf"
+      #   pdf.render_file 'foo.pdf'
       #
       def render_file(filename)
-        File.open(filename, "wb") { |f| render(f) }
+        File.open(filename, 'wb') { |f| render(f) }
       end
 
       # Write out the PDF Header, as per spec 3.4.1
@@ -201,7 +208,7 @@ module PDF
         output << "0 #{state.store.size + 1}\n"
         output << "0000000000 65535 f \n"
         state.store.each do |ref|
-          output.printf("%010d", ref.offset)
+          output.printf('%<offset>010d', offset: ref.offset)
           output << " 00000 n \n"
         end
       end
@@ -209,24 +216,26 @@ module PDF
       # Write out the PDF Trailer, as per spec 3.4.4
       #
       def render_trailer(output)
-        trailer_hash = {:Size => state.store.size + 1,
-                        :Root => state.store.root,
-                        :Info => state.store.info}
+        trailer_hash = {
+          Size: state.store.size + 1,
+          Root: state.store.root,
+          Info: state.store.info
+        }
         trailer_hash.merge!(state.trailer) if state.trailer
 
         output << "trailer\n"
-        output << PDF::Core::PdfObject(trailer_hash) << "\n"
+        output << PDF::Core.pdf_object(trailer_hash) << "\n"
         output << "startxref\n"
         output << @xref_offset << "\n"
-        output << "%%EOF" << "\n"
+        output << '%%EOF' << "\n"
       end
 
       def open_graphics_state
-        add_content "q"
+        add_content 'q'
       end
 
       def close_graphics_state
-        add_content "Q"
+        add_content 'Q'
       end
 
       def save_graphics_state(graphic_state = nil)
@@ -242,7 +251,7 @@ module PDF
       # false otherwise
       #
       def compression_enabled?
-        !!state.compress
+        state.compress
       end
 
       # Pops the last saved graphics state off the graphics state stack and