hexapdf 0.12.3 → 0.14.3

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

@@ -99,6 +99,12 @@ describe HexaPDF::Type::AcroForm::Field do
     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
@@ -175,6 +181,39 @@ describe HexaPDF::Type::AcroForm::Field do
     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

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

@@ -7,7 +7,7 @@ require 'hexapdf/type/acro_form/form'
 describe HexaPDF::Type::AcroForm::Form do
   before do
     @doc = HexaPDF::Document.new
-    @acro_form = @doc.add({}, type: :XXAcroForm)
+    @acro_form = @doc.add({Fields: []}, type: :XXAcroForm)
   end
 
   describe "signature flags" do
@@ -49,7 +49,7 @@ describe HexaPDF::Type::AcroForm::Form do
     root_fields = @acro_form.find_root_fields
     assert_equal(result, root_fields.map(&:value))
     assert_kind_of(HexaPDF::Type::AcroForm::TextField, root_fields[0])
-    refute(@acro_form.key?(:Fields))
+    assert_equal([], @acro_form[:Fields].value)
 
     @acro_form.find_root_fields!
     assert_equal(result, @acro_form[:Fields].value.map(&:value))
@@ -115,6 +115,10 @@ describe HexaPDF::Type::AcroForm::Form do
   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"}]
@@ -134,9 +138,57 @@ describe HexaPDF::Type::AcroForm::Form do
       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
@@ -150,13 +202,19 @@ describe HexaPDF::Type::AcroForm::Form do
     end
 
     it "creates a combo box" do
-      field = @acro_form.create_combo_box("field")
+      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")
+      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
 
@@ -185,15 +243,29 @@ describe HexaPDF::Type::AcroForm::Form do
     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) })
+  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.normal_appearance.kind_of?(HexaPDF::Stream) })
+      assert(@cb.each_widget.all? {|w| w.appearance.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 "perform_validation" do
@@ -204,9 +276,9 @@ describe HexaPDF::Type::AcroForm::Form do
 
     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, c| assert_match(/DR must also be present/, msg) })
+      refute(@acro_form.validate {|msg| assert_match(/DR must also be present/, msg) })
       @acro_form.default_resources[:Font] = {}
-      refute(@acro_form.validate {|msg, c| assert_match(/font.*is not.*resource/, msg) })
+      refute(@acro_form.validate {|msg| assert_match(/font.*is not.*resource/, msg) })
       @acro_form.default_resources[:Font][:F1] = :yes
       assert(@acro_form.validate)
     end

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

@@ -21,6 +21,56 @@ describe HexaPDF::Type::AcroForm::TextField do
     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)
@@ -81,14 +131,38 @@ describe HexaPDF::Type::AcroForm::TextField do
   end
 
   describe "create_appearances" do
-    it "creates the needed streams" 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 }
@@ -114,6 +188,8 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert(@field.validate)
       @field[:MaxLen] = 2
       refute(@field.validate)
+      @field[:V] = nil
+      assert(@field.validate)
     end
   end
 end

data/test/hexapdf/type/test_font_simple.rb

@@ -161,8 +161,9 @@ describe HexaPDF::Type::FontSimple do
   end
 
   describe "validation" do
+    before { assert(@font.validate) }
+
     it "validates the existence of required keys" do
-      assert(@font.validate)
       @font.delete(:FirstChar)
       refute(@font.validate)
     end

data/test/hexapdf/type/test_font_true_type.rb

@@ -16,6 +16,12 @@ describe HexaPDF::Type::FontTrueType do
   end
 
   describe "validation" do
+    it "ignores some missing fields if the font name is one of the standard PDF fonts" do
+      @font[:BaseFont] = :'Arial,Bold'
+      [:FirstChar, :LastChar, :Widths, :FontDescriptor].each {|field| @font.delete(field) }
+      assert(@font.validate)
+    end
+
     it "requires that the FontDescriptor key is set" do
       assert(@font.validate)
       @font.delete(:FontDescriptor)

data/test/hexapdf/type/test_form.rb

@@ -43,13 +43,20 @@ describe HexaPDF::Type::Form do
       @form.contents = 'test'
       assert_equal('test', @form.stream)
     end
+
+    it "clears the cache to make sure that a new canvas can be created" do
+      @form[:BBox] = [0, 0, 100, 100]
+      canvas = @form.canvas
+      @form.contents = ''
+      refute_same(canvas, @form.canvas)
+    end
   end
 
   describe "resources" do
     it "creates the resource dictionary if it is not found" do
       resources = @form.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal({}, resources.value)
+      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
     end
 
     it "returns the already used resource dictionary" do

data/test/hexapdf/type/test_page.rb

@@ -277,7 +277,7 @@ describe HexaPDF::Type::Page do
       page = @doc.add({Type: :Page, Parent: @doc.pages.root})
       resources = page.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal({}, resources.value)
+      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
     end
 
     it "returns the already used resource dictionary" do
@@ -319,6 +319,13 @@ describe HexaPDF::Type::Page do
     end
   end
 
+  it "returns all ancestor page tree nodes of a page" do
+    root = @doc.add({Type: :Pages})
+    kid = @doc.add({Type: :Pages, Parent: root})
+    page = @doc.add({Type: :Page, Parent: kid})
+    assert_equal([kid, root], page.ancestor_nodes)
+  end
+
   describe "canvas" do
     before do
       @page = @doc.pages.add

data/test/hexapdf/type/test_page_tree_node.rb

@@ -206,6 +206,48 @@ describe HexaPDF::Type::PageTreeNode do
     end
   end
 
+  describe "move_page" do
+    before do
+      define_multilevel_page_tree
+    end
+
+    it "moves the page to the first place" do
+      @root.move_page(@pages[1], 0)
+      assert_equal([@pages[1], @pages[0], *@pages[2..-1]], @root.each_page.to_a)
+      assert(@root.validate)
+    end
+
+    it "moves the page to the correct location with a positive index" do
+      @root.move_page(1, 3)
+      assert_equal([@pages[0], @pages[2], @pages[1], *@pages[3..-1]], @root.each_page.to_a)
+      assert(@root.validate)
+    end
+
+    it "moves the page to the last place" do
+      @root.move_page(1, -1)
+      assert_equal([@pages[0], *@pages[2..-1], @pages[1]], @root.each_page.to_a)
+      assert(@root.validate)
+    end
+
+    it "fails if the index to the moving page is invalid" do
+      assert_raises(HexaPDF::Error) { @root.move_page(10, 0) }
+    end
+
+    it "fails if the moving page was deleted/is null" do
+      @doc.delete(@pages[0])
+      assert_raises(HexaPDF::Error) { @root.move_page(@pages[0], 3) }
+    end
+
+    it "fails if the page was not yet added to a page tree" do
+      page = @doc.add({Type: :Page})
+      assert_raises(HexaPDF::Error) { @root.move_page(page, 3) }
+    end
+
+    it "fails if the page is not part of the page tree" do
+      assert_raises(HexaPDF::Error) { @kid1.move_page(@pages[6], 3) }
+    end
+  end
+
   describe "each_page" do
     before do
       define_multilevel_page_tree

data/test/hexapdf/type/test_resources.rb

@@ -194,6 +194,12 @@ describe HexaPDF::Type::Resources do
       assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet].value)
     end
 
+    it "handles an invalid ProcSet containing a single value instead of an array" do
+      @res[:ProcSet] = :PDF
+      @res.validate
+      assert_equal([:PDF], @res[:ProcSet].value)
+    end
+
     it "removes invalid procedure set names from ProcSet" do
       @res[:ProcSet] = [:PDF, :Unknown]
       @res.validate