hexapdf 1.9.1 → 1.11.0

data/test/hexapdf/layout/test_text_fragment.rb

@@ -43,10 +43,18 @@ describe HexaPDF::Layout::TextFragment do
 
     it "allows using a style object instead of directly specifying style properties" do
       style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
-      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom", style)
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("Tom", style) {}
       assert_equal(37.78, frags[0].width)
     end
 
+    it "handles control characters separately by not running them through the text shaper" do
+      frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("\tA\nB\rC\r\nD", font: @font) {}
+      assert_equal(5, frags.size)
+      assert_equal("\t", frags[0].text)
+      assert_equal("A\n", frags[1].text)
+      assert_equal("C\r\n", frags[3].text)
+    end
+
     it "replaces invalid glyphs with the result of the block" do
       zapf_dingbats = @doc.fonts.add('ZapfDingbats')
       i = 0
@@ -62,7 +70,7 @@ describe HexaPDF::Layout::TextFragment do
 
       frags = HexaPDF::Layout::TextFragment.create_with_fallback_glyphs("✂Tom✂Tom✂Tom✂Tom\u{ad}",
                                                                         style, &fallback)
-      assert_equal(8, frags.size)
+      assert_equal(7, frags.size)
       assert_equal(zapf_dingbats, frags[0].style.font)
       assert_equal(:a2, frags[0].items[0].name)
       assert_equal("Tom", frags[1].text)
@@ -71,8 +79,7 @@ describe HexaPDF::Layout::TextFragment do
       assert_equal("Tom", frags[3].text)
       assert_equal(:'.notdef', frags[4].items[0].name)
       assert_equal("Tom", frags[5].text)
-      assert_equal("Tom", frags[6].text)
-      assert_equal("\u{ad}", frags[7].text)
+      assert_equal("Tom\u{ad}", frags[6].text)
     end
   end
 

data/test/hexapdf/task/test_import_pages.rb

@@ -99,9 +99,10 @@ describe HexaPDF::Task::ImportPages do
       canvas = @doc.pages[0].canvas
       form = canvas.form
       form[:OC] = @ocg1
+      form.canvas.optional_content(@ocmd)
       canvas.xobject(form, at: [0, 0])
       @target.task(:import_pages, source: @doc)
-      assert_equal(['OCG'], @target.optional_content.ocgs.map(&:name))
+      assert_equal(['OCG', 'OCMD'], @target.optional_content.ocgs.map(&:name))
     end
 
     it "preserves OCGs/OCMDs associated with annotations" do
@@ -123,4 +124,44 @@ describe HexaPDF::Task::ImportPages do
       assert_equal(['OCG'], rb_groups[0].map(&:name))
     end
   end
+
+  describe "resize_to argument" do
+    before do
+      @doc.annotations.create_line(@pages[0], start_point: [10, 10], end_point: [100, 100]).
+        regenerate_appearance
+    end
+
+    it "works when given a symbolic page size" do
+      @target.task(:import_pages, source: @doc, resize_to: :A4)
+      assert_equal(2, @doc.each.select {|obj| obj.type == :Page }.size)
+      assert_operators(@target.pages[0].contents, [[:paint_xobject, [:XO1]]])
+      assert_operators(@target.pages[1].contents, [[:paint_xobject, [:XO1]]])
+    end
+
+    it "works when given a media box directly" do
+      @target.task(:import_pages, source: @doc, pages: 0, resize_to: [5, 5, 100, 100])
+      assert_equal(1, @target.each.select {|obj| obj.type == :Page }.size)
+      assert_operators(@target.pages[0].contents,
+                       [[:concatenate_matrix, [1, 0, 0, 1, 5, 5]],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [0.15959, 0, 0, 0.112841, 0.0, 0.0]],
+                        [:paint_xobject, [:XO1]],
+                        [:restore_graphics_state]])
+    end
+
+    it "flattens the annotations" do
+      @target.task(:import_pages, source: @doc, pages: 0, resize_to: [5, 5, 100, 100])
+      assert_operators(@target.pages[0].resources.xobject(:XO1).contents,
+                       [[:save_graphics_state],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1.0, 0, 0, 1.0, 0.0, 0.0]],
+                        [:paint_xobject, [:XO1]],
+                        [:restore_graphics_state],
+                        [:restore_graphics_state]])
+    end
+  end
 end

