pdf-reader 2.12.0 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b00946c8b23b65d19ace187550b15bb3fd2537e518c778f4c12da28672c9d8
-  data.tar.gz: 4c2ebeb19dada9f257fa65c2add2f2f6d64f011cb13e997533a4b63fc81baa6d
+  metadata.gz: 7174f6e8c3c655cc9a1c120e5f0b99d06b0c2355803480d1cf8347c1825ddb01
+  data.tar.gz: ade7c031fe3c3d6e022125ccd3ef65a9482e21a7d90e6ea9d9d65aeeee3b30e8
 SHA512:
-  metadata.gz: 99c9ac879424056221f616d7f7299d03dfc9906c6b81c333ad255439780cf56d2dfc0c31a62347a7a163bcdb4075f8d0c914e2deeebb5d78e8ebc34e19cd7abc
-  data.tar.gz: 50ef8b5e1061dd1d6b24a7727b5537664bcb22473757274b4cc2b92c89b9ba5ea7516f055571f5c8b72d678f7cef549858631408c86a6984196ba7d1773daaca
+  metadata.gz: '08d343015a23dd678264053ade37a3449c91bdfda9764c65bc6ae196529062c33272ffe191beaea9f1e20d31cb1de9c117535e27fee763968e822288324931c6'
+  data.tar.gz: 8b0df463cc6292048f0ad68dd682131d53a4bc9630f84841103f8c73a6c837e91cdf5af08f98c255bcefc7d2a67146387d26ab0c3cbece42853f2581981a613b

data/CHANGELOG

@@ -1,3 +1,7 @@
+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)
+
 v2.12.0 (26th December 2023)
 - Fix a sorbet method signature (http://github.com/yob/pdf-reader/pull/512)
 - Reduce allocations when parsing PDFs with hex strings (http://github.com/yob/pdf-reader/pull/528)

data/README.md

@@ -20,7 +20,7 @@ page.
 The recommended installation method is via Rubygems.
 
 ```ruby
-  gem install pdf-reader
+gem install pdf-reader
 ```
 
 # Usage
@@ -30,23 +30,23 @@ level information (metadata, page count, bookmarks, etc) is available via
 this object.
 
 ```ruby
-    reader = PDF::Reader.new("somefile.pdf")
+reader = PDF::Reader.new("somefile.pdf")
 
-    puts reader.pdf_version
-    puts reader.info
-    puts reader.metadata
-    puts reader.page_count
+puts reader.pdf_version
+puts reader.info
+puts reader.metadata
+puts reader.page_count
  ```
 
 PDF::Reader.new accepts an IO stream or a filename. Here's an example with
 an IO stream:
 
 ```ruby
-    require 'open-uri'
+require 'open-uri'
 
-    io     = open('http://example.com/somefile.pdf')
-    reader = PDF::Reader.new(io)
-    puts reader.info
+io     = open('http://example.com/somefile.pdf')
+reader = PDF::Reader.new(io)
+puts reader.info
  ```
 
 If you open a PDF with File#open or IO#open, I strongly recommend using "rb"
@@ -54,47 +54,47 @@ mode to ensure the file isn't mangled by ruby being 'helpful'. This is
 particularly important on windows and MRI >= 1.9.2.
 
 ```ruby
-    File.open("somefile.pdf", "rb") do |io|
-      reader = PDF::Reader.new(io)
-      puts reader.info
-    end
+File.open("somefile.pdf", "rb") do |io|
+  reader = PDF::Reader.new(io)
+  puts reader.info
+end
  ```
 
 PDF is a page based file format, so most visible information is available via
 page-based iteration
 
 ```ruby
-    reader = PDF::Reader.new("somefile.pdf")
+reader = PDF::Reader.new("somefile.pdf")
 
-    reader.pages.each do |page|
-      puts page.fonts
-      puts page.text
-      puts page.raw_content
-    end
+reader.pages.each do |page|
+  puts page.fonts
+  puts page.text
+  puts page.raw_content
+end
 ```
 
 If you need to access the full program for rendering a page, use the walk() method
 of PDF::Reader::Page.
 
 ```ruby
-    class RedGreenBlue
-      def set_rgb_color_for_nonstroking(r, g, b)
-        puts "R: #{r}, G: #{g}, B: #{b}"
-      end
-    end
-
-    reader   = PDF::Reader.new("somefile.pdf")
-    page     = reader.page(1)
-    receiver = RedGreenBlue.new
-    page.walk(receiver)
+class RedGreenBlue
+  def set_rgb_color_for_nonstroking(r, g, b)
+    puts "R: #{r}, G: #{g}, B: #{b}"
+  end
+end
+
+reader   = PDF::Reader.new("somefile.pdf")
+page     = reader.page(1)
+receiver = RedGreenBlue.new
+page.walk(receiver)
 ```
 
 For low level access to the objects in a PDF file, use the ObjectHash class like
 so:
 
 ```ruby
-    reader  = PDF::Reader.new("somefile.pdf")
-    puts reader.objects.inspect
+reader  = PDF::Reader.new("somefile.pdf")
+puts reader.objects.inspect
 ```
 
 # Text Encoding
@@ -141,7 +141,7 @@ the spec folder when you checkout a branch from Git.
 To remove any invalid CRLF characters added while checking out a branch from Git, run:
 
 ```ruby
-    rake fix_integrity
+rake fix_integrity
 ```
 
 # Maintainers

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

@@ -4,7 +4,7 @@ module PDF
     sig { returns(PDF::Reader::ObjectHash) }
     attr_reader :objects
 
-    sig { params(input: T.any(String, Tempfile, IO), opts: T::Hash[T.untyped, T.untyped]).void }
+    sig { params(input: T.any(String, Tempfile, IO, StringIO), opts: T::Hash[T.untyped, T.untyped]).void }
     def initialize(input, opts = {})
       @cache = T.let(T.unsafe(nil), PDF::Reader::ObjectCache)
       @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash)
@@ -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.12.0
+  version: 2.14.0
 platform: ruby
 authors:
 - James Healy
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-26 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,16 +97,28 @@ dependencies:
   name: Ascii85
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: ruby-rc4
   requirement: !ruby/object:Gem::Requirement
@@ -200,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
@@ -289,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.12.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.12.0
-  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.12.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
@@ -305,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: []