hexapdf 0.26.2 → 0.27.0

data/test/hexapdf/test_importer.rb

@@ -19,6 +19,7 @@ describe HexaPDF::Importer::NullableWeakRef do
 end
 
 describe HexaPDF::Importer do
+  class TestClass < HexaPDF::Dictionary; end
   before do
     @source = HexaPDF::Document.new
     obj = @source.add("test")
@@ -86,6 +87,19 @@ describe HexaPDF::Importer do
       assert_same(hash, obj[:hash])
     end
 
+    it "uses the class of the argument when directly importing a HexaPDF::Object" do
+      src_obj = @source.wrap(@hash, type: TestClass)
+      dest_obj = @importer.import(src_obj)
+      assert_instance_of(TestClass, dest_obj)
+    end
+
+    it "uses the class of the argument when importing an already mapped HexaPDF::Object" do
+      @importer.import(@obj) # also maps @hash
+      src_obj = @source.wrap(@hash, type: TestClass)
+      dest_obj = @importer.import(src_obj)
+      assert_instance_of(TestClass, dest_obj)
+    end
+
     it "duplicates the stream if it is a string" do
       src_obj = @source.add({}, stream: 'data')
       dst_obj = @importer.import(src_obj)

data/test/hexapdf/test_parser.rb

@@ -108,7 +108,7 @@ describe HexaPDF::Parser do
     end
 
     it "treats indirect objects with invalid values as null objects" do
-      create_parser("1 0 obj <</test ( /other (end)>> endobj")
+      create_parser("1 0 obj <</test <end)> > endobj")
       object, * = @parser.parse_indirect_object
       assert_nil(object)
     end
@@ -210,7 +210,7 @@ describe HexaPDF::Parser do
       end
 
       it "fails for invalid values" do
-        create_parser("1 0 obj <</test ( /other (end)>> endobj")
+        create_parser("1 0 obj <</test <end)> >endobj")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
         assert_match(/Invalid value after '1 0 obj'/, exp.message)
       end

data/test/hexapdf/test_revisions.rb

@@ -273,40 +273,48 @@ describe HexaPDF::Revisions do
       1 0 obj
       10
       endobj
+      xref
+      0 2
+      0000000000 65535 f 
+      0000000009 00000 n 
+      trailer
+      << /Size 2 >>
+      startxref
+      27
+      %%EOF
 
       2 0 obj
       20
       endobj
 
       3 0 obj
-      << /Type /XRef /Size 3 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
+      << /Type /XRef /Size 4 /Index [2 1] /W [1 1 1] /Filter /ASCIIHexDecode /Length 6
       >>stream
-      011C00
+      017600
       endstream
       endobj
 
       xref
-      0 4
-      0000000000 65535 f 
-      0000000009 00000 n 
+      2 2
       0000000000 65535 f 
-      0000000047 00000 n 
+      0000000137 00000 n 
       trailer
-      << /Size 3 >>
+      << /Size 4 /Prev 27>>
       startxref
-      170
+      260
       %%EOF
 
       xref
       0 0
       trailer
-      << /Size 3 /Prev 170 /XRefStm 47>>
+      << /Size 4 /Prev 260 /XRefStm 137>>
       startxref
-      302
+      360
       %%EOF
     EOF
-    doc = HexaPDF::Document.new(io: io)
-    assert_equal(1, doc.revisions.count)
+    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    assert_equal(2, doc.revisions.count)
+    assert_equal(10, doc.object(1).value)
     assert_equal(20, doc.object(2).value)
   end
 

data/test/hexapdf/test_tokenizer.rb

@@ -13,9 +13,19 @@ describe HexaPDF::Tokenizer do
   end
 
   it "handles object references" do
