pdf-reader 2.4.1 → 2.7.0

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'forwardable'
@@ -41,16 +42,14 @@ module PDF
       # starting a new page
       def page=(page)
         @state = PageState.new(page)
+        @page = page
         @content = []
         @characters = []
-        @mediabox = page.objects.deref(page.attributes[:MediaBox])
-        device_bl = @state.ctm_transform(@mediabox[0], @mediabox[1])
-        device_tr = @state.ctm_transform(@mediabox[2], @mediabox[3])
-        @device_mediabox = [ device_bl.first, device_bl.last, device_tr.first, device_tr.last]
       end
 
       def content
-        PageLayout.new(@characters, @device_mediabox).to_s
+        mediabox = @page.rectangles[:MediaBox].to_a
+        PageLayout.new(@characters, mediabox).to_s
       end
 
       #####################################################
@@ -104,6 +103,8 @@ module PDF
         glyphs.each_with_index do |glyph_code, index|
           # paint the current glyph
           newx, newy = @state.trm_transform(0,0)
+          newx, newy = apply_rotation(newx, newy)
+
           utf8_chars = @state.current_font.to_utf8(glyph_code)
 
           # apply to glyph displacment for the current glyph so the next
@@ -118,6 +119,28 @@ module PDF
         end
       end
 
+      # TODO: revist this. It rotates the co-ordinates to the right direction, but I don't
+      #       think it sets the correct x,y values. We get away with it because we don't
+      #       return the text with co-ordinates, only the full text arranged in a string.
+      #
+      #       We should provide an API for extracting the text with positioning data and spec
+      #       that. I suspect the co-ords might be wrong for rotated pages
+      def apply_rotation(x, y)
+        if @page.rotate == 90
+          tmp = x
+          x = y
+          y = tmp * -1
+        elsif @page.rotate == 180
+          y *= -1
+          x *= -1
+        elsif @page.rotate == 270
+          tmp = y
+          y = x
+          x = tmp * -1
+        end
+        return x, y
+      end
+
     end
   end
 end

data/lib/pdf/reader/pages_strategy.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/parser.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -166,7 +167,9 @@ class PDF::Reader
 
       # add a missing digit if required, as required by the spec
       str << "0" unless str.size % 2 == 0
-      str.scan(/../).map {|i| i.hex.chr}.join.force_encoding("binary")
+      str.chars.each_slice(2).map { |nibbles|
+        nibbles.join("").hex.chr
+      }.join.force_encoding("binary")
     end
     ################################################################################
     # Reads a PDF String from the buffer and converts it to a Ruby String
@@ -175,15 +178,18 @@ class PDF::Reader
       return "".dup.force_encoding("binary") if str == ")"
       Error.assert_equal(parse_token, ")")
 
-      str.gsub!(/\\([nrtbf()\\\n]|\d{1,3})?|\r\n?|\n\r/m) do |match|
-        MAPPING[match] || "".dup
+      str.gsub!(/\\(\r\n|[nrtbf()\\\n\r]|([0-7]{1,3}))?|\r\n?/m) do |match|
+        if $2.nil? # not octal digits
+          MAPPING[match] || "".dup
+        else # must be octal digits
+          ($2.oct & 0xff).chr # ignore high level overflow
+        end
       end
       str.force_encoding("binary")
     end
 
     MAPPING = {
       "\r"   => "\n",
-      "\n\r" => "\n",
       "\r\n" => "\n",
       "\\n"  => "\n",
       "\\r"  => "\r",
@@ -194,10 +200,9 @@ class PDF::Reader
       "\\)"  => ")",
       "\\\\" => "\\",
       "\\\n" => "",
+      "\\\r" => "",
+      "\\\r\n" => "",
     }
-    0.upto(9)   { |n| MAPPING["\\00"+n.to_s] = ("00"+n.to_s).oct.chr }
-    0.upto(99)  { |n| MAPPING["\\0"+n.to_s]  = ("0"+n.to_s).oct.chr }
-    0.upto(377) { |n| MAPPING["\\"+n.to_s]   = n.to_s.oct.chr }
 
     ################################################################################
     # Decodes the contents of a PDF Stream and returns it as a Ruby String.

