pdf-reader 2.4.1 → 2.7.0

data/lib/pdf/reader/font_descriptor.rb

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

data/lib/pdf/reader/form_xobject.rb

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

data/lib/pdf/reader/glyph_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -103,19 +104,25 @@ class PDF::Reader
 
     # returns a hash that maps glyph names to unicode codepoints. The mapping is based on
     # a text file supplied by Adobe at:
-    # http://www.adobe.com/devnet/opentype/archives/glyphlist.txt
+    # https://github.com/adobe-type-tools/agl-aglfn
     def load_adobe_glyph_mapping
       keyed_by_name      = {}
       keyed_by_codepoint = {}
 
-      File.open(File.dirname(__FILE__) + "/glyphlist.txt", "r:BINARY") do |f|
-        f.each do |l|
-          _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
-          if name && code
-            cp = "0x#{code}".hex
-            keyed_by_name[name.to_sym]   = cp
-            keyed_by_codepoint[cp]     ||= []
-            keyed_by_codepoint[cp]     << name.to_sym
+      paths = [
+        File.dirname(__FILE__) + "/glyphlist.txt",
+        File.dirname(__FILE__) + "/glyphlist-zapfdingbats.txt",
+      ]
+      paths.each do |path|
+        File.open(path, "r:BINARY") do |f|
+          f.each do |l|
+            _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
+            if name && code
+              cp = "0x#{code}".hex
+              keyed_by_name[name.to_sym]   = cp
+              keyed_by_codepoint[cp]     ||= []
+              keyed_by_codepoint[cp]     << name.to_sym
+            end
           end
         end
       end

data/lib/pdf/reader/glyphlist-zapfdingbats.txt

@@ -0,0 +1,245 @@
+# -----------------------------------------------------------
+# Copyright 2002-2019 Adobe (http://www.adobe.com/).
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the
+# following conditions are met:
+#
+# Redistributions of source code must retain the above
+# copyright notice, this list of conditions and the following
+# disclaimer.
+#
+# Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following
+# disclaimer in the documentation and/or other materials
+# provided with the distribution.
+#
+# Neither the name of Adobe nor the names of its contributors
+# may be used to endorse or promote products derived from this
+# software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------
+# Name:          ITC Zapf Dingbats Glyph List
+# Table version: 2.0
+# Date:          September 20, 2002
+# URL:           https://github.com/adobe-type-tools/agl-aglfn
+#
+# Format: two semicolon-delimited fields:
+#   (1) glyph name--upper/lowercase letters and digits
+#   (2) Unicode scalar value--four uppercase hexadecimal digits
+#
+a100;275E
+a101;2761
+a102;2762
+a103;2763
+a104;2764
+a105;2710
+a106;2765
+a107;2766
+a108;2767
+a109;2660
+a10;2721
+a110;2665
+a111;2666
+a112;2663
+a117;2709
+a118;2708
+a119;2707
+a11;261B
+a120;2460
+a121;2461
+a122;2462
+a123;2463
+a124;2464
+a125;2465
+a126;2466
+a127;2467
+a128;2468
+a129;2469
+a12;261E
+a130;2776
+a131;2777
+a132;2778
+a133;2779
+a134;277A
+a135;277B
+a136;277C
+a137;277D
+a138;277E
+a139;277F
+a13;270C
+a140;2780
+a141;2781
+a142;2782
+a143;2783
+a144;2784
+a145;2785
+a146;2786
+a147;2787
+a148;2788
+a149;2789
+a14;270D
+a150;278A
+a151;278B
+a152;278C
+a153;278D
+a154;278E
+a155;278F
+a156;2790
+a157;2791
+a158;2792
+a159;2793
+a15;270E
+a160;2794
+a161;2192
+a162;27A3
+a163;2194
+a164;2195
+a165;2799
+a166;279B
+a167;279C
+a168;279D
+a169;279E
+a16;270F
+a170;279F
+a171;27A0
+a172;27A1
+a173;27A2
+a174;27A4
+a175;27A5
+a176;27A6
+a177;27A7
+a178;27A8
+a179;27A9
+a17;2711
+a180;27AB
+a181;27AD
+a182;27AF
+a183;27B2
+a184;27B3
+a185;27B5
+a186;27B8
+a187;27BA
+a188;27BB
+a189;27BC
+a18;2712
+a190;27BD
+a191;27BE
+a192;279A
+a193;27AA
+a194;27B6
+a195;27B9
+a196;2798
+a197;27B4
+a198;27B7
+a199;27AC
+a19;2713
+a1;2701
+a200;27AE
+a201;27B1
+a202;2703
+a203;2750
+a204;2752
+a205;276E
+a206;2770
+a20;2714
+a21;2715
+a22;2716
+a23;2717
+a24;2718
+a25;2719
+a26;271A
+a27;271B
+a28;271C
+a29;2722
+a2;2702
+a30;2723
+a31;2724
+a32;2725
+a33;2726
+a34;2727
+a35;2605
+a36;2729
+a37;272A
+a38;272B
+a39;272C
+a3;2704
+a40;272D
+a41;272E
+a42;272F
+a43;2730
+a44;2731
+a45;2732
+a46;2733
+a47;2734
+a48;2735
+a49;2736
+a4;260E
+a50;2737
+a51;2738
+a52;2739
+a53;273A
+a54;273B
+a55;273C
+a56;273D
+a57;273E
+a58;273F
+a59;2740
+a5;2706
+a60;2741
+a61;2742
+a62;2743
+a63;2744
+a64;2745
+a65;2746
+a66;2747
+a67;2748
+a68;2749
+a69;274A
+a6;271D
+a70;274B
+a71;25CF
+a72;274D
+a73;25A0
+a74;274F
+a75;2751
+a76;25B2
+a77;25BC
+a78;25C6
+a79;2756
+a7;271E
+a81;25D7
+a82;2758
+a83;2759
+a84;275A
+a85;276F
+a86;2771
+a87;2772
+a88;2773
+a89;2768
+a8;271F
+a90;2769
+a91;276C
+a92;276D
+a93;276A
+a94;276B
+a95;2774
+a96;2775
+a97;275B
+a98;275C
+a99;275D
+a9;2720
+# END

