hexapdf 0.26.2 → 0.28.0

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::ButtonField do
     @field = @doc.add({FT: :Btn, T: 'button'}, type: :XXAcroFormField, subtype: :Btn)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "can be initialized as push button" do
     @field.initialize_as_push_button
     assert_nil(@field[:V])
@@ -232,6 +236,7 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       @field.create_appearances
       yes = widget.appearance_dict.normal_appearance[:Yes]
       off = widget.appearance_dict.normal_appearance[:Off]
+      widget.appearance_dict.normal_appearance[:Yes] = HexaPDF::Reference.new(yes.oid)
       @field.create_appearances
       assert_same(yes, widget.appearance_dict.normal_appearance[:Yes])
       assert_same(off, widget.appearance_dict.normal_appearance[:Off])
@@ -252,7 +257,7 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       refute_same(yes, widget.appearance_dict.normal_appearance[:Yes])
     end
 
-    it "fails for unsupported button types" do
+    it "fails for push buttons as they are not implemented yet" do
       @field.flag(:push_button)
       @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       assert_raises(HexaPDF::Error) { @field.create_appearances }

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::ChoiceField do
     @field = @doc.add({FT: :Ch, T: 'choice'}, type: :XXAcroFormField, subtype: :Ch)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "can be initialized as list box" do
     @field.initialize_as_list_box
     assert_nil(@field[:V])

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

@@ -111,14 +111,14 @@ describe HexaPDF::Type::AcroForm::Field do
       @field[:Subtype] = :Widget
       @field[:Rect] = [0, 0, 0, 0]
       widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_same(@field.data, widgets.first.data)
     end
 
     it "yields all widgets in the /Kids array" do
       @field[:Kids] = [{Subtype: :Widget, Rect: [0, 0, 0, 0], X: 1}]
       widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_equal(1, widgets.first[:X])
     end
 
@@ -128,8 +128,8 @@ describe HexaPDF::Type::AcroForm::Field do
         @doc.add({T: "b", Subtype: :Widget, Rect: [0, 0, 0, 0]}, type: :XXAcroFormField) <<
         @doc.add({T: "a", X: 1, Subtype: :Widget, Rect: [0, 0, 0, 0]}, type: :XXAcroFormField)
 
-      widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      widgets = @field.each_widget(direct_only: false).to_a
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_equal(1, widgets.first[:X])
     end
 

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,65 @@ 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 "combining fields with the same name" do
+      before do
+        @acro_form[:Fields] = [
+          @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 1]}),
+          @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 2]}),
+          @doc.add({T: 'Tx2'}),
+          @doc.add({T: 'e', Kids: [{Subtype: :Widget, Rect: [0, 0, 0, 3]}]}),
+        ]
+      end
+
+      it "merges fields with the same name into the first one" do
+        assert(@acro_form.validate)
+        assert_equal(2, @acro_form.root_fields.size)
+        assert_equal([[0, 0, 0, 1], [0, 0, 0, 2], [0, 0, 0, 3]],
+                     @acro_form.field_by_name('e').each_widget.map {|w| w[:Rect] })
+      end
+    end
+
     describe "automatically creates the terminal fields; appearances" do
       before do
         @cb = @acro_form.create_check_box('test2')

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

@@ -20,6 +20,10 @@ describe HexaPDF::Type::AcroForm::SignatureField do
     @field = @doc.wrap({}, type: :XXAcroFormField, subtype: :Sig)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "sets the field value" do
     @field.field_value = {Empty: :True}
     assert_equal({Empty: :True}, @field[:V].value)

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::TextField do
     @field = @doc.add({FT: :Tx}, type: :XXAcroFormField, subtype: :Tx)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "resolves /MaxLen as inheritable field" do
     assert_nil(@field[:MaxLen])
 
@@ -164,11 +168,20 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert_same(stream, @field[:AP][:N].raw_stream)
       @field.field_value = 'test'
       refute_same(stream, @field[:AP][:N].raw_stream)
+      stream = @field[:AP][:N].raw_stream
 
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       assert_nil(widget[:AP])
       @field.create_appearances
       refute_nil(widget[:AP][:N])
+
+      @doc.clear_cache
+      @field.create_appearances
+      assert_same(stream, @field[:Kids][0][:AP][:N].raw_stream)
+
+      @doc.clear_cache
+      @field.field_value = 'other'
+      refute_same(stream, @field[:Kids][0][:AP][:N].raw_stream)
     end
 
     it "always creates a new appearance stream if force is true" do

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

@@ -65,6 +65,60 @@ 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_font_true_type.rb

@@ -15,6 +15,26 @@ describe HexaPDF::Type::FontTrueType do
                       BaseFont: :Something, FontDescriptor: font_descriptor})
   end
 
+  describe "font_wrapper" do
+    it "returns the default value if the font is subset" do
+      @font[:BaseFont] = :'ABCDEF+Something'
+      assert_nil(@font.font_wrapper)
+    end
+
+    it "returns the default value if the font has no embedded font file" do
+      assert_nil(@font.font_wrapper)
+    end
+
+    it "uses a fully embedded TrueType font file" do
+      font_file = File.binread(File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf"))
+      @font[:FontDescriptor][:FontFile2] = @doc.add({}, stream: font_file)
+      font_wrapper = @font.font_wrapper
+      assert(font_wrapper)
+      assert_equal(font_file, font_wrapper.wrapped_font.io.string)
+      assert_same(font_wrapper, @font.font_wrapper)
+    end
+  end
+
   describe "validation" do
     it "ignores some missing fields if the font name is one of the standard PDF fonts" do
       @font[:BaseFont] = :'Arial,Bold'

data/test/hexapdf/type/test_object_stream.rb

@@ -104,7 +104,8 @@ describe HexaPDF::Type::ObjectStream do
       assert_equal("", @obj.stream)
     end
 
-    it "doesn't allow the Catalog entry to be compressed when encryption is used" do
+    it "doesn't allow the Catalog entry to be compressed" do
+      @doc.trailer.delete(:Encrypt)
       @obj.add_object(HexaPDF::Dictionary.new({Type: :Catalog}, oid: 8))
       @obj.write_objects(@revision)
       assert_equal(0, @obj.value[:N])

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
@@ -64,6 +64,9 @@ describe HexaPDF::Type::Outline do
         assert(correctable)
       end
       refute(@outline.key?(:Count))
+
+      @outline[:Count] = 0
+      assert(@outline.validate(auto_correct: false))
     end
   end
 end

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