data/lib/pdf/reader/point.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# typed: true
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # PDFs are all about positioning content on a page, so there's lots of need to
+    # work with a set of X,Y coordinates.
+    #
+    class Point
+
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+
+      def ==(other)
+        other.respond_to?(:x) && other.respond_to?(:y) && x == other.x && y == other.y
+      end
+
+    end
+  end
+end

data/lib/pdf/reader/print_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/rectangle.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+# typed: true
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # PDFs represent rectangles all over the place. They're 4 element arrays, like this:
+    #
+    #     [A, B, C, D]
+    #
+    # Four element arrays are yucky to work with though, so here's a class that's better.
+    # Initialize it with the 4 elements, and get utility functions (width, height, etc)
+    # for free.
+    #
+    # By convention the first two elements are x1, y1, the co-ords for the bottom left corner
+    # of the rectangle. The third and fourth elements are x2, y2, the co-ords for the top left
+    # corner of the rectangle. It's valid for the alternative corners to be used though, so
+    # we don't assume which is which.
+    #
+    class Rectangle
+
+      attr_reader :bottom_left, :bottom_right, :top_left, :top_right
+
+      def initialize(x1, y1, x2, y2)
+        set_corners(x1, y1, x2, y2)
+      end
+
+      def ==(other)
+        to_a == other.to_a
+      end
+
+      def height
+        top_right.y - bottom_right.y
+      end
+
+      def width
+        bottom_right.x - bottom_left.x
+      end
+
+      # A pdf-style 4-number array
+      def to_a
+        [
+          bottom_left.x,
+          bottom_left.y,
+          top_right.x,
+          top_right.y,
+        ]
+      end
+
+      def apply_rotation(degrees)
+        return if degrees != 90 && degrees != 180 && degrees != 270
+
+        if degrees == 90
+          new_x1 = bottom_left.x
+          new_y1 = bottom_left.y - width
+          new_x2 = bottom_left.x + height
+          new_y2 = bottom_left.y
+        elsif degrees == 180
+          new_x1 = bottom_left.x - width
+          new_y1 = bottom_left.y - height
+          new_x2 = bottom_left.x
+          new_y2 = bottom_left.y
+        elsif degrees == 270
+          new_x1 = bottom_left.x - height
+          new_y1 = bottom_left.y
+          new_x2 = bottom_left.x
+          new_y2 = bottom_left.y + width
+        end
+        set_corners(new_x1, new_y1, new_x2, new_y2)
+      end
+
+      private
+
+      def set_corners(x1, y1, x2, y2)
+        @bottom_left = PDF::Reader::Point.new(
+          [x1, x2].min,
+          [y1, y2].min,
+        )
+        @bottom_right = PDF::Reader::Point.new(
+          [x1, x2].max,
+          [y1, y2].min,
+        )
+        @top_left = PDF::Reader::Point.new(
+          [x1, x2].min,
+          [y1, y2].max,
+        )
+        @top_right = PDF::Reader::Point.new(
+          [x1, x2].max,
+          [y1, y2].max,
+        )
+      end
+    end
+  end
+end

data/lib/pdf/reader/reference.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/register_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 # Copyright (C) 2010 James Healy (jimmy@deefa.com)

data/lib/pdf/reader/resource_methods.rb

@@ -1,12 +1,17 @@
 # coding: utf-8
+# typed: false
 # frozen_string_literal: true
 
+# Setting this file to "typed: true" is difficult because it's a mixin that assumes some things
+# are aavailable from the class, like @objects and resources. Sorbet doesn't know about them.
+
 module PDF
   class Reader
 
     # mixin for common methods in Page and FormXobjects
     #
     module ResourceMethods
+
       # Returns a Hash of color spaces that are available to this page
       #
       # NOTE: this method de-serialise objects from the underlying PDF

data/lib/pdf/reader/standard_security_handler.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/standard_security_handler_v5.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'digest'

data/lib/pdf/reader/stream.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 # utilities.rb : General-purpose utility classes which don't fit anywhere else

data/lib/pdf/reader/text_run.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/token.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/transformation_matrix.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/unimplemented_security_handler.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'afm'
@@ -37,23 +38,15 @@ class PDF::Reader
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        m = @metrics.char_metrics_by_code[code_point]
-        if m.nil?
-          names = @font.encoding.int_to_name(code_point)
+        names = @font.encoding.int_to_name(code_point)
+        metrics = names.map { |name|
+          @metrics.char_metrics[name.to_s]
+        }.compact.first
 
