hexapdf 0.10.0 → 0.11.0

data/test/hexapdf/type/test_page.rb

@@ -33,16 +33,16 @@ describe HexaPDF::Type::Page do
   end
 
   it "must always be indirect" do
-    page = @doc.add(Type: :Page)
+    page = @doc.add({Type: :Page})
     page.must_be_indirect = false
     assert(page.must_be_indirect?)
   end
 
   describe "[]" do
     before do
-      @root = @doc.add(Type: :Pages)
-      @kid = @doc.add(Type: :Pages, Parent: @root)
-      @page = @doc.add(Type: :Page, Parent: @kid)
+      @root = @doc.add({Type: :Pages})
+      @kid = @doc.add({Type: :Pages, Parent: @root})
+      @page = @doc.add({Type: :Page, Parent: @kid})
     end
 
     it "works normal for non-inheritable fields" do
@@ -73,8 +73,8 @@ describe HexaPDF::Type::Page do
 
   describe "validation" do
     it "fails if a required inheritable field is not set" do
-      root = @doc.add(Type: :Pages)
-      page = @doc.add(Type: :Page, Parent: root)
+      root = @doc.add({Type: :Pages})
+      page = @doc.add({Type: :Page, Parent: root})
       message = ''
       refute(page.validate {|m, _| message = m })
       assert_match(/inheritable.*MediaBox/i, message)
@@ -274,7 +274,7 @@ describe HexaPDF::Type::Page do
 
   describe "resources" do
     it "creates the resource dictionary if it is not found" do
-      page = @doc.add(Type: :Page, Parent: @doc.pages.root)
+      page = @doc.add({Type: :Page, Parent: @doc.pages.root})
       resources = page.resources
       assert_equal(:XXResources, resources.type)
       assert_equal({}, resources.value)
@@ -282,7 +282,7 @@ describe HexaPDF::Type::Page do
 
     it "returns the already used resource dictionary" do
       @doc.pages.root[:Resources] = {Font: {F1: nil}}
-      page = @doc.pages.add(@doc.add(Type: :Page))
+      page = @doc.pages.add(@doc.add({Type: :Page}))
       resources = page.resources
       assert_equal(:XXResources, resources.type)
       assert_equal(@doc.pages.root[:Resources], resources)
@@ -300,14 +300,14 @@ describe HexaPDF::Type::Page do
 
   describe "index" do
     it "returns the index of the page in the page tree" do
-      kid1 = @doc.add(Type: :Pages, Parent: @doc.pages.root, Count: 4)
+      kid1 = @doc.add({Type: :Pages, Parent: @doc.pages.root, Count: 4})
       @doc.pages.root[:Kids] << kid1
 
-      kid11 = @doc.add(Type: :Pages, Parent: kid1)
+      kid11 = @doc.add({Type: :Pages, Parent: kid1})
       page1 = kid11.add_page
       kid1[:Kids] << kid11
       page2 = kid1.add_page
-      kid12 = @doc.add(Type: :Pages, Parent: kid1)
+      kid12 = @doc.add({Type: :Pages, Parent: kid1})
       page3 = kid12.add_page
       page4 = kid12.add_page
       kid1[:Kids] << kid12

data/test/hexapdf/type/test_page_tree_node.rb

@@ -7,7 +7,7 @@ require 'hexapdf/type/page_tree_node'
 describe HexaPDF::Type::PageTreeNode do
   before do
     @doc = HexaPDF::Document.new
-    @root = @doc.add(Type: :Pages)
+    @root = @doc.add({Type: :Pages})
   end
 
   # Defines the following page tree:
@@ -26,12 +26,12 @@ describe HexaPDF::Type::PageTreeNode do
   #       @pages[6]
   #       @pages[7]
   def define_multilevel_page_tree
