hexapdf 0.42.0 → 0.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd69db2c04dc802784438f9038c9a6ab32dac0806edca43b6c59406bba9d7ea6
-  data.tar.gz: a51a510a6a98b547b2b11fb07804ca9039a666adf95b52f65db9b070c3ffe9c3
+  metadata.gz: 24f6839e903fd945678915625b1e2ef6a12221f29a82cf1c7a6d8bcea38af288
+  data.tar.gz: 2f8309e2ef2406dd279e00643bf7fbf73ded63a1076c0067684a356fea8ee89e
 SHA512:
-  metadata.gz: 714cba0b758960066498413b545dc7cf2806e1e483f99b017958450bfe29fd12aac1eef40f670d189f7cd7dab5784dd83e7b6f95533b97cf71c883dd9f307485
-  data.tar.gz: c93ceed7393b57fa5c6ca83141a8307b6015a1fa6907886b52c57bf72384d4d23ac8356adede0dabc35578cad5e1cef074f75c94e01e5c9532cadd0a688bbd57
+  metadata.gz: 8c6ddd8ec6f19d39daa9a6422fdb3595d255b528fb93ca7907ef12dab0eca23c74de9fcfc27d02c15b3a9d3c24d47c7f7db6ea472f4c1ed34c2b7c06d4a8a351
+  data.tar.gz: 1d77c2da70d9048cbef6935afacde40fb6d4041414fce571a331a4bee33b0e3ee2ff59bb28eee02e515798c3c156a57f42f139356e946f64e878ea962756a1d8

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 0.43.0 - 2024-05-26
+
+### Added
+
+* [HexaPDF::Type::AcroForm::Form#create_namespace_field] for creating a pure
+  namespace field
+* [HexaPDF::Type::AcroForm::Form#delete_field] for deleting fields
+
+### Changed
+
+* Minimum Ruby version to be 3.0
+* **Breaking change**: Renamed `HexaPDF::Layout::BoxFitter#fit_successful?` to
+  [HexaPDF::Layout::BoxFitter#success?]
+* **Breaking Change**: Removed HexaPDF::Dictionary#to_h
+* Form field creation methods of [HexaPDF::Type::AcroForm::Form] to
+  automatically create parent fields as namespace fields
+
+### Fixed
+
+* [HexaPDF::Layout::TextBox#fit] to correctly calculate width in case of flowing
+  text around other boxes
+* [HexaPDF::Layout::TextBox#draw] to correctly draw border, background... on
+  boxes using position 'flow'
+* Comparison of Hash with [HexaPDF::Dictionary] objects by implementing
+  `#to_hash`
+* Parsing of invalid files having multiple end-of-file markers with the last one
+  being invalid
+
+
 ## 0.42.0 - 2024-05-12
 
 ### Added

data/Rakefile

@@ -47,7 +47,7 @@ namespace :dev do
   end
 
   task :test_all do
-    versions = `rbenv versions --bare | grep -i ^2.7\\\\\\|^3.`.split("\n")
+    versions = `rbenv versions --bare | grep -i ^3.`.split("\n")
     versions.each do |version|
       sh "eval \"$(rbenv init -)\"; rbenv shell #{version} && ruby -v && rake test"
     end

data/lib/hexapdf/dictionary.rb

@@ -228,9 +228,9 @@ module HexaPDF
       value.empty?
     end
 
-    # Returns a dup of the underlying hash.
-    def to_h
-      value.dup
+    # Returns a hash containing the preprocessed values (like in #[]).
+    def to_hash
+      value.each_with_object({}) {|(k, _), h| h[k] = self[k] }
     end
 
     private

data/lib/hexapdf/document.rb

@@ -278,6 +278,14 @@ module HexaPDF
     # If the same argument is provided in multiple invocations, the import is done only once and
     # the previously imported object is returned.
     #
+    # Note: If you first create a PDF document from scratch and then want to import objects from it
+    # into another PDF document, you need to run the following on the source document:
+    #
+    #   doc.dispatch_message(:complete_objects)
+    #   doc.validate
+    #
+    # This ensures that the source document has all the necessary PDF structures set-up correctly.
+    #
     # See: Importer
     def import(obj)
       source = (obj.kind_of?(HexaPDF::Object) ? obj.document : nil)
@@ -617,13 +625,18 @@ module HexaPDF
     # writing the document.
     #
     # The security handler used for encrypting is selected via the +name+ argument. All other
-    # arguments are passed on the security handler.
+    # arguments are passed on to the security handler.
     #
     # If the document should not be encrypted, the +name+ argument has to be set to +nil+. This
     # removes the security handler and deletes the trailer's Encrypt dictionary.
     #
     # See: Encryption::SecurityHandler#set_up_encryption and
     # Encryption::StandardSecurityHandler::EncryptionOptions for possible encryption options.
+    #
+    # Examples:
+    #
+    #   document.encrypt(name: nil)  # remove the existing encryption
+    #   document.encrypt(algorithm: :aes, key_length: 256, permissions: [:print, :extract_content]
     def encrypt(name: :Standard, **options)
       if name.nil?
         trailer.delete(:Encrypt)

data/lib/hexapdf/encryption.rb

@@ -46,6 +46,23 @@ module HexaPDF
   #
   # This module contains all encryption and security related code to facilitate PDF encryption.
   #
+  # === Working With Encrypted Documents
+  #
+  # When a PDF document is opened, an encryption password can be specified. This is necessary if a
+  # user password is set on the file and optional otherwise (because the default password is
+  # automatically tried):
+  #
+  #   HexaPDF::Document.open(filename, decryption_opts: {password: 'somepassword'}) do |doc|
+  #   end
+  #
+  # To remove the encryption from a PDF document, use the following:
+  #
+  #   document.encrypt(name: nil)
+  #
+  # To encrypt a PDF document, use the same method but specify the required encryption options:
+  #
+  #   document.encrypt(algorithm: :aes, key_length: 256)
+  #
   #
   # === Security Handlers
   #

data/lib/hexapdf/layout/box.rb

@@ -35,6 +35,7 @@
 #++
 require 'hexapdf/layout/style'
 require 'geom2d/utils'
+require 'hexapdf/utils'
 
 module HexaPDF
   module Layout

data/lib/hexapdf/layout/box_fitter.rb

@@ -47,8 +47,8 @@ module HexaPDF
     #
     # * Then use the #fit method to fit boxes one after the other. No drawing is done.
     #
-    # * Once all boxes have been fitted, the #fit_results, #remaining_boxes and #fit_successful?
-    #   methods can be used to get the result:
+    # * Once all boxes have been fitted, the #fit_results, #remaining_boxes and #success? methods
+    #   can be used to get the result:
     #
     #   - If there are no remaining boxes, all boxes were successfully fitted into the frames.
     #   - If there are remaining boxes but no fit results, the first box could not be fitted.
@@ -126,7 +126,7 @@ module HexaPDF
       end
 
       # Returns +true+ if all boxes were successfully fitted.
-      def fit_successful?
+      def success?
         @remaining_boxes.empty?
       end
 

data/lib/hexapdf/layout/column_box.rb

@@ -186,7 +186,7 @@ module HexaPDF
 
           children.each {|box| @box_fitter.fit(box) }
 
-          fit_successful = @box_fitter.fit_successful?
+          fit_successful = @box_fitter.success?
           initial_fit_successful = fit_successful if initial_fit_successful.nil?
 
           if fit_successful
@@ -211,7 +211,7 @@ module HexaPDF
         @draw_pos_x = frame.x + reserved_width_left
         @draw_pos_y = frame.y - @height + reserved_height_bottom
 
-        @box_fitter.fit_successful?
+        @box_fitter.success?
       end
 
       private

data/lib/hexapdf/layout/container_box.rb

@@ -137,7 +137,7 @@ module HexaPDF
         @box_fitter = BoxFitter.new([my_frame])
         children.each {|box| @box_fitter.fit(box) }
 
-        if @box_fitter.fit_successful?
+        if @box_fitter.success?
           update_content_width do
             result = @box_fitter.fit_results.max_by {|r| r.mask.x + r.mask.width }
             children.empty? ? 0 : result.mask.x + result.mask.width - my_frame.left

data/lib/hexapdf/layout/line.rb

@@ -173,6 +173,10 @@ module HexaPDF
       attr_accessor :items
 
       # An optional horizontal offset that should be taken into account when positioning the line.
+      #
+      # This offset always describes the offset from the left side (and not, for example, the offset
+      # from the right side of another line even if those two lines are actually on the same
+      # horizontal level).
       attr_accessor :x_offset
 
       # An optional vertical offset that should be taken into account when positioning the line.

data/lib/hexapdf/layout/list_box.rb

@@ -248,14 +248,14 @@ module HexaPDF
           top -= item_result.height + item_spacing
           height -= item_result.height + item_spacing
 
-          break if !box_fitter.fit_successful? || height <= 0
+          break if !box_fitter.success? || height <= 0
         end
 
         @height = @results.sum(&:height) + (@results.count - 1) * item_spacing + reserved_height
 
         @draw_pos_x = frame.x + reserved_width_left
         @draw_pos_y = frame.y - @height + reserved_height_bottom
-        @all_items_fitted = @results.all? {|r| r.box_fitter.fit_successful? } &&
+        @all_items_fitted = @results.all? {|r| r.box_fitter.success? } &&
           @results.size == @children.size
         @fit_successful = @all_items_fitted || (@initial_height > 0 && style.overflow == :truncate)
       end

data/lib/hexapdf/layout/table_box.rb

@@ -233,7 +233,7 @@ module HexaPDF
             @preferred_width = max_x_result.x + max_x_result.box.width + reserved_width
             @height = @preferred_height = box_fitter.content_heights[0] + reserved_height
             @fit_results = box_fitter.fit_results
-            @fit_successful = box_fitter.fit_successful?
+            @fit_successful = box_fitter.success?
           else
             @preferred_width = reserved_width
             @height = @preferred_height = reserved_height

data/lib/hexapdf/layout/text_box.rb

@@ -52,6 +52,7 @@ module HexaPDF
         @tl = TextLayouter.new(style)
         @items = items
         @result = nil
+        @x_offset = 0
       end
 
       # Returns the text that will be drawn.
@@ -80,7 +81,7 @@ module HexaPDF
           (@initial_height > 0 && @initial_height > available_height)
 
         frame = frame.child_frame(box: self)
-        @width = @height = 0
+        @width = @x_offset = @height = 0
         @result = if style.position == :flow
                     @tl.fit(@items, frame.width_specification, frame.shape.bbox.height,
                             apply_first_text_indent: !split_box?, frame: frame)
@@ -93,6 +94,14 @@ module HexaPDF
                   end
         @width += if @initial_width > 0 || style.text_align == :center || style.text_align == :right
                     width
+                  elsif style.position == :flow
+                    min_x = +Float::INFINITY
+                    max_x = -Float::INFINITY
+                    @result.lines.each do |line|
+                      min_x = [min_x, line.x_offset].min
+                      max_x = [max_x, line.x_offset + line.width].max
+                    end
+                    min_x.finite? ? (@x_offset = min_x; max_x - min_x) : 0
                   else
                     @result.lines.max_by(&:width)&.width || 0
                   end
@@ -125,6 +134,11 @@ module HexaPDF
         end
       end
 
+      # :nodoc:
+      def draw(canvas, x, y)
+        super(canvas, x + @x_offset, y)
+      end
+
       # :nodoc:
       def empty?
         super && (!@result || @result.lines.empty?)
@@ -142,7 +156,7 @@ module HexaPDF
         end
 
         return if @result.lines.empty?
-        @result.draw(canvas, x, y + content_height)
+        @result.draw(canvas, x - @x_offset, y + content_height)
       end
 
       # Creates a new TextBox instance for the items remaining after fitting the box.

data/lib/hexapdf/parser.rb

@@ -362,29 +362,32 @@ module HexaPDF
         pos = @io.pos
         lines = @io.read(step_size + 40).split(/[\r\n]+/)
 
-        eof_index = lines.rindex {|l| l.strip == '%%EOF' }
-        if !eof_index
-          eof_not_found = true
-        elsif lines[eof_index - 1].strip =~ /\Astartxref\s(\d+)\z/
-          startxref_offset = $1.to_i
-          startxref_mangled = true
-          break # we found it even if it the syntax is not entirely correct
-        elsif eof_index < 2 || lines[eof_index - 2].strip != "startxref"
-          startxref_missing = true
-        else
-          startxref_offset = lines[eof_index - 1].to_i
-          break # we found it
+        # Need to iterate through the whole lines array in case there are multiple %%EOF to try
+        eof_index = 0
+        while (eof_index = lines[0..(eof_index - 1)].rindex {|l| l.strip == '%%EOF' })
+          if lines[eof_index - 1].strip =~ /\Astartxref\s(\d+)\z/
+            startxref_offset = $1.to_i
+            startxref_mangled = true
+            break # we found it even if it the syntax is not entirely correct
+          elsif eof_index < 2 || lines[eof_index - 2].strip != "startxref"
+            startxref_missing = true
+          else
+            startxref_offset = lines[eof_index - 1].to_i
+            break # we found it
+          end
         end
+        eof_not_found ||= !eof_index
+        break if startxref_offset
       end
 
-      if eof_not_found
-        maybe_raise("PDF file trailer with end-of-file marker not found", pos: pos,
-                    force: !eof_index)
-      elsif startxref_mangled
+      if startxref_mangled
         maybe_raise("PDF file trailer keyword startxref on same line as value", pos: pos)
       elsif startxref_missing
         maybe_raise("PDF file trailer is missing startxref keyword", pos: pos,
-                    force: eof_index < 2 || lines[eof_index - 2].strip != "startxref")
+                    force: !startxref_offset)
+      elsif eof_not_found
+        maybe_raise("PDF file trailer with end-of-file marker not found", pos: pos,
+                    force: !startxref_offset)
       end
 
       @startxref_offset = startxref_offset

data/lib/hexapdf/type/acro_form/form.rb

@@ -163,10 +163,21 @@ module HexaPDF
           field
         end
 
+        # Creates an untyped namespace field for creating hierarchies.
+        #
+        # Example:
+        #
+        #   form.create_namespace_field('text')
+        #   form.create_text_field('text.a1')
+        def create_namespace_field(name)
+          create_field(name)
+        end
+
         # Creates a new text field with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field:
         #
@@ -202,8 +213,9 @@ module HexaPDF
 
         # Creates a new multiline text field with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
@@ -221,8 +233,9 @@ module HexaPDF
         # The +max_chars+ argument defines the maximum number of characters the comb text field can
         # accommodate.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
@@ -238,8 +251,9 @@ module HexaPDF
 
         # Creates a new file select field with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
@@ -254,8 +268,9 @@ module HexaPDF
 
         # Creates a new password field with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
@@ -270,8 +285,9 @@ module HexaPDF
 
         # Creates a new check box with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # Before a field value other than +false+ can be assigned to the check box, a widget needs
         # to be created.
@@ -281,8 +297,9 @@ module HexaPDF
 
         # Creates a radio button with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # Before a field value other than +nil+ can be assigned to the radio button, at least one
         # widget needs to be created.
@@ -292,8 +309,9 @@ module HexaPDF
 
         # Creates a combo box with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field:
         #
@@ -319,8 +337,9 @@ module HexaPDF
 
         # Creates a list box with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         #
         # The optional keyword arguments allow setting often used properties of the field:
         #
@@ -345,10 +364,38 @@ module HexaPDF
 
         # Creates a signature field with the given name and adds it to the form.
         #
-        # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
-        # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        # The +name+ may contain dots to signify a field hierarchy. If the parent fields don't
+        # already exist, they are created as pure namespace fields (see #create_namespace_field). If
+        # the +name+ doesn't contain dots, a top-level field is created.
         def create_signature_field(name)
-          create_field(name, :Sig) {}
+          create_field(name, :Sig)
+        end
+
+        # :call-seq:
+        #    form.delete_field(name)
+        #    form.delete_field(field)
+        #
+        # Deletes the field specified by the given name or via the given field object.
+        #
+        # If the field is a signature field, the associated signature dictionary is also deleted.
+        def delete_field(name_or_field)
+          field = (name_or_field.kind_of?(String) ? field_by_name(name_or_field) : name_or_field)
+          document.delete(field[:V]) if field.field_type == :Sig
+
+          to_delete = field.each_widget(direct_only: false).to_a
+          document.pages.each do |page|
+            next unless page.key?(:Annots)
+            page_annots = page[:Annots].to_a - to_delete
+            page[:Annots].value.replace(page_annots)
+          end
+          to_delete.each {|widget| document.delete(widget) }
+
+          if field[:Parent]
+            field[:Parent][:Kids].delete(field)
+          else
+            self[:Fields].delete(field)
+          end
+          document.delete(field)
         end
 
         # Fills form fields with the values from the given +data+ hash.
@@ -485,23 +532,27 @@ module HexaPDF
 
         private
 
-        # Creates a new field with the full name +name+ and the field type +type+.
-        def create_field(name, type)
+        # Creates a new field with the full name +name+ and the optional field type +type+.
+        def create_field(name, type = nil)
           parent_name, _, name = name.rpartition('.')
           parent_field = parent_name.empty? ? nil : field_by_name(parent_name)
           if !parent_name.empty? && !parent_field
-            raise HexaPDF::Error, "Parent field '#{parent_name}' not found"
+            parent_field = create_namespace_field(parent_name)
           end
 
-          field = document.add({FT: type, T: name, Parent: parent_field},
-                               type: :XXAcroFormField, subtype: type)
+          field = if type
+                    document.add({FT: type, T: name, Parent: parent_field},
+                                 type: :XXAcroFormField, subtype: type)
+                  else
+                    document.add({T: name, Parent: parent_field}, type: :XXAcroFormField)
+                  end
           if parent_field
             (parent_field[:Kids] ||= []) << field
           else
             (self[:Fields] ||= []) << field
           end
 
-          yield(field)
+          yield(field) if block_given?
 
           field
         end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.42.0'
+  VERSION = '0.43.0'
 
 end

data/test/hexapdf/layout/test_box_fitter.rb

@@ -20,13 +20,13 @@ describe HexaPDF::Layout::BoxFitter do
     @box_fitter.fit(HexaPDF::Layout::TextBox.new(items: [ibox] * count))
   end
 
-  def check_result(*pos, content_heights:, successful: true, boxes_remain: false)
+  def check_result(*pos, content_heights:, success: true, boxes_remain: false)
     pos.each_slice(2).with_index do |(x, y), index|
       assert_equal(x, @box_fitter.fit_results[index].x, "x #{index}")
       assert_equal(y, @box_fitter.fit_results[index].y, "y #{index}")
     end
     assert_equal(content_heights, @box_fitter.content_heights)
-    successful ? assert(@box_fitter.fit_successful?) : refute(@box_fitter.fit_successful?)
+    success ? assert(@box_fitter.success?) : refute(@box_fitter.success?)
     rboxes = @box_fitter.remaining_boxes.empty?
     boxes_remain ? refute(rboxes) : assert(rboxes)
   end
@@ -55,7 +55,7 @@ describe HexaPDF::Layout::BoxFitter do
     fit_box(70)
     fit_box(40)
     fit_box(20)
-    check_result(10, 80, 0, 10, 0, 0, 100, 100, successful: false, boxes_remain: true,
+    check_result(10, 80, 0, 10, 0, 0, 100, 100, success: false, boxes_remain: true,
                  content_heights: [90, 50])
     assert_equal(2, @box_fitter.remaining_boxes.size)
   end

data/test/hexapdf/layout/test_text_box.rb

@@ -50,10 +50,12 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "fits into the frame's outline" do
+      @frame.remove_area(Geom2D::Rectangle(0, 80, 20, 20))
+      @frame.remove_area(Geom2D::Rectangle(80, 70, 20, 20))
       box = create_box([@inline_box] * 20, style: {position: :flow})
       assert(box.fit(100, 100, @frame))
       assert_equal(100, box.width)
-      assert_equal(20, box.height)
+      assert_equal(30, box.height)
     end
 
     it "takes the style option last_line_gap into account" do
@@ -190,6 +192,30 @@ describe HexaPDF::Layout::TextBox do
                                           [:restore_graphics_state]])
     end
 
+    it "correctly draws borders, backgrounds... for position :flow" do
+      @frame.remove_area(Geom2D::Rectangle(0, 0, 40, 100))
+      box = create_box([@inline_box], style: {position: :flow, border: {width: 1}})
+      box.fit(60, 100, @frame)
+      box.draw(@canvas, 0, 90)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:append_rectangle, [40, 90, 10, 10]],
+                                          [:clip_path_non_zero],
+                                          [:end_path],
+                                          [:append_rectangle, [40.5, 90.5, 9.0, 9.0]],
+                                          [:stroke_path],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 41, 89]],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
     it "draws nothing onto the canvas if the box is empty" do
       box = create_box([])
       box.draw(@canvas, 5, 5)

