pdf-reader 2.13.0 → 2.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5db630726ada74d004eb928e8cf164d9a65070150bc99268bed3c3c22a4b16fd
-  data.tar.gz: 186960431832f9808e292e823a1b8cd3ccbe96bf89b7f8e6801b111b0899b690
+  metadata.gz: 38765d176ae7b8f4cff7ea6f10fff00b811f6812629d76a2b966f36139c23188
+  data.tar.gz: a406d525e4fccb84cc9e86b28aab06a12854c6f0f297a1a479d26b3f845267f6
 SHA512:
-  metadata.gz: 4cc29c3f7d3dd36ff55178c6825dab455bbfd9f3e3b62298dac03a835c741ffeebaa1959f3b3ceba19c82fe8a516acad554ad41e5142bd4a8c75a9725857fc96
-  data.tar.gz: a89f8815c83d6f89bc51e3aa232776d6d365eb45f0cbfd01ae9de157390144c9ff8bdbdf3e1359048612d3febeffbfd77a01d0c2b08da0b53dad64b6290f6292
+  metadata.gz: 010c16b1528d4c46d0175737c9694e2e326092b5e7091cbdd0e0ca41567e662b1adabe989c33b0b919a021bee9f985fa4f2862058bd144762c090e718b3089cc
+  data.tar.gz: 996fe5b0761280edd67c5523d00c04519b7c682c5ededd86d8dfd412df6e11d554d162ab5b4eb231709f4d3013c5963129b32358ef0b49a4521e8ba72dcf490b

data/CHANGELOG

