hexapdf 0.17.1 → 0.17.2

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

@@ -0,0 +1,201 @@
+# -*- 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
+
+  it "can be initialized as a multiline text field" do
+    @field.flag(:comb)
+    @field.initialize_as_multiline_text_field
+    assert(@field.multiline_text_field?)
+  end
+
+  it "can be initialized as comb text field" do
+    @field.flag(:multiline)
+    @field.initialize_as_comb_text_field
+    assert(@field.comb_text_field?)
+  end
+
+  it "can be initialized as password field" do
+    @field.flag(:multiline)
+    @field[:V] = 'test'
+    @field.initialize_as_password_field
+    assert_nil(@field[:V])
+    assert(@field.password_field?)
+  end
+
+  it "can be initialized as a file select field" do
+    @field.flag(:multiline)
+    @field.initialize_as_file_select_field
+    assert(@field.file_select_field?)
+  end
+
+  it "can check whether the field is a multiline text field" do
+    refute(@field.multiline_text_field?)
+    @field.flag(:multiline)
+    assert(@field.multiline_text_field?)
+  end
+
+  it "can check whether the field is a comb text field" do
+    refute(@field.comb_text_field?)
+    @field.flag(:comb)
+    assert(@field.comb_text_field?)
+  end
+
+  it "can check whether the field is a password field" do
+    refute(@field.password_field?)
+    @field.flag(:password)
+    assert(@field.password_field?)
+  end
+
+  it "can check whether the field is a file select field" do
+    refute(@field.file_select_field?)
+    @field.flag(:file_select)
+    assert(@field.file_select_field?)
+  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 "allows unsetting the value using +nil+" do
+      @field[:V] = "test"
+      @field.field_value = nil
+      assert_nil(@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
+    before do
+      @doc.acro_form(create: true)
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      @field.set_default_appearance_string
+    end
+
+    it "creates the needed streams" do
+      @field.create_appearances
+      assert(@field[:AP][:N])
+    end
+
+    it "doesn't create a new appearance stream if the field value hasn't changed, checked per widget" do
+      @field.create_appearances
+      stream = @field[:AP][:N].raw_stream
+      @field.create_appearances
+      assert_same(stream, @field[:AP][:N].raw_stream)
+      @field.field_value = 'test'
+      refute_same(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])
+    end
+
+    it "always creates a new appearance stream if force is true" do
+      @field.create_appearances
+      stream = @field[:AP][:N].raw_stream
+      @field.create_appearances(force: true)
+      refute_same(stream, @field[:AP][:N].raw_stream)
+    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,88 @@
+# -*- 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 font" do
+      @field.set_default_appearance_string(font: 'Times')
+      assert_equal("0 g /F2 0 Tf", @field[:DA])
+      assert_equal(:'Times-Roman', @doc.acro_form.default_resources.font(:F2)[:BaseFont])
+    end
+
+    it "allows specifying the font options" do
+      @field.set_default_appearance_string(font_options: {variant: :italic})
+      assert_equal("0 g /F2 0 Tf", @field[:DA])
+      assert_equal(:'Helvetica-Oblique', @doc.acro_form.default_resources.font(:F2)[:BaseFont])
+    end
+
+    it "allows specifying the font size" do
+      @field.set_default_appearance_string(font_size: 10)
+      assert_equal("0 g /F1 10 Tf", @field[:DA])
+    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

data/test/hexapdf/type/actions/test_launch.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/launch'
+
+describe HexaPDF::Type::Actions::Launch do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::Launch.new({}, document: @doc)
+  end
+
+  describe "validation" do
+    it "needs a launch target" do
+      refute(@action.validate)
+
+      @action.value = {F: {}}
+      assert(@action.validate)
+
+      @action.value = {Win: {F: "test.exe"}}
+      assert(@action.validate)
+    end
+  end
+end