-          m = names.map { |name|
-            @metrics.char_metrics[name.to_s]
-          }.compact.first
-        end
-
-        if m
-          m[:wx]
-        elsif @font.widths[code_point - 1]
-          @font.widths[code_point - 1]
-        elsif control_character?(code_point)
-          0
+        if metrics
+          metrics[:wx]
         else
-          0
+          @font.widths[code_point - 1] || 0
         end
       end
 

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/width_calculator.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 # PDF files may define fonts in a number of ways. Each approach means we must

data/lib/pdf/reader/xref.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -131,6 +132,9 @@ class PDF::Reader
             generation = buf.token.to_i
             state = buf.token
 
+            # Some PDF writers start numbering at 1 instead of 0. Fix up the number.
+            # TODO should this fix be logged?
+            objid = 0 if objid == 1 and offset == 0 and generation == 65535 and state == 'f'
             store(objid, generation, offset + @junk_offset) if state == "n" && offset > 0
             objid += 1
             params.clear
@@ -146,7 +150,9 @@ class PDF::Reader
       end
 
       load_offsets(trailer[:XRefStm])   if trailer.has_key?(:XRefStm)
-      load_offsets(trailer[:Prev].to_i) if trailer.has_key?(:Prev)
+      # Some PDF creators seem to use '/Prev 0' in trailer if there is no previous xref
+      # It's not possible for an xref to appear at offset 0, so can safely skip the ref
+      load_offsets(trailer[:Prev].to_i) if trailer.has_key?(:Prev) and trailer[:Prev].to_i != 0
 
       trailer
     end

data/lib/pdf/reader/zero_width_runs_filter.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # There's no point rendering zero-width characters
+  class ZeroWidthRunsFilter
+
+    def self.exclude_zero_width_runs(runs)
+      runs.reject { |run| run.width == 0 }
+    end
+  end
+end

data/lib/pdf/reader.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -136,7 +137,7 @@ module PDF
     def page_count
       pages = @objects.deref(root[:Pages])
       unless pages.kind_of?(::Hash)
-        raise MalformedPDFError, 'Pages structure is missing'
+        raise MalformedPDFError, "Pages structure is missing #{pages.class}"
       end
       @page_count ||= @objects.deref(pages[:Count])
     end
@@ -221,7 +222,7 @@ module PDF
       when Array then
         obj.map { |item| doc_strings_to_utf8(item) }
       when String then
-        if obj[0,2].unpack("C*") == [254, 255]
+        if has_utf16_bom?(obj)
           utf16_to_utf8(obj)
         else
           pdfdoc_to_utf8(obj)
@@ -231,6 +232,14 @@ module PDF
       end
     end
 
+    def has_utf16_bom?(str)
+      first_bytes = str[0,2]
+
+      return false if first_bytes.nil?
+
+      first_bytes.unpack("C*") == [254, 255]
+    end
+
     # TODO find a PDF I can use to spec this behaviour
     #
     def pdfdoc_to_utf8(obj)
@@ -242,7 +251,7 @@ module PDF
     # String#encode
     #
     def utf16_to_utf8(obj)
-      str = obj[2, obj.size]
+      str = obj[2, obj.size].to_s
       str = str.unpack("n*").pack("U*")
       str.force_encoding("utf-8")
       str
@@ -286,7 +295,9 @@ require 'pdf/reader/object_hash'
 require 'pdf/reader/object_stream'
 require 'pdf/reader/pages_strategy'
 require 'pdf/reader/parser'
+require 'pdf/reader/point'
 require 'pdf/reader/print_receiver'
+require 'pdf/reader/rectangle'
 require 'pdf/reader/reference'
 require 'pdf/reader/register_receiver'
 require 'pdf/reader/null_security_handler'
@@ -299,5 +310,4 @@ require 'pdf/reader/page_state'
 require 'pdf/reader/page_text_receiver'
 require 'pdf/reader/token'
 require 'pdf/reader/xref'
-require 'pdf/reader/orientation_detector'
 require 'pdf/reader/page'

data/lib/pdf-reader.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 require "pdf/reader"