pdf-reader 2.9.2 → 2.15.0

data/lib/pdf/reader/transformation_matrix.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -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,7 +75,8 @@ class PDF::Reader
     #       displacement to speed up processing documents that use vertical
     #       writing systems
     #
-    def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil)
+    #: (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
         self
@@ -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,13 +192,14 @@ 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) + (0 * e2)
-      newb = (@a * b2) + (@b * d2) + (0 * f2)
-      newc = (@c * a2) + (@d * c2) + (0 * e2)
-      newd = (@c * b2) + (@d * d2) + (0 * f2)
-      newe = (@e * a2) + (@f * c2) + (1 * e2)
-      newf = (@e * b2) + (@f * d2) + (1 * f2)
+      newa = (@a * a2) + (@b * c2) + (e2 * 0)
+      newb = (@a * b2) + (@b * d2) + (f2 * 0)
+      newc = (@c * a2) + (@d * c2) + (e2 * 0)
+      newd = (@c * b2) + (@d * d2) + (f2 * 0)
+      newe = (@e * a2) + (@f * c2) + (e2 * 1)
+      newf = (@e * b2) + (@f * d2) + (f2 * 1)
       @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
     end
 
@@ -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,20 @@ module PDF
     #
     class TypeCheck
 
+      #: (untyped) -> Integer
+      def self.cast_to_int!(obj)
+        if obj.is_a?(Integer)
+          obj
+        elsif obj.nil?
+          0
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "Unable to cast to integer"
+        end
+      end
+
+      #: (untyped) -> Numeric
       def self.cast_to_numeric!(obj)
         if obj.is_a?(Numeric)
           obj
@@ -23,6 +37,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> String
       def self.cast_to_string!(string)
         if string.is_a?(String)
           string
@@ -35,6 +50,7 @@ module PDF
         end
       end
 
+      #: (untyped) -> Symbol | nil
       def self.cast_to_symbol(obj)
         if obj.is_a?(Symbol)
           obj
@@ -46,6 +62,43 @@ module PDF
           raise MalformedPDFError, "Unable to cast to symbol"
         end
       end
+
+      #: (untyped) -> Symbol
+      def self.cast_to_symbol!(obj)
+        res = cast_to_symbol(obj)
+        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
+        elsif obj.respond_to?(:to_h)
+          obj.to_h
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        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
+          obj.each do |k, v|
+            raise MalformedPDFError, "Expected a stream" unless v.is_a?(PDF::Reader::Stream)
+            result[cast_to_symbol!(k)] = v
+          end
+          result
+        elsif obj.respond_to?(:to_h)
+          cast_to_pdf_dict_with_stream_values!(obj.to_h)
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        end
+      end
     end
   end
 end

data/lib/pdf/reader/unimplemented_security_handler.rb

@@ -7,10 +7,12 @@ class PDF::Reader
   # Security handler for when we don't support the flavour of encryption
   # used in a PDF.
   class UnimplementedSecurityHandler
+    #: (Hash[Symbol, untyped]) -> bool
     def self.supports?(encrypt)
       true
     end
 
+    #: (String, PDF::Reader::Reference) -> String
     def decrypt(buf, ref)
       raise PDF::Reader::EncryptedPDFError, "Unsupported encryption style"
     end

data/lib/pdf/reader/validating_receiver.rb

@@ -16,10 +16,12 @@ module PDF
     # Not all operators have type safety implemented yet, but we can expand the number over time.
     class ValidatingReceiver
 
+      #: (untyped) -> void
       def initialize(wrapped)
         @wrapped = wrapped
       end
 
+      #: (PDF::Reader::Page) -> void
       def page=(page)
         call_wrapped(:page=, page)
       end
@@ -27,10 +29,12 @@ module PDF
       #####################################################
       # Graphics State Operators
       #####################################################
+      #: (*untyped) -> void
       def save_graphics_state(*args)
         call_wrapped(:save_graphics_state)
       end
 
+      #: (*untyped) -> void
       def restore_graphics_state(*args)
         call_wrapped(:restore_graphics_state)
       end
@@ -39,6 +43,7 @@ module PDF
       # Matrix Operators
       #####################################################
 
