hexapdf 0.11.9 → 0.13.0

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

@@ -7,64 +7,231 @@ require 'hexapdf/type/acro_form/form'
 describe HexaPDF::Type::AcroForm::Form do
   before do
     @doc = HexaPDF::Document.new
-    @acroform = @doc.add({}, type: :XXAcroForm)
+    @acro_form = @doc.add({Fields: []}, type: :XXAcroForm)
   end
 
   describe "signature flags" do
     before do
-      @acroform[:SigFlags] = 3
+      @acro_form[:SigFlags] = 3
     end
 
     it "returns all signature flags" do
-      assert_equal([:signatures_exist, :append_only], @acroform.signature_flags)
+      assert_equal([:signatures_exist, :append_only], @acro_form.signature_flags)
     end
 
     it "returns true if the given flag is set" do
-      assert(@acroform.signature_flag?(:signatures_exist))
+      assert(@acro_form.signature_flag?(:signatures_exist))
     end
 
     it "raises an error if an unknown flag name is provided" do
-      assert_raises(ArgumentError) { @acroform.signature_flag?(:non_exist) }
+      assert_raises(ArgumentError) { @acro_form.signature_flag?(:non_exist) }
     end
 
     it "sets the given flag bits" do
-      @acroform[:SigFlags] = 0
-      @acroform.signature_flag(:append_only)
-      assert_equal([:append_only], @acroform.signature_flags)
-      @acroform.signature_flag(:signatures_exist, clear_existing: true)
-      assert_equal([:signatures_exist], @acroform.signature_flags)
+      @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: :Tx1}, {FT: :Tx2, Parent: {FT: :Tx3}}]
+    @doc.pages.add[:Annots] = [{FT: :Tx}, {FT: :Tx2, Parent: {FT: :Tx3}}]
     @doc.pages.add[:Annots] = [{Subtype: :Widget}]
     @doc.pages.add
 
-    result = [{FT: :Tx1}, {FT: :Tx3}]
-    assert_equal(result, @acroform.find_root_fields.map(&:value))
-    refute(@acroform.key?(:Fields))
+    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)
 
-    @acroform.find_root_fields!
-    assert_equal(result, @acroform[:Fields].value.map(&:value))
+    @acro_form.find_root_fields!
+    assert_equal(result, @acro_form[:Fields].value.map(&:value))
   end
 
   describe "each_field" do
     before do
