hexapdf 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae86345e0f2ed2dd27c9c58c550e7eaffb4d7c5d3ba388afb04318ee20491313
-  data.tar.gz: cfd9f8575ce9f4324c594c2617cc7e1bcf1d735276ac92a275f26acf74566bc9
+  metadata.gz: dd69db2c04dc802784438f9038c9a6ab32dac0806edca43b6c59406bba9d7ea6
+  data.tar.gz: a51a510a6a98b547b2b11fb07804ca9039a666adf95b52f65db9b070c3ffe9c3
 SHA512:
-  metadata.gz: d36715922fbbf5a93eeb5512ed0abf7ec78fbd099c49131500bd9f7db75c39248bb2bac12ad7e3df5c4a8a449351f63e0d83e0ed635f9a025e4bf25fdbe9f0e1
-  data.tar.gz: fc7a89694614826c8d151b7dab2c3f45ec335fc94efff873065c3dc68c845a691311b91b42c3b791eb71be80e1f8fd623838eb0cf1b94d0d1b758441df1b1a7a
+  metadata.gz: 714cba0b758960066498413b545dc7cf2806e1e483f99b017958450bfe29fd12aac1eef40f670d189f7cd7dab5784dd83e7b6f95533b97cf71c883dd9f307485
+  data.tar.gz: c93ceed7393b57fa5c6ca83141a8307b6015a1fa6907886b52c57bf72384d4d23ac8356adede0dabc35578cad5e1cef074f75c94e01e5c9532cadd0a688bbd57

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.42.0 - 2024-05-12
+
+### Added
+
+* Support for the `AFPercent_Format` JavaScript method
+* Support for the `AFTime_Format` JavaScript method
+* [HexaPDF::Type::AcroForm::Form#fill] for easily filling out form fields
+* CLI command `hexapdf usage` for showing space usage information
+* Support for attaching files via `hexapdf files` CLI command
+* Refinement on [HexaPDF::Utils] to support conversion of Numeric values to
+  points (e.g. `5.mm`, `5.cm`, `5.inch`)
+
+### Changed
+
+* [HexaPDF::Type::AcroForm::ButtonField#field_value=] to always allow using
+  `true` for check boxes
+* CLI commands to prompt whether an existing output file should be overwritten
+
+### Fixed
+
+* [HexaPDF::Type::Resources#font] to always return a correctly wrapped font
+  object
+* [HexaPDF::Type::AcroForm::TextField#field_value=] to actually use the value
+  returned by the call to the config option 'acro_form.on_invalid_value'
+
+
 ## 0.41.0 - 2024-05-05
 
 ### Added

data/examples/031-acro_form_java_script.rb

@@ -31,70 +31,82 @@ tx.set_format_action(:number, decimals: 2, separator_style: :comma)
 widget = tx.create_widget(page, Rect: [200, 615, 500, 635])
 tx.field_value = "1234567.898"
 
-canvas.text("Calculate actions", at: [50, 570])
+canvas.text("Percent format", at: [70, 590])
+tx = form.create_text_field("Percent_Format", font_size: 16)
+tx.set_format_action(:percent, decimals: 2, separator_style: :comma)
+widget = tx.create_widget(page, Rect: [200, 585, 500, 605])
+tx.field_value = "12,45678"
 
-canvas.text("Source fields", at: [70, 540])
-canvas.text("a:", at: [200, 540])
+canvas.text("Time format", at: [70, 560])
+tx = form.create_text_field("Time_Format", font_size: 16)
+tx.set_format_action(:time, format: :hh_mm_ss)
+widget = tx.create_widget(page, Rect: [200, 555, 500, 575])
+tx.field_value = "3:15:20 pm"
+
+canvas.text("Calculate actions", at: [50, 510])
+
+canvas.text("Source fields", at: [70, 480])
+canvas.text("a:", at: [200, 480])
 tx = form.create_text_field("a", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
-widget = tx.create_widget(page, Rect: [220, 535, 280, 555])
+widget = tx.create_widget(page, Rect: [220, 475, 280, 495])
 tx.field_value = "10,50"
-canvas.text("b:", at: [310, 540])
+canvas.text("b:", at: [310, 480])
 tx = form.create_text_field("b", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
-widget = tx.create_widget(page, Rect: [330, 535, 390, 555])
+widget = tx.create_widget(page, Rect: [330, 475, 390, 495])
 tx.field_value = "20,60"
-canvas.text("c:", at: [420, 540])
+canvas.text("c:", at: [420, 480])
 tx = form.create_text_field("c", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
-widget = tx.create_widget(page, Rect: [440, 535, 500, 555])
+widget = tx.create_widget(page, Rect: [440, 475, 500, 495])
 tx.field_value = "30,70"
 
-canvas.text("Predefined", at: [70, 510])
-canvas.text("Sum", at: [90, 480])
+canvas.text("Predefined", at: [70, 450])
+canvas.text("Sum", at: [90, 420])
 tx = form.create_text_field("sum", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:sum, fields: ['a', 'b', 'c'])
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 475, 500, 495])
-canvas.text("Average", at: [90, 450])
+widget = tx.create_widget(page, Rect: [310, 415, 500, 435])
+canvas.text("Average", at: [90, 390])
 tx = form.create_text_field("average", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:average, fields: ['a', 'b', 'c'])
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 445, 500, 465])
-canvas.text("Product", at: [90, 420])
+widget = tx.create_widget(page, Rect: [310, 385, 500, 405])
+canvas.text("Product", at: [90, 360])
 tx = form.create_text_field("product", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:product, fields: ['a', 'b', 'c'])
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 415, 500, 435])
-canvas.text("Minimum", at: [90, 390])
+widget = tx.create_widget(page, Rect: [310, 355, 500, 375])
+canvas.text("Minimum", at: [90, 330])
 tx = form.create_text_field("min", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:min, fields: ['a', 'b', 'c'])
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 385, 500, 405])
-canvas.text("Maximum", at: [90, 360])
+widget = tx.create_widget(page, Rect: [310, 325, 500, 345])
+canvas.text("Maximum", at: [90, 300])
 tx = form.create_text_field("max", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:max, fields: ['a', 'b', 'c'])
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 355, 500, 375])
+widget = tx.create_widget(page, Rect: [310, 295, 500, 315])
 
