pdf-reader 2.14.0 → 2.15.0

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,11 +57,13 @@ class PDF::Reader
 
       private
 
+      #: (Integer) -> bool
       def control_character?(code_point)
         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.to_s

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

@@ -12,11 +12,15 @@ 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
 

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

@@ -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 fd = @font.font_descriptor
-          @missing_width = fd.missing_width
+          @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,6 +27,7 @@ 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
 
@@ -38,6 +41,7 @@ class PDF::Reader
         end
       end
 
+      #: (Integer) -> Numeric?
       def glyph_width_from_descriptor(code_point)
         # true type fonts will have most of their information contained
         # with-in a program inside the font descriptor, however the widths

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

@@ -7,16 +7,18 @@ 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 fd = @font.font_descriptor
-          @missing_width = fd.missing_width
+          @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

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

@@ -11,10 +11,12 @@ class PDF::Reader
     # the descendant font
     class TypeZero
 
+      #: (PDF::Reader::Font) -> void
       def initialize(font)
         @font = font
       end
 
+      #: (Integer?) -> Numeric
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 

data/lib/pdf/reader/xref.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -46,8 +46,11 @@ class PDF::Reader
   # the Enumerable mixin. The key difference is no []= method - the hash
   # is read only.
   #
+  #: [Elem]
   class XRef
     include Enumerable
+
+    #: Hash[Symbol, untyped]
     attr_reader :trailer
 
     ################################################################################
@@ -55,16 +58,19 @@ class PDF::Reader
     #
     # io - must be an IO object, generally either a file or a StringIO
     #
+    #: (IO | Tempfile | StringIO) -> void
     def initialize(io)
       @io = io
-      @junk_offset = calc_junk_offset(io) || 0
-      @xref = {}
-      @trailer = load_offsets
+      @junk_offset = calc_junk_offset(io) || 0 #: Integer
+      @xref = {} #: Hash[Integer, Hash[Integer, Integer | PDF::Reader::Reference]]
+      @trailer = load_offsets #: Hash[Symbol, untyped]
     end
 
     ################################################################################
     # return the number of objects in this file. Objects with multiple generations are
     # only counter once.
+    #
+    #: () -> untyped
     def size
       @xref.size
     end
@@ -72,6 +78,7 @@ class PDF::Reader
     # returns the byte offset for the specified PDF object.
     #
     # ref - a PDF::Reader::Reference object containing an object ID and revision number
+    #: (untyped) -> untyped
     def [](ref)
       @xref.fetch(ref.id, {}).fetch(ref.gen)
     rescue
@@ -79,6 +86,9 @@ class PDF::Reader
     end
     ################################################################################
     # iterate over each object in the xref table
+    #
+    # @override(allow_incompatible: true)
+    #: () { (PDF::Reader::Reference) -> untyped } -> void
     def each(&block)
       ids = @xref.keys.sort
       ids.each do |id|
@@ -97,6 +107,7 @@ class PDF::Reader
     # After seeking to the offset, processing is handed of to either load_xref_table()
     # or load_xref_stream() based on what we find there.
     #
+    #: (?Integer?) -> Hash[Symbol, untyped]
     def load_offsets(offset = nil)
       offset ||= new_buffer.find_first_xref_offset
       offset += @junk_offset
@@ -117,7 +128,9 @@ class PDF::Reader
         # to handle the case where an XRef Stream has the Length specified via an
         # indirect object
         stream = PDF::Reader::Parser.new(buf).object(tok_one.to_i, tok_two.to_i)
-        return load_xref_stream(stream)
+        if stream.is_a?(PDF::Reader::Stream)
+          return load_xref_stream(stream)
+        end
       end
 
       raise PDF::Reader::MalformedPDFError,
@@ -126,6 +139,8 @@ class PDF::Reader
     ################################################################################
     # Assumes the underlying buffer is positioned at the start of a traditional
     # Xref table and processes it into memory.
+    #
+    #: (PDF::Reader::Buffer) -> Hash[Symbol, untyped]
     def load_xref_table(buf)
       params = []
 
@@ -169,8 +184,9 @@ class PDF::Reader
     ################################################################################
     # Read an XRef stream from the underlying buffer instead of a traditional xref table.
     #
+    #: (PDF::Reader::Stream) -> Hash[Symbol, untyped]
     def load_xref_stream(stream)
