hexapdf 0.11.9 → 0.13.0

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

@@ -0,0 +1,281 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../../content/common'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/button_field'
+
+describe HexaPDF::Type::AcroForm::ButtonField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.add({FT: :Btn, T: 'button'}, type: :XXAcroFormField, subtype: :Btn)
+  end
+
+  it "can be initialized as push button" do
+    @field.initialize_as_push_button
+    assert_nil(@field[:V])
+    assert(@field.push_button?)
+  end
+
+  it "can be initialized as check box" do
+    @field.initialize_as_check_box
+    assert_equal(:Off, @field[:V])
+    assert(@field.check_box?)
+  end
+
+  it "can be initialized as radio button" do
+    @field.initialize_as_radio_button
+    assert_equal(:Off, @field[:V])
+    assert_equal(1 << 15, @field[:Ff])
+  end
+
+  describe "push button" do
+    before do
+      @field.flag(:push_button)
+    end
+
+    it "can be asked whether it is a push button field" do
+      @field.flag(:push_button)
+      assert(@field.push_button?)
+    end
+
+    it "always returns nil when getting the field value" do
+      @field[:V] = :test
+      assert_nil(@field.field_value)
+    end
+
+    it "doesn't set a field value" do
+      @field.field_value = :test
+      assert_nil(@field[:V])
+    end
+
+    it "returns the correct concrete field type" do
+      assert_equal(:push_button, @field.concrete_field_type)
+    end
+
+    it "applies sensible default values when creating a widget" do
+      widget = @field.create_widget(@doc.pages.add)
+      border_style = widget.border_style
+      assert_equal([0], border_style.color.components)
+      assert_equal(1, border_style.width)
+      assert_equal(:beveled, border_style.style)
+      assert_equal([0.5], widget.background_color.components)
+    end
+  end
+
+  describe "check box" do
+    before do
+      @field.unflag(:push_button)
+      @field.unflag(:radio)
+    end
+
+    it "can be asked whether it is a check box field" do
+      assert(@field.check_box?)
+    end
+
+    it "returns a correct field value" do
+      refute(@field.field_value)
+      @field[:V] = :Off
+      refute(@field.field_value)
+      @field[:V] = :Yes
+      assert(@field.field_value)
+    end
+
+    it "sets a correct field value" do
+      @field.field_value = true
+      assert_equal(:Yes, @field[:V])
+      @field.field_value = false
+      assert_equal(:Off, @field[:V])
+    end
+
+    it "returns the correct concrete field type" do
+      assert_equal(:check_box, @field.concrete_field_type)
+    end
+
+    it "updates the widgets after setting the field value" do
+      widget = @field.create_widget(@doc.pages.add)
+      @field.field_value = true
+      assert_equal(:Yes, widget[:AS])
+    end
+
+    it "can determine the name of the on state" do
+      assert_equal(:Yes, @field.check_box_on_name)
+      widget = @field.create_widget(@doc.pages.add)
+      assert_equal(:Yes, @field.check_box_on_name)
+      widget[:AP][:N].delete(:Yes)
+      widget[:AP][:N][:On] = nil
+      assert_equal(:On, @field.check_box_on_name)
+    end
+
+    it "applies sensible default values when creating a widget" do
+      widget = @field.create_widget(@doc.pages.add)
+      assert_equal({Yes: nil, Off: nil}, widget[:AP][:N].value)
+      border_style = widget.border_style
+      assert_equal([0], border_style.color.components)
+      assert_equal(1, border_style.width)
+      assert_equal(:solid, border_style.style)
+      assert_equal([1], widget.background_color.components)
+      assert_equal(:check, widget.marker_style.style)
+    end
+  end
+
+  describe "radio button" do
+    before do
+      @field.unflag(:push_button)
+      @field.flag(:radio)
+    end
+
+    it "can be asked whether it is a radio button field" do
+      assert(@field.radio_button?)
+    end
+
+    it "returns a correct field value" do
+      assert_nil(@field.field_value)
+      @field[:V] = :Off
+      assert_nil(@field.field_value)
+      @field[:V] = :name
+      assert_equal(:name, @field.field_value)
+    end
+
+    it "sets a correct field value" do
+      @field.create_widget(@doc.pages.add, value: :button1)
+
+      @field.field_value = "button1"
+      assert_equal(:button1, @field[:V])
+      @field.field_value = nil
+      assert_equal(:Off, @field[:V])
+      assert_raises(HexaPDF::Error) { @field.field_value = :unknown }
+    end
+
+    it "returns the correct concrete field type" do
+      assert_equal(:radio_button, @field.concrete_field_type)
+    end
+
+    it "updates the widgets after setting the field value" do
+      widget = @field.create_widget(@doc.pages.add, value: :Test)
+      @field.field_value = :Test
+      assert_equal(:Test, widget[:AS])
+    end
+
+    it "returns an array of possible values" do
+      @field.create_widget(@doc.pages.add, value: "Test")
+      @field.create_widget(@doc.pages.add, value: :x)
+      @field.create_widget(@doc.pages.add, value: :y)
+      assert_equal([:Test, :x, :y], @field.radio_button_values)
+    end
+
+    it "applies sensible default values when creating a widget" do
+      widget = @field.create_widget(@doc.pages.add, value: 'test')
+      border_style = widget.border_style
+      assert_equal([0], border_style.color.components)
+      assert_equal(1, border_style.width)
+      assert_equal(:solid, border_style.style)
+      assert_equal([1], widget.background_color.components)
+      assert_equal(:circle, widget.marker_style.style)
+      assert_equal({test: nil, Off: nil}, widget[:AP][:N].value)
+    end
+
+    it "always creates standalone widgets" do
+      refute_same(@field.data, @field.create_widget(@doc.pages.add, value: 'test'))
+    end
+
+    it "fails if the value argument is not provided for create_widget" do
+      assert_raises(ArgumentError) { @field.create_widget(@doc.pages.add) }
+    end
+
+    it "fails if the value argument for create_widget doesn't respond to to_sym" do
+      assert_raises(ArgumentError) { @field.create_widget(@doc.pages.add, value: 5) }
+    end
+  end
+
+  it "returns a default field value" do
+    assert_method_invoked(@field, :normalized_field_value, [:DV]) do
+      @field.default_field_value
+    end
+  end
+
+  it "sets a default field value" do
+    assert_method_invoked(@field, :normalized_field_value_set, [:DV, :value]) do
+      @field.default_field_value = :value
+    end
+  end
+
+  it "resolves /Opt as inheritable field" do
+    @field[:Parent] = {Opt: 5}
+    assert_equal(5, @field[:Opt])
+
+    @field[:Opt] = 6
+    assert_equal(6, @field[:Opt])
+  end
+
+  describe "create_appearances" do
+    it "works for check boxes" do
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.create_appearances
+      assert(@field[:AP][:N][:Yes])
+    end
+
+    it "works for radio buttons" do
+      @field.initialize_as_radio_button
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0], value: :test)
+      @field.create_appearances
+      assert(widget[:AP][:N][:test])
+    end
+
+    it "won't generate appearances if they already exist" do
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.create_appearances
+      yes = widget.appearance.normal_appearance[:Yes]
+      off = widget.appearance.normal_appearance[:Off]
+      widget.appearance.normal_appearance.delete(:Off)
+      @field.create_appearances
+      assert_same(yes, widget.appearance.normal_appearance[:Yes])
+      refute_same(off, widget.appearance.normal_appearance[:Off])
+    end
+
+    it "fails for unsupported button types" do
+      @field.flag(:push_button)
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      assert_raises(HexaPDF::Error) { @field.create_appearances }
+    end
+
+    it "uses the configuration option acro_form.appearance_generator" do
+      @doc.config['acro_form.appearance_generator'] = 'NonExistent'
+      assert_raises(Exception) { @field.create_appearances }
+    end
+  end
+
+  describe "update_widgets" do
+    it "does nothing for push buttons" do
+      @field.flag(:push_button)
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.update_widgets
+      assert_nil(widget[:AS])
+    end
+
+    it "sets the /AS entry correctly" do
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      assert_nil(widget[:AS])
+      @field.update_widgets
+      assert_equal(:Off, widget[:AS])
+
+      @field[:V] = :Yes
+      @field.update_widgets
+      assert_equal(:Yes, widget[:AS])
+    end
+  end
+
+  describe "validation" do
+    it "checks the value of the /FT field" do
+      @field.delete(:FT)
+      refute(@field.validate(auto_correct: false))
+      assert(@field.validate)
+      assert_equal(:Btn, @field.field_type)
+    end
+
+    it "sets the field value to :Off it it is not set" do
+      assert(@field.validate)
+      assert_equal(:Off, @field[:V])
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/choice_field'
+
+describe HexaPDF::Type::AcroForm::ChoiceField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.add({FT: :Ch, T: 'choice'}, type: :XXAcroFormField, subtype: :Ch)
+  end
+
+  it "can be initialized as list box" do
+    @field.initialize_as_list_box
+    assert_nil(@field[:V])
+    assert(@field.list_box?)
+  end
+
+  it "can be initialized as combo box" do
+    @field.initialize_as_combo_box
+    assert_nil(@field[:V])
+    assert(@field.combo_box?)
+  end
+
+  describe "field_value" do
+    it "returns the correct Unicode string value" do
+      @field[:V] = "H\xe4llo".b
+      assert_equal("Hällo", @field.field_value)
+    end
+
+    it "returns an array of Unicode string values" do
+      @field[:V] = ["H\xe4llo".b, "\xFE\xFF".b << "Óthér".encode('UTF-16BE').b]
+      assert_equal(["Hällo", "Óthér"], @field.field_value)
+    end
+  end
+
+  describe "field_value=" do
+    before do
+      @field.option_items = ["test", "other"]
+    end
+
+    describe "combo_box" do
+      before do
+        @field.initialize_as_combo_box
+      end
+
+      it "can set the value for an uneditable combo box" do
+        @field.field_value = 'test'
+        assert_equal("test", @field[:V])
+      end
+
+      it "can set the value for an editable combo box" do
+        @field.flag(:edit)
+        @field.field_value = 'another'
+        assert_equal("another", @field[:V])
+      end
+
+      it "fails if mulitple values are provided for a combo box" do
+        assert_raises(HexaPDF::Error) { @field.field_value = ['a', 'b'] }
+      end
+
+      it "fails if an unlisted value is specified for an uneditable combo box" do
+        assert_raises(HexaPDF::Error) { @field.field_value = 'a' }
+      end
+    end
+
+    describe "list_box" do
+      before do
+        @field.initialize_as_list_box
+      end
+
+      it "can set a single value" do
+        @field.field_value = 'test'
+        assert_equal("test", @field[:V])
+      end
+
+      it "can set a multiple values if the list box is a multi-select" do
+        @field.flag(:multi_select)
+        @field.field_value = ['test', 'other']
+        assert_equal(['test', 'other'], @field[:V].value)
+      end
+
+      it "fails if mulitple values are provided but the list box is not a multi-select" do
+        assert_raises(HexaPDF::Error) { @field.field_value = ['a', 'b'] }
+      end
+
+      it "fails if an unlisted value is specified" do
+        assert_raises(HexaPDF::Error) { @field.field_value = 'a' }
+      end
+    end
+  end
+
+  it "sets and returns the default field value" do
+    @field.option_items = ["hällo"]
+    @field.default_field_value = 'hällo'
+    assert_equal('hällo', @field.default_field_value)
+    assert_raises(HexaPDF::Error) { @field.default_field_value = 'unknown' }
+  end
+
+  it "sets and returns the array with the option items" do
+    assert_equal([], @field.option_items)
+    @field.option_items = ["H\xe4llo".b, "\xFE\xFF".b << "Töne".encode('UTF-16BE').b]
+    assert_equal(["Hällo", "Töne"], @field.option_items)
+  end
+
+  it "returns the correct concrete field type" do
+    assert_equal(:list_box, @field.concrete_field_type)
+    @field.initialize_as_combo_box
+    assert_equal(:combo_box, @field.concrete_field_type)
+  end
+
+  describe "create_appearances" do
+    before do
+      @widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+    end
+
+    it "works for combo box fields" do
+      @field.initialize_as_combo_box
+      @field.set_default_appearance_string
+      @field.create_appearances
+      assert(@field[:AP][:N])
+    end
+
+    it "fails for list boxes" do
+      assert_raises(HexaPDF::Error) { @field.create_appearances }
+    end
+  end
+
+  describe "validation" do
+    it "checks the value of the /FT field" do
+      @field.delete(:FT)
+      refute(@field.validate(auto_correct: false))
+      assert(@field.validate)
+      assert_equal(:Ch, @field.field_type)
+    end
+  end
+end

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