-canvas.text("Simplified Field Notation", at: [70, 330])
-canvas.text("a + b + c", at: [90, 300])
+canvas.text("Simplified Field Notation", at: [70, 270])
+canvas.text("a + b + c", at: [90, 240])
 tx = form.create_text_field("sfn1", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:sfn, fields: "a + b + c")
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 295, 500, 315])
-canvas.text("(a + b)*(c - a) / b + 3.14", at: [90, 270])
+widget = tx.create_widget(page, Rect: [310, 235, 500, 255])
+canvas.text("(a + b)*(c - a) / b + 3.14", at: [90, 210])
 tx = form.create_text_field("sfn2", font_size: 16)
 tx.set_format_action(:number, decimals: 2)
 tx.set_calculate_action(:sfn, fields: "(a + b)*(c - a) / b + 3.14")
 tx.flag(:read_only)
-widget = tx.create_widget(page, Rect: [310, 265, 500, 285])
+widget = tx.create_widget(page, Rect: [310, 205, 500, 225])
 
 form.recalculate_fields
 

data/lib/hexapdf/cli/command.rb

@@ -53,7 +53,7 @@ module HexaPDF
       module Extensions #:nodoc:
         def help_banner #:nodoc:
           "hexapdf #{HexaPDF::VERSION} - Versatile PDF Manipulation Tool\n" \
-            "Copyright (c) 2014-2023 Thomas Leitner; licensed under the AGPLv3\n\n" \
+            "Copyright (c) 2014-2024 Thomas Leitner; licensed under the AGPLv3\n\n" \
             "#{format(usage, indent: 7)}\n\n"
         end
 
@@ -167,12 +167,12 @@ module HexaPDF
         end
       end
 
-      # Checks whether the given output file exists and raises an error if it does and
-      # HexaPDF::CLI#force is not set.
+      # Checks whether the given output file exists and ask whether to overwrite the output file if
+      # it does. If HexaPDF::CLI#force is set, a possibly existing output file is always overwritten.
       def maybe_raise_on_existing_file(filename)
         if !command_parser.force && File.exist?(filename)
-          raise Error, "Output file '#{filename}' already exists, not overwriting. Use --force to " \
-            "force writing"
+          response = read_from_console("Output file '#{filename}' already exists - overwrite? (y/n)")
+          exit(1) unless response =~ /y/i
         end
       end
 
@@ -377,9 +377,9 @@ module HexaPDF
       # console.
       def read_password(prompt = "Password")
         if $stdin.tty?
-          read_from_console(prompt)
+          read_from_console(prompt, noecho: true)
         else
-          ($stdin.gets || read_from_console(prompt)).chomp
+          ($stdin.gets || read_from_console(prompt, noecho: true)).chomp
         end
       end
 
@@ -407,11 +407,14 @@ module HexaPDF
       private
 
       # Displays the given prompt, reads from the console without echo and returns the read string.
-      def read_from_console(prompt)
+      def read_from_console(prompt, noecho: false)
         IO.console.write("#{prompt}: ")
-        str = IO.console.noecho {|io| io.gets.chomp }
-        puts
-        str
+        if noecho
+          IO.console.noecho {|io| io.gets.chomp }
+          puts
+        else
+          IO.console.gets.chomp
+        end
       end
 
     end

data/lib/hexapdf/cli/files.rb

@@ -39,19 +39,29 @@ require 'hexapdf/cli/command'
 module HexaPDF
   module CLI
 
-    # Lists or extracts embedded files from a PDF file.
+    # Lists or extracts embedded files from a PDF file or attaches them.
     #
     # See: HexaPDF::Type::EmbeddedFile
     class Files < Command
 
       def initialize #:nodoc:
         super('files', takes_commands: false)
-        short_desc("List or extract embedded files from a PDF file")
+        short_desc("List and extract embedded files from a PDF or attach files")
         long_desc(<<~EOF)
-          If the option --extract is not given, the available files are listed with their names and
-          indices. The --extract option can then be used to extract one or more files.
+          If neither the option --attach nor the option --extract is given, the available
+          files are listed with their names and indices. The --extract option can then be
+          used to extract one or more files. Or the --attach option can be used to attach
+          files to the PDF.
         EOF
 
+        options.on("--attach FILE", "-a FILE", String,
+                   "The file that should be attached. Can be used multiple times.") do |file|
+          @attach_files << [file, nil]
+        end
+        options.on("--description DESC", "-d DESC", String,
+                   "Adds a description to the last file to be attached.") do |description|
+          @attach_files[-1][1] = description
+        end
         options.on("--extract [a,b,c,...]", "-e [a,b,c,...]", Array,
                    "The indices of the files that should be extracted. Use 0 or no argument to " \
                    "extract all files.") do |indices|
@@ -66,15 +76,24 @@ module HexaPDF
           @password = (pwd == '-' ? read_password : pwd)
         end
 
+        @attach_files = []
         @indices = []
         @password = nil
         @search = false
       end
 
-      def execute(pdf) #:nodoc:
-        with_document(pdf, password: @password) do |doc|
-          if @indices.empty?
+      def execute(pdf, output = nil) #:nodoc:
+        if @indices.empty? && !@attach_files.empty?
+          raise Error, "Missing output file" unless output
+          maybe_raise_on_existing_file(output)
+        end
+        with_document(pdf, password: @password, out_file: output) do |doc|
+          if @indices.empty? && @attach_files.empty?
             list_files(doc)