-    create_tokenizer("1 0 R 2 15 R ")
+    #HexaPDF::Reference.new(1, 0), HexaPDF::Reference.new(1, 2), 2, -1, 'R', 0, 0, 'R', -1, 0, 'R',
+    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R -1 0 R")
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_token)
+    assert_equal(2, @tokenizer.next_token)
+    assert_equal(-1, @tokenizer.next_token)
+    assert_equal('R', @tokenizer.next_token)
+    assert_equal(0, @tokenizer.next_token)
+    assert_equal(0, @tokenizer.next_token)
+    assert_equal('R', @tokenizer.next_token)
+    assert_equal(-1, @tokenizer.next_token)
+    assert_equal(0, @tokenizer.next_token)
+    assert_equal('R', @tokenizer.next_token)
     @tokenizer.pos = 0
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_object)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_object)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.27.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.27.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -125,6 +125,14 @@ describe HexaPDF::Writer do
       refute_match(/^trailer/, output_io.string)
     end
 
+    it "updates the PDF version using the catalog's /Version entry if necessary" do
+      doc = HexaPDF::Document.new(io: @std_input_io)
+      doc.version = '2.0'
+      output_io = StringIO.new
+      HexaPDF::Writer.write(doc, output_io, incremental: true)
+      assert_equal('2.0', HexaPDF::Document.new(io: output_io).version)
+    end
+
     it "raises an error if the used encryption was changed" do
       io = StringIO.new
       doc = HexaPDF::Document.new
