hexapdf 0.15.8 → 0.17.1

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

@@ -1,247 +0,0 @@
-# -*- 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)
-  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 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

@@ -1,353 +0,0 @@
-# -*- 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_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

@@ -1,38 +0,0 @@
-# -*- 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