+          elsif !@indices.empty? && !@attach_files.empty?
+            raise Error, "Use either --attach or --extract but not both"
+          elsif !@attach_files.empty?
+            attach_files(doc)
           else
             extract_files(doc)
           end
@@ -116,6 +135,11 @@ module HexaPDF
         end
       end
 
+      # Attaches the files given on the CLI to the document.
+      def attach_files(doc)
+        @attach_files.each {|file, desc| doc.files.add(file, description: desc) }
+      end
+
       # Iterates over all embedded files.
       def each_file(doc, &block) # :yields: obj, index
         doc.files.each(search: @search).select(&:embedded_file?).each_with_index(&block)

data/lib/hexapdf/cli/form.rb

@@ -195,6 +195,7 @@ module HexaPDF
       # Fills out the form by interactively asking the user for field values.
       def fill_form(doc)
         current_page_index = -1
+        form = doc.acro_form
         each_field(doc) do |_page, page_index, field, _widget|
           next if field.flagged?(:read_only) && !@fill_read_only_fields
           if current_page_index != page_index
@@ -224,9 +225,9 @@ module HexaPDF
             print "    └─ New value: "
             value = $stdin.readline.chomp
             next if value.empty?
-            apply_field_value(field, value)
+            form.fill(field.full_field_name => value)
           rescue HexaPDF::Error => e
-            puts "       ⚠  #{e.message}"
+            puts "       ⚠ Error while setting '#{field.full_field_name}': #{e.message}"
             retry
           end
         end
@@ -234,18 +235,20 @@ module HexaPDF
 
       # Fills out the form using the data from the provided template file.
       def fill_form_with_template(doc)
-        data = parse_template
         form = doc.acro_form
-        data.each do |name, value|
+        data = parse_template
+        data.reject! do |name, _value|
           field = form.field_by_name(name)
           raise Error, "Field '#{name}' not found in input PDF" unless field
           if field.flagged?(:read_only) && !@fill_read_only_fields
             puts "Ignoring field '#{name}' because it is read only and --fill-read-only-fields " \
-              "is no set"
-            next
+              "is not set"
+            true
+          else
+            false
           end
-          apply_field_value(field, value)
         end
+        form.fill(data)
       end
 
       # Parses the data from the given template file.
@@ -273,30 +276,6 @@ module HexaPDF
         data
       end
 
-      # Applies the given value to the field.
-      def apply_field_value(field, value)
-        case field.concrete_field_type
-        when :single_line_text_field, :multiline_text_field, :comb_text_field, :file_select_field,
-            :combo_box, :list_box, :editable_combo_box
-          field.field_value = value
-        when :check_box
-          field.field_value = case value
-                              when /y(es)?|t(rue)?/
-                                true
-                              when /n(o)?|f(alse)?/
-                                false
-                              else
-                                value
-                              end
-        when :radio_button
-          field.field_value = value.to_sym
-        else
-          raise Error, "Field type #{field.concrete_field_type} not yet supported"
-        end
-      rescue StandardError
-        raise Error, "Error while setting '#{field.full_field_name}': #{$!.message}"
-      end
-
       # Iterates over all non-push button fields in page order. If a field appears on multiple
       # pages, it is only yielded on the first page if +with_seen+ is +false.
       def each_field(doc, with_seen: false) # :yields: page, page_index, field

data/lib/hexapdf/cli/inspect.rb

@@ -270,7 +270,7 @@ module HexaPDF
             if (rev_index = data.shift)
               rev_index = rev_index.to_i - 1
               if rev_index < 0 || rev_index >= @doc.revisions.count
-                $stderr.puts("Error: Invalid revision numer specified")
+                $stderr.puts("Error: Invalid revision number specified")
                 next
               end
               length = 0

data/lib/hexapdf/cli/usage.rb

