pdf-reader 2.14.0 → 2.15.0

data/lib/pdf/reader/reference.rb

@@ -31,26 +31,34 @@ class PDF::Reader
   ################################################################################
   # An internal PDF::Reader class that represents an indirect reference to a PDF Object
   class Reference
+    #: Integer
     attr_reader :id
+
+    #: Integer
     attr_reader :gen
     ################################################################################
     # Create a new Reference to an object with the specified id and revision number
+    #: (Integer, Integer) -> void
     def initialize(id, gen)
-      @id, @gen = id, gen
+      @id = id
+      @gen = gen
     end
     ################################################################################
     # returns the current Reference object in an array with a single element
+    #: () -> Array[PDF::Reader::Reference]
     def to_a
       [self]
     end
     ################################################################################
     # returns the ID of this reference. Use with caution, ignores the generation id
+    #: () -> Integer
     def to_i
       self.id
     end
     ################################################################################
     # returns true if the provided object points to the same PDF Object as the
     # current object
+    #: (Object) -> bool
     def ==(obj)
       return false unless obj.kind_of?(PDF::Reader::Reference)
 
@@ -61,6 +69,7 @@ class PDF::Reader
     # returns a hash based on the PDF::Reference this object points to. Two
     # different Reference objects that point to the same PDF Object will
     # return an identical hash
+    #: () -> Integer
     def hash
       "#{self.id}:#{self.gen}".hash
     end

data/lib/pdf/reader/register_receiver.rb

@@ -22,45 +22,55 @@ class PDF::Reader
   #
   class RegisterReceiver
 
+    #: Array[Hash[Symbol, untyped]]
     attr_accessor :callbacks
 
+    #: () -> void
     def initialize
-      @callbacks = []
+      @callbacks = [] #: Array[Hash[Symbol, untyped]]
     end
 
+    #: (untyped) -> bool
     def respond_to?(meth)
       true
     end
 
+    #: (Symbol, *untyped) -> void
     def method_missing(methodname, *args)
       callbacks << {:name => methodname.to_sym, :args => args}
     end
 
     # count the number of times a callback fired
+    #: (Symbol) -> Integer
     def count(methodname)
       callbacks.count { |cb| cb[:name] == methodname}
     end
 
     # return the details for every time the specified callback was fired
+    #: (Symbol) -> Array[Hash[Symbol, untyped]]
     def all(methodname)
       callbacks.select { |cb| cb[:name] == methodname }
     end
 
+    #: (Symbol) -> Array[Array[untyped]]
     def all_args(methodname)
       all(methodname).map { |cb| cb[:args] }
     end
 
     # return the details for the first time the specified callback was fired
+    #: (Symbol) -> Hash[Symbol, untyped]?
     def first_occurance_of(methodname)
       callbacks.find { |cb| cb[:name] == methodname }
     end
 
     # return the details for the final time the specified callback was fired
+    #: (Symbol) -> Hash[Symbol, untyped]?
     def final_occurance_of(methodname)
       all(methodname).last
     end
 
     # return the first occurance of a particular series of callbacks
+    #: (*Symbol) -> Array[Hash[Symbol, untyped]]?
     def series(*methods)
       return nil if methods.empty?
 
@@ -70,7 +80,10 @@ class PDF::Reader
       indexes.each do |idx|
         count = methods.size
         method_indexes.each do |midx|
-          count -= 1 if callbacks[idx+midx] && callbacks[idx+midx][:name] == methods[midx]
+          res = callbacks[idx+midx]
+          if res && res[:name] == methods[midx]
+            count -= 1
+          end
         end
         if count == 0
           return callbacks[idx, methods.size]

data/lib/pdf/reader/resources.rb

@@ -9,6 +9,7 @@ module PDF
     #
     class Resources
 
+      #: (PDF::Reader::ObjectHash, Hash[untyped, untyped]) -> void
       def initialize(objects, resources)
         @objects = objects
         @resources = resources
@@ -20,6 +21,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def color_spaces
         @objects.deref_hash!(@resources[:ColorSpace]) || {}
       end
@@ -30,6 +32,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def fonts
         @objects.deref_hash!(@resources[:Font]) || {}
       end
@@ -41,6 +44,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def graphic_states
         @objects.deref_hash!(@resources[:ExtGState]) || {}
       end
@@ -51,6 +55,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def patterns
         @objects.deref_hash!(@resources[:Pattern]) || {}
       end
@@ -61,6 +66,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Array[Symbol]
       def procedure_sets
         @objects.deref_array!(@resources[:ProcSet]) || []
       end