data/test/hexapdf/type/actions/test_uri.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/uri'
+
+describe HexaPDF::Type::Actions::URI do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::URI.new({}, document: @doc)
+  end
+
+  describe "validation" do
+    it "URI needs to be ASCII only" do
+      refute(@action.validate)
+
+      @action[:URI] = "hellö"
+      refute(@action.validate(auto_correct: false))
+      assert(@action.validate(auto_correct: true))
+      assert_equal("hell%C3%B6", @action[:URI])
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_markup_annotation.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/markup_annotation'
+
+describe HexaPDF::Type::Annotations::MarkupAnnotation do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = HexaPDF::Type::Annotations::MarkupAnnotation.new({Subtype: :Text, Rect: [0, 0, 1, 1]},
+                                                              document: @doc)
+  end
+
+  describe "validation" do
+    it "needs IRT set if RT is set" do
+      assert(@annot.validate)
+
+      @annot[:RT] = :R
+      refute(@annot.validate)
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_text.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/text'
+
+describe HexaPDF::Type::Annotations::Text do
+  before do
+    @doc = HexaPDF::Document.new
+    @doc.version = '1.5'
+    @annot = HexaPDF::Type::Annotations::Text.new({Rect: [0, 0, 1, 1]}, document: @doc, oid: 1)
+  end
+
+  describe "validation" do
+    it "checks for correct /StateModel values" do
+      @annot[:StateModel] = 'Invalid'
+      refute(@annot.validate {|msg| assert_match(/does not contain an allowed value/, msg) })
+    end
+
+    it "automatically sets /StateModel based on the /State entry" do
+      @annot[:State] = 'Marked'
+      assert(@annot.validate)
+      assert_equal('Marked', @annot[:StateModel])
+    end
+
+    it "checks whether /State and /StateModel match" do
+      @annot[:State] = 'Marked'
+      @annot[:StateModel] = 'Marked'
+      assert(@annot.validate)
+      @annot[:StateModel] = 'Review'
+      refute(@annot.validate {|msg| assert_match(/\/State and \/StateModel don't agree/, msg) })
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_widget.rb

@@ -0,0 +1,225 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/widget'
+
+describe HexaPDF::Type::Annotations::Widget::AppearanceCharacteristics do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({}, type: :XXAppearanceCharacteristics)
+  end
+
+  describe "validation" do
+    it "needs /R to be a multiple of 90" do
+      assert(@annot.validate)
+
+      @annot[:R] = 45
+      refute(@annot.validate)
+
+      @annot[:R] = 90
+      assert(@annot.validate)
+    end
+  end
+end
+
+describe HexaPDF::Type::Annotations::Widget do
+  before do
+    @doc = HexaPDF::Document.new
+    @widget = @doc.wrap({Type: :Annot, Subtype: :Widget})
+  end
+
+  describe "form_field" do
+    it "works for the field and widget being the same object" do
+      @widget[:FT] = :Tx
+      @widget[:T] = 'field'
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      assert_same(@widget.data, result.data)
+    end
+
+    it "works for a field with a parent field and the widget being the same object" do
+      @widget[:Parent] = {FT: :Tx, T: 'parent', Kids: [@widget]}
+      @widget[:T] = 'field'
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      assert_same(@widget.data, result.data)
+    end
+
+    it "works for the widget being in the /Kids array of the field" do
+      @widget[:Parent] = {FT: :Tx, T: 'parent', Kids: [@widget]}
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      refute_same(@widget.data, result.data)
+    end
+  end
+
+  describe "background_color" do
+    it "returns the current background color" do
+      assert_nil(@widget.background_color)
+      @widget[:MK] = {BG: []}
+      assert_nil(@widget.background_color)
+      @widget[:MK] = {BG: [1]}
+      assert_equal([1], @widget.background_color.components)
+    end
+
+    it "sets the color and returns self" do
+      assert_same(@widget, @widget.background_color(51))
+      assert_equal([0.2], @widget.background_color.components)
+    end
+  end
+
+  describe "border_style" do
+    before do
+      @widget[:MK] = {BC: [1, 0, 1]}
+      @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1, 0, 1])
+    end
+
+    describe "getter" do
+      it "no /Border, /BS or /MK set" do
+        @widget.delete(:MK)
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "no /Border, /BS but with /MK empty" do
+        @widget[:MK].delete(:BC)
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "uses the color from /MK" do
+        assert_equal([1, @color, :solid, 0, 0], @widget.border_style.to_a)
+        @widget[:MK][:BC] = []
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "uses the data from /Border" do
+        @widget[:Border] = [1, 2, 3, [1, 2]]
+        assert_equal([3, @color, [1, 2], 1, 2], @widget.border_style.to_a)
+      end
+
+      it "uses the data from /BS, overriding /Border values" do
+        @widget[:Border] = [1, 2, 3, [1, 2]]
+        @widget[:BS] = {W: 5, S: :D, D: [5, 6]}
+        assert_equal([5, @color, [5, 6], 0, 0], @widget.border_style.to_a)
+
+        [[:S, :solid], [:D, [5, 6]], [:B, :beveled], [:I, :inset],
+         [:U, :underlined], [:Unknown, :solid]].each do |val, result|
+          @widget[:BS] = {S: val, D: [5, 6]}
+          assert_equal([1, @color, result, 0, 0], @widget.border_style.to_a)
+        end
+      end
+    end
+
+    describe "setter" do
+      it "returns self" do
+        assert_equal(@widget, @widget.border_style(width: 1))
+      end
+
+      it "sets the color" do
+        @widget.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @widget[:MK][:BC].value)
+
+        @widget.border_style(color: :transparent)
+        assert_equal([], @widget[:MK][:BC].value)
+      end
+
+      it "sets the width" do
+        @widget.border_style(width: 2)
+        assert_equal(2, @widget[:BS][:W])
+      end
+
+      it "sets the style" do
+        [[:solid, :S], [[5, 6], :D], [:beveled, :B], [:inset, :I], [:underlined, :U]].each do |val, r|
+          @widget.border_style(style: val)
+          assert_equal(r, @widget[:BS][:S])
+          assert_equal(val, @widget[:BS][:D].value) if r == :D
+        end
+      end
+
+      it "overrides all priorly set values" do
+        @widget.border_style(width: 3, style: :inset, color: [1])
+        @widget.border_style(width: 5)
+        border_style = @widget.border_style
+        assert_equal(:solid, border_style.style)
+        assert_equal([0], border_style.color.components)
+      end
+
+      it "raises an error for an unknown style" do
+        assert_raises(ArgumentError) { @widget.border_style(style: :unknown) }
+      end
+    end
+  end
+
+  describe "marker_style" do
+    before do
+      @chars = %w[4 l 8 u n H S]
+      @values = [:check, :circle, :cross, :diamond, :square, :star, 'S']
+      @widget[:Parent] = {FT: :Btn}
+    end
+
+    describe "style" do
+      it "returns the style" do
+        @chars.zip(@values) do |char, result|
+          @widget[:MK] = {CA: char}
+          assert_equal(result, @widget.marker_style.style)
+        end
+      end
+
+      it "returns the correct default button style depending on the field" do
+        @widget.form_field.initialize_as_check_box
+        assert_equal(:check, @widget.marker_style.style)
+        @widget.form_field.initialize_as_radio_button
+        assert_equal(:circle, @widget.marker_style.style)
+      end
+
+      it "sets the button style" do
+        @values.zip(@chars) do |argument, char|
+          @widget.marker_style(style: argument)
+          assert_equal(char, @widget[:MK][:CA])
+        end
+      end
+
+      it "fails if an invalid argument is provided" do
+        assert_raises(ArgumentError) { @widget.marker_style(style: 5) }
+      end
+    end
+
+    describe "size" do
+      it "returns the size" do
+        @widget.form_field[:DA] = "/F 15 Tf"
+        assert_equal(15, @widget.marker_style.size)
+        @widget[:DA] = "/F 10 Tf"
+        assert_equal(10, @widget.marker_style.size)
+      end
+
+      it "returns the default size if none is set" do
+        assert_equal(0, @widget.marker_style.size)
+      end
+
+      it "sets the given size" do
+        @widget.marker_style(size: 10)
+        assert_equal('/ZaDb 10 Tf 0.0 g', @widget[:DA])
+      end
+    end
+
+    describe "color" do
+      it "returns the color" do
+        @widget.form_field[:DA] = "0 1 0 rg"
+        assert_equal([0, 1, 0], @widget.marker_style.color.components)
+        @widget[:DA] = "0 0 1 rg"
+        assert_equal([0, 0, 1], @widget.marker_style.color.components)
+      end
+
+      it "returns the default color if none is set" do
+        assert_equal([0], @widget.marker_style.color.components)
+      end
+
+      it "sets the given color" do
+        @widget.marker_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @widget.marker_style.color.components)
+        @widget.marker_style(color: [1.0, 20, 1.0, 1.0])
+        assert_equal([1, 0.2, 1, 1], @widget.marker_style.color.components)
+      end
+    end
+  end
+end