-    @pages = Array.new(8) { @doc.add(Type: :Page) }
-    @kid1 = @doc.add(Type: :Pages, Parent: @root, Count: 5)
-    @kid11 = @doc.add(Type: :Pages, Parent: @kid1)
+    @pages = Array.new(8) { @doc.add({Type: :Page}) }
+    @kid1 = @doc.add({Type: :Pages, Parent: @root, Count: 5})
+    @kid11 = @doc.add({Type: :Pages, Parent: @kid1})
     @kid11.add_page(@pages[0])
     @kid11.add_page(@pages[1])
-    @kid12 = @doc.add(Type: :Pages, Parent: @kid1)
+    @kid12 = @doc.add({Type: :Pages, Parent: @kid1})
     @kid12.add_page(@pages[2])
     @kid12.add_page(@pages[3])
     @kid12.add_page(@pages[4])
@@ -41,7 +41,7 @@ describe HexaPDF::Type::PageTreeNode do
     @pages[5][:Parent] = @root
     @root[:Kids] << @pages[5]
 
-    @kid2 = @doc.add(Type: :Pages, Parent: @root)
+    @kid2 = @doc.add({Type: :Pages, Parent: @root})
     @kid2.add_page(@pages[6])
     @kid2.add_page(@pages[7])
     @root[:Kids] << @kid2
@@ -49,7 +49,7 @@ describe HexaPDF::Type::PageTreeNode do
   end
 
   it "must always be indirect" do
-    pages = @doc.add(Type: :Pages)
+    pages = @doc.add({Type: :Pages})
     pages.must_be_indirect = false
     assert(pages.must_be_indirect?)
   end
@@ -84,7 +84,7 @@ describe HexaPDF::Type::PageTreeNode do
       @doc.config['page.default_media_box'] = :A4
       @doc.config['page.default_media_orientation'] = :landscape
       page = @root.insert_page(3)
-      assert_equal([page], @root[:Kids])
+      assert_equal([page], @root[:Kids].value)
       assert_equal(1, @root.page_count)
       assert_equal(:Page, page[:Type])
       assert_equal(@root, page[:Parent])
@@ -101,9 +101,9 @@ describe HexaPDF::Type::PageTreeNode do
     end
 
     it "inserts the provided page at the given index" do
-      page = @doc.wrap(Type: :Page)
+      page = @doc.wrap({Type: :Page})
       assert_equal(page, @root.insert_page(3, page))
-      assert_equal([page], @root[:Kids])
+      assert_equal([page], @root[:Kids].value)
       assert_equal(@root, page[:Parent])
       refute(@root.value.key?(:Parent))
     end
@@ -112,37 +112,37 @@ describe HexaPDF::Type::PageTreeNode do
       page3 = @root.insert_page(5)
       page1 = @root.insert_page(0)
       page2 = @root.insert_page(1)
-      assert_equal([page1, page2, page3], @root[:Kids])
+      assert_equal([page1, page2, page3], @root[:Kids].value)
       assert_equal(3, @root.page_count)
     end
 
     it "inserts multiple pages correctly in a multilevel page tree" do
       define_multilevel_page_tree
       page = @root.insert_page(2)
-      assert_equal([@pages[0], @pages[1], page], @kid11[:Kids])
+      assert_equal([@pages[0], @pages[1], page], @kid11[:Kids].value)
       assert_equal(3, @kid11.page_count)
       assert_equal(6, @kid1.page_count)
       assert_equal(9, @root.page_count)
 
       page = @root.insert_page(4)
-      assert_equal([@pages[2], page, @pages[3], @pages[4]], @kid12[:Kids])
+      assert_equal([@pages[2], page, @pages[3], @pages[4]], @kid12[:Kids].value)
       assert_equal(4, @kid12.page_count)
       assert_equal(7, @kid1.page_count)
       assert_equal(10, @root.page_count)
 
       page = @root.insert_page(8)
-      assert_equal([@kid1, @pages[5], page, @kid2], @root[:Kids])
+      assert_equal([@kid1, @pages[5], page, @kid2], @root[:Kids].value)
       assert_equal(11, @root.page_count)
 
       page = @root.insert_page(100)