@@ -0,0 +1,215 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2024 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/cli/command'
+
+module HexaPDF
+  module CLI
+
+    # Shows the space usage of various parts of a PDF file.
+    class Usage < Command
+
+      # Modifies the HexaPDF::PDFData class to store the size information
+      module PDFDataExtension
+
+        # Used to store the size of the indirect object.
+        attr_accessor :size
+
+        # Used to store the size of the object inside the object stream.
+        attr_accessor :size_in_object_stream
+
+      end
+
+      # Modifies HexaPDF::Parser to retrieve space used by indirect objects.
+      module ParserExtension
+
+        # :nodoc:
+        def initialize(*)
+          super
+          @last_size = nil
+        end
+
+        # :nodoc:
+        def load_object(xref_entry)
+          super.tap do |obj|
+            if xref_entry.type == :compressed
+              obj.data.size_in_object_stream = @last_size
+            elsif xref_entry.type == :in_use
+              obj.data.size = @last_size
+            end
+            @last_size = nil
+          end
+        end
+
+        # :nodoc:
+        def parse_indirect_object(offset = nil)
+          real_offset = (offset ? @header_offset + offset : @tokenizer.pos)
+          result = super
+          @last_size = @tokenizer.pos - real_offset
+          result
+        end
+
+        # :nodoc:
+        def load_compressed_object(xref_entry)
+          result = super
+          offsets = @object_stream_data[xref_entry.objstm].instance_variable_get(:@offsets)
+          @last_size = if xref_entry.pos == offsets.size - 1
+                         @object_stream_data[xref_entry.objstm].instance_variable_get(:@tokenizer).
+                           io.size - offsets[xref_entry.pos]
+                       else
+                         offsets[xref_entry.pos + 1] - offsets[xref_entry.pos]
+                       end
+          result
+        end
+
+      end
+
+      def initialize #:nodoc:
+        super('usage', takes_commands: false)
+        short_desc("Show space usage of various parts of a PDF file")
+        long_desc(<<~EOF)
+          This command displays some usage statistics of the PDF file, i.e. which parts take which
+          approximate space in the file.
+
+          Each statistic line shows the space used followed by the number of indirect objects in
+          parentheses. If some of those objects are in object streams, that number is displayed
+          after a slash.
+        EOF
+
+        options.on("--password PASSWORD", "-p", String,
+                   "The password for decryption. Use - for reading from standard input.") do |pwd|
+          @password = (pwd == '-' ? read_password : pwd)
+        end
+
+        @password = nil
+      end
+
+      def execute(file) #:nodoc:
+        HexaPDF::Parser.prepend(ParserExtension)
+        HexaPDF::PDFData.prepend(PDFDataExtension)
+
+        with_document(file, password: @password) do |doc|
+          # Prepare cache of outline items
+          outline_item_cache = {}
+          if doc.catalog.key?(:Outlines)
+            doc.outline.each_item {|item| outline_item_cache[item] = true }
+            outline_item_cache[doc.outline] = true
+          end
+
+          doc.revisions.each.with_index do |rev, index|
+            sum = count = 0
+            categories = {
+              Content: [],
+              Files: [],
+              Fonts: [],
+              Images: [],
+              Metadata: [],
+              ObjectStreams: [],
+              Outline: [],
+              XObjects: [],
+            }
+            puts if index > 0
+            puts "Usage information for revision #{index + 1}" if doc.revisions.count > 1
+            rev.each do |obj|
+              if command_parser.verbosity_info?
+                print "(#{obj.oid},#{obj.gen}): #{obj.data.size.to_i}"
+                print " (#{obj.data.size_in_object_stream})" if obj.data.size.nil?
+                puts
+              end
+              next unless obj.kind_of?(HexaPDF::Dictionary)
+
+              case obj.type
+              when :Page
+                Array(obj[:Contents]).each do |content|
+                  categories[:Content] << content if object_in_rev?(content, rev)
+                end
+              when :Font
+                categories[:Fonts] << obj
+              when :FontDescriptor
+                categories[:Fonts] << obj
+                [:FontFile, :FontFile2, :FontFile3].each do |name|
+                  categories[:Fonts] << obj[name] if object_in_rev?(obj[name], rev)
+                end
+              when :Metadata
+                categories[:Metadata] << obj
+              when :Filespec
+                categories[:Files] << obj
+                categories[:Files] << obj.embedded_file_stream if obj.embedded_file?
+              when :ObjStm
+                categories[:ObjectStreams] << obj
+              else
+                if obj[:Subtype] == :Image
+                  categories[:Images] << obj
+                elsif obj[:Subtype] == :Form
+                  categories[:XObjects] << obj
+                end
+              end
+              sum += obj.data.size if obj.data.size
+              count += 1
+            end
+
+            # Populate Outline category
+            outline_item_cache.reject! do |obj, _val|
+              object_in_rev?(obj, rev) && categories[:Outline] << obj
+            end
+
+            categories.each do |name, data|
+              next if data.empty?
+              object_stream_count = 0
+              category_sum = data.sum do |o|
+                object_stream_count += 1 unless o.data.size
+                o.data.size.to_i
+              end
+              object_stream_count = object_stream_count > 0 ? "/#{object_stream_count}" : ''
+              size = human_readable_file_size(category_sum)
+              puts "#{name.to_s.ljust(15)} #{size.rjust(8)} (#{data.count}#{object_stream_count})"
+            end
+            puts "#{'Total'.ljust(15)} #{human_readable_file_size(sum).rjust(8)} (#{count})"
+          end
+        end
+      end
+
+      private
+
+      # Returns +true+ if the +obj+ is in the given +rev+.
+      def object_in_rev?(obj, rev)
+        obj && rev.object(obj) == obj
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/cli.rb

@@ -48,6 +48,7 @@ require 'hexapdf/cli/watermark'
 require 'hexapdf/cli/image2pdf'
 require 'hexapdf/cli/form'
 require 'hexapdf/cli/fonts'
+require 'hexapdf/cli/usage'
 require 'hexapdf/version'
 require 'hexapdf/document'
 
@@ -107,6 +108,7 @@ module HexaPDF
         add_command(HexaPDF::CLI::Image2PDF.new)
         add_command(HexaPDF::CLI::Form.new)
         add_command(HexaPDF::CLI::Fonts.new)
+        add_command(HexaPDF::CLI::Usage.new)
         add_command(CmdParse::HelpCommand.new)
         version_command = CmdParse::VersionCommand.new(add_switches: false)
         add_command(version_command)

data/lib/hexapdf/configuration.rb

@@ -481,7 +481,7 @@ module HexaPDF
                       'acro_form.fallback_font' => 'Helvetica',
                       'acro_form.on_invalid_value' => proc do |field, value|
                         raise HexaPDF::Error, "Invalid value #{value.inspect} for " \
-                          "#{field.concrete_field_type} field #{field.full_field_name}"
+                          "#{field.concrete_field_type} field named '#{field.full_field_name}'"
                       end,
                       'acro_form.text_field.default_width' => 100,
                       'debug' => false,

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

@@ -165,14 +165,16 @@ module HexaPDF
         #                nothing is stored for them (e.g a no-op).
         #
         # Check boxes:: Provide +nil+ or +false+ as value to toggle all check box widgets off. If
-        #               there is only one possible value, +true+ may be used for checking the box,
-        #               i.e. toggling it to the on state. Otherwise provide the value (a Symbol or
-        #               an object responding to +#to_sym+) of the check box widget that should be
-        #               toggled on.
+        #               +true+ is provided, all check box widgets with the same name as the first
+        #               one are toggled on. Otherwise provide the value (a Symbol or an object
+        #               responding to +#to_sym+) of the check box widget that should be toggled on.
         #
         # Radio buttons:: To turn all radio buttons off, provide +nil+ as value. Otherwise provide
         #                 the value (a Symbol or an object responding to +#to_sym+) of a radio
         #                 button that should be turned on.
