pdf-reader 2.15.0 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1be615eb6abc5557e61ba53958c7211fac0f1528e75dc54eff27ffb5554d7c80
-  data.tar.gz: 875221f31dc119cd0f7ae3cc0246b3bbb70f6127c0047ec924c8030e9186b55b
+  metadata.gz: a9f0772356c29687ffafffb6af1cdc5d08ae7ac54f2d3da60d426f07f5338045
+  data.tar.gz: c8df04fcae9e48cd6bfd3ca22819e5108abc75f3084f9c6a2cbc86db07f9a387
 SHA512:
-  metadata.gz: 4b4501ca72d06b5a569fdcc77f384131fbd85342f8da7a084a02210ec7a3821e8b9f1cad88685262d0cc4e993f7b0031bed5d510c353c7d8fb5fe28f97a2ea83
-  data.tar.gz: a4fe329f2d8ae7cc295cb17d573963ddab6c0cde52d6524ad182f4651dab8ba90215bcb1ecf60c7fcf248135aed152b50a1d34afa03b270b93c5a172ac4048b3
+  metadata.gz: f9bf3dc84620d087f2593af2c6027984ae51998ec6706a7f12cc5bee8eabc77589fbb5804d878e1cf43def5566eccc72c9cb39913b27a66b0353243a107cccd7
+  data.tar.gz: 2f35f101c0753c23094879e8bca382ca4daf6344a2922f096459ef31126e8180ec47a7584c2535807b347122539af131c6348a3aca48f9e775652cd208192a01

data/CHANGELOG