@@ -4,6 +4,15 @@ 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
@@ -24,6 +33,14 @@ describe HexaPDF::Type::AcroForm::Field do
     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)
 
@@ -31,17 +48,42 @@ describe HexaPDF::Type::AcroForm::Field do
     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_name)
+    assert_nil(@field.full_field_name)
 
     @field[:T] = "Test"
-    assert_equal("Test", @field.full_name)
+    assert_equal("Test", @field.full_field_name)
 
     @field[:Parent] = {}
-    assert_equal("Test", @field.full_name)
+    assert_equal("Test", @field.full_field_name)
 
     @field[:Parent] = {T: 'Parent'}
-    assert_equal("Parent.Test", @field.full_name)
+    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
@@ -53,10 +95,125 @@ describe HexaPDF::Type::AcroForm::Field do
     @field[:Kids] = [{Subtype: :Widget}]
     assert(@field.terminal_field?)
 
-    @field[:Kids] = [{FT: :Tx}]
+    @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 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)
+      @field.delete_widget(widget)
+      refute(@field.key?(:Subtype))
+      assert(@page[:Annots].empty?)
+    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
@@ -68,7 +225,7 @@ describe HexaPDF::Type::AcroForm::Field do
       @field.delete(:FT)
       refute(@field.validate)
 
-      @field[:Kids] = [{}]
+      @field[:Kids] = [{T: 'name'}]
       assert(@field.validate)
     end