hexapdf 0.17.1 → 0.17.2

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

@@ -0,0 +1,259 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/field'
+
+describe HexaPDF::Type::AcroForm::Field::HashRefinement do
+  using HexaPDF::Type::AcroForm::Field::HashRefinement
+
+  it "returns self when calling value" do
+    x = {}
+    assert_same(x, x.value)
+  end
+end
+
+describe HexaPDF::Type::AcroForm::Field do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.add({}, type: :XXAcroFormField)
+    @doc.acro_form(create: true).root_fields << @field
+  end
+
+  it "must always be an indirect object" do
+    assert(@field.must_be_indirect?)
+  end
+
+  it "resolves inherited field values" do
+    assert_nil(@field[:FT])
+
+    @field[:Parent] = {FT: :Tx}
+    assert_equal(:Tx, @field[:FT])
+
+    @field[:FT] = :Ch
+    assert_equal(:Ch, @field[:FT])
+  end
+
+  it "has convenience methods for accessing the field flags" do
+    assert_equal([], @field.flags)
+    refute(@field.flagged?(:required))
+    @field.flag(:required, 2)
+    assert(@field.flagged?(2))
+    assert_equal(6, @field[:Ff])
+  end
+
+  it "returns the field type" do
+    assert_nil(@field.field_type)
+
+    @field[:FT] = :Tx
+    assert_equal(:Tx, @field.field_type)
+  end
+
+  it "returns the concrete field type" do
+    assert_nil(@field.concrete_field_type)
+
+    @field[:FT] = :Tx
+    assert_equal(:text_field, @field.concrete_field_type)
+    @field[:FT] = :Btn
+    assert_equal(:button_field, @field.concrete_field_type)
+    @field[:FT] = :Ch
+    assert_equal(:choice_field, @field.concrete_field_type)
+    @field[:FT] = :Sig
+    assert_equal(:signature_field, @field.concrete_field_type)
+  end
+
+  it "returns the field name" do
+    assert_nil(@field.field_name)
+    @field[:T] = 'test'
+    assert_equal('test', @field.field_name)
+  end
+
+  it "returns the full name of the field" do
+    assert_nil(@field.full_field_name)
+
+    @field[:T] = "Test"
+    assert_equal("Test", @field.full_field_name)
+
+    @field[:Parent] = {}
+    assert_equal("Test", @field.full_field_name)
+
+    @field[:Parent] = {T: 'Parent'}
+    assert_equal("Parent.Test", @field.full_field_name)
+  end
+
+  it "allows setting and retrieving the alternate field name" do
+    @field.alternate_field_name = 'Alternate'
+    assert_equal('Alternate', @field.alternate_field_name)
+    assert_equal('Alternate', @field[:TU])
+  end
+
+  it "returns whether the field is a terminal field" do
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = []
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = [{Subtype: :Widget}]
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = [{FT: :Tx, T: 'name'}]
+    refute(@field.terminal_field?)
+  end
+
+  it "can check whether a widget is embedded in the field" do
+    refute(@field.embedded_widget?)
+    @field[:Subtype] = :Wdiget
+    assert(@field.embedded_widget?)
+  end
+
+  describe "each_widget" do
+    it "yields a wrapped instance of self if a single widget is embedded" 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_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_equal(1, widgets.first[:X])
+    end
+
+    it "yields all widgets of other fields with the same full field name" do
+      @field[:T] = 'a'
+      @doc.acro_form.root_fields <<
+        @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)
+      assert_equal(1, widgets.first[:X])
+    end
+
+    it "yields nothing if no widgets are defined" do
+      assert_equal([], @field.each_widget.to_a)
+    end
+  end
+
+  describe "create_widget" do
+    before do
+      @page = @doc.pages.add
+    end
+
+    it "sets all required widget keys" do
+      widget = @field.create_widget(@page)
+      assert_equal(:Annot, widget.type)
+      assert_equal(:Widget, widget[:Subtype])
+      assert_equal([0, 0, 0, 0], widget[:Rect])
+    end
+
+    it "sets the additionally specified keys on the widget" do
+      widget = @field.create_widget(@page, X: 5)
+      assert_equal(5, widget[:X])
+    end
+
+    it "adds the new widget to the given page's annotations" do
+      widget = @field.create_widget(@page)
+      assert_equal([widget], @page[:Annots].value)
+    end
+
+    it "populates the field with the widget data if there is no widget" do
+      widget = @field.create_widget(@page)
+      assert_same(widget.data, @field.data)
+      assert_nil(@field[:Kids])
+    end
+
+    it "creates a standalone widget if embedding is not allowed" do
+      refute_same(@field.data, @field.create_widget(@page, allow_embedded: false).data)
+    end
+
+    it "extracts an embedded widget into a standalone object if necessary" do
+      widget1 = @field.create_widget(@page, Rect: [1, 2, 3, 4])
+      widget2 = @field.create_widget(@doc.pages.add, Rect: [2, 1, 4, 3])
+      kids = @field[:Kids]
+
+      assert_equal(2, kids.length)
+      refute_same(widget1, kids[0])
+      assert_same(widget2, kids[1])
+      assert_nil(@field[:Rect])
+      assert_equal({Rect: [1, 2, 3, 4], Type: :Annot, Subtype: :Widget, Parent: @field},
+                   kids[0].value)
+      assert_equal([2, 1, 4, 3], kids[1][:Rect].value)
+
+      refute_equal([widget1], @page[:Annots].value)
+      assert_equal([kids[0]], @page[:Annots].value)
+    end
+
+    it "fails if called on a non-terminal field" do
+      @field[:Kids] = [{T: 'name'}]
+      assert_raises(HexaPDF::Error) { @field.create_widget(@page) }
+    end
+  end
+
+  describe "delete_widget" do
+    before do
+      @page = @doc.pages.add
+    end
+
+    it "does nothing if the provided widget doesn't belong to the field" do
+      wrong_widget = @doc.add({Subtype: :Widget})
+
+      @field.create_widget(@page)
+      @field.delete_widget(wrong_widget)
+      assert_equal(:Widget, @field[:Subtype])
+
+      @field.create_widget(@page)
+      @field.delete_widget(wrong_widget)
+      assert_equal(2, @field[:Kids].size)
+    end
+
+    it "deletes the widget if it is embedded" do
+      widget = @field.create_widget(@page)
+      @doc.revisions.current.update(widget)
+      assert_same(widget, @doc.object(widget))
+      refute_same(@field, @doc.object(@field))
+
+      @field.delete_widget(widget)
+      refute(@field.key?(:Subtype))
+      assert(@page[:Annots].empty?)
+      assert_same(@field, @doc.object(@field))
+    end
+
+    it "deletes the widget if it is not embedded" do
+      @field.create_widget(@page)
+      widget2 = @field.create_widget(@page)
+      @field.delete_widget(widget2)
+      assert_equal(1, @field[:Kids].size)
+      assert_equal(@field[:Kids].value, @page[:Annots].value)
+    end
+  end
+
+  describe "perform_validation" do
+    before do
+      @field[:FT] = :Tx
+    end
+
+    it "requires the /FT key to be present for terminal fields" do
+      assert(@field.validate)
+
+      @field.delete(:FT)
+      refute(@field.validate)
+
+      @field[:Kids] = [{T: 'name'}]
+      assert(@field.validate)
+    end
+
+    it "doesn't allow periods in partial field names" do
+      assert(@field.validate)
+
+      @field[:T] = "Test"
+      assert(@field.validate)
+
+      @field[:T] = "Te.st"
+      refute(@field.validate)
+    end
+  end
+end

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