-      assert_equal([@kid1, @pages[5], @root[:Kids][2], @kid2, page], @root[:Kids])
+      assert_equal([@kid1, @pages[5], @root[:Kids][2], @kid2, page], @root[:Kids].value)
       assert_equal(12, @root.page_count)
     end
 
     it "allows negative indices to be specified" do
       define_multilevel_page_tree
       page = @root.insert_page(-1)
-      assert_equal(page, @root[:Kids].last)
+      assert_equal(page, @root[:Kids][-1])
 
       page = @root.insert_page(-4)
       assert_equal(page, @root[:Kids][2])
@@ -183,14 +183,14 @@ describe HexaPDF::Type::PageTreeNode do
     end
 
     it "does nothing if the page is not in its parent's /Kids array" do
-      @kid12[:Kids].shift
+      @kid12[:Kids].delete_at(0)
       assert_nil(@root.delete_page(@pages[2]))
       assert_equal(8, @root.page_count)
     end
 
     it "does nothing if the page is not part of the page tree" do
-      pages = @doc.add(Type: :Pages, Count: 1)
-      page = @doc.add(Type: :Page, Parent: pages)
+      pages = @doc.add({Type: :Pages, Count: 1})
+      page = @doc.add({Type: :Page, Parent: pages})
       pages[:Kids] << page
 
       assert_nil(@root.delete_page(page))
@@ -253,7 +253,7 @@ describe HexaPDF::Type::PageTreeNode do
       end
       assert(@root.validate)
       assert_equal(2, @kid12[:Count])
-      assert_equal([@pages[2], @pages[4]], @kid12[:Kids])
+      assert_equal([@pages[2], @pages[4]], @kid12[:Kids].value)
     end
 
     it "needs at least one page node" do

data/test/hexapdf/type/test_resources.rb

@@ -26,7 +26,7 @@ describe HexaPDF::Type::Resources do
     end
 
     it "returns the universal color space for unknown color spaces, with resolved references" do
-      data = @doc.add(Some: :data)
+      data = @doc.add({Some: :data})
       @res[:ColorSpace] = {CSName: [:SomeUnknownColorSpace,
                                     HexaPDF::Reference.new(data.oid, data.gen)]}
       color_space = @res.color_space(:CSName)
@@ -59,7 +59,7 @@ describe HexaPDF::Type::Resources do
     end
 
     it "doesn't add the same color space twice" do
-      object = @doc.add(some: :data)
+      object = @doc.add({some: :data})
       @res[:ColorSpace] = {space: [:DeviceN, HexaPDF::Reference.new(object.oid, object.gen)]}
       space = HexaPDF::Content::ColorSpace::Universal.new([:DeviceN, object])
       name = @res.add_color_space(space)
@@ -90,14 +90,14 @@ describe HexaPDF::Type::Resources do
 
   describe "private object_setter" do
     it "adds the object to the specified subdictionary" do
-      obj = @doc.add(some: :xobject)
+      obj = @doc.add({some: :xobject})
       name = @res.add_xobject(obj)
       assert(@res[:XObject].key?(name))
       assert_equal(obj, @res[:XObject][name])
     end
 
     it "doesn't add the same object twice" do
-      obj = @doc.add(some: :xobject)
+      obj = @doc.add({some: :xobject})
       name = @res.add_xobject(obj)
       name2 = @res.add_xobject(obj)
       assert_equal(name, name2)
@@ -171,13 +171,13 @@ describe HexaPDF::Type::Resources do
   describe "validation" do
     it "assigns the default value if ProcSet is not set" do
       @res.validate
-      assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet])
+      assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet].value)
     end
 
     it "removes invalid procedure set names from ProcSet" do
       @res[:ProcSet] = [:PDF, :Unknown]
       @res.validate
-      assert_equal([:PDF], @res[:ProcSet])
+      assert_equal([:PDF], @res[:ProcSet].value)
     end
   end
 end

data/test/hexapdf/type/test_trailer.rb