-      unless stream.is_a?(PDF::Reader::Stream) && stream.hash[:Type] == :XRef
+      unless stream.hash[:Type] == :XRef
         raise PDF::Reader::MalformedPDFError, "xref stream not found when expected"
       end
       trailer = Hash[stream.hash.select { |key, value|
@@ -216,8 +232,9 @@ class PDF::Reader
     # XRef streams pack info into integers 1-N bytes wide. Depending on the number of
     # bytes they need to be converted to an int in different ways.
     #
+    #: (String?) -> Integer
     def unpack_bytes(bytes)
-      if bytes.to_s.size == 0
+      res = if bytes.nil? || bytes == ""
         0
       elsif bytes.size == 1
         bytes.unpack("C")[0]
@@ -232,6 +249,7 @@ class PDF::Reader
       else
         raise UnsupportedFeatureError, "Unable to unpack xref stream entries of #{bytes.size} bytes"
       end
+      TypeCheck.cast_to_int!(res)
     end
     ################################################################################
     # Wrap the io stream we're working with in a buffer that can tokenise it for us.
@@ -239,12 +257,14 @@ class PDF::Reader
     # We create multiple buffers so we can be tokenising multiple sections of the file
     # at the same time without worrying about clearing the buffers contents.
     #
+    #: (?Integer) -> PDF::Reader::Buffer
     def new_buffer(offset = 0)
       PDF::Reader::Buffer.new(@io, :seek => offset)
     end
     ################################################################################
     # Stores an offset value for a particular PDF object ID and revision number
     #
+    #: (Integer, Integer, Integer | PDF::Reader::Reference) -> (Integer | PDF::Reader::Reference)
     def store(id, gen, offset)
       (@xref[id] ||= {})[gen] ||= offset
     end
@@ -258,6 +278,7 @@ class PDF::Reader
     # Adobe PDF 1.4 spec (3.4.1) 12. Acrobat viewers require only that the
     # header appear somewhere within the first 1024 bytes of the file
     #
+    #: (IO | Tempfile | StringIO) -> Integer?
     def calc_junk_offset(io)
       io.rewind
       offset = io.pos

data/lib/pdf/reader/zero_width_runs_filter.rb

@@ -6,6 +6,7 @@ class PDF::Reader
   # There's no point rendering zero-width characters
   class ZeroWidthRunsFilter
 
+    #: (Array[PDF::Reader::TextRun]) -> Array[PDF::Reader::TextRun]
     def self.exclude_zero_width_runs(runs)
       runs.reject { |run| run.width == 0 }
     end

data/lib/pdf/reader.rb

@@ -95,6 +95,7 @@ module PDF
   class Reader
 
     # lowlevel hash-like access to all objects in the underlying PDF
+    #: PDF::Reader::ObjectHash
     attr_reader :objects
 
     # creates a new document reader for the provided PDF.
@@ -115,14 +116,18 @@ module PDF
     # Using this method directly is supported, but it's more common to use
     # `PDF::Reader.open`
     #
+    #: (String | Tempfile | IO | StringIO, ?Hash[untyped, untyped]) -> void
     def initialize(input, opts = {})
-      @cache   = PDF::Reader::ObjectCache.new
+      @cache   = PDF::Reader::ObjectCache.new #: PDF::Reader::ObjectCache
       opts.merge!(:cache => @cache)
-      @objects = PDF::Reader::ObjectHash.new(input, opts)
+      @objects = PDF::Reader::ObjectHash.new(input, opts) #: PDF::Reader::ObjectHash
+      @page_count = nil #: Integer | nil
+      @root = nil #: Hash[Symbol, untyped] | nil
     end
 
     # Return a Hash with some basic information about the PDF file
     #
+    #: () -> Hash[untyped, untyped]?
     def info
       dict = @objects.deref_hash(@objects.trailer[:Info]) || {}
       doc_strings_to_utf8(dict)
@@ -131,6 +136,7 @@ module PDF
     # Return a String with extra XML metadata provided by the author of the PDF file. Not
     # always present.
     #
+    #: () -> String?
     def metadata
       stream = @objects.deref_stream(root[:Metadata])
       if stream.nil?
@@ -144,6 +150,7 @@ module PDF
 
     # To number of pages in this PDF
     #
+    #: () -> Integer
     def page_count
       pages = @objects.deref_hash(root[:Pages])
       unless pages.kind_of?(::Hash)
@@ -154,6 +161,7 @@ module PDF
 
     # The PDF version this file uses
     #
+    #: () -> Float
     def pdf_version
       @objects.pdf_version
     end
@@ -171,6 +179,7 @@ module PDF
     #     puts reader.pdf_version
     #   end
     #
+    #: (String | Tempfile | IO, ?Hash[untyped, untyped]) { (PDF::Reader) -> void } -> untyped
     def self.open(input, opts = {}, &block)
       yield PDF::Reader.new(input, opts)
     end
@@ -189,6 +198,7 @@ module PDF
     # See the docs for PDF::Reader::Page to read more about the
     # methods available on each page
     #
+    #: () -> Array[PDF::Reader::Page]
     def pages
       return [] if page_count <= 0
 
@@ -213,6 +223,7 @@ module PDF
     # See the docs for PDF::Reader::Page to read more about the
     # methods available on each page
     #
+    #: (Integer) -> PDF::Reader::Page
     def page(num)
       num = num.to_i
       if num < 1 || num > self.page_count
@@ -225,6 +236,7 @@ module PDF
 
     # recursively convert strings from outside a content stream into UTF-8
     #
+    #: (untyped) -> untyped
     def doc_strings_to_utf8(obj)
       case obj
       when ::Hash then
@@ -246,6 +258,7 @@ module PDF
       end
     end
 
+    #: (String) -> bool
     def has_utf16_bom?(str)
       first_bytes = str[0,2]
 
@@ -256,6 +269,7 @@ module PDF
 
     # TODO find a PDF I can use to spec this behaviour
     #
+    #: (String) -> String
     def pdfdoc_to_utf8(obj)
       obj.force_encoding("utf-8")
       obj
@@ -264,6 +278,7 @@ module PDF
     # one day we'll all run on a 1.9 compatible VM and I can just do this with
     # String#encode
     #
+    #: (String) -> String
     def utf16_to_utf8(obj)
       str = obj[2, obj.size].to_s
       str = str.unpack("n*").pack("U*")
@@ -271,6 +286,7 @@ module PDF
       str
     end
 
+    #: () -> Hash[Symbol, untyped]
     def root
       @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {}
     end