@@ -206,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.26.2)>>
+      <</Producer(HexaPDF version 0.27.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream

data/test/hexapdf/type/acro_form/test_form.rb

@@ -327,6 +327,12 @@ describe HexaPDF::Type::AcroForm::Form do
       assert_equal(1, result.size)
       assert(@doc.catalog.key?(:AcroForm))
     end
+
+    it "returns the fields that could not be flattened" do
+      @cb.create_appearances
+      result = @acro_form.flatten(create_appearances: false)
+      assert_equal([@tf], result)
+    end
   end
 
   describe "perform_validation" do
@@ -349,6 +355,47 @@ describe HexaPDF::Type::AcroForm::Form do
       assert_equal("0.0 g /F1 0 Tf", @acro_form[:DA])
     end
 
+    describe "field hierarchy validation" do
+      before do
+        @acro_form[:Fields] = [
+          nil,
+          HexaPDF::Object.new(nil),
+          5,
+          HexaPDF::Object.new(5),
+          @doc.add({T: :Tx1}),
+          @doc.add({T: :Tx2, Kids: [nil, @doc.add({Subtype: :Widget})]}),
+          @doc.add({T: :Tx3, FT: :Tx, Kids: [@doc.add({T: :Tx4}),
+                                             [:nothing],
+                                             @doc.add({T: :Tx5, Kids: [@doc.add({T: :Tx6})]})]}),
+        ]
+        @acro_form[:Fields][6][:Kids][0][:Parent] = @acro_form[:Fields][6]
+        @acro_form[:Fields][6][:Kids][2][:Parent] = @acro_form[:Fields][6]
+        @acro_form[:Fields][6][:Kids][2][:Kids][0][:Parent] = @acro_form[:Fields][6][:Kids][2]
+      end
+
+      it "removes invalid objects from the field hierarchy" do
+        assert(@acro_form.validate)
+        assert_equal([:Tx1, :Tx2, :Tx3, :Tx4, :Tx5, :Tx6],
+                     @acro_form.each_field(terminal_only: false).map {|f| f[:T] })
+      end
+
+      it "handles missing /Parent fields" do
+        @acro_form[:Fields][6][:Kids][0].delete(:Parent)
+        assert(@acro_form.validate)
+        assert_equal(1, @acro_form[:Fields][2][:Kids].size)
+        assert_equal(:Tx5, @acro_form[:Fields][2][:Kids][0][:T])
+        assert_equal(:Tx4, @acro_form[:Fields][3][:T])
+      end
+
+      it "handles /Parent field pointing to somewhere else" do
+        @acro_form[:Fields][6][:Kids][0][:Parent] = @acro_form[:Fields][4]
+        assert(@acro_form.validate)
+        assert_equal(2, @acro_form[:Fields][2][:Kids].size)
+        assert_equal(:Tx4, @acro_form[:Fields][2][:Kids][0][:T])
+        assert_equal(@acro_form[:Fields][2], @acro_form[:Fields][2][:Kids][0][:Parent])
+      end
+    end
+
     describe "automatically creates the terminal fields; appearances" do
       before do
         @cb = @acro_form.create_check_box('test2')

data/test/hexapdf/type/signature/common.rb

@@ -65,6 +65,58 @@ module HexaPDF
           end
       end
 
+      def timestamp_certificate
+        @timestamp_certificate ||=
+          begin
+            name = OpenSSL::X509::Name.parse('/CN=timestamp/DC=gettalong')
+
+            signer_cert = OpenSSL::X509::Certificate.new
+            signer_cert.serial = 3
+            signer_cert.version = 2
+            signer_cert.not_before = Time.now - 86400
+            signer_cert.not_after = Time.now + 86400
+            signer_cert.public_key = signer_key.public_key
+            signer_cert.subject = name
+            signer_cert.issuer = ca_certificate.subject
+
+            extension_factory = OpenSSL::X509::ExtensionFactory.new
+            extension_factory.subject_certificate = signer_cert
+            extension_factory.issuer_certificate = ca_certificate
+            signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
+            signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
+            signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
+            signer_cert.add_extension(extension_factory.create_extension('extendedKeyUsage', 'timeStamping', true))
+            signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
+
+            signer_cert
+          end
+      end
+
+      def start_tsa_server
+        return if defined?(@tsa_server)
+        require 'webrick'
+        port = 34567
+        @tsa_server = WEBrick::HTTPServer.new(Port: port, BindAddress: '127.0.0.1',
+                                              Logger: WEBrick::Log.new(StringIO.new), AccessLog: [])
+        @tsa_server.mount_proc('/') do |request, response|
+          @tsr = OpenSSL::Timestamp::Request.new(request.body)
+          case (@tsr.policy_id || '1.2.3.4.0')
+          when '1.2.3.4.0', '1.2.3.4.2'
+            fac = OpenSSL::Timestamp::Factory.new
+            fac.gen_time = Time.now
+            fac.serial_number = 1
+            fac.default_policy_id = '1.2.3.4.5'
+            fac.allowed_digests = ["sha256", "sha512"]
+            tsr = fac.create_timestamp(CERTIFICATES.signer_key, CERTIFICATES.timestamp_certificate,
+                                       @tsr)
+            response.body = tsr.to_der
+          when '1.2.3.4.1'
+            response.status = 403
+            response.body = "Invalid"
+          end
+        end
+        Thread.new { @tsa_server.start }
+      end
     end
 
   end

data/test/hexapdf/type/signature/test_adbe_pkcs7_detached.rb

@@ -1,5 +1,6 @@
 # -*- encoding: utf-8 -*-
 
+require 'digest'
 require 'test_helper'
 require_relative 'common'
 require 'hexapdf/type/signature'
@@ -95,5 +96,25 @@ describe HexaPDF::Type::Signature::AdbePkcs7Detached do
       assert_equal(:error, result.messages.last.type)
       assert_match(/Signature verification failed/, result.messages.last.content)
     end
+
+    it "verifies a timestamp signature" do
+      req = OpenSSL::Timestamp::Request.new
+      req.algorithm = 'SHA256'
+      req.message_imprint = Digest::SHA256.digest(@data)
+      req.policy_id = "1.2.3.4.5"
+      req.nonce = 42
+      fac = OpenSSL::Timestamp::Factory.new
+      fac.gen_time = Time.now
+      fac.serial_number = 1
+      fac.allowed_digests = ["sha256", "sha512"]
+      res = fac.create_timestamp(CERTIFICATES.signer_key, CERTIFICATES.timestamp_certificate, req)
+      @dict.contents = res.token.to_der
+      @dict.signature_type = 'ETSI.RFC3161'
+      @handler = HexaPDF::Type::Signature::AdbePkcs7Detached.new(@dict)
+
+      result = @handler.verify(@store)
+      assert_equal(:info, result.messages.last.type)
+      assert_match(/Signature valid/, result.messages.last.content)
+    end
   end
 end

data/test/hexapdf/type/test_catalog.rb

@@ -29,8 +29,11 @@ describe HexaPDF::Type::Catalog do
     assert_same(other, names)
   end
 
-  it "creates the document outline on access" do
-    assert_nil(@catalog[:Outlines])
+  it "uses or creates the document outline on access" do
+    @catalog[:Outlines] = {}
+    assert_equal(:Outlines, @catalog.outline.type)
+
+    @catalog.delete(:Outlines)
     outline = @catalog.outline
     assert_equal(:Outlines, outline.type)
     assert_same(outline, @catalog.outline)

data/test/hexapdf/type/test_outline.rb

@@ -25,7 +25,7 @@ describe HexaPDF::Type::Outline do
       end
       item1.add_item("Item5")
     end
-    assert_equal(%w[Item1 Item2 Item3 Item4 Item5], @outline.each_item.map(&:title))
+    assert_equal(%w[Item1 Item2 Item3 Item4 Item5], @outline.each_item.map {|i, _| i.title })
   end
 
   describe "perform_validation" do

data/test/hexapdf/type/test_outline_item.rb

@@ -10,6 +10,10 @@ describe HexaPDF::Type::OutlineItem do
     @item = @doc.add({Title: "root", Count: 0}, type: :XXOutlineItem)
   end
 
+  it "must be an indirect object" do
+    assert(@item.must_be_indirect?)
+  end
+
   describe "title" do
     it "returns the set title" do
       @item[:Title] = 'Test'
@@ -78,6 +82,43 @@ describe HexaPDF::Type::OutlineItem do
     end
   end
 
+  describe "level" do
+    it "returns 0 for the outline dictionary when treated as an item" do
+      assert_equal(0, @item.level)
+    end
+
+    it "returns 1 for the root level items" do
+      @item[:Parent] = {Type: :Outlines}
+      assert_equal(1, @item.level)
+    end
+
+    it "returns the correct level for items in the hierarchy" do
+      @item[:Parent] = {Title: 'Root elem', Parent: {Type: :Outlines}}
+      assert_equal(2, @item.level)
+    end
+  end
+
+  describe "destination_page" do
+    it "returns the page of a set destination" do
+      @item[:Dest] = [5, :Fit]
+      assert_equal(5, @item.destination_page)
+    end
+
+    it "returns the page of a set GoTO action" do
+      @item[:A] = {S: :GoTo, D: [5, :Fit]}
+      assert_equal(5, @item.destination_page)
+    end
+
+    it "returns nil if no destination or action is set" do
+      assert_nil(@item.destination_page)
+    end
+
+    it "returns nil if an action besides GoTo is set" do
+      @item[:A] = {S: :GoToR}
+      assert_nil(@item.destination_page)
+    end
+  end
+
   describe "add" do
     it "returns the created item" do
       new_item = @item.add_item("Test")
@@ -118,6 +159,24 @@ describe HexaPDF::Type::OutlineItem do
       assert_same(new_item, yielded_item)
     end
 
+    it "uses the provided outline item instead of creating a new one" do
+      item = @doc.wrap({Dest: [1, :Fit], flags: 1, First: 5, Count: 2}, type: :XXOutlineItem)
+      new_item = @item.add_item(item, destination: [2, :Fit])
+      assert_same(item, new_item)
+      assert_equal([1, :Fit], new_item.destination)
+      assert_same(@item, new_item[:Parent])
+      refute(new_item.key?(:First))
+      assert_equal(0, new_item[:Count])
+
+      item = @doc.wrap({Count: nil}, type: :XXOutlineItem)
+      new_item = @item.add_item(item)
+      refute(new_item.key?(:Count))
+
+      item = @doc.wrap({Count: -1}, type: :XXOutlineItem)
+      new_item = @item.add_item(item)
+      refute(new_item.key?(:Count))
+    end
+
     describe "position" do
       it "works for an empty item" do
         new_item = @item.add_item("Test")
@@ -211,7 +270,8 @@ describe HexaPDF::Type::OutlineItem do
       end
       item1.add_item("Item5")
     end
-    assert_equal(%w[Item1 Item2 Item3 Item4 Item5], @item.each_item.map(&:title))
+    assert_equal(['Item1', 1, 'Item2', 2, 'Item3', 2, 'Item4', 3, 'Item5', 2],
+                 @item.each_item.map {|i, l| [i.title, l] }.flatten)
   end
 
   describe "perform_validation" do
@@ -251,6 +311,7 @@ describe HexaPDF::Type::OutlineItem do
         assert(correctable)
       end
       refute(@item.key?(:Count))
+      assert(@item.validate(auto_correct: false))
     end
 
     it "fails validation if the previous item's /Next points somewhere else" do

data/test/hexapdf/type/test_page.rb

@@ -94,6 +94,11 @@ describe HexaPDF::Type::Page do
       @page = @doc.pages.add
     end
 
+    it "returns the crop box by default" do
+      @page[:CropBox] = [0, 0, 100, 200]
+      assert_equal([0, 0, 100, 200], @page.box)
+    end
+
     it "returns the correct media box" do
       @page[:MediaBox] = :media
       assert_equal(:media, @page.box(:media))
@@ -150,15 +155,25 @@ describe HexaPDF::Type::Page do
       @page = @doc.pages.add
     end
 
-    it "returns :portrait for appropriate media boxes and rotation values" do
-      @page.box(:media, [0, 0, 100, 300])
+    it "uses the crop box by default" do
+      @page[:CropBox] = [0, 0, 200, 100]
+      assert_equal(:landscape, @page.orientation)
+    end
+
+    it "uses the specified box for determining the orientation" do
+      @page[:ArtBox] = [0, 0, 200, 100]
+      assert_equal(:landscape, @page.orientation(:art))
+    end
+
+    it "returns :portrait for appropriate boxes and rotation values" do
+      @page.box(:crop, [0, 0, 100, 300])
       assert_equal(:portrait, @page.orientation)
       @page[:Rotate] = 0
       assert_equal(:portrait, @page.orientation)
       @page[:Rotate] = 180
       assert_equal(:portrait, @page.orientation)
 
-      @page.box(:media, [0, 0, 300, 100])
+      @page.box(:crop, [0, 0, 300, 100])
       @page[:Rotate] = 90
       assert_equal(:portrait, @page.orientation)
       @page[:Rotate] = 270
@@ -166,14 +181,14 @@ describe HexaPDF::Type::Page do
     end
 
     it "returns :landscape for appropriate media boxes and rotation values" do
-      @page.box(:media, [0, 0, 300, 100])
+      @page.box(:crop, [0, 0, 300, 100])
       assert_equal(:landscape, @page.orientation)
       @page[:Rotate] = 0
       assert_equal(:landscape, @page.orientation)
       @page[:Rotate] = 180
       assert_equal(:landscape, @page.orientation)
 
-      @page.box(:media, [0, 0, 100, 300])
+      @page.box(:crop, [0, 0, 100, 300])
       @page[:Rotate] = 90
       assert_equal(:landscape, @page.orientation)
       @page[:Rotate] = 270
@@ -204,18 +219,17 @@ describe HexaPDF::Type::Page do
 
     describe "flatten" do
       it "adjust all page boxes" do
-        @page.box(:crop, @page.box)
-        @page.box(:bleed, @page.box)
-        @page.box(:trim, @page.box)
-        @page.box(:art, @page.box)
+        @page.box(:crop, [0, 0, 1, 2])
+        @page.box(:bleed, [0, 0, 2, 3])
+        @page.box(:trim, [0, 0, 3, 4])
+        @page.box(:art, [0, 0, 4, 5])
 
         @page.rotate(90, flatten: true)
-        box = [-300, 50, -100, 200]
-        assert_equal(box, @page.box(:media).value)
-        assert_equal(box, @page.box(:crop).value)
-        assert_equal(box, @page.box(:bleed).value)
-        assert_equal(box, @page.box(:trim).value)
-        assert_equal(box, @page.box(:art).value)
+        assert_equal([-300, 50, -100, 200], @page.box(:media).value)
+        assert_equal([-2, 0, 0, 1], @page.box(:crop).value)
+        assert_equal([-3, 0, 0, 2], @page.box(:bleed).value)
+        assert_equal([-4, 0, 0, 3], @page.box(:trim).value)
+        assert_equal([-5, 0, 0, 4], @page.box(:art).value)
       end
 
       it "works correctly for 90 degrees" do
@@ -405,8 +419,8 @@ describe HexaPDF::Type::Page do
                                     [:restore_graphics_state]])
     end
 