@@ -11,7 +11,10 @@ describe HexaPDF::Type::Trailer do
     @doc.instance_variable_set(:@version, '1.2')
     def (@doc).version=(v); @version = v; end
     def (@doc).deref(obj); obj; end
-    def (@doc).wrap(obj, *); HexaPDF::Dictionary.new(obj, oid: (obj.oid rescue 0)); end
+    def (@doc).wrap(obj, *)
+      (obj.kind_of?(Array) ? HexaPDF::PDFArray : HexaPDF::Dictionary).
+        new(obj, oid: (obj.oid rescue 0))
+    end
     root = HexaPDF::Dictionary.new({}, oid: 3)
     @obj = HexaPDF::Type::Trailer.new({Size: 10, Root: root}, document: @doc)
   end
@@ -37,7 +40,7 @@ describe HexaPDF::Type::Trailer do
   describe "ID field" do
     it "sets a random ID" do
       @obj.set_random_id
-      assert_kind_of(Array, @obj[:ID])
+      assert_kind_of(HexaPDF::PDFArray, @obj[:ID])
       assert_equal(2, @obj[:ID].length)
       assert_same(@obj[:ID][0], @obj[:ID][1])
       assert_kind_of(String, @obj[:ID][0])

data/test/hexapdf/type/test_xref_stream.rb

@@ -7,6 +7,7 @@ describe HexaPDF::Type::XRefStream do
   before do
     @doc = Object.new
     def (@doc).deref(obj); obj; end
+    def (@doc).wrap(obj, **); obj; end
     @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc)
   end
 

data/test/hexapdf/utils/test_sorted_tree_node.rb

@@ -13,9 +13,9 @@ describe HexaPDF::Utils::SortedTreeNode do
 
   def add_multilevel_entries
     @kid11 = @doc.add({Limits: ['c', 'f'], Names: ['c', 1, 'f', 1]}, type: HexaPDF::NameTreeNode)
-    @kid12 = @doc.add(Limits: ['i', 'm'], Names: ['i', 1, 'm', 1])
+    @kid12 = @doc.add({Limits: ['i', 'm'], Names: ['i', 1, 'm', 1]})
     ref = HexaPDF::Reference.new(@kid11.oid, @kid11.gen)
-    @kid1 = @doc.add(Limits: ['c', 'm'], Kids: [ref, @kid12])
+    @kid1 = @doc.add({Limits: ['c', 'm'], Kids: [ref, @kid12]})
     @kid21 = @doc.add({Limits: ['o', 'q'], Names: ['o', 1, 'q', 1]}, type: HexaPDF::NameTreeNode)
     @kid221 = @doc.add({Limits: ['s', 'u'], Names: ['s', 1, 'u', 1]}, type: HexaPDF::NameTreeNode)
     @kid22 = @doc.add({Limits: ['s', 'u'], Kids: [@kid221]}, type: HexaPDF::NameTreeNode)
@@ -32,20 +32,20 @@ describe HexaPDF::Utils::SortedTreeNode do
       @root.add_entry('c', 1)
       @root.add_entry('a', 2)
       @root.add_entry('e', 3)
-      assert_equal(['a', 2, 'c', 1, 'e', 3], @root[:Names])
+      assert_equal(['a', 2, 'c', 1, 'e', 3], @root[:Names].value)
       refute(@root[:Limits])
     end
 
     it "replaces an existing entry if overwrite is true" do
       assert(@root.add_entry('a', 2))
       assert(@root.add_entry('a', 5))
-      assert_equal(['a', 5], @root[:Names])
+      assert_equal(['a', 5], @root[:Names].value)
     end
 
     it "doesn't replace an existing entry if overwrite is false" do
       assert(@root.add_entry('a', 2))
       refute(@root.add_entry('a', 5, overwrite: false))
-      assert_equal(['a', 2], @root[:Names])
+      assert_equal(['a', 2], @root[:Names].value)
     end
 
     it "works with one level of intermediate nodes" do
@@ -57,10 +57,10 @@ describe HexaPDF::Utils::SortedTreeNode do
       @root.add_entry('p', 1)
       @root.add_entry('r', 1)
       @root.add_entry('u', 1)
