hexapdf 0.15.7 → 0.17.0

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

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

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

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

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

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

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

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

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

data/test/hexapdf/type/test_annotation.rb

@@ -1,97 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/document'
-require 'hexapdf/type/annotation'
-
-describe HexaPDF::Type::Annotation::AppearanceDictionary do
-  before do
-    @doc = HexaPDF::Document.new
-    @ap = @doc.add({N: :n, D: :d, R: :r}, type: :XXAppearanceDictionary)
-  end
-
-  it "resolves the normal appearance" do
-    assert_equal(:n, @ap.normal_appearance)
-  end
-
-  it "resolves the rollover appearance" do
-    assert_equal(:r, @ap.rollover_appearance)
-    @ap.delete(:R)
-    assert_equal(:n, @ap.rollover_appearance)
-  end
-
-  it "resolves the down appearance" do
-    assert_equal(:d, @ap.down_appearance)
-    @ap.delete(:D)
-    assert_equal(:n, @ap.down_appearance)
-  end
-end
-
-describe HexaPDF::Type::Annotation do
-  before do
-    @doc = HexaPDF::Document.new
-    @annot = @doc.add({Type: :Annot, F: 0b100011})
-  end
-
-  it "must always be indirect" do
-    @annot.must_be_indirect = false
-    assert(@annot.must_be_indirect?)
-  end
-
-  it "returns the appearance dictionary" do
-    @annot[:AP] = :yes
-    assert_equal(:yes, @annot.appearance_dict)
-  end
-
-  it "returns the appearance stream of the given type" do
-    assert_nil(@annot.appearance)
-
-    @annot[:AP] = {N: {}}
-    assert_nil(@annot.appearance)
-
-    stream = @doc.wrap({}, stream: '')
-    @annot[:AP][:N] = stream
-    assert_nil(@annot.appearance)
-
-    stream[:BBox] = [1, 2, 3, 4]
-    appearance = @annot.appearance
-    assert_same(stream.data, appearance.data)
-    assert_equal(:Form, appearance[:Subtype])
-
-    @annot[:AP][:N] = {X: {}}
-    assert_nil(@annot.appearance)
-
-    @annot[:AS] = :X
-    @annot[:AP][:N][:X] = stream
-    assert_same(stream.data, @annot.appearance.data)
-
-    @annot[:AP][:D] = {X: stream}
-    assert_same(stream.data, @annot.appearance(:down).data)
-  end
-
-  describe "flags" do
-    it "returns all flags" do
-      assert_equal([:invisible, :hidden, :no_view], @annot.flags)
-    end
-  end
-
-  describe "flagged?" do
-    it "returns true if the given flag is set" do
-      assert(@annot.flagged?(:hidden))
-      refute(@annot.flagged?(:locked))
-    end
-
-    it "raises an error if an unknown flag name is provided" do
-      assert_raises(ArgumentError) { @annot.flagged?(:unknown) }
-    end
-  end
-
-  describe "flag" do
-    it "sets the given flag bits" do
-      @annot.flag(:locked)
-      assert_equal([:invisible, :hidden, :no_view, :locked], @annot.flags)
-      @annot.flag(:locked, clear_existing: true)
-      assert_equal([:locked], @annot.flags)
-    end
-  end
-end