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-08-05 19:51:11 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-pdf-reader (Old) and /work/SRC/openSUSE:Factory/.rubygem-pdf-reader.new.1521 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-pdf-reader" Fri Aug 5 19:51:11 2022 rev:7 rq:993154 version:2.10.0 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-pdf-reader/rubygem-pdf-reader.changes 2022-03-04 00:18:45.288299318 +0100 +++ /work/SRC/openSUSE:Factory/.rubygem-pdf-reader.new.1521/rubygem-pdf-reader.changes 2022-08-05 19:52:10.637637912 +0200 @@ -1,0 +2,11 @@ +Thu Aug 4 13:22:24 UTC 2022 - Stephan Kulow <[email protected]> + +updated to version 2.10.0 + see installed CHANGELOG + + v2.10.0 (12th May 2022) + - Various bug fixes + - Expanded sorbet type annotations + + +------------------------------------------------------------------- Old: ---- pdf-reader-2.9.2.gem New: ---- pdf-reader-2.10.0.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-pdf-reader.spec ++++++ --- /var/tmp/diff_new_pack.u8uaYK/_old 2022-08-05 19:52:11.205639379 +0200 +++ /var/tmp/diff_new_pack.u8uaYK/_new 2022-08-05 19:52:11.217639410 +0200 @@ -24,7 +24,7 @@ # Name: rubygem-pdf-reader -Version: 2.9.2 +Version: 2.10.0 Release: 0 %define mod_name pdf-reader %define mod_full_name %{mod_name}-%{version} ++++++ pdf-reader-2.9.2.gem -> pdf-reader-2.10.0.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/CHANGELOG new/CHANGELOG --- old/CHANGELOG 2022-02-20 01:11:04.000000000 +0100 +++ new/CHANGELOG 2022-05-12 01:08:31.000000000 +0200 @@ -1,3 +1,7 @@ +v2.10.0 (12th May 2022) +- Various bug fixes +- Expanded sorbet type annotations + v2.9.2 (20th February 2022) - Fix PDF::Reader::ObjectHash#page_references to return an Array of PDF::Reader::Reference (http://github.com/yob/pdf-reader/pull/444) 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/cid_widths.rb new/lib/pdf/reader/cid_widths.rb --- old/lib/pdf/reader/cid_widths.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/cid_widths.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,9 +1,7 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true -# - require 'forwardable' class PDF::Reader @@ -33,10 +31,10 @@ params << array.shift if params.size == 2 && params.last.is_a?(Array) - widths.merge! parse_first_form(params.first, params.last) + widths.merge! parse_first_form(params.first.to_i, Array(params.last)) params = [] elsif params.size == 3 - widths.merge! parse_second_form(params[0], params[1], params[2]) + widths.merge! parse_second_form(params[0].to_i, params[1].to_i, params[2].to_i) params = [] end end @@ -54,6 +52,8 @@ # 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 + (first..final).inject({}) { |accum, index| accum[index] = width accum diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/error.rb new/lib/pdf/reader/error.rb --- old/lib/pdf/reader/error.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/error.rb 2022-05-12 01:08:31.000000000 +0200 @@ -58,10 +58,6 @@ def self.validate_not_nil(object, name) raise ArgumentError, "#{object} must not be nil" if object.nil? end - ################################################################################ - def self.validate_not_nil_as_malformed(object, name) - raise MalformedPDFError, "#{object} must not be nil" if object.nil? - end 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/filter/depredict.rb 2022-05-12 01:08:31.000000000 +0200 @@ -125,7 +125,7 @@ row_data[index] = (byte + paeth) % 256 end else - raise ArgumentError, "Invalid filter algorithm #{filter}" + raise MalformedPDFError, "Invalid filter algorithm #{filter}" end s = [] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/font.rb new/lib/pdf/reader/font.rb --- old/lib/pdf/reader/font.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/font.rb 2022-05-12 01:08:31.000000000 +0200 @@ -205,14 +205,17 @@ end def extract_descendants(obj) - return unless obj[:DescendantFonts] # per PDF 32000-1:2008 pp. 280 :DescendentFonts is: # A one-element array specifying the CIDFont dictionary that is the # descendant of this Type 0 font. - descendants = @ohash.deref_array(obj[:DescendantFonts]) - @descendantfonts = descendants.map { |desc| - PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc)) - } + if obj[:DescendantFonts] + descendants = @ohash.deref_array(obj[:DescendantFonts]) + @descendantfonts = descendants.map { |desc| + PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc)) + } + else + @descendantfonts = [] + end end def to_utf8_via_cmap(params) @@ -226,9 +229,7 @@ @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR }.flatten.pack("U*") when Array - params.collect { |param| to_utf8_via_cmap(param) } - else - params + params.collect { |param| to_utf8_via_cmap(param) }.join("") end end @@ -243,9 +244,7 @@ when String encoding.to_utf8(params) when Array - params.collect { |param| to_utf8_via_encoding(param) } - else - params + params.collect { |param| to_utf8_via_encoding(param) }.join("") end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/font_descriptor.rb new/lib/pdf/reader/font_descriptor.rb --- old/lib/pdf/reader/font_descriptor.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/font_descriptor.rb 2022-05-12 01:08:31.000000000 +0200 @@ -56,7 +56,9 @@ end char_metric = ttf_program_stream.horizontal_metrics.metrics[glyph_id] if char_metric - return char_metric.advance_width + char_metric.advance_width + else + 0 end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/form_xobject.rb new/lib/pdf/reader/form_xobject.rb --- old/lib/pdf/reader/form_xobject.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/form_xobject.rb 2022-05-12 01:08:31.000000000 +0200 @@ -45,7 +45,7 @@ def font_objects raw_fonts = @objects.deref_hash(fonts) ::Hash[raw_fonts.map { |label, font| - [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font))] + [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font) || {})] }] end @@ -55,6 +55,9 @@ # See the comments on PDF::Reader::Page#walk for more detail. # def walk(*receivers) + receivers = receivers.map { |receiver| + ValidatingReceiver.new(receiver) + } content_stream(receivers, raw_content) end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/lzw.rb new/lib/pdf/reader/lzw.rb --- old/lib/pdf/reader/lzw.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/lzw.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true module PDF @@ -25,12 +25,14 @@ def initialize(data, bits_in_chunk) @data = data @data.force_encoding("BINARY") - @bits_in_chunk = bits_in_chunk + set_bits_in_chunk(bits_in_chunk) @current_pos = 0 @bits_left_in_byte = 8 end def set_bits_in_chunk(bits_in_chunk) + raise MalformedPDFError, "invalid LZW bits" if bits_in_chunk < 9 || bits_in_chunk > 12 + @bits_in_chunk = bits_in_chunk end @@ -39,7 +41,7 @@ chunk = -1 while bits_left_in_chunk > 0 and @current_pos < @data.size chunk = 0 if chunk < 0 - codepoint = @data[@current_pos, 1].unpack("C*")[0] + codepoint = @data[@current_pos, 1].to_s.unpack("C*")[0].to_i current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits dif = bits_left_in_chunk - @bits_left_in_byte if dif > 0 then current_byte <<= dif @@ -61,21 +63,25 @@ CODE_CLEAR_TABLE = 256 #clear table # stores de pairs code => string - class StringTable < Hash # :nodoc: + class StringTable attr_reader :string_table_pos def initialize - super + @data = Hash.new @string_table_pos = 258 #initial code end #if code less than 258 return fixed string def [](key) - if key > 257 then super else key.chr end + if key > 257 + @data[key] + else + key.chr + end end def add(string) - store(@string_table_pos, string) + @data.store(@string_table_pos, string) @string_table_pos += 1 end end @@ -83,7 +89,7 @@ # Decompresses a LZW compressed string. # def self.decode(data) - stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits + 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 @@ -119,8 +125,17 @@ result end - def self.create_new_string(string_table,some_code, other_code) - string_table[some_code] + string_table[other_code][0].chr + def self.create_new_string(string_table, some_code, other_code) + raise MalformedPDFError, "invalid LZW data" if some_code.nil? || other_code.nil? + + item_one = string_table[some_code] + item_two = string_table[other_code] + + if item_one && item_two + item_one + item_two.chr + else + raise MalformedPDFError, "invalid LZW data" + end end private_class_method :create_new_string 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/object_hash.rb 2022-05-12 01:08:31.000000000 +0200 @@ -243,7 +243,7 @@ obj.tap { |obj| if !obj.is_a?(PDF::Reader::Stream) - raise MalformedPDFError, "expected object to be an Array or nil" + raise MalformedPDFError, "expected object to be a Stream or nil" end } end @@ -496,7 +496,9 @@ def fetch_object_stream(key) if xref[key].is_a?(PDF::Reader::Reference) container_key = xref[key] - object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key)) + stream = deref_stream(container_key) + raise MalformedPDFError, "Object Stream cannot be nil" if stream.nil? + object_streams[container_key] ||= PDF::Reader::ObjectStream.new(stream) object_streams[container_key][key.id] end end @@ -573,7 +575,9 @@ def get_page_objects(obj) derefed_obj = deref_hash(obj) - if derefed_obj[:Type] == :Page + if derefed_obj.nil? + raise MalformedPDFError, "Expected Page or Pages object, got nil" + elsif derefed_obj[:Type] == :Page [obj] elsif derefed_obj[:Kids] kids = deref_array(derefed_obj[:Kids]) || [] 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/object_stream.rb 2022-05-12 01:08:31.000000000 +0200 @@ -24,7 +24,7 @@ end def size - @dict[:N] + TypeCheck.cast_to_int!(@dict[:N]) end private @@ -40,7 +40,7 @@ end def first - @dict[:First] + TypeCheck.cast_to_int!(@dict[:First]) end def buffer 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/page.rb 2022-05-12 01:08:31.000000000 +0200 @@ -278,7 +278,9 @@ [] else obj = objects.deref_hash(origin) - PDF::Reader::Error.validate_not_nil_as_malformed(obj, "parent") + if obj.nil? + raise MalformedPDFError, "parent mus not be nil" + end [ select_inheritable(obj) ] + ancestors(obj[:Parent]) end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/page_state.rb new/lib/pdf/reader/page_state.rb --- old/lib/pdf/reader/page_state.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/page_state.rb 2022-05-12 01:08:31.000000000 +0200 @@ -16,7 +16,7 @@ :h_scaling => 1.0, :text_leading => 0, :text_font => nil, - :text_font_size => nil, + :text_font_size => 0, :text_mode => 0, :text_rise => 0, :text_knockout => 0 @@ -32,6 +32,12 @@ @cs_stack = [page.color_spaces] @stack = [DEFAULT_GRAPHICS_STATE.dup] state[:ctm] = identity_matrix + + # These are only valid when inside a `BT` block and we re-initialize them on each + # `BT`. However, we need the instance variables set so PDFs with the text operators + # out order don't trigger NoMethodError when these are nil + @text_matrix = identity_matrix + @text_line_matrix = identity_matrix end ##################################################### 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/resources.rb 2022-05-12 01:08:31.000000000 +0200 @@ -92,7 +92,8 @@ # of calling it over and over. # def xobjects - @objects.deref_hash!(@resources[:XObject]) || {} + dict = @objects.deref_hash!(@resources[:XObject]) || {} + TypeCheck.cast_to_pdf_dict_with_stream_values!(dict) end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/stream.rb new/lib/pdf/reader/stream.rb --- old/lib/pdf/reader/stream.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/stream.rb 2022-05-12 01:08:31.000000000 +0200 @@ -40,7 +40,7 @@ # Creates a new stream with the specified dictionary and data. The dictionary # should be a standard ruby hash, the data should be a standard ruby string. def initialize(hash, data) - @hash = hash + @hash = TypeCheck.cast_to_pdf_dict!(hash) @data = data @udata = nil end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/type_check.rb new/lib/pdf/reader/type_check.rb --- old/lib/pdf/reader/type_check.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/type_check.rb 2022-05-12 01:08:31.000000000 +0200 @@ -9,6 +9,18 @@ # class TypeCheck + def self.cast_to_int!(obj) + if obj.is_a?(Integer) + obj + elsif obj.nil? + 0 + elsif obj.respond_to?(:to_i) + obj.to_i + else + raise MalformedPDFError, "Unable to cast to integer" + end + end + def self.cast_to_numeric!(obj) if obj.is_a?(Numeric) obj @@ -46,6 +58,40 @@ raise MalformedPDFError, "Unable to cast to symbol" end end + + def self.cast_to_symbol!(obj) + res = cast_to_symbol(obj) + if res + res + else + raise MalformedPDFError, "Unable to cast to symbol" + end + end + + def self.cast_to_pdf_dict!(obj) + if obj.is_a?(Hash) + obj + elsif obj.respond_to?(:to_h) + obj.to_h + else + raise MalformedPDFError, "Unable to cast to hash" + end + end + + def self.cast_to_pdf_dict_with_stream_values!(obj) + if obj.is_a?(Hash) + result = Hash.new + obj.each do |k, v| + raise MalformedPDFError, "Expected a stream" unless v.is_a?(PDF::Reader::Stream) + result[cast_to_symbol!(k)] = v + end + result + elsif obj.respond_to?(:to_h) + cast_to_pdf_dict_with_stream_values!(obj.to_h) + else + raise MalformedPDFError, "Unable to cast to hash" + end + end end end 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-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/width_calculator/built_in.rb 2022-05-12 01:08:31.000000000 +0200 @@ -53,12 +53,13 @@ private def control_character?(code_point) - @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/] + match = @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/] + match ? true : false end def extract_basefont(font_name) if BUILTINS.include?(font_name) - font_name + font_name.to_s else "Times-Roman" end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/width_calculator/composite.rb new/lib/pdf/reader/width_calculator/composite.rb --- old/lib/pdf/reader/width_calculator/composite.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/width_calculator/composite.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -22,7 +22,11 @@ w = @widths[code_point] # 0 is a valid width - return w.to_f unless w.nil? + if w + w.to_f + else + 0 + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/width_calculator/true_type.rb new/lib/pdf/reader/width_calculator/true_type.rb --- old/lib/pdf/reader/width_calculator/true_type.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/width_calculator/true_type.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -10,8 +10,8 @@ def initialize(font) @font = font - if @font.font_descriptor - @missing_width = @font.font_descriptor.missing_width + if fd = @font.font_descriptor + @missing_width = fd.missing_width else @missing_width = 0 end @@ -30,25 +30,23 @@ # in ruby a negative index is valid, and will go from the end of the array # which is undesireable in this case. - if @font.first_char && @font.first_char <= code_point - @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f + first_char = @font.first_char + if first_char && first_char <= code_point + @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f else @missing_width.to_f end end def glyph_width_from_descriptor(code_point) - return unless @font.font_descriptor - # true type fonts will have most of their information contained # with-in a program inside the font descriptor, however the widths # may not be in standard PDF glyph widths (1000 units => 1 text space unit) # so this width will need to be scaled - w = @font.font_descriptor.glyph_width(code_point) - if w - w.to_f * @font.font_descriptor.glyph_to_pdf_scale_factor - else - nil + if fd = @font.font_descriptor + if w = fd.glyph_width(code_point) + w.to_f * fd.glyph_to_pdf_scale_factor.to_f + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/width_calculator/type_one_or_three.rb new/lib/pdf/reader/width_calculator/type_one_or_three.rb --- old/lib/pdf/reader/width_calculator/type_one_or_three.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/width_calculator/type_one_or_three.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -10,8 +10,8 @@ def initialize(font) @font = font - if @font.font_descriptor - @missing_width = @font.font_descriptor.missing_width + if fd = @font.font_descriptor + @missing_width = fd.missing_width else @missing_width = 0 end @@ -23,8 +23,9 @@ # in ruby a negative index is valid, and will go from the end of the array # which is undesireable in this case. - if @font.first_char <= code_point - @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f + first_char = @font.first_char + if first_char && first_char <= code_point + @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f else @missing_width.to_f end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/pdf/reader/width_calculator/type_zero.rb new/lib/pdf/reader/width_calculator/type_zero.rb --- old/lib/pdf/reader/width_calculator/type_zero.rb 2022-02-20 01:11:04.000000000 +0100 +++ new/lib/pdf/reader/width_calculator/type_zero.rb 2022-05-12 01:08:31.000000000 +0200 @@ -1,5 +1,5 @@ # coding: utf-8 -# typed: true +# typed: strict # frozen_string_literal: true class PDF::Reader @@ -13,13 +13,16 @@ def initialize(font) @font = font - @descendant_font = @font.descendantfonts.first end def glyph_width(code_point) return 0 if code_point.nil? || code_point < 0 - @descendant_font.glyph_width(code_point).to_f + if descendant_font = @font.descendantfonts.first + descendant_font.glyph_width(code_point).to_f + else + 0 + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2022-02-20 01:11:04.000000000 +0100 +++ new/metadata 2022-05-12 01:08:31.000000000 +0200 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: pdf-reader version: !ruby/object:Gem::Version - version: 2.9.2 + version: 2.10.0 platform: ruby authors: - James Healy autorequire: bindir: bin cert_chain: [] -date: 2022-02-20 00:00:00.000000000 Z +date: 2022-05-11 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: rake @@ -288,9 +288,9 @@ - MIT metadata: bug_tracker_uri: https://github.com/yob/pdf-reader/issues - changelog_uri: https://github.com/yob/pdf-reader/blob/v2.9.2/CHANGELOG - documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.9.2 - source_code_uri: https://github.com/yob/pdf-reader/tree/v2.9.2 + 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 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-02-20 01:11:04.000000000 +0100 +++ new/rbi/pdf-reader.rbi 2022-05-12 01:08:31.000000000 +0200 @@ -145,16 +145,18 @@ end class CidWidths - sig { params(default: T.untyped, array: T.untyped).void } - def initialize(default, array); end + sig { params(default: Numeric, array: T::Array[Numeric]).void } + def initialize(default, array) + @widths = T.let(T.unsafe(nil), T::Hash[Numeric, Numeric]) + end - sig { params(default: T.untyped, array: T.untyped).returns(T.untyped) } + sig { params(default: Numeric, array: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) } def parse_array(default, array); end - sig { params(first: T.untyped, widths: T.untyped).returns(T.untyped) } + sig { params(first: Integer, widths: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) } def parse_first_form(first, widths); end - sig { params(first: T.untyped, final: T.untyped, width: T.untyped).returns(T.untyped) } + sig { params(first: Integer, final: Integer, width: Numeric).returns(T::Hash[Numeric, Numeric]) } def parse_second_form(first, final, width); end end @@ -279,9 +281,6 @@ sig { params(object: Object, name: String).void } def self.validate_not_nil(object, name); end - - sig { params(object: Object, name: String).void } - def self.validate_not_nil_as_malformed(object, name); end end class MalformedPDFError < RuntimeError @@ -300,138 +299,146 @@ end class Font - sig { returns(T.untyped) } + sig { returns(T.nilable(Symbol)) } attr_accessor :subtype - sig { returns(T.untyped) } + sig { returns(PDF::Reader::Encoding) } attr_accessor :encoding - sig { returns(T.untyped) } + sig { returns(T::Array[PDF::Reader::Font]) } attr_accessor :descendantfonts - sig { returns(T.untyped) } + sig { returns(PDF::Reader::CMap) } attr_accessor :tounicode - sig { returns(T.untyped) } + sig { returns(T::Array[Integer]) } attr_reader :widths - sig { returns(T.untyped) } + sig { returns(T.nilable(Integer)) } attr_reader :first_char - sig { returns(T.untyped) } + sig { returns(T.nilable(Integer)) } attr_reader :last_char - sig { returns(T.untyped) } + sig { returns(T.nilable(Symbol)) } attr_reader :basefont - sig { returns(T.untyped) } + sig { returns(T.nilable(PDF::Reader::FontDescriptor)) } attr_reader :font_descriptor - sig { returns(T.untyped) } + sig { returns(T::Array[Numeric]) } attr_reader :cid_widths - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :cid_default_width - sig { params(ohash: T.untyped, obj: T.untyped).void } + sig { params(ohash: PDF::Reader::ObjectHash, obj: T::Hash[Symbol, T.untyped]).void } def initialize(ohash, obj); end - sig { params(params: T.untyped).returns(T.untyped) } + sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) } def to_utf8(params); end - sig { params(data: T.untyped).returns(T.untyped) } + sig { params(data: String).returns(T::Array[T.nilable(T.any(Numeric, String))]) } def unpack(data); end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.any(String, Integer)).returns(T.untyped) } def glyph_width(code_point); end - sig { params(font_name: T.untyped).returns(T.untyped) } + sig { params(font_name: Symbol).returns(PDF::Reader::Encoding) } def default_encoding(font_name); end - sig { returns(T.untyped) } + sig { + returns( + T.any( + PDF::Reader::WidthCalculator::BuiltIn, + PDF::Reader::WidthCalculator::Composite, + PDF::Reader::WidthCalculator::TrueType, + PDF::Reader::WidthCalculator::TypeOneOrThree, + PDF::Reader::WidthCalculator::TypeZero, + ) + ) + } def build_width_calculator; end - sig { params(obj: T.untyped).returns(T.untyped) } + sig { params(obj: T.untyped).void } def extract_base_info(obj); end - sig { params(obj: T.untyped).returns(T.untyped) } + sig { params(obj: T.untyped).void } def extract_descriptor(obj); end - sig { params(obj: T.untyped).returns(T.untyped) } + sig { params(obj: T.untyped).void } def extract_descendants(obj); end - sig { params(params: T.untyped).returns(T.untyped) } + sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) } def to_utf8_via_cmap(params); end - sig { params(params: T.untyped).returns(T.untyped) } + sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) } def to_utf8_via_encoding(params); end end class FontDescriptor - sig { returns(T.untyped) } + sig { returns(String) } attr_reader :font_name - sig { returns(T.untyped) } + sig { returns(T.nilable(String)) } attr_reader :font_family - sig { returns(T.untyped) } + sig { returns(Symbol) } attr_reader :font_stretch - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :font_weight - sig { returns(T.untyped) } + sig { returns(T::Array[Numeric]) } attr_reader :font_bounding_box - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :cap_height - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :ascent - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :descent - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :leading - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :avg_width - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :max_width - sig { returns(T.untyped) } + sig { returns(Numeric) } attr_reader :missing_width - sig { returns(T.untyped) } + sig { returns(T.nilable(Numeric)) } attr_reader :italic_angle - sig { returns(T.untyped) } + sig { returns(T.nilable(Numeric)) } attr_reader :stem_v - sig { returns(T.untyped) } + sig { returns(T.nilable(Numeric)) } attr_reader :x_height - sig { returns(T.untyped) } + sig { returns(Integer) } attr_reader :font_flags sig { params(ohash: PDF::Reader::ObjectHash, fd_hash: T::Hash[T.untyped, T.untyped]).void } def initialize(ohash, fd_hash); end - sig { params(char_code: T.untyped).returns(T.untyped) } + sig { params(char_code: Integer).returns(Numeric) } def glyph_width(char_code); end - sig { returns(T.untyped) } + sig { returns(Numeric) } def glyph_to_pdf_scale_factor; end - sig { returns(T.untyped) } + sig { returns(TTFunk::File) } def ttf_program_stream; end end class FormXObject - include ResourceMethods - sig { returns(T.untyped) } attr_reader :xobject @@ -517,34 +524,43 @@ CODE_CLEAR_TABLE = 256 class BitStream - sig { params(data: T.untyped, bits_in_chunk: T.untyped).void } - def initialize(data, bits_in_chunk); end + sig { params(data: String, bits_in_chunk: Integer).void } + def initialize(data, bits_in_chunk) + @data = T.let(T.unsafe(nil), String) + @bits_in_chunk = T.let(T.unsafe(nil), Integer) + @current_pos = T.let(T.unsafe(nil), Integer) + @bits_left_in_byte = T.let(T.unsafe(nil), Integer) + + end - sig { params(bits_in_chunk: T.untyped).returns(T.untyped) } + sig { params(bits_in_chunk: Integer).void } def set_bits_in_chunk(bits_in_chunk); end - sig { returns(T.untyped) } + sig { returns(Integer) } def read; end end - class StringTable < Hash - sig { returns(T.untyped) } + class StringTable + sig { returns(Integer) } attr_reader :string_table_pos sig { void } - def initialize; end + def initialize + @data = T.let(T.unsafe(nil), T::Hash[Integer, String]) + @string_table_pos = T.let(T.unsafe(nil), Integer) + end - sig { params(key: T.untyped).returns(T.untyped) } + sig { params(key: Integer).returns(T.nilable(String)) } def [](key); end - sig { params(string: T.untyped).returns(T.untyped) } + sig { params(string: String).void } def add(string); end end - sig { params(data: T.untyped).returns(T.untyped) } + sig { params(data: String).returns(String) } def self.decode(data); end - sig { params(string_table: T.untyped, some_code: T.untyped, other_code: T.untyped).returns(T.untyped) } + sig { params(string_table: PDF::Reader::LZW::StringTable, some_code: T.nilable(Integer), other_code: T.nilable(Integer)).returns(String) } def self.create_new_string(string_table, some_code, other_code); end end @@ -647,7 +663,7 @@ sig { params(key: T.untyped).returns(T.nilable(T::Array[Numeric])) } def deref_array_of_numbers(key); end - sig { params(key: T.untyped).returns(T.nilable(T:Hash[Symbol, T.untyped])) } + sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) } def deref_hash(key); end sig { params(key: T.untyped).returns(T.nilable(Symbol)) } @@ -674,10 +690,10 @@ sig { params(key: T.untyped).returns(T.untyped) } def deref!(key); end - sig { params(key: T.untyped).returns(T::Array[T.untyped]) } + sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) } def deref_array!(key); end - sig { params(key: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) } def deref_hash!(key); end sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) } @@ -763,22 +779,25 @@ end class ObjectStream - sig { params(stream: T.untyped).void } - def initialize(stream); end + sig { params(stream: PDF::Reader::Stream).void } + def initialize(stream) + @dict = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) + @data = T.let(T.unsafe(nil), String) + end sig { params(objid: T.untyped).returns(T.untyped) } def [](objid); end - sig { returns(T.untyped) } + sig { returns(Integer) } def size; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Integer, Integer]) } def offsets; end - sig { returns(T.untyped) } + sig { returns(Integer) } def first; end - sig { returns(T.untyped) } + sig { returns(PDF::Reader::Buffer) } def buffer; end end @@ -807,8 +826,6 @@ end class Page - include ResourceMethods - sig { returns(PDF::Reader::ObjectHash) } attr_reader :objects @@ -881,7 +898,7 @@ sig { params(origin: T.untyped).returns(T.untyped) } def ancestors(origin = @page_object[:Parent]); end - sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) } + sig { params(obj: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) } def select_inheritable(obj); end end @@ -1386,31 +1403,36 @@ def series(*methods); end end - module ResourceMethods - extend T::Helpers + class Resources - sig { returns(T.untyped) } + sig { params(objects: PDF::Reader::ObjectHash, resources: T::Hash[T.untyped, T.untyped]).void } + def initialize(objects, resources) + @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash) + @resources = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped]) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } def color_spaces; end - sig { returns(T::Hash[T.untyped, T.untyped]) } + sig { returns(T::Hash[Symbol, T.untyped]) } def fonts; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } def graphic_states; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } def patterns; end - sig { returns(T.untyped) } + sig { returns(T::Array[Symbol]) } def procedure_sets; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } def properties; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, T.untyped]) } def shadings; end - sig { returns(T.untyped) } + sig { returns(T::Hash[Symbol, PDF::Reader::Stream]) } def xobjects; end end @@ -1674,6 +1696,9 @@ class TypeCheck + sig { params(obj: T.untyped).returns(Integer) } + def self.cast_to_int!(obj); end + sig { params(obj: T.untyped).returns(Numeric) } def self.cast_to_numeric!(obj); end @@ -1682,6 +1707,15 @@ sig { params(obj: T.untyped).returns(T.nilable(Symbol)) } def self.cast_to_symbol(obj); end + + sig { params(obj: T.untyped).returns(Symbol) } + def self.cast_to_symbol!(obj); end + + sig { params(obj: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + def self.cast_to_pdf_dict!(obj); end + + sig { params(obj: T.untyped).returns(T::Hash[Symbol, PDF::Reader::Stream]) } + def self.cast_to_pdf_dict_with_stream_values!(obj); end end class ValidatingReceiver @@ -1923,54 +1957,67 @@ :ZapfDingbats ] - sig { params(font: T.untyped).void } - def initialize(font); end + sig { params(font: PDF::Reader::Font).void } + def initialize(font) + @font = T.let(T.unsafe(nil), PDF::Reader::Font) + end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.nilable(Integer)).returns(Numeric) } def glyph_width(code_point); end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: Integer).returns(T::Boolean) } def control_character?(code_point); end - sig { params(font_name: T.untyped).returns(T.untyped) } + sig { params(font_name: T.nilable(Symbol)).returns(String) } def extract_basefont(font_name); end end class Composite - sig { params(font: T.untyped).void } - def initialize(font); end + sig { params(font: PDF::Reader::Font).void } + def initialize(font) + @font = T.let(T.unsafe(nil), PDF::Reader::Font) + @widths = T.let(T.unsafe(nil), PDF::Reader::CidWidths) + end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.nilable(Integer)).returns(Numeric) } def glyph_width(code_point); end end class TrueType - sig { params(font: T.untyped).void } - def initialize(font); end + sig { params(font: PDF::Reader::Font).void } + def initialize(font) + @font = T.let(T.unsafe(nil), PDF::Reader::Font) + @missing_width = T.let(T.unsafe(nil), Numeric) + end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.nilable(Integer)).returns(Numeric) } def glyph_width(code_point); end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: Integer).returns(T.nilable(Numeric)) } def glyph_width_from_font(code_point); end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: Integer).returns(T.nilable(Numeric)) } def glyph_width_from_descriptor(code_point); end end class TypeOneOrThree - sig { params(font: T.untyped).void } - def initialize(font); end + sig { params(font: PDF::Reader::Font).void } + def initialize(font) + @font = T.let(T.unsafe(nil), PDF::Reader::Font) + @missing_width = T.let(T.unsafe(nil), Numeric) + end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.nilable(Integer)).returns(Numeric) } def glyph_width(code_point); end end class TypeZero - sig { params(font: T.untyped).void } - def initialize(font); end + sig { params(font: PDF::Reader::Font).void } + def initialize(font) + @font = T.let(T.unsafe(nil), PDF::Reader::Font) + end - sig { params(code_point: T.untyped).returns(T.untyped) } + sig { params(code_point: T.nilable(Integer)).returns(Numeric) } def glyph_width(code_point); end end end