@@ -0,0 +1,357 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/form'
+
+describe HexaPDF::Type::AcroForm::Form do
+  before do
+    @doc = HexaPDF::Document.new
+    @acro_form = @doc.add({Fields: []}, type: :XXAcroForm)
+  end
+
+  describe "signature flags" do
+    before do
+      @acro_form[:SigFlags] = 3
+    end
+
+    it "returns all signature flags" do
+      assert_equal([:signatures_exist, :append_only], @acro_form.signature_flags)
+    end
+
+    it "returns true if the given flag is set" do
+      assert(@acro_form.signature_flag?(:signatures_exist))
+    end
+
+    it "raises an error if an unknown flag name is provided" do
+      assert_raises(ArgumentError) { @acro_form.signature_flag?(:non_exist) }
+    end
+
+    it "sets the given flag bits" do
+      @acro_form[:SigFlags] = 0
+      @acro_form.signature_flag(:append_only)
+      assert_equal([:append_only], @acro_form.signature_flags)
+      @acro_form.signature_flag(:signatures_exist, clear_existing: true)
+      assert_equal([:signatures_exist], @acro_form.signature_flags)
+    end
+  end
+
+  it "returns the root fields" do
+    assert_equal([], @acro_form.root_fields.value)
+  end
+
+  it "finds the root fields" do
+    @doc.pages.add[:Annots] = [{FT: :Tx}, {FT: :Tx2, Parent: {FT: :Tx3}}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget}]
+    @doc.pages.add
+
+    result = [{FT: :Tx}, {FT: :Tx3}]
+    root_fields = @acro_form.find_root_fields
+    assert_equal(result, root_fields.map(&:value))
+    assert_kind_of(HexaPDF::Type::AcroForm::TextField, root_fields[0])
+    assert_equal([], @acro_form[:Fields].value)
+
+    @acro_form.find_root_fields!
+    assert_equal(result, @acro_form[:Fields].value.map(&:value))
+  end
+
+  describe "each_field" do
+    before do
+      @acro_form[:Fields] = [
+        {T: :Tx1},
+        {T: :Tx2, Kids: [{Subtype: :Widget}]},
+        {T: :Tx3, FT: :Tx, Kids: [{T: :Tx4}, {T: :Tx5, Kids: [{T: :Tx6}]}]},
+      ]
+      @acro_form[:Fields][2][:Kids][0][:Parent] = @acro_form[:Fields][2]
+      @acro_form[:Fields][2][:Kids][1][:Parent] = @acro_form[:Fields][2]
+      @acro_form[:Fields][2][:Kids][1][:Kids][0][:Parent] = @acro_form[:Fields][2][:Kids][1]
+    end
+
+    it "iterates over all terminal fields" do
+      assert_equal([:Tx1, :Tx2, :Tx4, :Tx6], @acro_form.each_field.map {|h| h[:T] })
+    end
+
+    it "iterates over all fields" do
+      assert_equal([:Tx1, :Tx2, :Tx3, :Tx4, :Tx5, :Tx6],
+                   @acro_form.each_field(terminal_only: false).map {|h| h[:T] })
+    end
+
+    it "converts the fields into their proper types if possible" do
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, @acro_form.each_field.to_a.last)
+    end
+  end
+
+  describe "field_by_name" do
+    before do
+      @acro_form[:Fields] = [
+        {T: "root only", Kids: [{Subtype: :Widget}]},
+        {T: "children", Kids: [{T: "child", FT: :Btn}, {T: "sub", Kids: [{T: "child"}]}]},
+      ]
+    end
+
+    it "works for root fields" do
+      assert(@acro_form.field_by_name("root only"))
+    end
+
+    it "works for 1st level children" do
+      assert(@acro_form.field_by_name("children.child"))
+    end
+
+    it "works for children on any level" do
+      assert(@acro_form.field_by_name("children.sub.child"))
+    end
+
+    it "returns nil for unknown fields" do
+      assert_nil(@acro_form.field_by_name("non root field"))
+      assert_nil(@acro_form.field_by_name("root only.no child"))
+      assert_nil(@acro_form.field_by_name("root only.no"))
+      assert_nil(@acro_form.field_by_name("children.no child"))
+      assert_nil(@acro_form.field_by_name("children.sub.no child"))
+    end
+
+    it "returns the correct field class" do
+      assert_kind_of(HexaPDF::Type::AcroForm::ButtonField, @acro_form.field_by_name('children.child'))
+    end
+  end
+
+  describe "create fields" do
+    before do
+      @acro_form = @doc.acro_form(create: true)
+    end
+
+    describe "handles the general case" do
+      it "works for names with a dot" do
+        @acro_form[:Fields] = [{T: "root"}]
+        field = @acro_form.create_text_field("root.field")
+        assert_equal('root.field', field.full_field_name)
+        assert_equal([field], @acro_form[:Fields][0][:Kids])
+      end
+
+      it "works for names without a dot" do
+        field = @acro_form.create_text_field("field")
+        assert_equal('field', field.full_field_name)
+        assert([field], @acro_form[:Fields])
+      end
+
+      it "fails if the parent field is not found" do
+        assert_raises(HexaPDF::Error) { @acro_form.create_text_field("root.field") }
+      end
+    end
+
+    def applies_variable_text_properties(method, **args)
+      field = @acro_form.send(method, "field", **args, font: 'Times')
+      font_name, font_size = field.parse_default_appearance_string
+      assert_equal(:'Times-Roman', @acro_form.default_resources.font(font_name)[:BaseFont])
+      assert_equal(0, font_size)
+
+      field = @acro_form.send(method, "field", **args, font_options: {variant: :bold})
+      font_name, font_size = field.parse_default_appearance_string
+      assert_equal(:'Helvetica-Bold', @acro_form.default_resources.font(font_name)[:BaseFont])
+
+      field = @acro_form.send(method, "field", **args, font_size: 10)
+      font_name, font_size = field.parse_default_appearance_string
+      assert_equal(:Helvetica, @acro_form.default_resources.font(font_name)[:BaseFont])
+      assert_equal(10, font_size)
+
+      field = @acro_form.send(method, "field", **args, font: 'Courier', font_size: 10, align: :center)
+      font_name, font_size = field.parse_default_appearance_string
+      assert_equal(:Courier, @acro_form.default_resources.font(font_name)[:BaseFont])
+      assert_equal(10, font_size)
+      assert_equal(:center, field.text_alignment)
+    end
+
+    it "creates a text field" do
+      field = @acro_form.create_text_field("field")
+      assert_equal(:Tx, field.field_type)
+      applies_variable_text_properties(:create_text_field)
+    end
+
+    it "creates a multiline text field" do
+      field = @acro_form.create_multiline_text_field("field")
+      assert_equal(:Tx, field.field_type)
+      assert(field.multiline_text_field?)
+      applies_variable_text_properties(:create_multiline_text_field)
+    end
+
+    it "creates a comb text field" do
+      field = @acro_form.create_comb_text_field("field", max_chars: 9)
+      assert_equal(:Tx, field.field_type)
+      assert_equal(9, field[:MaxLen])
+      assert(field.comb_text_field?)
+      applies_variable_text_properties(:create_comb_text_field, max_chars: 9)
+    end
+
+    it "creates a password field" do
+      field = @acro_form.create_password_field("field")
+      assert_equal(:Tx, field.field_type)
+      assert(field.password_field?)
+      applies_variable_text_properties(:create_password_field)
+    end
+
+    it "creates a file select field" do
+      field = @acro_form.create_file_select_field("field")
+      assert_equal(:Tx, field.field_type)
+      assert(field.file_select_field?)
+      applies_variable_text_properties(:create_file_select_field)
+    end
+
+    it "creates a check box" do
+      field = @acro_form.create_check_box("field")
+      assert(field.check_box?)
+    end
+
+    it "creates a radio button" do
+      field = @acro_form.create_radio_button("field")
+      assert(field.radio_button?)
+    end
+
+    it "creates a combo box" do
+      field = @acro_form.create_combo_box("field", option_items: ['a', 'b', 'c'], editable: true)
+      assert(field.combo_box?)
+      assert_equal(['a', 'b', 'c'], field.option_items)
+      assert(field.flagged?(:edit))
+      applies_variable_text_properties(:create_combo_box)
+    end
+
+    it "creates a list box" do
+      field = @acro_form.create_list_box("field", option_items: ['a', 'b', 'c'], multi_select: true)
+      assert(field.list_box?)
+      assert_equal(['a', 'b', 'c'], field.option_items)
+      assert(field.flagged?(:multi_select))
+      applies_variable_text_properties(:create_list_box)
+    end
+  end
+
+  it "returns the default resources" do
+    assert_kind_of(HexaPDF::Type::Resources, @acro_form.default_resources)
+  end
+
+  describe "set_default_appearance_string" do
+    it "uses sane default values if no arguments are provided" do
+      @acro_form.set_default_appearance_string
+      assert_equal("0 g /F1 0 Tf", @acro_form[:DA])
+      font = @acro_form.default_resources.font(:F1)
+      assert(font)
+      assert_equal(:Helvetica, font[:BaseFont])
+    end
+
+    it "allows specifying the used font and font size" do
+      @acro_form.set_default_appearance_string(font: 'Times', font_size: 10)
+      assert_equal("0 g /F1 10 Tf", @acro_form[:DA])
+      assert_equal(:'Times-Roman', @acro_form.default_resources.font(:F1)[:BaseFont])
+    end
+  end
+
+  it "sets the /NeedAppearances key" do
+    @acro_form.need_appearances!
+    assert(@acro_form[:NeedAppearances])
+  end
+
+  describe "create_appearances" do
+    before do
+      @tf = @acro_form.create_text_field('test')
+      @tf.set_default_appearance_string
+      @tf.create_widget(@doc.pages.add)
+      @cb = @acro_form.create_check_box('test2')
+      @cb.create_widget(@doc.pages.add)
+    end
+
+    it "creates the appearances of all field widgets if necessary" do
+      @acro_form.create_appearances
+      assert(@tf.each_widget.all? {|w| w.appearance_dict.normal_appearance.kind_of?(HexaPDF::Stream) })
+      assert(@cb.each_widget.all? {|w| w.appearance_dict.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
+    end
+
+    it "force the creation of appearances if force is true" do
+      @acro_form.create_appearances
+      text_stream = @tf[:AP][:N].raw_stream
+      @acro_form.create_appearances
+      assert_same(text_stream, @tf[:AP][:N].raw_stream)
+      @acro_form.create_appearances(force: true)
+      refute_same(text_stream, @tf[:AP][:N].raw_stream)
+    end
+  end
+
+  describe "flatten" do
+    before do
+      @acro_form.root_fields << @doc.wrap({T: 'test'})
+      @tf = @acro_form.create_text_field('textfields')
+      @tf.set_default_appearance_string
+      @tf[:V] = 'Test'
+      @tf.create_widget(@doc.pages.add)
+      @cb = @acro_form.create_check_box('test.checkbox')
+      @cb.create_widget(@doc.pages[0])
+      @cb.create_widget(@doc.pages.add)
+    end
+
+    it "creates the missing appearances if instructed to do so" do
+      assert_equal(3, @acro_form.flatten(create_appearances: false).size)
+      assert_equal(0, @acro_form.flatten(create_appearances: true).size)
+    end
+
+    it "flattens the whole interactive form" do
+      result = @acro_form.flatten
+      assert(result.empty?)
+      assert(@tf.null?)
+      assert(@cb.null?)
+      assert(@acro_form.null?)
+      refute(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "flattens the given fields" do
+      result = @acro_form.flatten(fields: [@cb])
+      assert(result.empty?)
+      assert(@cb.null?)
+      refute(@tf.null?)
+      refute(@acro_form.null?)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "doesn't delete the form object if not all fields were flattened" do
+      @acro_form.create_appearances
+      @tf.delete(:AP)
+      result = @acro_form.flatten(create_appearances: false)
+      assert_equal(1, result.size)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+  end
+
+  describe "perform_validation" do
+    it "checks whether the /DR field is available when /DA is set" do
+      @acro_form[:DA] = 'test'
+      refute(@acro_form.validate)
+    end
+
+    it "checks whether the font used in /DA is available in /DR" do
+      @acro_form[:DA] = '/F2 0 Tf /F1 0 Tf'
+      refute(@acro_form.validate {|msg| assert_match(/DR must also be present/, msg) })
+      @acro_form.default_resources[:Font] = {}
+      refute(@acro_form.validate {|msg| assert_match(/font.*is not.*resource/, msg) })
+      @acro_form.default_resources[:Font][:F1] = :yes
+      assert(@acro_form.validate)
+    end
+
+    it "set the default appearance string, though optional, to a valid value to avoid problems" do
+      assert(@acro_form.validate)
+      assert_equal("0 g /F1 0 Tf", @acro_form[:DA])
+    end
+
+    describe "automatically creates the terminal fields; appearances" do
+      before do
+        @cb = @acro_form.create_check_box('test2')
+        @cb.create_widget(@doc.pages.add)
+      end
+
+      it "does this if the configuration option is true" do
+        assert(@acro_form.validate)
+        assert_kind_of(HexaPDF::Stream, @cb[:AP][:N][:Yes])
+      end
+
+      it "does nothing if the configuration option is false" do
+        @doc.config['acro_form.create_appearances'] = false
+        assert(@acro_form.validate)
+        refute_kind_of(HexaPDF::Stream, @cb[:AP][:N][:Yes])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/signature_field'
+
+describe HexaPDF::Type::AcroForm::SignatureField::LockDictionary do
+  it "validates the presence of the /Fields key" do
+    doc = HexaPDF::Document.new
+    obj = HexaPDF::Type::AcroForm::SignatureField::LockDictionary.new({Action: :All}, document: doc)
+    assert(obj.validate)
+    obj[:Action] = :Include
+    refute(obj.validate)
+  end
+end
+
+describe HexaPDF::Type::AcroForm::SignatureField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.wrap({}, type: :XXAcroFormField, subtype: :Sig)
+  end
+
+  it "sets the field value" do
+    @field.field_value = {Empty: :True}
+    assert_equal({Empty: :True}, @field[:V].value)
+  end
+
+  it "gets the field value" do
+    @field[:V] = {Empty: :True}
+    assert_equal({Empty: :True}, @field.field_value.value)
+  end
+
+  it "validates the value of the /FT field" do
+    refute(@field.validate(auto_correct: false))
+    assert(@field.validate)
+    assert_equal(:Sig, @field.field_type)
+  end
+end