-    it "works correctly if the page has its origin not at (0,0)" do
-      @page.box(:media, [-10, -5, 100, 300])
+    it "works correctly if the page has its crop box origin not at (0,0)" do
+      @page.box(:crop, [-10, -5, 100, 300])
       @page.canvas(type: :underlay).line_width = 2
       @page.canvas(type: :page).line_width = 2
       @page.canvas(type: :overlay).line_width = 2
@@ -427,6 +441,13 @@ describe HexaPDF::Type::Page do
                                     [:restore_graphics_state]])
     end
 
+    it "allows disabling the origin translation" do
+      @page.box(:crop, [-10, -5, 100, 300])
+      @page.canvas(translate_origin: false).line_width = 2
+
+      assert_page_operators(@page, [[:set_line_width, [2]]])
+    end
+
     it "fails if the page canvas is requested for a page with existing contents" do
       @page.contents = "q Q"
       assert_raises(HexaPDF::Error) { @page.canvas }
@@ -554,10 +575,10 @@ describe HexaPDF::Type::Page do
                                           [:restore_graphics_state]])
     end
 
-    it "adjusts the position to counter the translation in #canvas based on the page's media box" do
-      @page[:MediaBox] = [-15, -15, 100, 100]
+    it "potentially adjusts the origin so that it is always in (0,0)" do
+      @canvas.translate(-15, -15)
       @page.flatten_annotations
