Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package rubygem-pdf-reader for openSUSE:Factory checked in at 2022-10-30 18:28:56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-pdf-reader (Old) and /work/SRC/openSUSE:Factory/.rubygem-pdf-reader.new.2275 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-pdf-reader" Sun Oct 30 18:28:56 2022 rev:8 rq:1032151 version:2.11.0 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-pdf-reader/rubygem-pdf-reader.changes 2022-08-05 19:52:10.637637912 +0200 +++ /work/SRC/openSUSE:Factory/.rubygem-pdf-reader.new.2275/rubygem-pdf-reader.changes 2022-10-30 18:29:12.478504990 +0100 @@ -1,0 +2,11 @@ +Fri Oct 28 05:02:51 UTC 2022 - Stephan Kulow <[email protected]> + +updated to version 2.11.0 + see installed CHANGELOG + + v2.11.0 (26th October 2022) + - Various bug fixes + - Expanded sorbet type annotations + + +------------------------------------------------------------------- Old: ---- pdf-reader-2.10.0.gem New: ---- pdf-reader-2.11.0.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-pdf-reader.spec ++++++ --- /var/tmp/diff_new_pack.Ag5aaR/_old 2022-10-30 18:29:13.930512836 +0100 +++ /var/tmp/diff_new_pack.Ag5aaR/_new 2022-10-30 18:29:13.938512879 +0100 @@ -24,7 +24,7 @@ # Name: rubygem-pdf-reader -Version: 2.10.0 +Version: 2.11.0 Release: 0 %define mod_name pdf-reader %define mod_full_name %{mod_name}-%{version} ++++++ pdf-reader-2.10.0.gem -> pdf-reader-2.11.0.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/CHANGELOG new/CHANGELOG --- old/CHANGELOG 2022-05-12 01:08:31.000000000 +0200 +++ new/CHANGELOG 2022-10-26 13:21:29.000000000 +0200 @@ -1,3 +1,7 @@ +v2.11.0 (26th October 2022) +- Various bug fixes +- Expanded sorbet type annotations + v2.10.0 (12th May 2022) - Various bug fixes - Expanded sorbet type annotations diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Rakefile new/Rakefile --- old/Rakefile 2022-05-12 01:08:31.000000000 +0200 +++ new/Rakefile 2022-10-26 13:21:29.000000000 +0200 @@ -14,7 +14,7 @@ Cane::RakeTask.new(:quality) do |cane| cane.abc_max = 20 cane.style_measure = 100 - cane.max_violations = 28 + cane.max_violations = 33 cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb" end Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/buffer.rb new/lib/pdf/reader/buffer.rb --- old/lib/pdf/reader/buffer.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/buffer.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: ASCII-8BIT -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/cid_widths.rb new/lib/pdf/reader/cid_widths.rb --- old/lib/pdf/reader/cid_widths.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/cid_widths.rb 2022-10-26 13:21:29.000000000 +0200 @@ -52,7 +52,9 @@ # this is the form 10 20 123 where all index between 10 and 20 have width 123 def parse_second_form(first, final, width) - raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}" unless first < final + if first > final + raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}" + end (first..final).inject({}) { |accum, index| accum[index] = width diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/cmap.rb new/lib/pdf/reader/cmap.rb --- old/lib/pdf/reader/cmap.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/cmap.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/encoding.rb new/lib/pdf/reader/encoding.rb --- old/lib/pdf/reader/encoding.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/encoding.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ @@ -76,9 +76,9 @@ diff.each do |val| if val.kind_of?(Numeric) byte = val.to_i - else + elsif codepoint = glyphlist.name_to_unicode(val) @differences[byte] = val - @mapping[byte] = glyphlist.name_to_unicode(val) + @mapping[byte] = codepoint byte += 1 end end @@ -167,7 +167,7 @@ end def convert_to_utf8(str) - ret = str.unpack(unpack).map! { |c| @mapping[c] || c }.pack("U*") + ret = str.unpack(unpack).map! { |c| @mapping[c.to_i] || c }.pack("U*") ret.force_encoding("UTF-8") ret end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/filter/depredict.rb new/lib/pdf/reader/filter/depredict.rb --- old/lib/pdf/reader/filter/depredict.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/filter/depredict.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/glyph_hash.rb new/lib/pdf/reader/glyph_hash.rb --- old/lib/pdf/reader/glyph_hash.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/glyph_hash.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ @@ -33,10 +33,18 @@ # class GlyphHash # :nodoc: def initialize + @@by_codepoint_cache ||= nil + @@by_name_cache ||= nil + # only parse the glyph list once, and cache the results (for performance) - adobe = @@cache ||= load_adobe_glyph_mapping - @by_name = adobe.first - @by_codepoint = adobe.last + if @@by_codepoint_cache != nil && @@by_name_cache != nil + @by_name = @@by_name_cache + @by_codepoint = @@by_codepoint_cache + else + by_name, by_codepoint = load_adobe_glyph_mapping + @by_name = @@by_name_cache ||= by_name + @by_codepoint = @@by_codepoint_cache ||= by_codepoint + end end # attempt to convert a PDF Name to a unicode codepoint. Returns nil @@ -127,7 +135,7 @@ end end - [keyed_by_name.freeze, keyed_by_codepoint.freeze] + return keyed_by_name.freeze, keyed_by_codepoint.freeze end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/no_text_filter.rb new/lib/pdf/reader/no_text_filter.rb --- old/lib/pdf/reader/no_text_filter.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/pdf/reader/no_text_filter.rb 2022-10-26 13:21:29.000000000 +0200 @@ -0,0 +1,14 @@ +# coding: utf-8 +# typed: strict +# frozen_string_literal: true + +class PDF::Reader + # There's no point rendering zero-width characters + class NoTextFilter + + def self.exclude_empty_strings(runs) + runs.reject { |run| run.text.to_s.size == 0 } + end + end +end + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/object_hash.rb new/lib/pdf/reader/object_hash.rb --- old/lib/pdf/reader/object_hash.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/object_hash.rb 2022-10-26 13:21:29.000000000 +0200 @@ -2,6 +2,8 @@ # typed: true # frozen_string_literal: true +require 'tempfile' + class PDF::Reader # Provides low level access to the objects in a PDF file via a hash-like # object. @@ -566,7 +568,7 @@ end def object_streams - @object_stream ||= {} + @object_streams ||= {} end # returns an array of object references for all pages in this object store. The ordering of @@ -591,18 +593,18 @@ def read_version @io.seek(0) - _m, version = *@io.read(10).match(/PDF-(\d.\d)/) + _m, version = *@io.read(10).to_s.match(/PDF-(\d.\d)/) @io.seek(0) version.to_f end def extract_io_from(input) - if input.respond_to?(:seek) && input.respond_to?(:read) + if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile) input elsif File.file?(input.to_s) - StringIO.new read_as_binary(input) + StringIO.new read_as_binary(input.to_s) else - raise ArgumentError, "input must be an IO-like object or a filename" + raise ArgumentError, "input must be an IO-like object or a filename (#{input.class})" end end @@ -610,7 +612,7 @@ if File.respond_to?(:binread) File.binread(input.to_s) else - File.open(input.to_s,"rb") { |f| f.read } + File.open(input.to_s,"rb") { |f| f.read } || "" end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/object_stream.rb new/lib/pdf/reader/object_stream.rb --- old/lib/pdf/reader/object_stream.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/object_stream.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/overlapping_runs_filter.rb new/lib/pdf/reader/overlapping_runs_filter.rb --- old/lib/pdf/reader/overlapping_runs_filter.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/overlapping_runs_filter.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,6 +1,6 @@ -# typed: true # coding: utf-8 # frozen_string_literal: true +# typed: strict class PDF::Reader # remove duplicates from a collection of TextRun objects. This can be helpful when a PDF diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/page.rb new/lib/pdf/reader/page.rb --- old/lib/pdf/reader/page.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/page.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true module PDF @@ -43,10 +43,10 @@ # def initialize(objects, pagenum, options = {}) @objects, @pagenum = objects, pagenum - @page_object = objects.deref_hash(objects.page_references[pagenum - 1]) + @page_object = objects.deref_hash(objects.page_references[pagenum - 1]) || {} @cache = options[:cache] || {} - unless @page_object.is_a?(::Hash) + if @page_object.empty? raise InvalidPageError, "Invalid page: #{pagenum}" end end @@ -250,8 +250,8 @@ params = [] while (token = parser.parse_token(PagesStrategy::OPERATORS)) - if token.kind_of?(Token) and PagesStrategy::OPERATORS.has_key?(token) - callback(receivers, PagesStrategy::OPERATORS[token], params) + if token.kind_of?(Token) && method_name = PagesStrategy::OPERATORS[token] + callback(receivers, method_name, params) params.clear else params << token @@ -263,9 +263,26 @@ # calls the name callback method on each receiver object with params as the arguments # + # The silly style here is because sorbet won't let me use splat arguments + # def callback(receivers, name, params=[]) receivers.each do |receiver| - receiver.send(name, *params) if receiver.respond_to?(name) + if receiver.respond_to?(name) + case params.size + when 0 then receiver.send(name) + when 1 then receiver.send(name, params[0]) + when 2 then receiver.send(name, params[0], params[1]) + when 3 then receiver.send(name, params[0], params[1], params[2]) + when 4 then receiver.send(name, params[0], params[1], params[2], params[3]) + when 5 then receiver.send(name, params[0], params[1], params[2], params[3], params[4]) + when 6 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5]) + when 7 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6]) + when 8 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]) + when 9 then receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8]) + else + receiver.send(name, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9]) + end + end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/page_layout.rb new/lib/pdf/reader/page_layout.rb --- old/lib/pdf/reader/page_layout.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/page_layout.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true require 'pdf/reader/overlapping_runs_filter' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/page_text_receiver.rb new/lib/pdf/reader/page_text_receiver.rb --- old/lib/pdf/reader/page_text_receiver.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/page_text_receiver.rb 2022-10-26 13:21:29.000000000 +0200 @@ -62,6 +62,8 @@ runs = OverlappingRunsFilter.exclude_redundant_runs(runs) end + runs = NoTextFilter.exclude_empty_strings(runs) + if opts.fetch(:merge, true) runs = merge_runs(runs) end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/pages_strategy.rb new/lib/pdf/reader/pages_strategy.rb --- old/lib/pdf/reader/pages_strategy.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/pages_strategy.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/reference.rb new/lib/pdf/reader/reference.rb --- old/lib/pdf/reader/reference.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/reference.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ @@ -31,7 +31,8 @@ ################################################################################ # An internal PDF::Reader class that represents an indirect reference to a PDF Object class Reference - attr_reader :id, :gen + attr_reader :id + attr_reader :gen ################################################################################ # Create a new Reference to an object with the specified id and revision number def initialize(id, gen) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/resources.rb new/lib/pdf/reader/resources.rb --- old/lib/pdf/reader/resources.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/resources.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true module PDF diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/synchronized_cache.rb new/lib/pdf/reader/synchronized_cache.rb --- old/lib/pdf/reader/synchronized_cache.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/synchronized_cache.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # encoding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true # utilities.rb : General-purpose utility classes which don't fit anywhere else diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/text_run.rb new/lib/pdf/reader/text_run.rb --- old/lib/pdf/reader/text_run.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/text_run.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -7,7 +7,10 @@ class TextRun include Comparable - attr_reader :origin, :width, :font_size, :text + attr_reader :origin + attr_reader :width + attr_reader :font_size + attr_reader :text alias :to_s :text diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/transformation_matrix.rb new/lib/pdf/reader/transformation_matrix.rb --- old/lib/pdf/reader/transformation_matrix.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/transformation_matrix.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -51,7 +51,7 @@ # displacement to speed up processing documents that use vertical # writing systems # - def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil) + def multiply!(a,b,c, d,e,f) if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0 # the identity matrix, no effect self @@ -164,12 +164,12 @@ # [ e f 1 ] [ e f 1 ] # def regular_multiply!(a2,b2,c2,d2,e2,f2) - newa = (@a * a2) + (@b * c2) + (0 * e2) - newb = (@a * b2) + (@b * d2) + (0 * f2) - newc = (@c * a2) + (@d * c2) + (0 * e2) - newd = (@c * b2) + (@d * d2) + (0 * f2) - newe = (@e * a2) + (@f * c2) + (1 * e2) - newf = (@e * b2) + (@f * d2) + (1 * f2) + newa = (@a * a2) + (@b * c2) + (e2 * 0) + newb = (@a * b2) + (@b * d2) + (f2 * 0) + newc = (@c * a2) + (@d * c2) + (e2 * 0) + newd = (@c * b2) + (@d * d2) + (f2 * 0) + newe = (@e * a2) + (@f * c2) + (e2 * 1) + newf = (@e * b2) + (@f * d2) + (f2 * 1) @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/width_calculator/built_in.rb new/lib/pdf/reader/width_calculator/built_in.rb --- old/lib/pdf/reader/width_calculator/built_in.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/width_calculator/built_in.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true require 'afm' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/xref.rb new/lib/pdf/reader/xref.rb --- old/lib/pdf/reader/xref.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader/xref.rb 2022-10-26 13:21:29.000000000 +0200 @@ -73,7 +73,7 @@ # # ref - a PDF::Reader::Reference object containing an object ID and revision number def [](ref) - @xref[ref.id][ref.gen] + @xref.fetch(ref.id, {}).fetch(ref.gen) rescue raise InvalidObjectError, "Object #{ref.id}, Generation #{ref.gen} is invalid" end @@ -82,8 +82,8 @@ def each(&block) ids = @xref.keys.sort ids.each do |id| - gen = @xref[id].keys.sort[-1] - yield PDF::Reader::Reference.new(id, gen) + gen = @xref.fetch(id, {}).keys.sort[-1] + yield PDF::Reader::Reference.new(id, gen.to_i) end end ################################################################################ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader.rb new/lib/pdf/reader.rb --- old/lib/pdf/reader.rb 2022-05-12 01:08:31.000000000 +0200 +++ new/lib/pdf/reader.rb 2022-10-26 13:21:29.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true ################################################################################ @@ -128,7 +128,7 @@ doc_strings_to_utf8(dict) end - # Return a Hash with extra metadata provided by the author of the PDF file. Not + # Return a String with extra XML metadata provided by the author of the PDF file. Not # always present. # def metadata @@ -182,7 +182,7 @@ # # reader.pages.each do |page| # puts page.fonts - # puts page.images + # puts page.rectangles # puts page.text # end # @@ -272,13 +272,7 @@ end def root - @root ||= begin - obj = @objects.deref_hash(@objects.trailer[:Root]) || {} - unless obj.kind_of?(::Hash) - raise MalformedPDFError, "PDF malformed, trailer Root should be a dictionary" - end - obj - end + @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {} end end @@ -315,6 +309,7 @@ require 'pdf/reader/rectangle' require 'pdf/reader/reference' require 'pdf/reader/register_receiver' +require 'pdf/reader/no_text_filter' require 'pdf/reader/null_security_handler' require 'pdf/reader/security_handler_factory' require 'pdf/reader/standard_key_builder' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2022-05-12 01:08:31.000000000 +0200 +++ new/metadata 2022-10-26 13:21:29.000000000 +0200 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: pdf-reader version: !ruby/object:Gem::Version - version: 2.10.0 + version: 2.11.0 platform: ruby authors: - James Healy autorequire: bindir: bin cert_chain: [] -date: 2022-05-11 00:00:00.000000000 Z +date: 2022-10-26 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: rake @@ -246,6 +246,7 @@ - lib/pdf/reader/glyphlist.txt - lib/pdf/reader/key_builder_v5.rb - lib/pdf/reader/lzw.rb +- lib/pdf/reader/no_text_filter.rb - lib/pdf/reader/null_security_handler.rb - lib/pdf/reader/object_cache.rb - lib/pdf/reader/object_hash.rb @@ -288,9 +289,9 @@ - MIT metadata: bug_tracker_uri: https://github.com/yob/pdf-reader/issues - changelog_uri: https://github.com/yob/pdf-reader/blob/v2.10.0/CHANGELOG - documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.10.0 - source_code_uri: https://github.com/yob/pdf-reader/tree/v2.10.0 + changelog_uri: https://github.com/yob/pdf-reader/blob/v2.11.0/CHANGELOG + documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.11.0 + source_code_uri: https://github.com/yob/pdf-reader/tree/v2.11.0 post_install_message: rdoc_options: - "--title" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/rbi/pdf-reader.rbi new/rbi/pdf-reader.rbi --- old/rbi/pdf-reader.rbi 2022-05-12 01:08:31.000000000 +0200 +++ new/rbi/pdf-reader.rbi 2022-10-26 13:21:29.000000000 +0200 @@ -1,16 +1,21 @@ # typed: strong module PDF class Reader - sig { returns(T.untyped) } + sig { returns(PDF::Reader::ObjectHash) } attr_reader :objects - sig { params(input: T.any(String, IO), opts: T::Hash[T.untyped, T.untyped]).void } - def initialize(input, opts = {}); end + sig { params(input: T.any(String, Tempfile, IO), 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) + @page_count = T.let(T.unsafe(nil), T.nilable(Integer)) + @root = T.let(T.unsafe(nil), T.nilable(T.nilable(T::Hash[Symbol, T.untyped]))) + end sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) } def info; end - sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) } + sig { returns(T.nilable(String)) } def metadata; end sig { returns(Integer) } @@ -19,7 +24,7 @@ sig { returns(Float) } def pdf_version; end - sig { params(input: T.any(String, IO), opts: T::Hash[T.untyped, T.untyped], block: T.proc.params(arg0: PDF::Reader).void).returns(T.untyped) } + sig { params(input: T.any(String, Tempfile, IO), opts: T::Hash[T.untyped, T.untyped], block: T.proc.params(arg0: PDF::Reader).void).returns(T.untyped) } def self.open(input, opts = {}, &block); end sig { returns(T::Array[PDF::Reader::Page]) } @@ -70,28 +75,29 @@ end class Buffer - TOKEN_WHITESPACE = [0x00, 0x09, 0x0A, 0x0C, 0x0D, 0x20] - TOKEN_DELIMITER = [0x25, 0x3C, 0x3E, 0x28, 0x5B, 0x7B, 0x29, 0x5D, 0x7D, 0x2F] - LEFT_PAREN = "(" - LESS_THAN = "<" - STREAM = "stream" - ID = "ID" - FWD_SLASH = "/" - NULL_BYTE = "\x00" - CR = "\r" - LF = "\n" - CRLF = "\r\n" - WHITE_SPACE = [LF, CR, ' '] - TRAILING_BYTECOUNT = 5000 + 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) sig { returns(Integer) } attr_reader :pos - sig { params(io: T.any(StringIO, File), opts: T::Hash[Symbol, T.untyped]).void } + sig { params(io: T.any(StringIO, Tempfile, IO), opts: T::Hash[Symbol, T.untyped]).void } def initialize(io, opts = {}) @pos = T.let(T.unsafe(nil), Integer) @tokens = T.let(T.unsafe(nil), T::Array[T.any(String, PDF::Reader::Reference)]) - @io = T.let(T.unsafe(nil), T.any(StringIO, File)) + @io = T.let(T.unsafe(nil), T.any(StringIO, Tempfile, IO)) @in_content_stream = T.let(T.unsafe(nil), T::Boolean) end @@ -161,17 +167,7 @@ end class CMap - CMAP_KEYWORDS = { - "begincodespacerange" => 1, - "endcodespacerange" => 1, - "beginbfchar" => 1, - "endbfchar" => 1, - "beginbfrange" => 1, - "endbfrange" => 1, - "begin" => 1, - "begincmap" => 1, - "def" => 1 - } + CMAP_KEYWORDS = T.let(T.unsafe(nil), T::Hash[String, Symbol]) sig { returns(T.untyped) } attr_reader :map @@ -210,20 +206,27 @@ end class Encoding - CONTROL_CHARS = [0,1,2,3,4,5,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23, - 24,25,26,27,28,29,30,31] - UNKNOWN_CHAR = 0x25AF + CONTROL_CHARS = T.let(T.unsafe(nil), T::Array[Integer]) + UNKNOWN_CHAR = T.let(T.unsafe(nil), Integer) - sig { returns(T.untyped) } + sig { returns(String) } attr_reader :unpack sig { params(enc: T.untyped).void } - def initialize(enc); end + def initialize(enc) + @mapping = T.let(T.unsafe(nil), T::Hash[Integer, Integer]) + @unpack = T.let(T.unsafe(nil), String) + @enc_name = T.let(T.unsafe(nil), Symbol) + @string_cache = T.let(T.unsafe(nil), T::Hash[Integer, String]) + @map_file = T.let(T.unsafe(nil), T.nilable(String)) + @differences = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, Integer])) + @glyphlist = T.let(T.unsafe(nil), T.nilable(PDF::Reader::GlyphHash)) + end - sig { params(diff: T.untyped).returns(T.untyped) } + sig { params(diff: T::Array[T.any(Integer, Symbol)]).returns(T::Hash[Integer, Integer]) } def differences=(diff); end - sig { returns(T.untyped) } + sig { returns(T::Hash[Integer, Integer]) } def differences; end sig { params(str: String).returns(String) } @@ -235,31 +238,31 @@ sig { params(glyph_code: Integer).returns(T::Array[Symbol]) } def int_to_name(glyph_code); end - sig { returns(T.untyped) } + sig { returns(T::Hash[Integer, Integer]) } def default_mapping; end - sig { params(glyph_code: T.untyped).returns(T.untyped) } + sig { params(glyph_code: Integer).returns(String) } def internal_int_to_utf8_string(glyph_code); end - sig { returns(T.untyped) } + sig { returns(T::Boolean) } def utf8_conversion_impossible?; end - sig { params(times: T.untyped).returns(T.untyped) } + sig { params(times: Integer).returns(String) } def little_boxes(times); end - sig { params(str: T.untyped).returns(T.untyped) } + sig { params(str: String).returns(String) } def convert_to_utf8(str); end - sig { params(enc: T.untyped).returns(T.untyped) } + sig { params(enc: T.untyped).returns(String) } def get_unpack(enc); end - sig { params(enc: T.untyped).returns(T.untyped) } + sig { params(enc: T.untyped).returns(T.nilable(String)) } def get_mapping_file(enc); end - sig { returns(T.untyped) } + sig { returns(PDF::Reader::GlyphHash) } def glyphlist; end - sig { params(file: T.untyped).returns(T.untyped) } + sig { params(file: String).void } def load_mapping(file); end end @@ -474,16 +477,22 @@ end class GlyphHash + @@by_name_cache = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, Integer])) + @@by_codepoint_cache = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, T::Array[Symbol]])) + sig { void } - def initialize; end + def initialize + @by_name = T.let(T.unsafe(nil), T::Hash[Symbol, Integer]) + @by_codepoint = T.let(T.unsafe(nil), T::Hash[Integer, T::Array[Symbol]]) + end - sig { params(name: T.untyped).returns(T.untyped) } + sig { params(name: T.nilable(Symbol)).returns(T.nilable(Integer)) } def name_to_unicode(name); end - sig { params(codepoint: T.untyped).returns(T.untyped) } + sig { params(codepoint: T.nilable(Integer)).returns(T::Array[Symbol]) } def unicode_to_name(codepoint); end - sig { returns(T.untyped) } + sig { returns([T::Hash[Symbol, Integer], T::Hash[Integer, T::Array[Symbol]]]) } def load_adobe_glyph_mapping; end end @@ -633,25 +642,45 @@ sig { returns(T.untyped) } attr_accessor :default - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :trailer - sig { returns(T.untyped) } + sig { returns(Float) } attr_reader :pdf_version - sig { returns(T.untyped) } + sig { returns( + T.any( + PDF::Reader::NullSecurityHandler, + PDF::Reader::AesV2SecurityHandler, + PDF::Reader::AesV3SecurityHandler, + PDF::Reader::Rc4SecurityHandler, + )) } attr_reader :sec_handler - sig { params(input: T.untyped, opts: T.untyped).void } - def initialize(input, opts = {}); end + sig { params(input: T.any(IO, Tempfile, StringIO, String), opts: T::Hash[Symbol, T.untyped]).void } + def initialize(input, opts = {}) + @io = T.let(T.unsafe(nil), T.any(IO, Tempfile, StringIO)) + @xref = T.let(T.unsafe(nil), PDF::Reader::XRef) + @pdf_version = T.let(T.unsafe(nil), Float) + @trailer = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) + @cache = T.let(T.unsafe(nil), PDF::Reader::ObjectCache) + @sec_handler = T.let(T.unsafe(nil), T.any( + PDF::Reader::NullSecurityHandler, + PDF::Reader::AesV2SecurityHandler, + PDF::Reader::AesV3SecurityHandler, + PDF::Reader::Rc4SecurityHandler, + )) + @page_references = T.let(T.unsafe(nil), T.nilable(T::Array[T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])])) + @object_streams = T.let(T.unsafe(nil), T.nilable(T::Hash[PDF::Reader::Reference, PDF::Reader::ObjectStream])) + end - sig { params(ref: T.untyped).returns(T.untyped) } + sig { params(ref: T.any(Integer, PDF::Reader::Reference)).returns(T.nilable(Symbol)) } def obj_type(ref); end - sig { params(ref: T.untyped).returns(T.untyped) } + sig { params(ref: T.any(Integer, PDF::Reader::Reference)).returns(T::Boolean) } def stream?(ref); end - sig { params(key: T.untyped).returns(T.untyped) } + sig { params(key: T.any(Integer, PDF::Reader::Reference)).returns(T.untyped) } def [](key); end sig { params(key: T.untyped).returns(T.untyped) } @@ -735,7 +764,7 @@ sig { returns(T.untyped) } def to_a; end - sig { returns(T::Array[PDF::Reader::Reference]) } + sig { returns(T::Array[T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])]) } def page_references; end sig { returns(T::Boolean) } @@ -765,16 +794,16 @@ sig { returns(T.untyped) } def object_streams; end - sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Array[T::Hash[T.untyped, T.untyped]]) } + sig { params(obj: T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])).returns(T::Array[T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])]) } def get_page_objects(obj); end sig { returns(Float) } def read_version; end - sig { params(input: T.untyped).returns(IO) } + sig { params(input: T.any(IO, Tempfile, StringIO, String)).returns(T.any(IO, Tempfile, StringIO)) } def extract_io_from(input); end - sig { params(input: T.untyped).returns(T.untyped) } + sig { params(input: String).returns(String) } def read_as_binary(input); end end @@ -783,9 +812,15 @@ def initialize(stream) @dict = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) @data = T.let(T.unsafe(nil), String) + @offsets = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, Integer])) + @buffer = T.let(T.unsafe(nil), T.nilable(PDF::Reader::Buffer)) end - sig { params(objid: T.untyped).returns(T.untyped) } + sig { + params(objid: Integer).returns( + T.any(PDF::Reader::Reference, PDF::Reader::Token, Numeric, String, Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped], NilClass) + ) + } def [](objid); end sig { returns(Integer) } @@ -802,7 +837,7 @@ end class OverlappingRunsFilter - OVERLAPPING_THRESHOLD = 0.5 + OVERLAPPING_THRESHOLD = T.let(T.unsafe(nil), Float) sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) } def self.exclude_redundant_runs(runs); end @@ -811,6 +846,11 @@ def self.detect_intersection(sweep_line_status, event_point); end end + class NoTextFilter + sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) } + def self.exclude_empty_strings(runs); end + end + class EventPoint sig { returns(Numeric) } attr_reader :x @@ -819,7 +859,10 @@ attr_reader :run sig { params(x: Numeric, run: PDF::Reader::TextRun).void } - def initialize(x, run); end + def initialize(x, run) + @x = T.let(T.unsafe(nil), Numeric) + @run = T.let(T.unsafe(nil), PDF::Reader::TextRun) + end sig { returns(T::Boolean) } def start?; end @@ -829,14 +872,22 @@ sig { returns(PDF::Reader::ObjectHash) } attr_reader :objects - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :page_object - sig { returns(T.untyped) } + sig { returns(T.any(PDF::Reader::ObjectCache, T::Hash[T.untyped, T.untyped])) } attr_reader :cache sig { params(objects: PDF::Reader::ObjectHash, pagenum: Integer, options: T::Hash[Symbol, T.untyped]).void } - def initialize(objects, pagenum, options = {}); end + def initialize(objects, pagenum, options = {}) + @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash) + @pagenum = T.let(T.unsafe(nil), Integer) + @page_object = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) + @cache = T.let(T.unsafe(nil), T.any(PDF::Reader::ObjectCache, T::Hash[T.untyped, T.untyped])) + @attributes = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, T.untyped])) + @root = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, T.untyped])) + @resources = T.let(T.unsafe(nil), T.nilable(PDF::Reader::Resources)) + end sig { returns(Integer) } def number; end @@ -886,10 +937,10 @@ sig { returns(PDF::Reader::Resources) } def resources; end - sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) } + sig { params(receivers: T::Array[T.untyped], instructions: String).void } def content_stream(receivers, instructions); end - sig { params(receivers: T.untyped, name: T.untyped, params: T.untyped).returns(T.untyped) } + sig { params(receivers: T::Array[Object], name: Symbol, params: T::Array[T.untyped]).void } def callback(receivers, name, params = []); end sig { returns(T.untyped) } @@ -903,10 +954,21 @@ end class PageLayout - DEFAULT_FONT_SIZE = 12 + DEFAULT_FONT_SIZE = T.let(T.unsafe(nil), Numeric) sig { params(runs: T::Array[PDF::Reader::TextRun], mediabox: T.any(T::Array[Numeric], PDF::Reader::Rectangle)).void } - def initialize(runs, mediabox); end + def initialize(runs, mediabox) + @mediabox = T.let(T.unsafe(nil), PDF::Reader::Rectangle) + @runs = T.let(T.unsafe(nil), T::Array[PDF::Reader::TextRun]) + @mean_font_size = T.let(T.unsafe(nil), Numeric) + @median_glyph_width = T.let(T.unsafe(nil), Numeric) + @x_offset = T.let(T.unsafe(nil), Numeric) + @y_offset = T.let(T.unsafe(nil), Numeric) + @row_count = T.let(T.unsafe(nil), T.nilable(Integer)) + @col_count = T.let(T.unsafe(nil), T.nilable(Integer)) + @row_multiplier = T.let(T.unsafe(nil), T.nilable(Numeric)) + @col_multiplier = T.let(T.unsafe(nil), T.nilable(Numeric)) + end sig { returns(String) } def to_s; end @@ -943,6 +1005,12 @@ sig { params(mediabox: T.untyped).returns(T.untyped) } def process_mediabox(mediabox); end + + sig { returns(Numeric) } + def page_width; end + + sig { returns(Numeric) } + def page_height; end end class PageState @@ -1127,81 +1195,7 @@ end class PagesStrategy - OPERATORS = { - 'b' => :close_fill_stroke, - 'B' => :fill_stroke, - 'b*' => :close_fill_stroke_with_even_odd, - 'B*' => :fill_stroke_with_even_odd, - 'BDC' => :begin_marked_content_with_pl, - 'BI' => :begin_inline_image, - 'BMC' => :begin_marked_content, - 'BT' => :begin_text_object, - 'BX' => :begin_compatibility_section, - 'c' => :append_curved_segment, - 'cm' => :concatenate_matrix, - 'CS' => :set_stroke_color_space, - 'cs' => :set_nonstroke_color_space, - 'd' => :set_line_dash, - 'd0' => :set_glyph_width, - 'd1' => :set_glyph_width_and_bounding_box, - 'Do' => :invoke_xobject, - 'DP' => :define_marked_content_with_pl, - 'EI' => :end_inline_image, - 'EMC' => :end_marked_content, - 'ET' => :end_text_object, - 'EX' => :end_compatibility_section, - 'f' => :fill_path_with_nonzero, - 'F' => :fill_path_with_nonzero, - 'f*' => :fill_path_with_even_odd, - 'G' => :set_gray_for_stroking, - 'g' => :set_gray_for_nonstroking, - 'gs' => :set_graphics_state_parameters, - 'h' => :close_subpath, - 'i' => :set_flatness_tolerance, - 'ID' => :begin_inline_image_data, - 'j' => :set_line_join_style, - 'J' => :set_line_cap_style, - 'K' => :set_cmyk_color_for_stroking, - 'k' => :set_cmyk_color_for_nonstroking, - 'l' => :append_line, - 'm' => :begin_new_subpath, - 'M' => :set_miter_limit, - 'MP' => :define_marked_content_point, - 'n' => :end_path, - 'q' => :save_graphics_state, - 'Q' => :restore_graphics_state, - 're' => :append_rectangle, - 'RG' => :set_rgb_color_for_stroking, - 'rg' => :set_rgb_color_for_nonstroking, - 'ri' => :set_color_rendering_intent, - 's' => :close_and_stroke_path, - 'S' => :stroke_path, - 'SC' => :set_color_for_stroking, - 'sc' => :set_color_for_nonstroking, - 'SCN' => :set_color_for_stroking_and_special, - 'scn' => :set_color_for_nonstroking_and_special, - 'sh' => :paint_area_with_shading_pattern, - 'T*' => :move_to_start_of_next_line, - 'Tc' => :set_character_spacing, - 'Td' => :move_text_position, - 'TD' => :move_text_position_and_set_leading, - 'Tf' => :set_text_font_and_size, - 'Tj' => :show_text, - 'TJ' => :show_text_with_positioning, - 'TL' => :set_text_leading, - 'Tm' => :set_text_matrix_and_text_line_matrix, - 'Tr' => :set_text_rendering_mode, - 'Ts' => :set_text_rise, - 'Tw' => :set_word_spacing, - 'Tz' => :set_horizontal_text_scaling, - 'v' => :append_curved_segment_initial_point_replicated, - 'w' => :set_line_width, - 'W' => :set_clipping_path_with_nonzero, - 'W*' => :set_clipping_path_with_even_odd, - 'y' => :append_curved_segment_final_point_replicated, - '\'' => :move_to_next_line_and_show_text, - '"' => :set_spacing_next_line_show_text, - } + OPERATORS = T.let(T.unsafe(nil), T::Hash[String, Symbol]) end class Parser @@ -1349,25 +1343,28 @@ end class Reference - sig { returns(T.untyped) } + sig { returns(Integer) } attr_reader :id - sig { returns(T.untyped) } + sig { returns(Integer) } attr_reader :gen - sig { params(id: T.untyped, gen: T.untyped).void } - def initialize(id, gen); end + sig { params(id: Integer, gen: Integer).void } + def initialize(id, gen) + @id = T.let(T.unsafe(nil), Integer) + @gen = T.let(T.unsafe(nil), Integer) + end - sig { returns(T.untyped) } + sig { returns(T::Array[PDF::Reader::Reference]) } def to_a; end - sig { returns(T.untyped) } + sig { returns(Integer) } def to_i; end - sig { params(obj: T.untyped).returns(T.untyped) } + sig { params(obj: Object).returns(T::Boolean) } def ==(obj); end - sig { returns(T.untyped) } + sig { returns(Integer) } def hash; end end @@ -1501,54 +1498,68 @@ class SynchronizedCache sig { void } - def initialize; end + def initialize + @cache = T.let(T.unsafe(nil), T::Hash[Object, T.untyped]) + @mutex = T.let(T.unsafe(nil), Mutex) + end - sig { params(key: T.untyped).returns(T.untyped) } + sig { params(key: Object).returns(T.untyped) } def [](key); end - sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) } + sig { params(key: Object, value: T.nilable(Object)).returns(T.untyped) } def []=(key, value); end end class TextRun include Comparable - sig { returns(T.untyped) } - attr_reader :x - - sig { returns(T.untyped) } - attr_reader :y - - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :width - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :font_size - sig { returns(T.untyped) } + sig { returns(String) } attr_reader :text + sig { returns(PDF::Reader::Point) } + attr_reader :origin + sig do params( - x: T.untyped, - y: T.untyped, - width: T.untyped, - font_size: T.untyped, - text: T.untyped + x: Numeric, + y: Numeric, + width: Numeric, + font_size: Numeric, + text: String ).void end - def initialize(x, y, width, font_size, text); end + def initialize(x, y, width, font_size, text) + @origin = T.let(T.unsafe(nil), PDF::Reader::Point) + @width = T.let(T.unsafe(nil), Numeric) + @font_size = T.let(T.unsafe(nil), Numeric) + @text = T.let(T.unsafe(nil), String) + @endx = T.let(T.unsafe(nil), T.nilable(Numeric)) + @endy = T.let(T.unsafe(nil), T.nilable(Numeric)) + @mergable_range = T.let(T.unsafe(nil), T.nilable(T::Range[Numeric])) + end sig { params(other: T.untyped).returns(T.untyped) } def <=>(other); end - sig { returns(T.untyped) } + sig { returns(Numeric) } def endx; end - sig { returns(T.untyped) } + sig { returns(Numeric) } def endy; end - sig { returns(T.untyped) } + sig { returns(Numeric) } + def x; end + + sig { returns(Numeric) } + def y; end + + sig { returns(Numeric) } def mean_character_width; end sig { params(other: PDF::Reader::TextRun).returns(T::Boolean) } @@ -1557,22 +1568,22 @@ sig { params(other: PDF::Reader::TextRun).returns(PDF::Reader::TextRun) } def +(other); end - sig { returns(T.untyped) } + sig { returns(String) } def inspect; end - sig { params(other_run: T.untyped).returns(T.untyped) } + sig { params(other_run: T.untyped).returns(T::Boolean) } def intersect?(other_run); end - sig { params(other_run: T.untyped).returns(T.untyped) } + sig { params(other_run: T.untyped).returns(Numeric) } def intersection_area_percent(other_run); end - sig { returns(T.untyped) } + sig { returns(Numeric) } def area; end - sig { returns(T.untyped) } + sig { returns(T::Range[Numeric]) } def mergable_range; end - sig { returns(T.untyped) } + sig { returns(Numeric) } def character_count; end end @@ -1582,114 +1593,121 @@ end class TransformationMatrix - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :a - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :b - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :c - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :d - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :e - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :f sig do params( - a: T.untyped, - b: T.untyped, - c: T.untyped, - d: T.untyped, - e: T.untyped, - f: T.untyped + a: Numeric, + b: Numeric, + c: Numeric, + d: Numeric, + e: Numeric, + f: Numeric ).void end - def initialize(a, b, c, d, e, f); end + def initialize(a, b, c, d, e, f) + @a = T.let(T.unsafe(nil), Numeric) + @b = T.let(T.unsafe(nil), Numeric) + @c = T.let(T.unsafe(nil), Numeric) + @d = T.let(T.unsafe(nil), Numeric) + @e = T.let(T.unsafe(nil), Numeric) + @f = T.let(T.unsafe(nil), Numeric) + end - sig { returns(T.untyped) } + sig { returns(String) } def inspect; end - sig { returns(T.untyped) } + sig { returns(T::Array[Numeric]) } def to_a; end sig do params( - a: T.untyped, - b: T.untyped, - c: T.untyped, - d: T.untyped, - e: T.untyped, - f: T.untyped - ).returns(T.untyped) + a: Numeric, + b: Numeric, + c: Numeric, + d: Numeric, + e: Numeric, + f: Numeric + ).returns(PDF::Reader::TransformationMatrix) end - def multiply!(a, b = nil, c = nil, d = nil, e = nil, f = nil); end + def multiply!(a, b, c, d, e, f); end - sig { params(e2: T.untyped).returns(T.untyped) } + sig { params(e2: Numeric).void } def horizontal_displacement_multiply!(e2); end sig do params( - a2: T.untyped, - b2: T.untyped, - c2: T.untyped, - d2: T.untyped, - e2: T.untyped, - f2: T.untyped - ).returns(T.untyped) + a2: Numeric, + b2: Numeric, + c2: Numeric, + d2: Numeric, + e2: Numeric, + f2: Numeric + ).void end def horizontal_displacement_multiply_reversed!(a2, b2, c2, d2, e2, f2); end sig do params( - a2: T.untyped, - b2: T.untyped, - c2: T.untyped, - d2: T.untyped, - e2: T.untyped, - f2: T.untyped - ).returns(T.untyped) + a2: Numeric, + b2: Numeric, + c2: Numeric, + d2: Numeric, + e2: Numeric, + f2: Numeric + ).void end def xy_scaling_multiply!(a2, b2, c2, d2, e2, f2); end sig do params( - a2: T.untyped, - b2: T.untyped, - c2: T.untyped, - d2: T.untyped, - e2: T.untyped, - f2: T.untyped - ).returns(T.untyped) + a2: Numeric, + b2: Numeric, + c2: Numeric, + d2: Numeric, + e2: Numeric, + f2: Numeric + ).void end def xy_scaling_multiply_reversed!(a2, b2, c2, d2, e2, f2); end sig do params( - a2: T.untyped, - b2: T.untyped, - c2: T.untyped, - d2: T.untyped, - e2: T.untyped, - f2: T.untyped - ).returns(T.untyped) + a2: Numeric, + b2: Numeric, + c2: Numeric, + d2: Numeric, + e2: Numeric, + f2: Numeric + ).void end def regular_multiply!(a2, b2, c2, d2, e2, f2); end sig do params( - a2: T.untyped, - b2: T.untyped, - c2: T.untyped, - d2: T.untyped, - e2: T.untyped, - f2: T.untyped - ).returns(T.untyped) + a2: Numeric, + b2: Numeric, + c2: Numeric, + d2: Numeric, + e2: Numeric, + f2: Numeric + ).void end def faster_multiply!(a2, b2, c2, d2, e2, f2); end end @@ -1819,12 +1837,18 @@ class XRef include Enumerable + extend T::Generic # Provides `type_member` helper - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } attr_reader :trailer - sig { params(io: T.untyped).void } - def initialize(io); end + sig { params(io: T.any(IO, Tempfile, StringIO)).void } + def initialize(io) + @io = T.let(T.unsafe(nil), T.any(IO, Tempfile, StringIO)) + @junk_offset = T.let(T.unsafe(nil), Integer) + @xref = T.let(T.unsafe(nil), T::Hash[Integer, T::Hash[Integer, Integer]]) + @trailer = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) + end sig { returns(T.untyped) } def size; end @@ -1888,7 +1912,9 @@ class Depredict sig { params(options: T::Hash[T.untyped, T.untyped]).void } - def initialize(options = {}); end + def initialize(options = {}) + @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped]) + end sig { params(data: String).returns(String) } def filter(data); end @@ -1949,17 +1975,14 @@ module WidthCalculator class BuiltIn - BUILTINS = [ - :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique", - :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique", - :Symbol, - :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic", - :ZapfDingbats - ] + BUILTINS = T.let(T.unsafe(nil), T::Array[Symbol]) + + @@all_metrics = T.let(T.unsafe(nil), T.nilable(PDF::Reader::SynchronizedCache)) sig { params(font: PDF::Reader::Font).void } def initialize(font) @font = T.let(T.unsafe(nil), PDF::Reader::Font) + @metrics = T.let(T.unsafe(nil), AFM::Font) end sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