@@ -71,6 +77,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def properties
         @objects.deref_hash!(@resources[:Properties]) || {}
       end
@@ -81,6 +88,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, untyped]
       def shadings
         @objects.deref_hash!(@resources[:Shading]) || {}
       end
@@ -91,6 +99,7 @@ module PDF
       #       with no caching. You will want to cache the results instead
       #       of calling it over and over.
       #
+      #: () -> Hash[Symbol, PDF::Reader::Stream]
       def xobjects
         dict = @objects.deref_hash!(@resources[:XObject]) || {}
         TypeCheck.cast_to_pdf_dict_with_stream_values!(dict)

data/lib/pdf/reader/security_handler_factory.rb

@@ -7,6 +7,13 @@ class PDF::Reader
   # able to decrypt the file.
   class SecurityHandlerFactory
 
+    #: (Hash[Symbol, untyped], Array[untyped] | nil, String | nil) -> (
+    #|   NullSecurityHandler |
+    #|   AesV2SecurityHandler |
+    #|   Rc4SecurityHandler |
+    #|   AesV3SecurityHandler |
+    #|   UnimplementedSecurityHandler
+    #| )
     def self.build(encrypt, doc_id, password)
       doc_id   ||= []
       password ||= ""
@@ -22,6 +29,9 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped], Array[untyped], String) -> (
+    #|    AesV2SecurityHandler | Rc4SecurityHandler
+    #| )
     def self.build_standard_handler(encrypt, doc_id, password)
       encmeta = !encrypt.has_key?(:EncryptMetadata) || encrypt[:EncryptMetadata].to_s == "true"
       key_builder = StandardKeyBuilder.new(
@@ -41,6 +51,7 @@ class PDF::Reader
       end
     end
 
+    #: (Hash[Symbol, untyped], Array[untyped], String) -> (AesV3SecurityHandler)
     def self.build_v5_handler(encrypt, doc_id, password)
       key_builder = KeyBuilderV5.new(
         owner_key: encrypt[:O],
@@ -52,6 +63,7 @@ class PDF::Reader
     end
 
     # This handler supports all encryption that follows upto PDF 1.5 spec (revision 4)
+    #: (Hash[Symbol, untyped]) -> bool
     def self.standard?(encrypt)
       return false if encrypt.nil?
 
@@ -65,6 +77,7 @@ class PDF::Reader
     # This handler supports both
     # - AES-256 encryption defined in PDF 1.7 Extension Level 3 ('revision 5')
     # - AES-256 encryption defined in PDF 2.0 ('revision 6')
+    #: (Hash[Symbol, untyped]) -> untyped
     def self.standard_v5?(encrypt)
       return false if encrypt.nil?
 

data/lib/pdf/reader/standard_key_builder.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 
 require 'digest/md5'
 require 'rc4'
@@ -23,16 +24,17 @@ class PDF::Reader
     PassPadBytes = [ 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
                      0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
                      0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
-                     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ]
+                     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ] #: Array[Integer]
 
+    #: (?Hash[Symbol, untyped]) -> void
     def initialize(opts = {})
-      @key_length    = opts[:key_length].to_i/8
-      @revision      = opts[:revision].to_i
-      @owner_key     = opts[:owner_key]
-      @user_key      = opts[:user_key]
-      @permissions   = opts[:permissions].to_i
-      @encryptMeta   = opts.fetch(:encrypted_metadata, true)
-      @file_id       = opts[:file_id] || ""
+      @key_length    = opts[:key_length].to_i/8 #: Integer
+      @revision      = opts[:revision].to_i #: Integer
+      @owner_key     = opts[:owner_key] #: String?
+      @user_key      = opts[:user_key] #: String?
+      @permissions   = opts[:permissions].to_i #: Integer
+      @encryptMeta   = opts.fetch(:encrypted_metadata, true) #: bool
+      @file_id       = opts[:file_id] || "" #: String
 
       if @key_length != 5 && @key_length != 16
         msg = "StandardKeyBuilder only supports 40 and 128 bit\
@@ -47,8 +49,8 @@ class PDF::Reader
     # decrypting the file will be returned. If the password doesn't match the file,
     # and exception will be raised.
     #
-    def key(pass)
-      pass ||= ""
+    #: (?String) -> String
+    def key(pass = "")
       encrypt_key   = auth_owner_pass(pass)
       encrypt_key ||= auth_user_pass(pass)
 
@@ -60,14 +62,17 @@ class PDF::Reader
 
     # Pads supplied password to 32bytes using PassPadBytes as specified on
     # pp61 of spec
+    #
+    #: (?String?) -> String
     def pad_pass(p="")
-      if p.nil? || p.empty?
-        PassPadBytes.pack('C*')
-      else
-        p[0, 32] + PassPadBytes[0, 32-p.length].pack('C*')
-      end
+      return PassPadBytes.pack('C*') if p.nil? || p.empty?
+
+      pTrimmedLength = [p.bytesize, 32].min
+      pad = PassPadBytes[0, 32 - pTrimmedLength] || []
+      p[0, 32].to_s + pad.pack('C*')
     end
 
+    #: (String, Integer) -> String
     def xor_each_byte(buf, int)
       buf.each_byte.map{ |b| b^int}.pack("C*")
     end
@@ -84,6 +89,7 @@ class PDF::Reader
     # if the supplied password is not a valid owner password for this document
     # then it returns nil
     #
+    #: (String) -> String?
     def auth_owner_pass(pass)
       md5 = Digest::MD5.digest(pad_pass(pass))
       if @revision > 2 then
@@ -92,7 +98,13 @@ class PDF::Reader
         #first iteration decrypt owner_key
         out = @owner_key
         #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
-        19.downto(0).each { |i| out=RC4.new(xor_each_byte(keyBegins,i)).decrypt(out) }
+        19.downto(0).each { |i|
+          # The RC4 gem doen't have type annotations, so the type checker doesn't
+          # know decrypt() returns a string
+          out = TypeCheck.cast_to_string!(
+            RC4.new(xor_each_byte(keyBegins,i)).decrypt(out)
+          )
+        }
       else
         out = RC4.new( md5[0, 5] ).decrypt( @owner_key )
       end
@@ -110,6 +122,7 @@ class PDF::Reader
     # if the supplied password is not a valid user password for this document
     # then it returns nil
     #
+    #: (String) -> String?
     def auth_user_pass(pass)
       keyBegins = make_file_key(pass)
       if @revision >= 3
@@ -117,28 +130,29 @@ class PDF::Reader
         out = Digest::MD5.digest(PassPadBytes.pack("C*") + @file_id)
         #zero doesn't matter -> so from 0-19
         20.times{ |i| out=RC4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
-        pass = @user_key[0, 16] == out
+        pass = @user_key.to_s[0, 16] == out
       else
         pass = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
       end
       pass ? keyBegins : nil
     end
 
+    #: (String) -> String
     def make_file_key( user_pass )
       # a) if there's a password, pad it to 32 bytes, else, just use the padding.
-      @buf  = pad_pass(user_pass)
+      buf  = pad_pass(user_pass)
       # c) add owner key
-      @buf << @owner_key
+      buf << @owner_key
       # d) add permissions 1 byte at a time, in little-endian order
-      (0..24).step(8){|e| @buf << (@permissions >> e & 0xFF)}
+      (0..24).step(8){|e| buf << (@permissions >> e & 0xFF)}
       # e) add the file ID
-      @buf << @file_id
+      buf << @file_id
       # f) if revision >= 4 and metadata not encrypted then add 4 bytes of 0xFF
       if @revision >= 4 && !@encryptMeta
-        @buf << [0xFF,0xFF,0xFF,0xFF].pack('C*')
+        buf << [0xFF,0xFF,0xFF,0xFF].pack('C*')
       end
       # b) init MD5 digest + g) finish the hash
-      md5 = Digest::MD5.digest(@buf)
+      md5 = Digest::MD5.digest(buf)
       # h) spin hash 50 times
       if @revision >= 3
         50.times {

data/lib/pdf/reader/stream.rb

@@ -34,18 +34,24 @@ class PDF::Reader
   # compression, etc) and a stream of bytes.
   #
   class Stream
-    attr_accessor :hash, :data
+    #: Hash[Symbol, untyped]
+    attr_accessor :hash
+
+    #: String
+    attr_accessor :data
 
     ################################################################################
     # Creates a new stream with the specified dictionary and data. The dictionary
     # should be a standard ruby hash, the data should be a standard ruby string.
+    #: (Hash[Symbol, untyped], String) -> void
     def initialize(hash, data)
-      @hash = TypeCheck.cast_to_pdf_dict!(hash)
+      @hash = TypeCheck.cast_to_pdf_dict!(hash) #: Hash[Symbol, untyped]
       @data = data
-      @udata = nil
+      @udata = nil #: String | nil
     end
     ################################################################################
     # apply this streams filters to its data and return the result.
+    #: () -> String
     def unfiltered_data
       return @udata if @udata
       @udata = data.dup

data/lib/pdf/reader/synchronized_cache.rb

@@ -20,13 +20,16 @@ class PDF::Reader
   # same time, we don't want to throw away thread safety We have two
   # interchangeable thread-safe cache implementations:
   class SynchronizedCache
+    #: () -> void
     def initialize
-      @cache = {}
-      @mutex = Mutex.new
+      @cache = {} #: Hash[Object, untyped]
+      @mutex = Mutex.new #: Mutex
     end
+    #: (Object) -> untyped
     def [](key)
       @mutex.synchronize { @cache[key] }
     end
+    #: (Object, (Object | nil)) -> untyped
     def []=(key,value)
       @mutex.synchronize { @cache[key] = value }
     end

data/lib/pdf/reader/text_run.rb

@@ -7,22 +7,34 @@ class PDF::Reader
   class TextRun
     include Comparable
 
+    #: PDF::Reader::Point
     attr_reader :origin
+
+    #: Numeric
     attr_reader :width
+
+    #: Numeric
     attr_reader :font_size
+
+    #: String
     attr_reader :text
 
     alias :to_s :text
 
+    #: (Numeric, Numeric, Numeric, Numeric, String) -> void
     def initialize(x, y, width, font_size, text)
-      @origin = PDF::Reader::Point.new(x, y)
+      @origin = PDF::Reader::Point.new(x, y) #: PDF::Reader::Point
       @width = width
       @font_size = font_size
       @text = text
+      @endx = nil #: Numeric | nil
+      @endy = nil #: Numeric | nil
+      @mergable_range = nil #: Range[Numeric] | nil
     end
 
     # Allows collections of TextRun objects to be sorted. They will be sorted
     # in order of their position on a cartesian plain - Top Left to Bottom Right
+    #: (PDF::Reader::Point) -> Numeric
     def <=>(other)
       if x == other.x && y == other.y
         0
@@ -34,33 +46,42 @@ class PDF::Reader
         -1
       elsif x > other.x
         1
+      else
+        0 # Unreachable?
       end
     end
 
+    #: () -> Numeric
     def x
       @origin.x
     end
 
+    #: () -> Numeric
     def y
       @origin.y
     end
 
+    #: () -> Numeric
     def endx
       @endx ||= @origin.x + width
     end
 
+    #: () -> Numeric
     def endy
       @endy ||= @origin.y + font_size
     end
 
+    #: () -> Numeric
     def mean_character_width
       @width / character_count
     end
 
+    #: (PDF::Reader::TextRun) -> bool
     def mergable?(other)
       y.to_i == other.y.to_i && font_size == other.font_size && mergable_range.include?(other.x)
     end
 
+    #: (PDF::Reader::TextRun) -> PDF::Reader::TextRun
     def +(other)
       raise ArgumentError, "#{other} cannot be merged with this run" unless mergable?(other)
 
@@ -71,16 +92,19 @@ class PDF::Reader
       end
     end
 
+    #: () -> String
     def inspect
       "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
     end
 
+    #: (PDF::Reader::TextRun) -> bool
     def intersect?(other_run)
       x <= other_run.endx && endx >= other_run.x &&
         endy >= other_run.y && y <= other_run.endy
     end
 
     # return what percentage of this text run is overlapped by another run
+    #: (PDF::Reader::TextRun) -> Numeric
     def intersection_area_percent(other_run)
       return 0 unless intersect?(other_run)
 
@@ -93,16 +117,19 @@ class PDF::Reader
 
     private
 
+    #: () -> Numeric
     def area
       (endx - x) * (endy - y)
     end
 
+    #: () -> Range[Numeric]
     def mergable_range
       @mergable_range ||= Range.new(endx - 3, endx + font_size)
     end
 
     # Assume string encoding is marked correctly and we can trust String#size to return a
     # character count
+    #: () -> Float
     def character_count
       @text.size.to_f
     end

data/lib/pdf/reader/token.rb

@@ -35,6 +35,7 @@ class PDF::Reader
   class Token < String # :nodoc:
     ################################################################################
     # Creates a new token with the specified value
+    #: (untyped) -> void
     def initialize(val)
       super
     end

data/lib/pdf/reader/transformation_matrix.rb

@@ -14,16 +14,40 @@ class PDF::Reader
   # only 6 numbers. This is important to save CPU time, memory and GC pressure
   # caused by allocating too many unnecessary objects.
   class TransformationMatrix
-    attr_reader :a, :b, :c, :d, :e, :f
+    #: Numeric
+    attr_reader :a
 
+    #: Numeric
+    attr_reader :b
+
+    #: Numeric
+    attr_reader :c
+
+    #: Numeric
+    attr_reader :d
+
+    #: Numeric
+    attr_reader :e
+
+    #: Numeric
+    attr_reader :f
+
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def initialize(a, b, c, d, e, f)
-      @a, @b, @c, @d, @e, @f = a, b, c, d, e, f
+      @a = a
+      @b = b
+      @c = c
+      @d = d
+      @e = e
+      @f = f
     end
 
+    #: () -> String
     def inspect
       "#{a}, #{b}, 0,\n#{c}, #{d}, #{0},\n#{e}, #{f}, 1"
     end
 
+    #: () -> [Numeric]
     def to_a
       [@a,@b,0,
        @c,@d,0,
@@ -51,6 +75,7 @@ class PDF::Reader
     #       displacement to speed up processing documents that use vertical
     #       writing systems
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> PDF::Reader::TransformationMatrix
     def multiply!(a,b,c, d,e,f)
       if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0
         # the identity matrix, no effect
@@ -90,6 +115,7 @@ class PDF::Reader
     #   [ 3 4 0 ] x [ 0  1 0 ]
     #   [ 5 6 1 ]   [ e2 0 1 ]
     #
+    #: (Numeric) -> void
     def horizontal_displacement_multiply!(e2)
       @e = @e + e2
     end
@@ -105,6 +131,7 @@ class PDF::Reader
     #   [ 0 1 0 ] x [ 3 4 0 ]
     #   [ 5 0 1 ]   [ 5 6 1 ]
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def horizontal_displacement_multiply_reversed!(a2,b2,c2,d2,e2,f2)
       newa = a2
       newb = b2
@@ -124,6 +151,7 @@ class PDF::Reader
     #   [ 3 4 0 ] x [ 0 5 0 ]
     #   [ 5 6 1 ]   [ 0 0 1 ]
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def xy_scaling_multiply!(a2,b2,c2,d2,e2,f2)
       newa = @a * a2
       newb = @b * d2
@@ -143,6 +171,7 @@ class PDF::Reader
     #   [ 0 5 0 ] x [ 3 4 0 ]
     #   [ 0 0 1 ]   [ 5 6 1 ]
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def xy_scaling_multiply_reversed!(a2,b2,c2,d2,e2,f2)
       newa = @a * a2
       newb = @a * b2
@@ -163,6 +192,7 @@ class PDF::Reader
     #   [ c d 0 ] x [ c d 0 ]
     #   [ e f 1 ]   [ e f 1 ]
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def regular_multiply!(a2,b2,c2,d2,e2,f2)
       newa = (@a * a2) + (@b * c2) + (e2 * 0)
       newb = (@a * b2) + (@b * d2) + (f2 * 0)
@@ -183,6 +213,7 @@ class PDF::Reader
     #   [ c d 0 ] x [ c d 0 ]
     #   [ e f 1 ]   [ e f 1 ]
     #
+    #: (Numeric, Numeric, Numeric, Numeric, Numeric, Numeric) -> void
     def faster_multiply!(a2,b2,c2, d2,e2,f2)
       newa = (@a * a2) + (@b * c2)
       newb = (@a * b2) + (@b * d2)

data/lib/pdf/reader/type_check.rb

@@ -9,6 +9,7 @@ module PDF
     #
     class TypeCheck
 
+      #: (untyped) -> Integer
       def self.cast_to_int!(obj)
         if obj.is_a?(Integer)
           obj
@@ -21,6 +22,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> Numeric
       def self.cast_to_numeric!(obj)
         if obj.is_a?(Numeric)
           obj
@@ -35,6 +37,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> String
       def self.cast_to_string!(string)
         if string.is_a?(String)
           string
@@ -47,6 +50,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> Symbol | nil
       def self.cast_to_symbol(obj)
         if obj.is_a?(Symbol)
           obj
@@ -59,15 +63,17 @@ module PDF
         end
       end
 
+      #: (untyped) -> Symbol
       def self.cast_to_symbol!(obj)
         res = cast_to_symbol(obj)
-        if res
-          res
-        else
+        if res.nil?
           raise MalformedPDFError, "Unable to cast to symbol"
+        else
+          res
         end
       end
 
+      #: (untyped) -> Hash[Symbol, untyped]
       def self.cast_to_pdf_dict!(obj)
         if obj.is_a?(Hash)
           obj
@@ -78,6 +84,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> Hash[Symbol, PDF::Reader::Stream]
       def self.cast_to_pdf_dict_with_stream_values!(obj)
         if obj.is_a?(Hash)
           result = Hash.new