data/test/hexapdf/test_dictionary_fields.rb

@@ -129,6 +129,11 @@ describe HexaPDF::DictionaryFields do
       str = @field.convert("\xfe\xff\x00t\x00e\x00s\x00t".b, self)
       assert_equal('test', str)
       assert_equal(Encoding::UTF_8, str.encoding)
+
+      str = @field.convert("\xef\xbb\xbfHall\xC3\xB6".b, self)
+      assert_equal('Hallö', str)
+      assert_equal(Encoding::UTF_8, str.encoding)
+
       str = @field.convert("Testing\x9c\x92".b, self)
       assert_equal("Testing\u0153\u2122", str)
       assert_equal(Encoding::UTF_8, str.encoding)
@@ -141,6 +146,9 @@ describe HexaPDF::DictionaryFields do
     it "calls document.on_invalid_string if the provided string is invalid" do
       str = "\xfe\xff\xD8\x00\x00s\x00t".b
       assert_equal("st", @field.convert(str, self))
+
+      str = "\xef\xbb\xbfHall\xFF\xC3".b
+      assert_equal("Hall", @field.convert(str, self))
     end
   end
 

data/test/hexapdf/test_parser.rb

@@ -702,15 +702,6 @@ describe HexaPDF::Parser do
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
-    it "uses a security handler for decrypting indirect objects if necessary" do
-      handler = Minitest::Mock.new
-      handler.expect(:decrypt, HexaPDF::Object.new(:result, oid: 1), [HexaPDF::Object])
-      @document.instance_variable_set(:@security_handler, handler)
-      create_parser("1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
-      assert_equal(:result, @parser.load_object(@xref).value)
-      assert(handler.verify)
-    end
-
     it "ignores parts where the starting line is split across lines" do
       create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(5, @parser.load_object(@xref).value)
@@ -774,6 +765,31 @@ describe HexaPDF::Parser do
       assert_equal({Root: HexaPDF::Reference.new(1, 0)}, @parser.reconstructed_revision.trailer.value)
     end
 
+    it "decrypts strings and streams correctly in case of whole/part document recovery" do
+      io = StringIO.new
+      doc = HexaPDF::Document.new
+      doc.catalog[:XXTest] = doc.add({Data: "string"}, stream: "stream")
+      doc.encrypt
+      xref_section = doc.write(io)[1]
+      test_oid = doc.catalog[:XXTest].oid
+
+      # whole document corruption
+      invalid_doc = io.string.sub(/xref\n0 #{xref_section.max_oid + 1}/, "xref\n0 1")
+      doc = HexaPDF::Document.new(io: StringIO.new(invalid_doc))
+      assert(doc.revisions.parser.reconstructed?)
+      assert_equal('string', doc.catalog[:XXTest][:Data])
+      assert_equal('stream', doc.catalog[:XXTest].stream)
+
+      # part document corruption
+      invalid_doc = io.string.sub(xref_section[test_oid].pos.to_s.rjust(10, '0'),
+                                  (xref_section[test_oid].pos + 5).to_s.rjust(10, '0'))
+      doc = HexaPDF::Document.new(io: StringIO.new(invalid_doc))
+      refute(doc.revisions.parser.reconstructed?)
+      assert_equal('string', doc.catalog[:XXTest][:Data])
+      assert_equal('stream', doc.catalog[:XXTest].stream)
+      assert(doc.revisions.parser.reconstructed?)
+    end
+
     it "fails if no valid trailer is found and couldn't be constructed" do
       create_parser("1 0 obj\n5\nendobj\nquack trailer <</Size 1>>\nstartxref\n22\n%%EOF")
       assert_raises(HexaPDF::MalformedPDFError) { @parser.reconstructed_revision.trailer }

data/test/hexapdf/test_serializer.rb

@@ -58,7 +58,7 @@ describe HexaPDF::Serializer do
     assert_serialized("1208925819614629174706176", 1_208_925_819_614_629_174_706_176)
   end
 
-  it "serializes floats with a precision of 4" do
+  it "serializes floats with a precision of 6" do
     assert_serialized("1.5", 1.5)
     assert_serialized("-1.5", -1.5)
     assert_serialized("9.123456", 9.123456)
@@ -66,6 +66,12 @@ describe HexaPDF::Serializer do
     assert_serialized("0.000005", 0.000005)
     assert_serialized("-0.000005", -0.000005)
     assert_serialized("0.0", 0.0)
+    assert_serialized("123456789012345.0", 1.23456789012345e14)
+    assert_serialized("123456789012345.34", 1.2345678901234534e14)
+    assert_serialized("-123456789012345.0", -1.23456789012345e14)
+    assert_serialized("-123456789012345.34", -1.2345678901234534e14)
+    assert_serialized("999999999999999", 1.23456789012345e15)
+    assert_serialized("-999999999999999", -1.23456789012345e15)
     assert_raises(HexaPDF::Error) { @serializer.serialize(0.0 / 0) }
     assert_raises(HexaPDF::Error) { @serializer.serialize(1.0 / 0) }
     assert_raises(HexaPDF::Error) { @serializer.serialize(-1.0 / 0) }

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

@@ -928,7 +928,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
         it "creates the /N appearance stream" do
           @field[:I] = [1, 2]
-          @field[:V] = ['b', 'c']
+          @field[:V] = ['b', 'c', 'd']
           @field.set_default_appearance_string(font_size: 12, font_color: "red")
           @generator.create_appearances
           assert_operators(@widget[:AP][:N].stream,

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

@@ -103,6 +103,11 @@ describe HexaPDF::Type::AcroForm::ChoiceField do
         @field.option_items = [1, 2, 3, 4]
         @field.list_box_top_index = 2
         assert_equal(2, @field.list_box_top_index)
+
+        @field[:TI] = 100
+        assert_equal(0, @field.list_box_top_index)
+        @field[:TI] = "other"
+        assert_equal(0, @field.list_box_top_index)
       end
 
       it "fails if mulitple values are provided but the list box is not a multi-select" do

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

@@ -113,7 +113,9 @@ describe HexaPDF::Type::AcroForm::Field do
 
   it "can check whether a widget is embedded in the field" do
     refute(@field.embedded_widget?)
-    @field[:Subtype] = :Wdiget
+    @field[:Subtype] = :Link
+    refute(@field.embedded_widget?)
+    @field[:Subtype] = :Widget
     assert(@field.embedded_widget?)
   end
 

data/test/hexapdf/type/test_catalog.rb

@@ -50,6 +50,16 @@ describe HexaPDF::Type::Catalog do
     assert_equal(:XXOCConfiguration, oc[:D].type)
   end
 
+  it "uses or creates the document security store on access" do
+    @catalog[:DSS] = {}
+    assert_equal(:DSS, @catalog.dss.type)
+
+    @catalog.delete(:DSS)
+    dss = @catalog.dss
+    assert_equal(:DSS, dss.type)
+    assert_same(dss, @catalog.dss)
+  end
+
   describe "acro_form" do
     it "returns an existing form object" do
       @catalog[:AcroForm] = :test

data/test/hexapdf/type/test_document_security_store.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../digital_signature/common'
+require 'hexapdf/document'
+require 'hexapdf/type/document_security_store'
+
+describe HexaPDF::Type::DocumentSecurityStore do
+  before do
+    @doc = HexaPDF::Document.new
+    @dss = @doc.add({Type: :DSS})
+  end
+
+  [[:add_cert, :Certs], [:add_ocsp, :OCSPs], [:add_crl, :CRLs]].each do |method, field|
+    describe method do
+      it "adds a #{field[0..-2]} as an indirect stream object" do
+        result = @dss.send(method, "der_data")
+        assert_kind_of(HexaPDF::Stream, result)
+        assert_equal(:FlateDecode, result[:Filter])
+        assert_equal("der_data", result.stream)
+        assert_equal(1, @dss[field].size)
+      end
+
+      it "returns the same stream object for duplicate #{field[0..-2]} data" do
+        result1 = @dss.send(method, "der_data")
+        result2 = @dss.send(method, "der_data")
+        assert_same(result1, result2)
+        assert_equal(1, @dss[field].size)
+      end
+
+      it "adds distinct stream objects for different #{field[0..-2]} data" do
+        @dss.send(method, "data_one")
+        @dss.send(method, "data_two")
+        assert_equal(2, @dss[field].size)
+      end
+    end
+  end
+
+  describe "add_vri" do
+    before do
+      @signature_contents = 'signature bytes'
+      @signature = @doc.add({Type: :Sig, Contents: @signature_contents})
+      @vri_key = OpenSSL::Digest::SHA1.hexdigest(@signature_contents).upcase.to_sym
+    end
+
+    it "returns the VRI entry" do
+      vri = @dss.add_vri(@signature)
+      assert_equal(:VRI, vri.type)
+    end
+
+    it "creates the /VRI dictionary with an entry for the signature" do
+      vri = @dss.add_vri(@signature)
+      assert(@dss.key?(:VRI))
+      assert_same(vri, @dss[:VRI][@vri_key])
+    end
+
+    it "populates /Cert in the VRI entry and the DSS /Certs array" do
+      @dss.add_vri(@signature, certs: ["cert1", "cert2"])
+      assert_equal(2, @dss[:VRI][@vri_key][:Cert].size)
+      assert_equal(2, @dss[:Certs].size)
+    end
+
+    it "populates /OCSP in the VRI entry and the DSS /OCSPs array" do
+      @dss.add_vri(@signature, ocsps: ["ocsp1", "ocsp2"])
+      assert_equal(2, @dss[:VRI][@vri_key][:OCSP].size)
+      assert_equal(2, @dss[:OCSPs].size)
+    end
+
+    it "populates /CRL in the VRI entry and the DSS /CRLs array" do
+      @dss.add_vri(@signature, crls: ["crl1"])
+      assert_equal(1, @dss[:VRI][@vri_key][:CRL].size)
+      assert_equal(1, @dss[:CRLs].size)
+    end
+
+    it "de-duplicates DER streams shared across multiple VRI entries" do
+      @dss.add_vri(@signature, certs: ["shared_cert", "cert_a"])
+      @dss.add_vri(@doc.add({Type: :Sig, Contents: 'new'}), certs: ["shared_cert", "cert_b"])
+      # shared_cert added once despite appearing in both VRI entries
+      assert_equal(2, @dss[:VRI].value.size)
+      assert_equal(3, @dss[:Certs].size)
+    end
+
+    it "creates a VRI entry with no optional arrays when all inputs are empty" do
+      @dss.add_vri(@signature)
+      vri = @dss[:VRI][@vri_key]
+      refute(vri.key?(:Cert))
+      refute(vri.key?(:OCSP))
+      refute(vri.key?(:CRL))
+    end
+  end
+
+  describe "vri_for" do
+    before do
+      @signature = @doc.add({Type: :Sig, Contents: 'signature bytes'})
+    end
+
+    it "returns nil if no /VRI entry exists" do
+      assert_nil(@dss.vri_for(@signature))
+    end
+
+    it "returns the VRI entry for the signature if it exists" do
+      @dss[:VRI] = {}
+      assert_nil(@dss.vri_for(@signature))
+      @dss.add_vri(@signature)
+      assert_equal(@dss[:VRI].value.first[1], @dss.vri_for(@signature))
+    end
+  end
+
+  describe "certificates" do
+    it "returns an empty array if no /Certs entry exists" do
+      assert_equal([], @dss.certificates)
+    end
+
+    it "returns an array with certificate instances" do
+      cert = CERTIFICATES.signer_certificate
+      @dss[:Certs] = [@doc.add({}, stream: cert.to_der)]
+      assert_equal([cert], @dss.certificates)
+    end
+  end
+end

data/test/test_helper.rb

@@ -3,9 +3,13 @@
 begin
   require 'simplecov'
   SimpleCov.start do
-    minimum_coverage line: 100 unless ENV['NO_SIMPLECOV']
-    add_filter '/test/'
-    add_filter '/fast_arc4.rb'
+    enable_coverage(:method)
+    unless ENV['NO_SIMPLECOV']
+      coverage(:line) { minimum 100 }
+      coverage(:method) { minimum 100 }
+    end
+    skip '/test/'
+    skip '/fast_arc4.rb'
   end
 rescue LoadError
 end