+        #
+        # Note that in most cases the field needs to already have widgets because the value is
+        # checked against the possibly allowed values which depend on the existing widgets.
         def field_value=(value)
           normalized_field_value_set(:V, value)
         end
@@ -303,7 +305,7 @@ module HexaPDF
                       elsif check_box?
                         if value == false
                           :Off
-                        elsif value == true && av.size == 1
+                        elsif value == true && av.size >= 1
                           av[0]
                         elsif av.include?(value.to_sym)
                           value.to_sym

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

@@ -272,6 +272,9 @@ module HexaPDF
         #
         # 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.
+        #
+        # Before a field value other than +false+ can be assigned to the check box, a widget needs
+        # to be created.
         def create_check_box(name)
           create_field(name, :Btn, &:initialize_as_check_box)
         end
@@ -280,6 +283,9 @@ module HexaPDF
         #
         # 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.
+        #
+        # Before a field value other than +nil+ can be assigned to the radio button, at least one
+        # widget needs to be created.
         def create_radio_button(name)
           create_field(name, :Btn, &:initialize_as_radio_button)
         end
@@ -345,6 +351,45 @@ module HexaPDF
           create_field(name, :Sig) {}
         end
 
+        # Fills form fields with the values from the given +data+ hash.
+        #
+        # The keys of the +data+ hash need to be full field names and the values are the respective
+        # values, usually in string form. It is possible to specify only some of the fields of the
+        # form.
+        #
+        # What kind of values are supported for a field depends on the field type:
+        #
+        # * For fields containing text (single/multiline/comb text fields, file select fields, combo
+        #   boxes and list boxes) the value needs to be a string and it is assigned as is.
+        #
+        # * For check boxes, the values "y"/"yes"/"t"/"true" are handled as assigning +true+ to the
+        #   field, the values "n"/"no"/"f"/"false" are handled as assigning +false+ to the field,
+        #   and every other string value is assigned as is. See ButtonField#field_value= for
+        #   details.
+        #
+        # * For radio buttons the value needs to be a String or a Symbol representing the name of
+        #   the radio button widget to select.
+        def fill(data)
+          data.each do |field_name, value|
+            field = field_by_name(field_name)
+            raise HexaPDF::Error, "AcroForm field named '#{field_name}' not found" unless field
+
+            case field.concrete_field_type
+            when :single_line_text_field, :multiline_text_field, :comb_text_field, :file_select_field,
+                :combo_box, :list_box, :editable_combo_box, :radio_button
+              field.field_value = value
+            when :check_box
+              field.field_value = case value
+                                  when /\A(?:y(es)?|t(rue)?)\z/ then true
+                                  when /\A(?:n(o)?|f(alse)?)\z/ then false
+                                  else value
+                                  end
+            else
+              raise HexaPDF::Error, "AcroForm field type #{field.concrete_field_type} not yet supported"
+            end
+          end
+        end
+
         # Returns the dictionary containing the default resources for form field appearance streams.
         def default_resources
           self[:DR] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},

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

@@ -35,6 +35,7 @@
 #++
 
 require 'json'
+require 'time'
 require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
@@ -56,6 +57,7 @@ module HexaPDF
       #   JavaScript actions are:
       #
       #   * +AFNumber_Format+: See #af_number_format_action and #apply_af_number_format
+      #   * +AFPercent_Format+: See #af_percent_format_action and #apply_af_percent_format
       #
       # Calculating a field's value::
       #
@@ -184,6 +186,10 @@ module HexaPDF
           return [value, nil] unless (action_string = action_string(format_action))
           if action_string.start_with?('AFNumber_Format(')
             apply_af_number_format(value, action_string)
+          elsif action_string.start_with?('AFPercent_Format(')
+            apply_af_percent_format(value, action_string)
+          elsif action_string.start_with?('AFTime_Format(')
+            apply_af_time_format(value, action_string)
           else
             [value, nil]
           end
@@ -235,8 +241,15 @@ module HexaPDF
         # See: #apply_af_number_format
         def af_number_format_action(decimals: 2, separator_style: :point, negative_style: :minus_black,
                                     currency_string: "", prepend_currency: true)
-          "AFNumber_Format(#{decimals}, #{AF_NUMBER_FORMAT_MAPPINGS[:separator][separator_style]}, " \
-            "#{AF_NUMBER_FORMAT_MAPPINGS[:negative][negative_style]}, 0, \"#{currency_string}\", " \
+          separator_style = AF_NUMBER_FORMAT_MAPPINGS[:separator].fetch(separator_style) do
+            raise ArgumentError, "Unsupported value for separator_style argument: #{separator_style}"
+          end
+          negative_style = AF_NUMBER_FORMAT_MAPPINGS[:negative].fetch(negative_style) do
+            raise ArgumentError, "Unsupported value for negative_style argument: #{negative_style}"
+          end
+
+          "AFNumber_Format(#{decimals}, #{separator_style}, " \
+            "#{negative_style}, 0, \"#{currency_string}\", " \
             "#{prepend_currency});"
         end
 
@@ -323,21 +336,141 @@ module HexaPDF
             end
           end
 
-          result = sprintf(format, value)
+          [af_format_number(value, format, match[:sep_style]), text_color]
+        end
 
-          before_decimal_point, after_decimal_point = result.split('.')
-          if match[:sep_style] == '0' || match[:sep_style] == '2'
-            separator = (match[:sep_style] == '0' ? ',' : '.')
-            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
+        # Returns the appropriate JavaScript action string for the AFPercent_Format function.
+        #
+        # +decimals+::
+        #     The number of decimal digits to use. Default 2.
+        #
+        # +separator_style+::
+        #     Specifies the character for the decimal and thousands separator, one of:
+        #
+        #     :point:: (Default) Use point as decimal separator and comma as thousands separator.
+        #     :point_no_thousands:: Use point as decimal separator and no thousands separator.
+        #     :comma:: Use comma as decimal separator and point as thousands separator.
+        #     :comma_no_thousands:: Use comma as decimal separator and no thousands separator.
+        #
+        # See: #apply_af_percent_format
+        def af_percent_format_action(decimals: 2, separator_style: :point)
+          separator_style = AF_NUMBER_FORMAT_MAPPINGS[:separator].fetch(separator_style) do
+            raise ArgumentError, "Unsupported value for separator_style argument: #{separator_style}"
           end