+      #: (*untyped) -> void
       def concatenate_matrix(*args)
         a, b, c, d, e, f = *args
         call_wrapped(
@@ -56,10 +61,12 @@ module PDF
       # Text Object Operators
       #####################################################
 
+      #: (*untyped) -> void
       def begin_text_object(*args)
         call_wrapped(:begin_text_object)
       end
 
+      #: (*untyped) -> void
       def end_text_object(*args)
         call_wrapped(:end_text_object)
       end
@@ -67,6 +74,7 @@ module PDF
       #####################################################
       # Text State Operators
       #####################################################
+      #: (*untyped) -> void
       def set_character_spacing(*args)
         char_spacing, _ = *args
         call_wrapped(
@@ -75,6 +83,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_horizontal_text_scaling(*args)
         h_scaling, _ = *args
         call_wrapped(
@@ -83,6 +92,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_text_font_and_size(*args)
         label, size, _ = *args
         call_wrapped(
@@ -92,6 +102,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_text_leading(*args)
         leading, _ = *args
         call_wrapped(
@@ -100,6 +111,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_text_rendering_mode(*args)
         mode, _ = *args
         call_wrapped(
@@ -108,6 +120,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_text_rise(*args)
         rise, _ = *args
         call_wrapped(
@@ -116,6 +129,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_word_spacing(*args)
         word_spacing, _ = *args
         call_wrapped(
@@ -128,6 +142,7 @@ module PDF
       # Text Positioning Operators
       #####################################################
 
+      #: (*untyped) -> void
       def move_text_position(*args) # Td
         x, y, _ = *args
         call_wrapped(
@@ -137,6 +152,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def move_text_position_and_set_leading(*args) # TD
         x, y, _ = *args
         call_wrapped(
@@ -146,6 +162,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_text_matrix_and_text_line_matrix(*args) # Tm
         a, b, c, d, e, f = *args
         call_wrapped(
@@ -159,6 +176,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def move_to_start_of_next_line(*args) # T*
         call_wrapped(:move_to_start_of_next_line)
       end
@@ -166,6 +184,7 @@ module PDF
       #####################################################
       # Text Showing Operators
       #####################################################
+      #: (*untyped) -> void
       def show_text(*args) # Tj (AWAY)
         string, _ = *args
         call_wrapped(
@@ -174,6 +193,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def show_text_with_positioning(*args) # TJ [(A) 120 (WA) 20 (Y)]
         params, _ = *args
         unless params.is_a?(Array)
@@ -186,6 +206,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def move_to_next_line_and_show_text(*args) # '
         string, _ = *args
         call_wrapped(
@@ -194,6 +215,7 @@ module PDF
         )
       end
 
+      #: (*untyped) -> void
       def set_spacing_next_line_show_text(*args) # "
         aw, ac, string = *args
         call_wrapped(
@@ -208,6 +230,7 @@ module PDF
       # Form XObject Operators
       #####################################################
 
+      #: (*untyped) -> void
       def invoke_xobject(*args)
         label, _ = *args
 
@@ -221,16 +244,19 @@ module PDF
       # Inline Image Operators
       #####################################################
 
+      #: (*untyped) -> void
       def begin_inline_image(*args)
         call_wrapped(:begin_inline_image)
       end
 
+      #: (*untyped) -> void
       def begin_inline_image_data(*args)
         # We can't use call_wrapped() here because sorbet won't allow splat args with a dynamic
         # number of elements
         @wrapped.begin_inline_image_data(*args) if @wrapped.respond_to?(:begin_inline_image_data)
       end
 
+      #: (*untyped) -> void
       def end_inline_image(*args)
         data, _ = *args
 
@@ -244,16 +270,19 @@ module PDF
       # Final safety net for any operators that don't have type checking enabled yet
       #####################################################
 
+      #: (untyped) -> bool
       def respond_to?(meth)
         @wrapped.respond_to?(meth)
       end
 
+      #: (Symbol, *untyped) -> void
       def method_missing(methodname, *args)
         @wrapped.send(methodname, *args)
       end
 
       private
 
+      #: (untyped, *untyped) -> void
       def call_wrapped(methodname, *args)
         @wrapped.send(methodname, *args) if @wrapped.respond_to?(methodname)
       end

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'afm'
@@ -12,6 +12,7 @@ class PDF::Reader
     # the reader is expected to have it's own copy of the font metrics.
     # see Section 9.6.2.2, PDF 32000-1:2008, pp 256
     class BuiltIn
+      @@all_metrics = nil #: PDF::Reader::SynchronizedCache | nil
 
       BUILTINS = [
         :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
@@ -19,11 +20,13 @@ class PDF::Reader
         :Symbol,
         :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
         :ZapfDingbats
-      ]
+      ] #: Array[Symbol]
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
         @@all_metrics ||= PDF::Reader::SynchronizedCache.new
+        @metrics = nil #: AFM::Font?
 
         basefont = extract_basefont(font.basefont)
         metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{basefont}.afm")
@@ -35,8 +38,10 @@ class PDF::Reader
         end
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
-        return 0 if code_point.nil? || code_point < 0
+        return 0 if code_point.nil? || code_point < 0 || @metrics.nil?
+
 
         names = @font.encoding.int_to_name(code_point)
         metrics = names.map { |name|
@@ -52,13 +57,16 @@ class PDF::Reader
 
       private
 
+      #: (Integer) -> bool
       def control_character?(code_point)
-        @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match = @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match ? true : false
       end
 
+      #: (Symbol?) -> String
       def extract_basefont(font_name)
         if BUILTINS.include?(font_name)
-          font_name
+          font_name.to_s
         else
           "Times-Roman"
         end

data/lib/pdf/reader/width_calculator/composite.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -12,17 +12,25 @@ class PDF::Reader
     # see Section 9.7.4.1, PDF 32000-1:2008, pp 269-270
     class Composite
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
-        @widths = PDF::Reader::CidWidths.new(@font.cid_default_width, @font.cid_widths)
+        @widths = PDF::Reader::CidWidths.new(
+          @font.cid_default_width, @font.cid_widths
+        ) #: PDF::Reader::CidWidths
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
         w = @widths[code_point]
         # 0 is a valid width
-        return w.to_f unless w.nil?
+        if w
+          w.to_f
+        else
+          0
+        end
       end
     end
   end

data/lib/pdf/reader/width_calculator/true_type.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -7,16 +7,18 @@ class PDF::Reader
     # Calculates the width of a glyph in a TrueType font
     class TrueType
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width #: Numeric
         else
           @missing_width = 0
         end
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
         glyph_width_from_font(code_point) || glyph_width_from_descriptor(code_point) || 0
@@ -25,30 +27,30 @@ class PDF::Reader
       private
 
       #TODO convert Type3 units 1000 units => 1 text space unit
+      #: (Integer) -> Numeric?
       def glyph_width_from_font(code_point)
         return if @font.widths.nil? || @font.widths.count == 0
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char && @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end
       end
 
+      #: (Integer) -> Numeric?
       def glyph_width_from_descriptor(code_point)
-        return unless @font.font_descriptor
-
         # true type fonts will have most of their information contained
         # with-in a program inside the font descriptor, however the widths
         # may not be in standard PDF glyph widths (1000 units => 1 text space unit)
         # so this width will need to be scaled
-        w = @font.font_descriptor.glyph_width(code_point)
-        if w
-          w.to_f * @font.font_descriptor.glyph_to_pdf_scale_factor
-        else
-          nil
+        if fd = @font.font_descriptor
+          if w = fd.glyph_width(code_point)
+            w.to_f * fd.glyph_to_pdf_scale_factor.to_f
+          end
         end
       end
     end

data/lib/pdf/reader/width_calculator/type_one_or_three.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -7,24 +7,27 @@ class PDF::Reader
     # Calculates the width of a glyph in a Type One or Type Three
     class TypeOneOrThree
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width #: Numeric
         else
           @missing_width = 0
         end
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
         return 0 if @font.widths.nil? || @font.widths.count == 0
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end

data/lib/pdf/reader/width_calculator/type_zero.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -11,15 +11,20 @@ class PDF::Reader
     # the descendant font
     class TypeZero
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
-        @descendant_font = @font.descendantfonts.first
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        @descendant_font.glyph_width(code_point).to_f
+        if descendant_font = @font.descendantfonts.first
+          descendant_font.glyph_width(code_point).to_f
+        else
+          0
+        end
       end
     end
   end