@@ -1,5 +1,32 @@
-v2.15.0 (13th August 2025)
+v2.16.0 (9th August 2026)
+- Add new method that use Point(x, y) instead of Array[Integer], for improved typing with sorbet (https://github.com/yob/pdf-reader/pull/578)
+- Support extracting text via ActualText annotations (https://github.com/yob/pdf-reader/pull/587)
+- Accept any IO-like object in PDF::Reader.new() (https://github.com/yob/pdf-reader/pull/607)
+- Expanded type annotations
+- Add dynamically generated RBS type signaturesd to published gem (https://github.com/yob/pdf-reader/pull/580)
+- A few bug fixes to CMap parsing and Unicode extraction
+  - https://github.com/yob/pdf-reader/pull/582
+  - https://github.com/yob/pdf-reader/pull/593
+- Fix occasional exception when parsing PDFDoc strings with invalid bytes (https://github.com/yob/pdf-reader/pull/590)
+- Fox occasional exception parsing differnce tables with an unmatched surrgate pair
+  - https://github.com/yob/pdf-reader/pull/604
+  - https://github.com/yob/pdf-reader/pull/605
+- Reduce object allocations when parsing many PDFs
+  - https://github.com/yob/pdf-reader/pull/595
+  - https://github.com/yob/pdf-reader/pull/596
+  - https://github.com/yob/pdf-reader/pull/598
+  - https://github.com/yob/pdf-reader/pull/599
+  - https://github.com/yob/pdf-reader/pull/600
+  - https://github.com/yob/pdf-reader/pull/601
+- Add truffleruby to the test matrix in CI (https://github.com/yob/pdf-reader/pull/583)
+- Add JRuby 10.1 to the test matrix (https://github.com/yob/pdf-reader/pull/597)
+
+v2.15.1 (28th December 2025)
+- Add ruby 4.0 to the CI matrix (https://github.com/yob/pdf-reader/pull/575)
+- Avoiding raising an error when ToUnicode poins to the wrong object type (https://github.com/yob/pdf-reader/pull/573)
+- Skip invalid UTF-16 surrogate pairs in CMaps (https://github.com/yob/pdf-reader/pull/574)
 
+v2.15.0 (13th August 2025)
 - Overhaul sorbet types, moving from an external RBI file to inline comments in RBS syntax
   - multiple PRs, but mainly https://github.com/yob/pdf-reader/pull/562
   - See https://railsatscale.com/2025-04-23-rbs-support-for-sorbet/
@@ -88,7 +115,7 @@ v2.6.0 (12th November 2021)
 
 v2.5.0 (6th June 2021)
 - bump minimum ruby version to 2.0
-- Correctly handle trascoding to UTF-8 from some fonts that use a difference table [#344](https://github.com/yob/pdf-reader/pull/344/) 
+- Correctly handle trascoding to UTF-8 from some fonts that use a difference table [#344](https://github.com/yob/pdf-reader/pull/344/)
 - Fix some character spacing issues with the TJ operator [#343](https://github.com/yob/pdf-reader/pull/343)
 - Fix crash with some encrypted PDFs [#348](https://github.com/yob/pdf-reader/pull/348/)
 - Fix positions of text on some PDFs with pages rotated 90° [#350](https://github.com/yob/pdf-reader/pull/350/)

data/Rakefile

@@ -14,7 +14,7 @@ desc "Run cane to check quality metrics"
 Cane::RakeTask.new(:quality) do |cane|
   cane.abc_max = 20
   cane.style_measure = 100
-  cane.max_violations = 33
+  cane.max_violations = 32
 
   cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end

data/lib/pdf/reader/bounding_rectangle_runs_filter.rb

@@ -10,7 +10,7 @@ class PDF::Reader
 
     #: (Array[PDF::Reader::TextRun], PDF::Reader::Rectangle) -> Array[PDF::Reader::TextRun]
     def self.runs_within_rect(runs, rect)
-      runs.select { |run| rect.contains?(run.origin) }
+      runs.select { |run| rect.contains_xy?(run.x, run.y) }
     end
   end
 end

data/lib/pdf/reader/buffer.rb

@@ -62,6 +62,9 @@ class PDF::Reader
     # must match whole tokens
     DIGITS_ONLY = %r{\A\d+\z} #: Regexp
 
+    # bytes that terminate a PDF name token (used in prepare_regular_token)
+    NAME_TERMINATOR_BYTES = ([nil, 0x20, 0x0A] + TOKEN_DELIMITER).freeze #: Array[Integer?]
+
     #: Integer
     attr_reader :pos
 
@@ -255,13 +258,25 @@ class PDF::Reader
 
       token_one = @tokens[0]
       token_two = @tokens[1]
-      if token_one.is_a?(String) && token_two.is_a?(String) && token_one.match(DIGITS_ONLY) && token_two.match(DIGITS_ONLY)
+      if token_one.is_a?(String) && token_two.is_a?(String) && match?(token_one, DIGITS_ONLY) && match?(token_two, DIGITS_ONLY)
         @tokens[0] = PDF::Reader::Reference.new(token_one.to_i, token_two.to_i)
         @tokens.delete_at(2)
         @tokens.delete_at(1)
       end
     end
 
+    # Once min ruby version is >= 2.4, we can drop this method and just use String#match?
+    #
+    #: (String, Regexp) -> bool
+    def match?(str, regexp)
+      # We prefer match? because fewer objects are allocated, and this code path is hot
+      if str.respond_to?(:match?)
+        str.match?(regexp)
+      else
+        str.match(regexp) != nil
+      end
+    end
+
     # Extract data between ID and EI
     # If the EI follows white-space the space is dropped from the data
     # The EI must followed by white-space or end of buffer
@@ -327,8 +342,12 @@ class PDF::Reader
           # ignore it
         else
           @tokens << str if str.size > 0
-          @tokens << ">" if byte != 0x3E # '>'
-          @tokens << byte.chr
+          if byte == 0x3E
+            @tokens << ">"
+          else
+            @tokens << ">"
+            @tokens << byte.chr
+          end
           break
         end
       end
@@ -383,6 +402,7 @@ class PDF::Reader
 
         case byte
         when nil
+          @tokens << tok if tok.size > 0
           break
         when 0x25
           # comment, ignore everything until the next EOL char
@@ -390,63 +410,95 @@ class PDF::Reader
             commentbyte = @io.getbyte
             break if commentbyte.nil? || commentbyte == 0x0A || commentbyte == 0x0D
           end
-        when *TOKEN_WHITESPACE
+        when 0x00, 0x09, 0x0A, 0x0C, 0x0D, 0x20 # TOKEN_WHITESPACE
           # white space, token finished
-          @tokens << tok if tok.size > 0
-
-          #If the token was empty, chomp the rest of the whitespace too
-          while TOKEN_WHITESPACE.include?(peek_byte) && tok.size == 0
-            @io.getbyte
+          if tok.size > 0
+            @tokens << tok
+          else
+            #If the token was empty, chomp the rest of the whitespace too
+            while TOKEN_WHITESPACE.include?(peek_byte)
+              @io.getbyte
+            end
           end
-          tok = "".dup
           break
         when 0x3C
           # opening delimiter '<', start of new token
-          @tokens << tok if tok.size > 0
+          if tok.size > 0
+            @tokens << tok
+          end
           if peek_byte == 0x3C # check if token is actually '<<'
             @io.getbyte
             @tokens << "<<"
           else
             @tokens << "<"
           end
-          tok = "".dup
           break
         when 0x3E
           # closing delimiter '>', start of new token
-          @tokens << tok if tok.size > 0
+          if tok.size > 0
+            @tokens << tok
+          end
           if peek_byte == 0x3E # check if token is actually '>>'
             @io.getbyte
             @tokens << ">>"
           else
             @tokens << ">"
           end
-          tok = "".dup
           break
-        when 0x28, 0x5B, 0x7B
-          # opening delimiter, start of new token
-          @tokens << tok if tok.size > 0
-          @tokens << byte.chr
-          tok = "".dup
+        when 0x28
+          # opening delimiter '(', start of new token
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "("
           break
-        when 0x29, 0x5D, 0x7D
-          # closing delimiter
-          @tokens << tok if tok.size > 0
-          @tokens << byte.chr
-          tok = "".dup
+        when 0x5B
+          # opening delimiter '[', start of new token
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "["
+          break
+        when 0x7B
+          # opening delimiter '{', start of new token
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "{"
+          break
+        when 0x29
+          # closing delimiter ')'
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << ")"
+          break
+        when 0x5D
+          # closing delimiter ']'
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "]"
+          break
+        when 0x7D
+          # closing delimiter '}'
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "}"
           break
         when 0x2F
           # PDF name, start of new token
-          @tokens << tok if tok.size > 0
-          @tokens << byte.chr
-          @tokens << "" if byte == 0x2F && ([nil, 0x20, 0x0A] + TOKEN_DELIMITER).include?(peek_byte)
-          tok = "".dup
+          if tok.size > 0
+            @tokens << tok
+          end
+          @tokens << "/"
+          @tokens << "" if NAME_TERMINATOR_BYTES.include?(peek_byte)
           break
         else
           tok << byte
         end
       end
-
-      @tokens << tok if tok.size > 0
     end
 
     # peek at the next character in the io stream, leaving the stream position

data/lib/pdf/reader/cmap.rb

@@ -46,6 +46,12 @@ class PDF::Reader
       "def" => :noop
     } #: Hash[String, Symbol]
 
+    # Indicates the start of a UTF-16 surrogate pair, see
+    # https://en.wikipedia.org/wiki/Universal_Character_Set_characters
+    HIGH_SURROGATE_RANGE = (0xD800..0xDBFF) #: Range[Integer]
+
+    EMPTY_CODEPOINTS = [].freeze #: Array[Integer]
+
     #: Hash[Integer, Array[Integer]]
     attr_reader :map
 
@@ -66,7 +72,7 @@ class PDF::Reader
     #
     #: (Integer) -> Array[Integer]
     def decode(c)
-      @map.fetch(c, [])
+      @map.fetch(c, EMPTY_CODEPOINTS)
     end
 
     private
@@ -77,7 +83,7 @@ class PDF::Reader
       mode = initial_mode
       instructions = []
 
-      while token = parser.parse_token(CMAP_KEYWORDS)
+      while token = parser.parse_token
         if token.is_a?(String) || token.is_a?(Array)
           if token == "beginbfchar"
             mode = :char
@@ -104,7 +110,7 @@ class PDF::Reader
     #: (String) -> PDF::Reader::Parser
     def build_parser(instructions)
       buffer = Buffer.new(StringIO.new(instructions))
-      Parser.new(buffer)
+      Parser.new(buffer, operators: CMAP_KEYWORDS, relaxed_dictionaries: true)
     end
 
     # The following includes some manual decoding of UTF-16BE strings into unicode codepoints. In
@@ -124,15 +130,16 @@ class PDF::Reader
       end
       result = []
       while unpacked_string.any? do
-        if unpacked_string.size >= 2 &&
-            unpacked_string.first.to_i >= 0xD800 &&
-            unpacked_string.first.to_i <= 0xDBFF
+        if unpacked_string.size >= 2 && HIGH_SURROGATE_RANGE.include?(unpacked_string.first.to_i)
           # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
           # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
           # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
           point_one = unpacked_string.shift.to_i
           point_two = unpacked_string.shift.to_i
           result << (point_one - 0xD800) * 0x400 + (point_two - 0xDC00) + 0x10000
+        elsif unpacked_string.size == 1 && HIGH_SURROGATE_RANGE.include?(unpacked_string.first.to_i)
+            # the start of a surrogate pair but the pair is missing. Skip it
+            unpacked_string.shift
         else
           result << unpacked_string.shift
         end
@@ -170,7 +177,7 @@ class PDF::Reader
       end_code   = str_to_int(end_code).first
       dst        = str_to_int(dst)
 
-      return if start_code.nil? || end_code.nil?
+      return if start_code.nil? || end_code.nil? || dst.empty?
 
       # add all values in the range to our mapping
       (start_code..end_code).each_with_index do |val, idx|

data/lib/pdf/reader/encoding.rb

@@ -34,15 +34,19 @@ class PDF::Reader
     CONTROL_CHARS = [0,1,2,3,4,5,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,
                      24,25,26,27,28,29,30,31] #: Array[Integer]
     UNKNOWN_CHAR = 0x25AF #: Integer # ▯
+    DEFAULT_MAPPING = (0..255).each_with_object({}) { |i, h|
+      h[i] = CONTROL_CHARS.include?(i) ? UNKNOWN_CHAR : i
+    }.freeze #: Hash[Integer, Integer]
+
+    # Cache mapping files to avoid re-reading and re-parsing the same file for
+    # every Encoding that uses it (e.g. many fonts sharing StandardEncoding).
+    FILE_MAPPINGS = {} #: Hash[String, Hash[Integer, Integer]]
 
     #: String
     attr_reader :unpack
 
     #: (Hash[Symbol, untyped] | Symbol | nil) -> void
     def initialize(enc)
-      # maps from character codes to Unicode codepoints
-      @mapping  = default_mapping #: Hash[Integer, Integer]
-
       # maps from character codes to UTF-8 strings.
       @string_cache  = {} #: Hash[Integer, String]
 
@@ -58,7 +62,15 @@ class PDF::Reader
       @differences = nil #: Hash[Integer, Integer] | nil
       @glyphlist = nil #: PDF::Reader::GlyphHash | nil
 
-      load_mapping(@map_file) if @map_file
+      # maps from character codes to Unicode codepoints
+      # If we have a mapping file, use the cached parsed version (loaded once per file)
+      if @map_file
+        @mapping = (
+          FILE_MAPPINGS[@map_file] ||= build_file_mapping(@map_file)
+        ).dup #: Hash[Integer, Integer]
+      else
+        @mapping = DEFAULT_MAPPING.dup
+      end #: Hash[Integer, Integer]
 
       if enc.is_a?(Hash) && enc[:Differences]
         self.differences = enc[:Differences]
@@ -149,25 +161,15 @@ class PDF::Reader
     private
 
     # returns a hash that:
-    # - maps control chars and nil to the unicode "unknown character"
-    # - leaves all other bytes <= 255 unchaged
-    #
-    # Each specific encoding will change this default as required for their glyphs
-    #: () -> Hash[Integer, Integer]
-    def default_mapping
-      all_bytes = (0..255).to_a
-      tuples = all_bytes.map {|i|
-        CONTROL_CHARS.include?(i) ? [i, UNKNOWN_CHAR] : [i,i]
-      }
-      mapping = Hash[tuples]
-      mapping
-    end
-
     #: (Integer) -> String
     def internal_int_to_utf8_string(glyph_code)
-      ret = [
-        @mapping[glyph_code.to_i] || glyph_code.to_i
-      ].pack("U*")
+      codepoint = @mapping[glyph_code.to_i] || glyph_code.to_i
+      if valid_unicode_scalar?(codepoint.to_i)
+        codepoints = [codepoint]
+      else
+        codepoints = [UNKNOWN_CHAR]
+      end
+      ret = codepoints.pack("U*")
       ret.force_encoding("UTF-8")
       ret
     end
@@ -187,11 +189,22 @@ class PDF::Reader
 
     #: (String) -> String
     def convert_to_utf8(str)
-      ret = str.unpack(unpack).map! { |c| @mapping[c.to_i] || c }.pack("U*")
+      ret = str.unpack(unpack).map! { |c|
+        codepoint = @mapping[c.to_i] || c
+        valid_unicode_scalar?(codepoint.to_i) ? codepoint : UNKNOWN_CHAR
+      }.pack("U*")
       ret.force_encoding("UTF-8")
       ret
     end
 
+    # true if the integer is a Unicode scalar value that can be encoded as
+    # UTF-8. Surrogates (U+D800..U+DFFF) and code points above U+10FFFF are
+    # excluded, as packing them produces invalid UTF-8 byte sequences.
+    #: (Integer) -> bool
+    def valid_unicode_scalar?(codepoint)
+      codepoint.between?(0, 0xD7FF) || codepoint.between?(0xE000, 0x10FFFF)
+    end
+
     #: (Symbol) -> String
     def get_unpack(enc)
       case enc
@@ -229,14 +242,17 @@ class PDF::Reader
       @glyphlist ||= PDF::Reader::GlyphHash.new
     end
 
-    #: (String) -> void
-    def load_mapping(file)
+    #: (String) -> Hash[Integer, Integer]
+    def build_file_mapping(file)
+      mapping = DEFAULT_MAPPING.dup
       File.open(file, "r:BINARY") do |f|
         f.each do |l|
-          _m, single_byte, unicode = *l.match(/\A([0-9A-Za-z]+);([0-9A-F]{4})/)
-          @mapping["0x#{single_byte}".hex] = "0x#{unicode}".hex if single_byte
+          if l =~ /\A([0-9A-Za-z]+);([0-9A-F]{4})/
+            mapping[$1.to_i(16)] = $2.to_i(16)
+          end
         end
       end
+      mapping.freeze
     end
 
   end

data/lib/pdf/reader/encoding_utils.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+    # Utiliy class for some conversions to utf8 (the standard output encoding for pdf-reader).
+    # This is not used for general purpose of encoding management while parsing PDFs, that lives
+    # in PDF::Reader::Encoding
+    class EncodingUtils
+
+      UTF16_BOM = [254, 255] #: Array[Integer]
+
+      # PDFDocEncoding bytes that map to Unicode codepoints differing from their
+      # byte value. All other bytes map directly to their Unicode codepoint value
+      # (0x00-0x17/0x20-0x7F: ASCII; 0xA1-0xFF: Latin-1, which PDFDocEncoding
+      # matches exactly).
+      PDFDOC_CODEPOINTS = {
+        0x18 => 0x02D8, # BREVE
+        0x19 => 0x02C7, # CARON
+        0x1A => 0x02C6, # MODIFIER LETTER CIRCUMFLEX ACCENT
+        0x1B => 0x02D9, # DOT ABOVE
+        0x1C => 0x02DD, # DOUBLE ACUTE ACCENT
+        0x1D => 0x02DB, # OGONEK
+        0x1E => 0x02DA, # RING ABOVE
+        0x1F => 0x02DC, # SMALL TILDE
+        0x80 => 0x2022, # BULLET
+        0x81 => 0x2020, # DAGGER
+        0x82 => 0x2021, # DOUBLE DAGGER
+        0x83 => 0x2026, # HORIZONTAL ELLIPSIS
+        0x84 => 0x2014, # EM DASH
+        0x85 => 0x2013, # EN DASH
+        0x86 => 0x0192, # LATIN SMALL LETTER F WITH HOOK
+        0x87 => 0x2044, # FRACTION SLASH
+        0x88 => 0x2039, # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+        0x89 => 0x203A, # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+        0x8A => 0x2212, # MINUS SIGN
+        0x8B => 0x2030, # PER MILLE SIGN
+        0x8C => 0x201E, # DOUBLE LOW-9 QUOTATION MARK
+        0x8D => 0x201C, # LEFT DOUBLE QUOTATION MARK
+        0x8E => 0x201D, # RIGHT DOUBLE QUOTATION MARK
+        0x8F => 0x2018, # LEFT SINGLE QUOTATION MARK
+        0x90 => 0x2019, # RIGHT SINGLE QUOTATION MARK
+        0x91 => 0x201A, # SINGLE LOW-9 QUOTATION MARK
+        0x92 => 0x2122, # TRADE MARK SIGN
+        0x93 => 0xFB01, # LATIN SMALL LIGATURE FI
+        0x94 => 0xFB02, # LATIN SMALL LIGATURE FL
+        0x95 => 0x0141, # LATIN CAPITAL LETTER L WITH STROKE
+        0x96 => 0x0152, # LATIN CAPITAL LIGATURE OE
+        0x97 => 0x0160, # LATIN CAPITAL LETTER S WITH CARON
+        0x98 => 0x0178, # LATIN CAPITAL LETTER Y WITH DIAERESIS
+        0x99 => 0x017D, # LATIN CAPITAL LETTER Z WITH CARON
+        0x9A => 0x0131, # LATIN SMALL LETTER DOTLESS I
+        0x9B => 0x0142, # LATIN SMALL LETTER L WITH STROKE
+        0x9C => 0x0153, # LATIN SMALL LIGATURE OE
+        0x9D => 0x0161, # LATIN SMALL LETTER S WITH CARON
+        0x9E => 0x017E, # LATIN SMALL LETTER Z WITH CARON
+        0xA0 => 0x20AC, # EURO SIGN
+      }.freeze #: Hash[Integer, Integer]
+
+     #: (untyped) -> untyped
+      def self.obj_to_utf8(obj)
+        new.obj_to_utf8(obj)
+      end
+
+      #: (String) -> String
+      def self.string_to_utf8(str)
+        new.string_to_utf8(str)
+      end
+
+      # Recursively convert Hashes, Arrays, and Strings to UTF-8
+      #
+      #: (untyped) -> untyped
+      def obj_to_utf8(obj)
+        case obj
+        when ::Hash then
+          {}.tap { |new_hash|
+            obj.each do |key, value|
+              new_hash[key] = obj_to_utf8(value)
+            end
+          }
+        when Array then
+          obj.map { |item| obj_to_utf8(item) }
+        when String then
+          string_to_utf8(obj)
+        else
+          obj
+        end
+      end
+
+      # Convert a String to UTF-8
+      #
+      #: (String) -> String
+      def string_to_utf8(str)
+        if has_utf16_bom?(str)
+          utf16_to_utf8(str)
+        else
+          pdfdoc_to_utf8(str)
+        end
+      end
+
+      private
+
+      #: (String) -> bool
+      def has_utf16_bom?(str)
+        first_bytes = str[0,2]
+
+        return false if first_bytes.nil?
+
+        first_bytes.unpack("C*") == UTF16_BOM
+      end
+
+      #: (String) -> String
+      def pdfdoc_to_utf8(str)
+        str.bytes.map { |b| PDFDOC_CODEPOINTS[b] || b }.pack("U*")
+      end
+
+      #: (String) -> String
+      def utf16_to_utf8(obj)
+        obj.dup.force_encoding(
+          ::Encoding::UTF_16
+        ).encode(
+          ::Encoding::UTF_8, invalid: :replace, replace: "\uFFFD"
+        )
+      end
+    end
+  end
+end

data/lib/pdf/reader/error.rb

@@ -33,16 +33,26 @@ class PDF::Reader
     ################################################################################
     #: (untyped, untyped, ?untyped) -> untyped
     def self.str_assert(lvalue, rvalue, chars=nil)
-      raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
+      if chars and !lvalue.kind_of?(String)
+        raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead"
+      end
       lvalue = lvalue[0,chars] if chars
-      raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"  if lvalue != rvalue
+
+      if lvalue != rvalue
+        raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"
+      end
     end
     ################################################################################
     #: (untyped, untyped, ?untyped) -> untyped
     def self.str_assert_not(lvalue, rvalue, chars=nil)
-      raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
+      if chars and !lvalue.kind_of?(String)
+        raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead"
+      end
       lvalue = lvalue[0,chars] if chars
-      raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"  if lvalue == rvalue
+
+      if lvalue == rvalue
+        raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead"
+      end
     end
     ################################################################################
     #: (untyped, untyped) -> untyped
@@ -50,12 +60,12 @@ class PDF::Reader
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found '#{lvalue}' instead" if lvalue != rvalue
     end
     ################################################################################
-    #: (Object, String, Module) -> void
+    #: (Object, String, Module[untyped]) -> void
     def self.validate_type(object, name, klass)
       raise ArgumentError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
     end
     ################################################################################
-    #: (Object, String, Module) -> void
+    #: (Object, String, Module[untyped]) -> void
     def self.validate_type_as_malformed(object, name, klass)
       raise MalformedPDFError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
     end