-      assert_equal(['c', 'm'], kid1[:Limits])
-      assert_equal(['c', 1, 'd', 1, 'm', 1], kid1[:Names])
-      assert_equal(['p', 'u'], kid2[:Limits])
-      assert_equal(['p', 1, 'r', 1, 't', 1, 'u', 1], kid2[:Names])
+      assert_equal(['c', 'm'], kid1[:Limits].value)
+      assert_equal(['c', 1, 'd', 1, 'm', 1], kid1[:Names].value)
+      assert_equal(['p', 'u'], kid2[:Limits].value)
+      assert_equal(['p', 1, 'r', 1, 't', 1, 'u', 1], kid2[:Names].value)
     end
 
     it "works with multiple levels of intermediate nodes" do
@@ -74,16 +74,16 @@ describe HexaPDF::Utils::SortedTreeNode do
       @root.add_entry('r', 1)
       @root.add_entry('v', 1)
       assert_equal(['a', 'm'], @kid1[:Limits])
-      assert_equal(['a', 'f'], @kid11[:Limits])
-      assert_equal(['a', 1, 'c', 1, 'e', 1, 'f', 1], @kid11[:Names])
+      assert_equal(['a', 'f'], @kid11[:Limits].value)
+      assert_equal(['a', 1, 'c', 1, 'e', 1, 'f', 1], @kid11[:Names].value)
       assert_equal(['g', 'm'], @kid12[:Limits])
       assert_equal(['g', 1, 'i', 1, 'j', 1, 'm', 1], @kid12[:Names])
-      assert_equal(['n', 'v'], @kid2[:Limits])
-      assert_equal(['n', 'q'], @kid21[:Limits])
-      assert_equal(['n', 1, 'o', 1, 'p', 1, 'q', 1], @kid21[:Names])
-      assert_equal(['r', 'v'], @kid22[:Limits])
-      assert_equal(['r', 'v'], @kid221[:Limits])
-      assert_equal(['r', 1, 's', 1, 'u', 1, 'v', 1], @kid221[:Names])
+      assert_equal(['n', 'v'], @kid2[:Limits].value)
+      assert_equal(['n', 'q'], @kid21[:Limits].value)
+      assert_equal(['n', 1, 'o', 1, 'p', 1, 'q', 1], @kid21[:Names].value)
+      assert_equal(['r', 'v'], @kid22[:Limits].value)
+      assert_equal(['r', 'v'], @kid221[:Limits].value)
+      assert_equal(['r', 1, 's', 1, 'u', 1, 'v', 1], @kid221[:Names].value)
     end
 
     it "splits nodes if needed" do
@@ -92,18 +92,18 @@ describe HexaPDF::Utils::SortedTreeNode do
       refute(@root.value.key?(:Limits))
       refute(@root.value.key?(:Names))
       assert_equal(6, @root[:Kids].size)
-      assert_equal(['a', 1, 'b', 1], @root[:Kids][0][:Names])
-      assert_equal(['a', 'b'], @root[:Kids][0][:Limits])
-      assert_equal(['c', 1, 'd', 1], @root[:Kids][1][:Names])
-      assert_equal(['c', 'd'], @root[:Kids][1][:Limits])
-      assert_equal(['e', 1, 'f', 1], @root[:Kids][2][:Names])
-      assert_equal(['e', 'f'], @root[:Kids][2][:Limits])
-      assert_equal(['g', 1, 'h', 1, 'i', 1], @root[:Kids][3][:Names])
-      assert_equal(['g', 'i'], @root[:Kids][3][:Limits])
-      assert_equal(['j', 1, 'k', 1], @root[:Kids][4][:Names])
-      assert_equal(['j', 'k'], @root[:Kids][4][:Limits])
-      assert_equal(['l', 1, 'm', 1], @root[:Kids][5][:Names])
-      assert_equal(['l', 'm'], @root[:Kids][5][:Limits])
+      assert_equal(['a', 1, 'b', 1], @root[:Kids][0][:Names].value)
+      assert_equal(['a', 'b'], @root[:Kids][0][:Limits].value)
+      assert_equal(['c', 1, 'd', 1], @root[:Kids][1][:Names].value)
+      assert_equal(['c', 'd'], @root[:Kids][1][:Limits].value)
+      assert_equal(['e', 1, 'f', 1], @root[:Kids][2][:Names].value)
+      assert_equal(['e', 'f'], @root[:Kids][2][:Limits].value)
+      assert_equal(['g', 1, 'h', 1, 'i', 1], @root[:Kids][3][:Names].value)
+      assert_equal(['g', 'i'], @root[:Kids][3][:Limits].value)
+      assert_equal(['j', 1, 'k', 1], @root[:Kids][4][:Names].value)
+      assert_equal(['j', 'k'], @root[:Kids][4][:Limits].value)
+      assert_equal(['l', 1, 'm', 1], @root[:Kids][5][:Names].value)
+      assert_equal(['l', 'm'], @root[:Kids][5][:Limits].value)
     end
 
     it "fails if not called on the root node" do
@@ -127,7 +127,7 @@ describe HexaPDF::Utils::SortedTreeNode do
       add_multilevel_entries
       obj = @doc.add(1)
       @kid11[:Names][1] = HexaPDF::Reference.new(obj.oid, obj.gen)
-      assert_equal(obj, @root.find_entry('c'))
+      assert_equal(1, @root.find_entry('c'))
     end
 
     it "returns nil for non-existing entries" do
@@ -144,9 +144,9 @@ describe HexaPDF::Utils::SortedTreeNode do
     it "works with only the root node" do
       %w[a b c d e f g].each {|name| @root.add_entry(name, 1) }
       %w[g b a unknown e d c].each {|name| @root.delete_entry(name) }
-      refute(@root.value.key?(:Kids))
-      refute(@root.value.key?(:Limits))
-      assert_equal(['f', 1], @root[:Names])
+      refute(@root.key?(:Kids))
+      refute(@root.key?(:Limits))
+      assert_equal(['f', 1], @root[:Names].value)
       assert_equal(1, @root.delete_entry('f'))
     end
 
@@ -179,7 +179,7 @@ describe HexaPDF::Utils::SortedTreeNode do
       add_multilevel_entries
       obj = @doc.add(1)
       @kid11[:Names][1] = HexaPDF::Reference.new(obj.oid, obj.gen)
-      assert_equal(['c', obj, 'f', 1], @kid11.each_entry.to_a.flatten)
+      assert_equal(['c', 1, 'f', 1], @kid11.each_entry.to_a.flatten)
     end
 
     it "works on an uninitalized tree" do
@@ -233,6 +233,6 @@ describe HexaPDF::Utils::SortedTreeNode do
     root = HexaPDF::NumberTreeNode.new({}, document: @doc)
     root.add_entry(2, 1)
     root.add_entry(1, 2)
-    assert_equal([1, 2, 2, 1], root[:Nums])
+    assert_equal([1, 2, 2, 1], root[:Nums].value)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-02 00:00:00.000000000 Z
+date: 2019-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -84,12 +84,17 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.58.2
-description: |-
-  HexaPDF is a pure Ruby library with an accompanying application for working with PDF files.
+description: |
+  HexaPDF is a pure Ruby library with an accompanying application for working with PDF
+  files.
 
-  In short, it allows creating new PDF files, manipulating existing PDF files, merging multiple PDF files into one, extracting meta information, text, images and files from PDF files, securing PDF files by encrypting them and optimizing PDF files for smaller file size or other criteria.
+  In short, it allows creating new PDF files, manipulating existing PDF files, merging multiple
+  PDF files into one, extracting meta information, text, images and files from PDF files, securing
+  PDF files by encrypting them and optimizing PDF files for smaller file size or other
+  criteria.
 
-  HexaPDF was designed with ease of use and performance in mind. It uses lazy loading and lazy computing when possible and tries to produce small PDF files by default.
+  HexaPDF was designed with ease of use and performance in mind. It uses lazy loading and lazy
+  computing when possible and tries to produce small PDF files by default.
 email: t_leitner@gmx.at
 executables:
 - hexapdf
@@ -214,6 +219,7 @@ files:
 - lib/hexapdf/cli/batch.rb
 - lib/hexapdf/cli/command.rb
 - lib/hexapdf/cli/files.rb
+- lib/hexapdf/cli/image2pdf.rb
 - lib/hexapdf/cli/images.rb
 - lib/hexapdf/cli/info.rb
 - lib/hexapdf/cli/inspect.rb
@@ -221,6 +227,7 @@ files:
 - lib/hexapdf/cli/modify.rb
 - lib/hexapdf/cli/optimize.rb
 - lib/hexapdf/cli/split.rb
+- lib/hexapdf/cli/watermark.rb
 - lib/hexapdf/composer.rb
 - lib/hexapdf/configuration.rb
 - lib/hexapdf/content.rb
@@ -332,6 +339,7 @@ files:
 - lib/hexapdf/number_tree_node.rb
 - lib/hexapdf/object.rb
 - lib/hexapdf/parser.rb
+- lib/hexapdf/pdf_array.rb
 - lib/hexapdf/rectangle.rb
 - lib/hexapdf/reference.rb
 - lib/hexapdf/revision.rb
@@ -343,6 +351,9 @@ files:
 - lib/hexapdf/task/optimize.rb
 - lib/hexapdf/tokenizer.rb
 - lib/hexapdf/type.rb
+- lib/hexapdf/type/acro_form.rb
+- lib/hexapdf/type/acro_form/field.rb
+- lib/hexapdf/type/acro_form/form.rb
 - lib/hexapdf/type/action.rb
 - lib/hexapdf/type/actions.rb
 - lib/hexapdf/type/actions/go_to.rb
@@ -354,6 +365,7 @@ files:
 - lib/hexapdf/type/annotations/link.rb
 - lib/hexapdf/type/annotations/markup_annotation.rb
 - lib/hexapdf/type/annotations/text.rb
+- lib/hexapdf/type/annotations/widget.rb
 - lib/hexapdf/type/catalog.rb
 - lib/hexapdf/type/cid_font.rb
 - lib/hexapdf/type/embedded_file.rb
@@ -367,6 +379,7 @@ files:
 - lib/hexapdf/type/font_type3.rb
 - lib/hexapdf/type/form.rb
 - lib/hexapdf/type/graphics_state_parameter.rb
+- lib/hexapdf/type/icon_fit.rb
 - lib/hexapdf/type/image.rb
 - lib/hexapdf/type/info.rb
 - lib/hexapdf/type/names.rb
@@ -559,6 +572,7 @@ files:
 - test/hexapdf/test_importer.rb
 - test/hexapdf/test_object.rb
 - test/hexapdf/test_parser.rb
+- test/hexapdf/test_pdf_array.rb
 - test/hexapdf/test_rectangle.rb
 - test/hexapdf/test_reference.rb
 - test/hexapdf/test_revision.rb
@@ -569,11 +583,13 @@ files:
 - test/hexapdf/test_type.rb
 - test/hexapdf/test_writer.rb
 - test/hexapdf/test_xref_section.rb
+- test/hexapdf/type/acro_form/test_field.rb
+- test/hexapdf/type/acro_form/test_form.rb
 - test/hexapdf/type/actions/test_launch.rb
 - test/hexapdf/type/actions/test_uri.rb
-- test/hexapdf/type/annotations/test_link.rb
 - test/hexapdf/type/annotations/test_markup_annotation.rb
 - test/hexapdf/type/annotations/test_text.rb
+- test/hexapdf/type/annotations/test_widget.rb
 - test/hexapdf/type/test_annotation.rb
 - test/hexapdf/type/test_catalog.rb
 - test/hexapdf/type/test_cid_font.rb