-      @acroform[:Fields] = [
-        {FT: :Tx1},
-        {FT: :Tx2, Kids: [{Subtype: :Widget}]},
-        {FT: :Tx3, Kids: [{FT: :Tx4}, {FT: :Tx5, Kids: [{FT: :Tx6}]}]},
+      @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], @acroform.each_field.map {|h| h[:FT] })
+      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],
-                   @acroform.each_field(terminal_only: false).map {|h| h[:FT] })
+                   @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
+    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
+
+    it "creates a text field" do
+      field = @acro_form.create_text_field("field")
+      assert_equal(:Tx, field.field_type)
+    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")
+      assert(field.combo_box?)
+    end
+
+    it "creates a list box" do
+      field = @acro_form.create_list_box("field")
+      assert(field.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
+
+  it "creates the appearances of all field widgets if necessary" 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)
+    @acro_form.create_appearances
+    assert(tf.each_widget.all? {|w| w.appearance.normal_appearance.kind_of?(HexaPDF::Stream) })
+    assert(cb.each_widget.all? {|w| w.appearance.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
+  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_text_field.rb

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../../content/common'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/text_field'
+
+describe HexaPDF::Type::AcroForm::TextField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.add({FT: :Tx}, type: :XXAcroFormField, subtype: :Tx)
+  end
+
+  it "resolves /MaxLen as inheritable field" do
+    assert_nil(@field[:MaxLen])
+
+    @field[:Parent] = {MaxLen: 5}
+    assert_equal(5, @field[:MaxLen])
+
+    @field[:MaxLen] = 6
+    assert_equal(6, @field[:MaxLen])
+  end
+
+  describe "field_value" do
+    it "handles unset values" do
+      assert_nil(@field.field_value)
+    end
+
+    it "handles string values" do
+      @field[:V] = "str"
+      assert_equal("str", @field.field_value)
+    end
+
+    it "handles stream values" do
+      @field[:V] = @doc.wrap({}, stream: "str")
+      assert_equal("str", @field.field_value)
+    end
+  end
+
+  describe "field_value=" do
+    it "sets the field to the given value" do
+      @field.field_value = 'str'
+      assert_equal('str', @field.field_value)
+    end
+
+    it "converts whitespace characters to simple spaces for single line text fields" do
+      @field.field_value = "str\ning"
+      assert_equal('str ing', @field.field_value)
+    end
+
+    it "updates the widgets to reflect the changed value" do
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.set_default_appearance_string
+      @field.field_value = 'str'
+      assert(widget[:AP][:N])
+    end
+
+    it "fails if the :password flag is set" do
+      @field.flag(:password)
+      assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
+    end
+  end
+
+  it "sets and returns the default field value" do
+    @field.default_field_value = 'hallo'
+    assert_equal('hallo', @field.default_field_value)
+  end
+
+  it "returns the correct concrete field type" do
+    assert_equal(:single_line_text_field, @field.concrete_field_type)
+    @field.flag(:multiline, clear_existing: true)
+    assert_equal(:multiline_text_field, @field.concrete_field_type)
+    @field.flag(:password, clear_existing: true)
+    assert_equal(:password_field, @field.concrete_field_type)
+    @field.flag(:file_select, clear_existing: true)
+    assert_equal(:file_select_field, @field.concrete_field_type)
+    @field.flag(:comb, clear_existing: true)
+    assert_equal(:comb_text_field, @field.concrete_field_type)
+    @field.flag(:rich_text, clear_existing: true)
+    assert_equal(:rich_text_field, @field.concrete_field_type)
+  end
+
+  describe "create_appearances" do
+    it "creates the needed streams" do
+      @doc.acro_form(create: true)
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.set_default_appearance_string
+      @field.create_appearances
+      assert(@field[:AP][:N])
+    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 "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(:Tx, @field.field_type)
+    end
+
+    it "checks that the field value has a valid type" do
+      assert(@field.validate) # no field value
+      @field[:V] = :sym
+      refute(@field.validate)
+    end
+
+    it "checks the field value against /MaxLen" do
+      @field[:V] = 'Test'
+      assert(@field.validate)
+      @field[:MaxLen] = 2
+      refute(@field.validate)
+      @field[:V] = nil
+      assert(@field.validate)
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/variable_text_field'
+
+describe HexaPDF::Type::AcroForm::VariableTextField do
+  before do
+    @doc = HexaPDF::Document.new
+    @doc.acro_form(create: true).set_default_appearance_string
+    @field = @doc.add({}, type: HexaPDF::Type::AcroForm::VariableTextField)
+  end
+
+  describe "text_alignment" do
+    it "returns the alignment value for displaying text" do
+      assert_equal(:left, @field.text_alignment)
+      @field[:Q] = 1
+      assert_equal(:center, @field.text_alignment)
+      @field[:Q] = 2
+      assert_equal(:right, @field.text_alignment)
+    end
+
+    it "sets the alignment value for displaying text to a given value" do
+      @field.text_alignment(:center)
+      assert_equal(1, @field[:Q])
+      @field.text_alignment(:right)
+      assert_equal(2, @field[:Q])
+      @field.text_alignment(:left)
+      assert_equal(0, @field[:Q])
+      assert_raises(ArgumentError) { @field.text_alignment(:unknown) }
+    end
+  end
+
+  describe "set_default_appearance_string" do
+    it "creates the AcroForm object if it doesn't exist" do
+      @doc.catalog.delete(:AcroForm)
+      @field.set_default_appearance_string
+      assert(@doc.acro_form)
+    end
+
+    it "uses sane default values if no arguments are provided" do
+      @field.set_default_appearance_string
+      assert_equal("0 g /F1 0 Tf", @field[:DA])
+      font = @doc.acro_form.default_resources.font(:F1)
+      assert(font)
+      assert_equal(:Helvetica, font[:BaseFont])
+    end
+
+    it "allows specifying the used font and font size" do
+      @field.set_default_appearance_string(font: 'Times', font_size: 10)
+      assert_equal("0 g /F2 10 Tf", @field[:DA])
+      assert_equal(:'Times-Roman', @doc.acro_form.default_resources.font(:F2)[:BaseFont])
+    end
+  end
+
+  describe "parse_default_appearance_string" do
+    it "parses the default appearance string of the field" do
+      @field[:DA] = "1 g /F1 20 Tf 5 w /F2 10 Tf"
+      assert_equal([:F2, 10], @field.parse_default_appearance_string)
+    end
+
+    it "uses the default appearance string of a parent field" do
+      parent = @doc.add({DA: "/F1 15 Tf"}, type: :XXAcroFormField)
+      @field[:Parent] = parent
+      assert_equal([:F1, 15], @field.parse_default_appearance_string)
+    end
+
+    it "uses the global default appearance string" do
+      assert_equal([:F1, 0], @field.parse_default_appearance_string)
+    end
+
+    it "fails if no /DA value is set" do
+      @doc.acro_form.delete(:DA)
+      assert_raises(HexaPDF::Error) { @field.parse_default_appearance_string }
+    end
+  end
+end