data/test/hexapdf/test_dictionary.rb

@@ -323,11 +323,13 @@ describe HexaPDF::Dictionary do
     end
   end
 
-  describe "to_h" do
-    it "returns a shallow copy of the value" do
-      obj = @dict.to_h
+  describe "to_hash" do
+    it "returns a copy of the value where each entry is pre-processed" do
+      @dict[:value] = HexaPDF::Reference.new(1, 0)
+      obj = @dict.to_hash
       refute_equal(obj.object_id, @dict.value.object_id)
-      assert_equal(obj, @dict.value)
+      assert_equal(:obj, obj[:Object])
+      assert_equal("deref", obj[:value])
     end
   end
 

data/test/hexapdf/test_parser.rb

@@ -367,6 +367,11 @@ describe HexaPDF::Parser do
       assert_equal(5, @parser.startxref_offset)
     end
 
+    it "handles the case of multiple %%EOF and the last one being invalid" do
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      assert_equal(5, @parser.startxref_offset)
+    end
+
     it "fails even in big files when nothing is found" do
       create_parser("\nhallo" * 5000)
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
@@ -402,6 +407,13 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/startxref on same line/, exp.message)
     end
+
+    it "fails on strict parsing if there are multiple %%EOF and the last one is invalid" do
+      @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/missing startxref keyword/, exp.message)
+    end
   end
 
   describe "file_header_version" do

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