@@ -1,3 +1,10 @@
+v2.14.1 (4th February 2025)
+- Fix issue in RBI signatures, introduced in v2.14.0(https://github.com/yob/pdf-reader/pull/550)
+
+v2.14.0 (29th January 2025)
+- Raise minimum supported ruby to 2.1 (https://github.com/yob/pdf-reader/pull/543)
+- Add support for filtering to Page#text (https://github.com/yob/pdf-reader/pull/545)
+
 v2.13.0 (2nd November 2024)
 - Permit Ascii86 v1.0 and v2.0 (https://github.com/yob/pdf-reader/pull/539)
 - Allow StringIO type for PDF::Reader input (https://github.com/yob/pdf-reader/pull/535)

data/Rakefile

@@ -41,7 +41,7 @@ end
 desc "Create a YAML file of integrity info for PDFs in the spec suite"
 task :integrity_yaml do
   data = {}
-  Dir.glob("spec/data/**/*.*").sort.each do |path|
+  Dir.glob("spec/data/**/*.pdf").sort.each do |path|
     path_without_spec = path.gsub("spec/","")
     data[path_without_spec] = {
       :bytes => File.size(path),

data/lib/pdf/reader/advanced_text_run_filter.rb

@@ -0,0 +1,137 @@
+# coding: utf-8
+# frozen_string_literal: true
+# typed: strict
+
+class PDF::Reader
+  # Filter a collection of TextRun objects based on a set of conditions.
+  # It can be used to filter text runs based on their attributes.
+  # The filter can return the text runs that matches the conditions (only) or
+  # the text runs that do not match the conditions (exclude).
+  #
+  # You can filter the text runs based on all its attributes with the operators
+  # mentioned in VALID_OPERATORS.
+  # The filter can be nested with 'or' and 'and' conditions.
+  #
+  # Examples:
+  # 1. Single condition
+  # AdvancedTextRunFilter.exclude(text_runs, text: { include: 'sample' })
+  #
+  # 2. Multiple conditions (and)
+  # AdvancedTextRunFilter.exclude(text_runs, {
+  #   font_size: { greater_than: 10, less_than: 15 }
+  # })
+  #
+  # 3. Multiple possible values (or)
+  # AdvancedTextRunFilter.exclude(text_runs, {
+  #  font_size: { equal: [10, 12] }
+  # })
+  #
+  # 4. Complex AND/OR filter
+  # AdvancedTextRunFilter.exclude(text_runs, {
+  #   and: [
+  #     { font_size: { greater_than: 10 } },
+  #     { or: [
+  #       { text: { include: "sample" } },
+  #       { width: { greater_than: 100 } }
+  #     ]}
+  #   ]
+  # })
+  class AdvancedTextRunFilter
+    VALID_OPERATORS = %i[
+      equal
+      not_equal
+      greater_than
+      less_than
+      greater_than_or_equal
+      less_than_or_equal
+      include
+      exclude
+    ]
+
+    def self.only(text_runs, filter_hash)
+      new(text_runs, filter_hash).only
+    end
+
+    def self.exclude(text_runs, filter_hash)
+      new(text_runs, filter_hash).exclude
+    end
+
+    attr_reader :text_runs, :filter_hash
+
+    def initialize(text_runs, filter_hash)
+      @text_runs = text_runs
+      @filter_hash = filter_hash
+    end
+
+    def only
+      return text_runs if filter_hash.empty?
+      text_runs.select { |text_run| evaluate_filter(text_run) }
+    end
+
+    def exclude
+      return text_runs if filter_hash.empty?
+      text_runs.reject { |text_run| evaluate_filter(text_run) }
+    end
+
+    private
+
+    def evaluate_filter(text_run)
+      if filter_hash[:or]
+        evaluate_or_filters(text_run, filter_hash[:or])
+      elsif filter_hash[:and]
+        evaluate_and_filters(text_run, filter_hash[:and])
+      else
+        evaluate_filters(text_run, filter_hash)
+      end
+    end
+
+    def evaluate_or_filters(text_run, conditions)
+      conditions.any? do |condition|
+        evaluate_filters(text_run, condition)
+      end
+    end
+
+    def evaluate_and_filters(text_run, conditions)
+      conditions.all? do |condition|
+        evaluate_filters(text_run, condition)
+      end
+    end
+
+    def evaluate_filters(text_run, filter_hash)
+      filter_hash.all? do |attribute, conditions|
+        evaluate_attribute_conditions(text_run, attribute, conditions)
+      end
+    end
+
+    def evaluate_attribute_conditions(text_run, attribute, conditions)
+      conditions.all? do |operator, value|
+        unless VALID_OPERATORS.include?(operator)
+          raise ArgumentError, "Invalid operator: #{operator}"
+        end
+
+        apply_operator(text_run.send(attribute), operator, value)
+      end
+    end
+
+    def apply_operator(attribute_value, operator, filter_value)
+      case operator
+      when :equal
+        Array(filter_value).include?(attribute_value)
+      when :not_equal
+        !Array(filter_value).include?(attribute_value)
+      when :greater_than
+        attribute_value > filter_value
+      when :less_than
+        attribute_value < filter_value
+      when :greater_than_or_equal
+        attribute_value >= filter_value
+      when :less_than_or_equal
+        attribute_value <= filter_value
+      when :include
+        Array(filter_value).any? { |v| attribute_value.to_s.include?(v.to_s) }
+      when :exclude
+        Array(filter_value).none? { |v| attribute_value.to_s.include?(v.to_s) }
+      end
+    end
+  end
+end

data/lib/pdf/reader/buffer.rb

@@ -1,5 +1,5 @@
 # coding: ASCII-8BIT
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -52,7 +52,7 @@ class PDF::Reader
     CR = "\r"
     LF = "\n"
     CRLF = "\r\n"
-    WHITE_SPACE = [LF, CR, ' ']
+    WHITE_SPACE = ["\n", "\r", ' ']
 
     # Quite a few PDFs have trailing junk.
     # This can be several k of nuls in some cases

data/lib/pdf/reader/encoding.rb

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

data/lib/pdf/reader/page_text_receiver.rb

@@ -68,6 +68,14 @@ module PDF
           runs = merge_runs(runs)
         end
 
+        if (only_filter = opts.fetch(:only, nil))
+          runs = AdvancedTextRunFilter.only(runs, only_filter)
+        end
+
+        if (exclude_filter = opts.fetch(:exclude, nil))
+          runs = AdvancedTextRunFilter.exclude(runs, exclude_filter)
+        end
+
         runs
       end
 

data/lib/pdf/reader.rb

@@ -280,6 +280,7 @@ end
 ################################################################################
 
 require 'pdf/reader/resources'
+require 'pdf/reader/advanced_text_run_filter'
 require 'pdf/reader/buffer'
 require 'pdf/reader/bounding_rectangle_runs_filter'
 require 'pdf/reader/cid_widths'

data/rbi/pdf-reader.rbi

@@ -75,20 +75,20 @@ module PDF
     end
 
     class Buffer
-      TOKEN_WHITESPACE = T.let(T.unsafe(nil), T::Array[Integer])
-      TOKEN_DELIMITER = T.let(T.unsafe(nil), T::Array[Integer])
-      LEFT_PAREN = T.let(T.unsafe(nil), String)
-      LESS_THAN = T.let(T.unsafe(nil), String)
-      STREAM = T.let(T.unsafe(nil), String)
-      ID = T.let(T.unsafe(nil), String)
-      FWD_SLASH = T.let(T.unsafe(nil), String)
-      NULL_BYTE = T.let(T.unsafe(nil), String)
-      CR = T.let(T.unsafe(nil), String)
-      LF = T.let(T.unsafe(nil), String)
-      CRLF = T.let(T.unsafe(nil), String)
-      WHITE_SPACE = T.let(T.unsafe(nil), T::Array[String])
-      TRAILING_BYTECOUNT = T.let(T.unsafe(nil), Integer)
-      DIGITS_ONLY = T.let(T.unsafe(nil), Regexp)
+      TOKEN_WHITESPACE = T.let(T::Array[String])
+      TOKEN_DELIMITER = T.let(T::Array[Integer])
+      LEFT_PAREN = T.let(String)
+      LESS_THAN = T.let(String)
+      STREAM = T.let(String)
+      ID = T.let(String)
+      FWD_SLASH = T.let(String)
+      NULL_BYTE = T.let(String)
+      CR = T.let(String)
+      LF = T.let(String)
+      CRLF = T.let(String)
+      WHITE_SPACE = T.let(T::Array[String])
+      TRAILING_BYTECOUNT = T.let(Integer)
+      DIGITS_ONLY = T.let(Regexp)
 
       sig { returns(Integer) }
       attr_reader :pos
@@ -851,6 +851,52 @@ module PDF
       def self.exclude_empty_strings(runs); end
     end
 
+    class AdvancedTextRunFilter
+      VALID_OPERATORS = T.let(T::Array[Symbol])
+
+      sig { params(text_runs: T::Array[PDF::Reader::TextRun], filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
+      def self.only(text_runs, filter_hash); end
+
+      sig { params(text_runs: T::Array[PDF::Reader::TextRun], filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
+      def self.exclude(text_runs, filter_hash); end
+
+      sig { returns(T::Array[PDF::Reader::TextRun]) }
+      attr_reader :text_runs
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :filter_hash
+
+      sig { params(text_runs: T::Array[PDF::Reader::TextRun], filter_hash: T::Hash[Symbol, T.untyped]).void }
+      def initialize(text_runs, filter_hash)
+        @text_runs = T.let(T.unsafe(nil), T::Array[PDF::Reader::TextRun])
+        @filter_hash = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+      end
+
+      sig { returns(T::Array[PDF::Reader::TextRun]) }
+      def only; end
+
+      sig { returns(T::Array[PDF::Reader::TextRun]) }
+      def exclude; end
+
+      sig { params(text_run: PDF::Reader::TextRun).returns(T::Boolean) }
+      def evaluate_filter(text_run); end
+
+      sig { params(text_run: PDF::Reader::TextRun, conditions: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Boolean) }
+      def evaluate_or_filters(text_run, conditions); end
+
+      sig { params(text_run: PDF::Reader::TextRun, conditions: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Boolean) }
+      def evaluate_and_filters(text_run, conditions); end
+
+      sig { params(text_run: PDF::Reader::TextRun, filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def evaluate_filters(text_run, filter_hash); end
+
+      sig { params(text_run: PDF::Reader::TextRun, attribute: Symbol, conditions: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def evaluate_attribute_conditions(text_run, attribute, conditions); end
+
+      sig { params(attribute_value: T.untyped, operator: Symbol, filter_value: T.untyped).returns(T::Boolean) }
+      def apply_operator(attribute_value, operator, filter_value); end
+    end
+
     class EventPoint
       sig { returns(Numeric) }
       attr_reader :x

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader
 version: !ruby/object:Gem::Version
-  version: 2.13.0
+  version: 2.14.1
 platform: ruby
 authors:
 - James Healy
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -212,6 +211,7 @@ files:
 - examples/version.rb
 - lib/pdf-reader.rb
 - lib/pdf/reader.rb
+- lib/pdf/reader/advanced_text_run_filter.rb
 - lib/pdf/reader/aes_v2_security_handler.rb
 - lib/pdf/reader/aes_v3_security_handler.rb
 - lib/pdf/reader/afm/Courier-Bold.afm
@@ -301,10 +301,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/yob/pdf-reader/issues
-  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.13.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.13.0
-  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.13.0
-post_install_message:
+  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.14.1/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.14.1
+  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.14.1
 rdoc_options:
 - "--title"
 - PDF::Reader Documentation
@@ -317,15 +316,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A library for accessing the content of PDF files
 test_files: []