-          result = if after_decimal_point
-                     decimal_point = (match[:sep_style] =~ /[01]/ ? '.' : ',')
-                     "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
-                   else
-                     before_decimal_point
-                   end
+          "AFPercent_Format(#{decimals}, #{separator_style});"
+        end
+
+        # Regular expression for matching the AFPercent_Format method.
+        #
+        # See: #apply_af_percent_format
+        AF_PERCENT_FORMAT_RE = /
+          \AAFPercent_Format\(
+            \s*(?<ndec>\d+)\s*,
+            \s*(?<sep_style>[0-3])\s*
+          \);?\z
+        /x
+
+        # Implements the JavaScript AFPercent_Format function and returns the formatted field value.
+        #
+        # The argument +value+ has to be the field's value (a String) and +action_string+ has to be
+        # the JavaScript action string.
+        #
+        # The AFPercent_Format function assumes that the text field's value contains a number (as a
+        # string) and formats it according to the instructions.
+        #
+        # It has the form <tt>AFPercent_Format(no_of_decimals, separator_style)</tt> where the
+        # arguments have the following meaning:
+        #
+        # +no_of_decimals+::
+        #   The number of decimal places after the decimal point, e.g. for 3 it would result in
+        #   123.456.
+        #
+        # +separator_style+::
+        #   Defines which decimal separator and whether a thousands separator should be used.
+        #
+        #   Possible values are:
+        #
+        #   +0+:: Comma for thousands separator, point for decimal separator: 12,345.67
+        #   +1+:: No thousands separator, point for decimal separator: 12345.67
+        #   +2+:: Point for thousands separator, comma for decimal separator: 12.345,67
+        #   +3+:: No thousands separator, comma for decimal separator: 12345,67
+        def apply_af_percent_format(value, action_string)
+          return value unless (match = AF_PERCENT_FORMAT_RE.match(action_string))
+          af_format_number(af_make_number(value) * 100, "%.#{match[:ndec]}f%%", match[:sep_style])
+        end
 
-          [result, text_color]
+        AF_TIME_FORMAT_MAPPINGS = { #:nodoc:
+          format_integers: {
+            hh_mm: 0,
+            0 => 0,
+            hh12_mm: 1,
+            1 => 1,
+            hh_mm_ss: 2,
+            2 => 2,
+            hh12_mm_ss: 3,
+            3 => 3,
+          },
+          strftime_format: {
+            '0' => '%H:%M',
+            '1' => '%l:%M %p',
+            '2' => '%H:%M:%S',
+            '3' => '%l:%M:%S %p',
+          },
+        }
+
+        # Returns the appropriate JavaScript action string for the AFTime_Format function.
+        #
+        # +format+::
+        #     Specifies the time format, one of:
+        #
+        #     :hh_mm:: (Default) Use 24h time format %H:%M (e.g. 15:25)
+        #     :hh12_mm:: (Default) Use 12h time format %l:%M %p (e.g. 3:25 PM)
+        #     :hh_mm_ss:: Use 24h time format with seconds %H:%M:%S (e.g. 15:25:37)
+        #     :hh12_mm_ss:: Use 24h time format with seconds %l:%M:%S %p (e.g. 3:25:37 PM)
+        #
+        # See: #apply_af_time_format
+        def af_time_format_action(format: :hh_mm)
+          format = AF_TIME_FORMAT_MAPPINGS[:format_integers].fetch(format) do
+            raise ArgumentError, "Unsupported value for time_format argument: #{format}"
+          end
+          "AFTime_Format(#{format});"
+        end
+
+        # Regular expression for matching the AFTime_Format method.
+        #
+        # See: #apply_af_time_format
+        AF_TIME_FORMAT_RE = /
+          \AAFTime_Format\(
+            \s*(?<time_format>[0-3])\s*
+          \);?\z
+        /x
+
+        # Implements the JavaScript AFTime_Format function and returns the formatted field value.
+        #
+        # The argument +value+ has to be the field's value (a String) and +action_string+ has to be
+        # the JavaScript action string.
+        #
+        # The AFTime_Format function assumes that the text field's value contains a valid time
+        # string (for HexaPDF that is anything Time.parse can work with) and formats it according to
+        # the instructions.
+        #
+        # It has the form <tt>AFTime_Format(time_format)</tt> where the argument has the following
+        # meaning:
+        #
+        # +time_format+::
+        #   Defines the time format which should be applied.
+        #
+        #   Possible values are:
+        #
+        #   +0+:: Use 24h time format, e.g. 15:25
+        #   +1+:: Use 12h time format, e.g. 3:25 PM
+        #   +2+:: Use 24h time format with seconds, e.g. 15:25:37
+        #   +3+:: Use 12h time format with seconds, e.g. 3:25:37 PM
+        def apply_af_time_format(value, action_string)
+          return value unless (match = AF_TIME_FORMAT_RE.match(action_string))
+          value = Time.parse(value) rescue nil
+          return "" unless value
+          value.strftime(AF_TIME_FORMAT_MAPPINGS[:strftime_format][match[:time_format]]).strip
         end
 
         # Handles JavaScript calculate actions for single-line text fields.
@@ -483,6 +616,24 @@ module HexaPDF
           value.to_s.tr(',', '.').to_f
         end
 