@@ -128,6 +128,12 @@ describe HexaPDF::Type::AcroForm::Form do
       @acro_form = @doc.acro_form(create: true)
     end
 
+    it "creates a pure namespace field" do
+      field = @acro_form.create_namespace_field('text')
+      assert_equal('text', field.full_field_name)
+      assert_nil(field.concrete_field_type)
+    end
+
     describe "handles the general case" do
       it "works for names with a dot" do
         @acro_form[:Fields] = [{T: "root"}]
@@ -142,8 +148,13 @@ describe HexaPDF::Type::AcroForm::Form do
         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") }
+      it "creates the parent fields as namespace fields if necessary" do
+        field = @acro_form.create_text_field("root.sub.field")
+        level1 = @acro_form.field_by_name('root')
+        assert_equal(1, level1[:Kids].size)
+        level2 = @acro_form.field_by_name('root.sub')
+        assert_equal(1, level2[:Kids].size)
+        assert_same(field, level2[:Kids][0])
       end
     end
 
@@ -241,6 +252,56 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "delete_field" do
+    before do
+      @field = @acro_form.create_signature_field("sig")
+    end
+
+    it "deletes a field via name" do
+      @acro_form.delete_field('sig')
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes a field via field object" do
+      @acro_form.delete_field(@field)
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes the set signature object" do
+      obj = @doc.add({})
+      @field.field_value = obj
+      @acro_form.delete_field(@field)
+      assert(obj.null?)
+    end
+
+    it "deletes all widget annotations from the document and the annotation array" do
+      widget1 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      widget2 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      refute(@doc.pages[1][:Annots].empty?)
+      @acro_form.delete_field(@field)
+      assert(@doc.pages[0][:Annots].empty?)
+      assert(@doc.pages[1][:Annots].empty?)
+      assert(@doc.object(widget1).null?)
+      assert(@doc.object(widget2).null?)
+    end
+
+    it "deletes the field from the field hierarchy" do
+      @acro_form.delete_field('sig')
+      refute(@acro_form.field_by_name('sig'))
+      assert(@acro_form[:Fields].empty?)
+
+      @acro_form.create_signature_field("sub.sub.sig")
+      @acro_form.delete_field("sub.sub.sig")
+      refute(@acro_form.field_by_name('sub.sub.sig'))
+      assert(@acro_form[:Fields][0][:Kids][0][:Kids].empty?)
+    end
+
+    it "deletes the field itself" do
+      @acro_form.delete_field('sig')
+      assert(@doc.object(@field).null?)
+    end
+  end
+
   describe "fill" do
     it "works for text field types" do
       field = @acro_form.create_text_field('test')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.42.0
+  version: 0.43.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-12 00:00:00.000000000 Z
+date: 2024-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse