pdf-reader 2.13.0 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5db630726ada74d004eb928e8cf164d9a65070150bc99268bed3c3c22a4b16fd
-  data.tar.gz: 186960431832f9808e292e823a1b8cd3ccbe96bf89b7f8e6801b111b0899b690
+  metadata.gz: 7174f6e8c3c655cc9a1c120e5f0b99d06b0c2355803480d1cf8347c1825ddb01
+  data.tar.gz: ade7c031fe3c3d6e022125ccd3ef65a9482e21a7d90e6ea9d9d65aeeee3b30e8
 SHA512:
-  metadata.gz: 4cc29c3f7d3dd36ff55178c6825dab455bbfd9f3e3b62298dac03a835c741ffeebaa1959f3b3ceba19c82fe8a516acad554ad41e5142bd4a8c75a9725857fc96
-  data.tar.gz: a89f8815c83d6f89bc51e3aa232776d6d365eb45f0cbfd01ae9de157390144c9ff8bdbdf3e1359048612d3febeffbfd77a01d0c2b08da0b53dad64b6290f6292
+  metadata.gz: '08d343015a23dd678264053ade37a3449c91bdfda9764c65bc6ae196529062c33272ffe191beaea9f1e20d31cb1de9c117535e27fee763968e822288324931c6'
+  data.tar.gz: 8b0df463cc6292048f0ad68dd682131d53a4bc9630f84841103f8c73a6c837e91cdf5af08f98c255bcefc7d2a67146387d26ab0c3cbece42853f2581981a613b

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[TextRun], filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Array[TextRun]) }
+      def self.only(text_runs, filter_hash); end
+
+      sig { params(text_runs: T::Array[TextRun], filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Array[TextRun]) }
+      def self.exclude(text_runs, filter_hash); end
+
+      sig { returns(T::Array[TextRun]) }
+      attr_reader :text_runs
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :filter_hash
+
+      sig { params(text_runs: T::Array[TextRun], filter_hash: T::Hash[Symbol, T.untyped]).void }
+      def initialize(text_runs, filter_hash)
+        @text_runs = T.let(T.unsafe(nil), T::Array[TextRun])
+        @filter_hash = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+      end
+
+      sig { returns(T::Array[TextRun]) }
+      def only; end
+
+      sig { returns(T::Array[TextRun]) }
+      def exclude; end
+
+      sig { params(text_run: TextRun).returns(T::Boolean) }
+      def evaluate_filter(text_run); end
+
+      sig { params(text_run: TextRun, conditions: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Boolean) }
+      def evaluate_or_filters(text_run, conditions); end
+
+      sig { params(text_run: TextRun, conditions: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Boolean) }
+      def evaluate_and_filters(text_run, conditions); end
+
+      sig { params(text_run: TextRun, filter_hash: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def evaluate_filters(text_run, filter_hash); end
+
+      sig { params(text_run: 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.0
 platform: ruby
 authors:
 - James Healy
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 2025-01-29 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.0/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.14.0
+  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.14.0
 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: []