+        # Formats the numeric value according to the format string and separator style.
+        def af_format_number(value, format, sep_style)
+          result = sprintf(format, value)
+
+          before_decimal_point, after_decimal_point = result.split('.')
+          if sep_style == '0' || sep_style == '2'
+            separator = (sep_style == '0' ? ',' : '.')
+            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
+          end
+
+          if after_decimal_point
+            decimal_point = (sep_style <= "1" ? '.' : ',')
+            "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
+          else
+            before_decimal_point
+          end
+        end
+
         # Returns the JavaScript action string for the given action.
         def action_string(action)
           return nil unless action && action[:S] == :JavaScript

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

@@ -170,7 +170,7 @@ module HexaPDF
           elsif comb_text_field? && !key?(:MaxLen)
             raise HexaPDF::Error, "A comb text field need a valid /MaxLen value"
           elsif str && !str.kind_of?(String)
-            @document.config['acro_form.on_invalid_value'].call(self, str)
+            str = @document.config['acro_form.on_invalid_value'].call(self, str)
           end
           str = str.gsub(/[[:space:]]/, ' ') if str && concrete_field_type == :single_line_text_field
           if key?(:MaxLen) && str && str.length > self[:MaxLen]
@@ -254,9 +254,21 @@ module HexaPDF
         # :number::
         #     Assumes that the field value is a number and formats it according to the given
         #     arguments. See JavaScriptActions.af_number_format_action for details on the arguments.
+        #
+        # :percent::
+        #     Assumes that the field value is a number and formats it as percentage (where 1=100%
+        #     and 0=0%). See JavaScriptActions.af_percent_format_action for details on the
+        #     arguments.
+        #
+        # :time::
+        #     Assumes that the field value is a string with a time value and formats it according to
+        #     the given argument. See JavaScriptActions.af_time_format_action for details on the
+        #     arguments.
         def set_format_action(type, **arguments)
           action_string = case type
                           when :number then JavaScriptActions.af_number_format_action(**arguments)
+                          when :percent then JavaScriptActions.af_percent_format_action(**arguments)
+                          when :time then JavaScriptActions.af_time_format_action(**arguments)
                           else
                             raise ArgumentError, "Invalid value for type argument: #{type.inspect}"
                           end

data/lib/hexapdf/type/resources.rb

@@ -143,7 +143,8 @@ module HexaPDF
       #
       # If the dictionary is not found, an error is raised.
       def font(name)
-        object_getter(:Font, name)
+        font = object_getter(:Font, name)
+        font.kind_of?(Hash) ? document.wrap(font) : font
       end
 
       # Adds the font dictionary to the resources and returns the name under which it is stored.

data/lib/hexapdf/utils.rb

@@ -39,8 +39,27 @@ require 'geom2d/utils'
 module HexaPDF
 
   # This module contains helper methods for the whole library.
+  #
+  # Furthermore, it refines Numeric to provide #mm, #cm, and #inch methods.
   module Utils
 
+    refine Numeric do
+      # Intrepeting self as millimeters returns the equivalent number of points.
+      def mm
+        self * 72 / 25.4
+      end
+
+      # Intrepeting self as centimeters returns the equivalent number of points.
+      def cm
+        self * 72 / 2.54
+      end
+
+      # Intrepeting self as inches returns the equivalent number of points.
+      def inch
+        self * 72
+      end
+    end
+
     # The precision with which to compare floating point numbers.
     #
     # This is chosen with respect to precision that is used for serializing floating point numbers.

data/lib/hexapdf/version.rb

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

data/test/hexapdf/test_utils.rb

@@ -6,6 +6,22 @@ require 'hexapdf/utils'
 describe HexaPDF::Utils do
   include HexaPDF::Utils
 
+  describe "Numeric refinement" do
+    using HexaPDF::Utils
+
+    it "converts mm to points" do
+      assert_equal(72, 25.4.mm)
+    end
+
+    it "converts cm to points" do
+      assert_equal(72, 2.54.cm)
+    end
+
+    it "converts inch to points" do
+      assert_equal(144, 2.inch)
+    end
+  end
+
   it "checks floats for equality with a certain precision" do
     assert(float_equal(1.0, 1))
     assert(float_equal(1.0, 1.0000003))

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

@@ -93,6 +93,11 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       @field.field_value = "check"
       assert_equal(:check, @field[:V])
       assert_raises(HexaPDF::Error) { @field.field_value = :unknown }
+
+      @field.field_value = :Off
+      @field.create_widget(@doc.pages[0], value: :other)
+      @field.field_value = true
+      assert_equal(:check, @field[:V])
     end
 
     it "returns the correct concrete field type" do

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

@@ -241,6 +241,53 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "fill" do
+    it "works for text field types" do
+      field = @acro_form.create_text_field('test')
+      @acro_form.fill("test" => "value")
+      assert_equal("value", field.field_value)
+    end
+
+    it "works for radio buttons" do
+      field = @acro_form.create_radio_button("test")
+      field.create_widget(@doc.pages.add, value: :name)
+      @acro_form.fill("test" => "name")
+      assert_equal(:name, field.field_value)
+    end
+
+    it "works for check boxes" do
+      field = @acro_form.create_check_box('test')
+      field.create_widget(@doc.pages.add)
+
+      ["t", "true", "y", "yes"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_equal(:Yes, field.field_value)
+        field.field_value = :Off
+      end
+
+      ["f", "false", "n", "no"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_nil(field.field_value)
+        field.field_value = :Yes
+      end
+
+      field.create_widget(@doc.pages.add, value: :Other)
+      @acro_form.fill("test" => "Other")
+      assert_equal(:Other, field.field_value)
+    end
+
+    it "raises an error if a field is not found" do
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("unknown" => "test") }
+      assert_match(/named 'unknown' not found/, error.message)
+    end
+
+    it "raises an error if a field type is not supported for filling in" do
+      @acro_form.create_check_box('test').initialize_as_push_button
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("test" => "test") }
+      assert_match(/push_button not yet supported/, error.message)
+    end
+  end
+
   it "returns the default resources" do
     assert_kind_of(HexaPDF::Type::Resources, @acro_form.default_resources)
   end

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