data/lib/pdf/reader/lzw.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 module PDF
@@ -35,9 +36,9 @@ module PDF
 
         def read
           bits_left_in_chunk = @bits_in_chunk
-          chunk = nil
+          chunk = -1
           while bits_left_in_chunk > 0 and @current_pos < @data.size
-            chunk = 0 if chunk.nil?
+            chunk = 0 if chunk < 0
             codepoint = @data[@current_pos, 1].unpack("C*")[0]
             current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
@@ -83,6 +84,7 @@ module PDF
       #
       def self.decode(data)
         stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
+        string_table = StringTable.new
         result = "".dup
         until (code = stream.read) == CODE_EOD
           if code == CODE_CLEAR_TABLE

data/lib/pdf/reader/null_security_handler.rb

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

data/lib/pdf/reader/object_cache.rb

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

data/lib/pdf/reader/object_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -331,11 +332,15 @@ class PDF::Reader
     def decrypt(ref, obj)
       case obj
       when PDF::Reader::Stream then
-        obj.data = sec_handler.decrypt(obj.data, ref)
+        # PDF 32000-1:2008 7.5.8.2: "The cross-reference stream shall not be encrypted [...]."
+        # Therefore we shouldn't try to decrypt it.
+        obj.data = sec_handler.decrypt(obj.data, ref) unless obj.hash[:Type] == :XRef
         obj
       when Hash                then
-        arr = obj.map { |key,val| [key, decrypt(ref, val)] }.flatten(1)
-        Hash[*arr]
+        arr = obj.map { |key,val| [key, decrypt(ref, val)] }
+        arr.each_with_object({}) { |(k,v), accum|
+          accum[k] = v
+        }
       when Array               then
         obj.collect { |item| decrypt(ref, item) }
       when String

data/lib/pdf/reader/object_stream.rb

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

data/lib/pdf/reader/overlapping_runs_filter.rb

@@ -1,4 +1,6 @@
+# typed: true
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF
@@ -38,7 +40,8 @@ class PDF::Reader
 
     def self.detect_intersection(sweep_line_status, event_point)
       sweep_line_status.each do |open_text_run|
-        if event_point.x >= open_text_run.x &&
+        if open_text_run.text == event_point.run.text &&
+            event_point.x >= open_text_run.x &&
             event_point.x <= open_text_run.endx &&
             open_text_run.intersection_area_percent(event_point.run) >= OVERLAPPING_THRESHOLD
           return true
@@ -51,10 +54,14 @@ class PDF::Reader
   # Utility class used to avoid modifying the underlying TextRun objects while we're
   # looking for duplicates
   class EventPoint
-    attr_reader :x, :run
 
-    def initialize x, run
-      @x, @run = x, run
+    attr_reader :x
+
+    attr_reader :run
+
+    def initialize(x, run)
+      @x = x
+      @run = run
     end
 
     def start?

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 module PDF
@@ -68,10 +69,33 @@ module PDF
         @attributes
       end
 
+      def height
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+        rect.height
+      end
+
+      def width
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+        rect.width
+      end
+
+      def origin
+        rect = Rectangle.new(*attributes[:MediaBox])
+        rect.apply_rotation(rotate) if rotate > 0
+
+        rect.bottom_left
+      end
+
       # Convenience method to identify the page's orientation.
       #
       def orientation
-        OrientationDetector.new(attributes).orientation
+        if height > width
+          "portrait"
+        else
+          "landscape"
+        end
       end
 
       # returns the plain text content of this page encoded as UTF-8. Any
@@ -139,23 +163,50 @@ module PDF
       # returns the "boxes" that define the page object.
       # values are defaulted according to section 7.7.3.3 of the PDF Spec 1.7
       #
+      # DEPRECATED. Recommend using Page#rectangles instead
+      #
       def boxes
-        mediabox = attributes[:MediaBox]
-        cropbox = attributes[:Cropbox] || mediabox
+        # In ruby 2.4+ we could use Hash#transform_values
+        Hash[rectangles.map{ |k,rect| [k,rect.to_a] } ]
+      end
+
+      # returns the "boxes" that define the page object.
+      # values are defaulted according to section 7.7.3.3 of the PDF Spec 1.7
+      #
+      def rectangles
+        mediabox = objects.deref!(attributes[:MediaBox])
+        cropbox = objects.deref!(attributes[:Cropbox]) || mediabox
+        bleedbox = objects.deref!(attributes[:BleedBox]) || cropbox
+        trimbox = objects.deref!(attributes[:TrimBox]) || cropbox
+        artbox = objects.deref!(attributes[:ArtBox]) || cropbox
+
+        mediarect = Rectangle.new(*mediabox)
+        croprect = Rectangle.new(*cropbox)
+        bleedrect = Rectangle.new(*bleedbox)
+        trimrect = Rectangle.new(*trimbox)
+        artrect = Rectangle.new(*artbox)
+
+        if rotate > 0
+          mediarect.apply_rotation(rotate)
+          croprect.apply_rotation(rotate)
+          bleedrect.apply_rotation(rotate)
+          trimrect.apply_rotation(rotate)
+          artrect.apply_rotation(rotate)
+        end
 
         {
-          MediaBox: objects.deref!(mediabox),
-          CropBox: objects.deref!(cropbox),
-          BleedBox: objects.deref!(attributes[:BleedBox] || cropbox),
-          TrimBox: objects.deref!(attributes[:TrimBox] || cropbox),
-          ArtBox: objects.deref!(attributes[:ArtBox] || cropbox)
+          MediaBox: mediarect,
+          CropBox: croprect,
+          BleedBox: bleedrect,
+          TrimBox: trimrect,
+          ArtBox: artrect,
         }
       end
 
       private
 
       def root
-        root ||= objects.deref(@objects.trailer[:Root])
+       @root ||= objects.deref(@objects.trailer[:Root])
       end
 
       # Returns the resources that accompany this page. Includes

data/lib/pdf/reader/page_layout.rb

@@ -1,7 +1,9 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'pdf/reader/overlapping_runs_filter'
+require 'pdf/reader/zero_width_runs_filter'
 
 class PDF::Reader
 
@@ -15,14 +17,17 @@ class PDF::Reader
     DEFAULT_FONT_SIZE = 12
 
     def initialize(runs, mediabox)
-      raise ArgumentError, "a mediabox must be provided" if mediabox.nil?
-
-      @runs    = merge_runs(OverlappingRunsFilter.exclude_redundant_runs(runs))
+      # mediabox is a 4-element array for now, but it'd be nice to switch to a
+      # PDF::Reader::Rectangle at some point
+      PDF::Reader::Error.validate_not_nil(mediabox, "mediabox")
+
+      runs = ZeroWidthRunsFilter.exclude_zero_width_runs(runs)
+      runs = OverlappingRunsFilter.exclude_redundant_runs(runs)
+      @mediabox = mediabox
+      @runs = merge_runs(runs)
       @mean_font_size   = mean(@runs.map(&:font_size)) || DEFAULT_FONT_SIZE
       @mean_font_size = DEFAULT_FONT_SIZE if @mean_font_size == 0
-      @mean_glyph_width = mean(@runs.map(&:mean_character_width)) || 0
-      @page_width  = (mediabox[2] - mediabox[0]).abs
-      @page_height = (mediabox[3] - mediabox[1]).abs
+      @median_glyph_width = median(@runs.map(&:mean_character_width)) || 0
       @x_offset = @runs.map(&:x).sort.first || 0
       lowest_y = @runs.map(&:y).sort.first || 0
       @y_offset = lowest_y > 0 ? 0 : lowest_y
@@ -30,6 +35,7 @@ class PDF::Reader
 
     def to_s
       return "" if @runs.empty?
+      return "" if row_count == 0
 
       page = row_count.times.map { |i| " " * col_count }
       @runs.each do |run|
@@ -44,6 +50,16 @@ class PDF::Reader
 
     private
 
+    def page_width
+      # TODO once @mediabox is a Rectangle, this can be just `@mediabox.width`
+      (@mediabox[2].to_f - @mediabox[0].to_f).abs
+    end
+
+    def page_height
+      # TODO once @mediabox is a Rectangle, this can be just `@mediabox.height`
+      (@mediabox[3].to_f - @mediabox[1].to_f).abs
+    end
+
     # given an array of strings, return a new array with empty rows from the
     # beginning and end removed.
     #
@@ -62,19 +78,19 @@ class PDF::Reader
     end
 
     def row_count
-      @row_count ||= (@page_height / @mean_font_size).floor
+      @row_count ||= (page_height / @mean_font_size).floor
     end
 
     def col_count
-      @col_count ||= ((@page_width  / @mean_glyph_width) * 1.05).floor
+      @col_count ||= ((page_width  / @median_glyph_width) * 1.05).floor
     end
 
     def row_multiplier
-      @row_multiplier ||= @page_height.to_f / row_count.to_f
+      @row_multiplier ||= page_height.to_f / row_count.to_f
     end
 
     def col_multiplier
-      @col_multiplier ||= @page_width.to_f / col_count.to_f
+      @col_multiplier ||= page_width.to_f / col_count.to_f
     end
 
     def mean(collection)
@@ -85,12 +101,12 @@ class PDF::Reader
       end
     end
 
-    def each_line(&block)
-      @runs.sort.group_by { |run|
-        run.y.to_i
-      }.map { |y, collection|
-        yield y, collection
-      }
+    def median(collection)
+      if collection.size == 0
+        0
+      else
+        collection.sort[(collection.size * 0.5).floor]
+      end
     end
 
     # take a collection of TextRun objects and merge any that are in close
@@ -104,17 +120,15 @@ class PDF::Reader
     end
 
     def group_chars_into_runs(chars)
-      runs = []
-      while head = chars.shift
+      chars.each_with_object([]) do |char, runs|
         if runs.empty?
-          runs << head
-        elsif runs.last.mergable?(head)
-          runs[-1] = runs.last + head
+          runs << char
+        elsif runs.last.mergable?(char)
+          runs[-1] = runs.last + char
         else
-          runs << head
+          runs << char
         end
       end
-      runs
     end
 
     def local_string_insert(haystack, needle, index)

data/lib/pdf/reader/page_state.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'pdf/reader/transformation_matrix'
@@ -30,15 +31,7 @@ class PDF::Reader
         @xobject_stack = [page.xobjects]
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
-        if page.rotate == 0
-          state[:ctm]  = identity_matrix
-        else
-          rotate_cos = Math.cos(page.rotate * (Math::PI/180.0)).round(2)
-          rotate_sin = Math.sin(page.rotate * (Math::PI/180.0)).round(2)
-          state[:ctm] = TransformationMatrix.new(rotate_cos, rotate_sin,
-                                                 rotate_sin * -1, rotate_cos,
-                                                 0, 0)
-        end
+        state[:ctm]  = identity_matrix
       end
 
       #####################################################
@@ -320,7 +313,7 @@ class PDF::Reader
       #                 may need to be added
       #
       def process_glyph_displacement(w0, tj, word_boundary)
-        fs = font_size # font size
+        fs = state[:text_font_size]
         tc = state[:char_spacing]
         if word_boundary
           tw = state[:word_spacing]
@@ -330,22 +323,24 @@ class PDF::Reader
         th = state[:h_scaling]
         # optimise the common path to reduce Float allocations
         if th == 1 && tj == 0 && tc == 0 && tw == 0
-          glyph_width = w0 * fs
-          tx = glyph_width
+          tx = w0 * fs
+        elsif tj != 0
+          # don't apply spacing to TJ displacement
+          tx = (w0 - (tj/1000.0)) * fs * th
         else
-          glyph_width = ((w0 - (tj/1000.0)) * fs) * th
-          tx = glyph_width + ((tc + tw) * th)
+          # apply horizontal scaling to spacing values but not font size
+          tx = ((w0 * fs) + tc + tw) * th
         end
-
-        # TODO: I'm pretty sure that tx shouldn't need to be divided by
-        #       ctm[0] here, but this gets my tests green and I'm out of
-        #       ideas for now
         # TODO: support ty > 0
-        if ctm.a == 1 || ctm.a == 0
-          @text_matrix.horizontal_displacement_multiply!(tx)
-        else
-          @text_matrix.horizontal_displacement_multiply!(tx/ctm.a)
-        end
+        ty = 0
+        temp = TransformationMatrix.new(1, 0,
+                                        0, 1,
+                                        tx, ty)
+        @text_matrix = temp.multiply!(
+          @text_matrix.a, @text_matrix.b,
+          @text_matrix.c, @text_matrix.d,
+          @text_matrix.e, @text_matrix.f
+        )
         @font_size = @text_rendering_matrix = nil # invalidate cached value
       end