-      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 15, 15]], range: 1)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 15, 15]], range: 2)
     end
 
     it "adjusts the position in case the form /Matrix has an offset" do

data/test/hexapdf/type/test_resources.rb

@@ -189,11 +189,6 @@ describe HexaPDF::Type::Resources do
   end
 
   describe "validation" do
-    it "assigns the default value if ProcSet is not set" do
-      @res.validate
-      assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet].value)
-    end
-
     it "handles an invalid ProcSet containing a single value instead of an array" do
       @res[:ProcSet] = :PDF
       @res.validate

data/test/hexapdf/type/test_signature.rb

@@ -128,4 +128,12 @@ describe HexaPDF::Type::Signature do
     assert_kind_of(OpenSSL::X509::Store, store)
     assert(kwargs[:allow_self_signed])
   end
+
+  describe "perform_validation" do
+    it "upgrades the version to 2.0 if the /SubFilter needs it" do
+      refute(@sig.validate(auto_correct: false))
+      assert(@sig.validate(auto_correct: true))
+      assert_equal('2.0', @doc.version)
+    end
+  end
 end

data/test/test_helper.rb

@@ -3,7 +3,7 @@
 begin
   require 'simplecov'
   SimpleCov.start do
-    minimum_coverage line: 100
+    minimum_coverage line: 100 unless ENV['NO_SIMPLECOV']
     add_filter '/test/'
     add_filter '/fast_arc4.rb'
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.26.2
+  version: 0.27.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-21 00:00:00.000000000 Z
+date: 2022-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -44,6 +44,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -699,7 +713,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="