@@ -31,6 +31,11 @@ describe HexaPDF::Type::AcroForm::JavaScriptActions do
                                                     prepend_currency: false))
       end
 
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_number_format_action(separator_style: :unknown) }
+        assert_raises(ArgumentError) { @klass.af_number_format_action(negative_style: :unknown) }
+      end
+
       def assert_format(arg_string, result_value, result_color)
         @action[:JS] = "AFNumber_Format(#{arg_string});"
         value, text_color = @klass.apply_format(@value, @action)
@@ -77,10 +82,106 @@ describe HexaPDF::Type::AcroForm::JavaScriptActions do
         assert_equal('1.234,57', value)
       end
 
-      it "does nothing to the value if the JavasSript method could not be determined " do
+      it "does nothing to the value if the JavaScript method could not be determined " do
         assert_format('2, 3, 0, 0, " E", false, a', "1234567.898765", nil)
       end
     end
+
+    describe "AFPercent_Format" do
+      before do
+        @value = '123.456789'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFPercent_Format(2, 0);',
+                     @klass.af_percent_format_action)
+        assert_equal('AFPercent_Format(1, 1);',
+                     @klass.af_percent_format_action(decimals: 1, separator_style: :point_no_thousands))
+      end
+
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_percent_format_action(separator_style: :unknown) }
+      end
+
+      def assert_format(arg_string, result_value)
+        @action[:JS] = "AFPercent_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        assert_nil(text_color)
+      end
+
+      it "works with both commas and points as decimal separator" do
+        @value = '123.456789'
+        assert_format('2, 2', "12.345,68%")
+        @value = '123,456789'
+        assert_format('2, 2', "12.345,68%")
+        @value = '123,4567,89'
+        assert_format('2, 2', "12.345,67%")
+      end
+
+      it "respects the set number of decimals" do
+        assert_format('0, 2', "12.346%")
+        assert_format('2, 2', "12.345,68%")
+      end
+
+      it "respects the digit separator style" do
+        ["12,345.68%", "12345.68%", "12.345,68%", "12345,68%"].each_with_index do |result, style|
+          assert_format("2, #{style}", result)
+        end
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFPercent_Format(2,2 )"
+        value, = @klass.apply_format('1.234', @action)
+        assert_equal('123,40%', value)
+      end
+
+      it "does nothing to the value if the JavaScript method could not be determined " do
+        assert_format('2, "df"', "123.456789")
+      end
+    end
+
+    describe "AFTime_Format" do
+      before do
+        @value = '15:25:37'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFTime_Format(0);',
+                     @klass.af_time_format_action)
+        assert_equal('AFTime_Format(1);',
+                     @klass.af_time_format_action(format: :hh12_mm))
+      end
+
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_time_format_action(format: :unknown) }
+      end
+
+      def assert_format(arg_string, result_value)
+        @action[:JS] = "AFTime_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        assert_nil(text_color)
+      end
+
+      it "respects the time format" do
+        ["15:25", "3:25 PM", "15:25:37", "3:25:37 PM"].each_with_index do |result, style|
+          assert_format(style, result)
+        end
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFTime_Format(2 )"
+        value, = @klass.apply_format('15:34', @action)
+        assert_equal('15:34:00', value)
+      end
+
+      it "does nothing to the value if the JavaScript method could not be determined " do
+        assert_format('1, "df"', "15:25:37")
+      end
+    end
   end
 
   describe "calculate" do

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

@@ -114,6 +114,12 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert(widget[:AP][:N])
     end
 
+    it "calls acro_form.on_invalid_value if the provided value is not a string" do
+      @doc.config['acro_form.on_invalid_value'] = proc {|_field, value| value.to_s }
+      @field.field_value = 10
+      assert_equal("10", @field.field_value)
+    end
+
     it "fails if the :password flag is set" do
       @field.flag(:password)
       assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
@@ -124,10 +130,6 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
     end
 
-    it "fails if the provided value is not a string" do
-      assert_raises(HexaPDF::Error) { @field.field_value = 10 }
-    end
-
     it "fails if the value exceeds the length set by /MaxLen" do
       @field[:MaxLen] = 5
       assert_raises(HexaPDF::Error) { @field.field_value = 'testdf' }
@@ -210,6 +212,22 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert_equal('AFNumber_Format(0, 0, 0, 0, "", true);', @field[:AA][:F][:JS])
     end
 
+    it "applies the percent format" do
+      @doc.acro_form(create: true)
+      @field.set_format_action(:percent, decimals: 0)
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:F))
+      assert_equal('AFPercent_Format(0, 0);', @field[:AA][:F][:JS])
+    end
+
+    it "applies the time format" do
+      @doc.acro_form(create: true)
+      @field.set_format_action(:time, format: :hh_mm_ss)
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:F))
+      assert_equal('AFTime_Format(2);', @field[:AA][:F][:JS])
+    end
+
     it "fails if an unknown format action is specified" do
       assert_raises(ArgumentError) { @field.set_format_action(:unknown) }
     end

data/test/hexapdf/type/test_resources.rb

@@ -146,6 +146,11 @@ describe HexaPDF::Type::Resources do
         @res.font(:test)
       end
     end
+
+    it "wraps the resulting object in the appropriate font class" do
+      @res[:Font] = {test: {Type: :Font, Subtype: :Type1}}
+      assert_kind_of(HexaPDF::Type::FontType1, @res.font(:test))
+    end
   end
 
   describe "add_font" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-05 00:00:00.000000000 Z
+date: 2024-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -325,6 +325,7 @@ files:
 - lib/hexapdf/cli/modify.rb
 - lib/hexapdf/cli/optimize.rb
 - lib/hexapdf/cli/split.rb
+- lib/hexapdf/cli/usage.rb
 - lib/hexapdf/cli/watermark.rb
 - lib/hexapdf/composer.rb
 - lib/hexapdf/configuration.rb