hexapdf 0.41.0 → 0.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae86345e0f2ed2dd27c9c58c550e7eaffb4d7c5d3ba388afb04318ee20491313
-  data.tar.gz: cfd9f8575ce9f4324c594c2617cc7e1bcf1d735276ac92a275f26acf74566bc9
+  metadata.gz: 24f6839e903fd945678915625b1e2ef6a12221f29a82cf1c7a6d8bcea38af288
+  data.tar.gz: 2f8309e2ef2406dd279e00643bf7fbf73ded63a1076c0067684a356fea8ee89e
 SHA512:
-  metadata.gz: d36715922fbbf5a93eeb5512ed0abf7ec78fbd099c49131500bd9f7db75c39248bb2bac12ad7e3df5c4a8a449351f63e0d83e0ed635f9a025e4bf25fdbe9f0e1
-  data.tar.gz: fc7a89694614826c8d151b7dab2c3f45ec335fc94efff873065c3dc68c845a691311b91b42c3b791eb71be80e1f8fd623838eb0cf1b94d0d1b758441df1b1a7a
+  metadata.gz: 8c6ddd8ec6f19d39daa9a6422fdb3595d255b528fb93ca7907ef12dab0eca23c74de9fcfc27d02c15b3a9d3c24d47c7f7db6ea472f4c1ed34c2b7c06d4a8a351
+  data.tar.gz: 1d77c2da70d9048cbef6935afacde40fb6d4041414fce571a331a4bee33b0e3ee2ff59bb28eee02e515798c3c156a57f42f139356e946f64e878ea962756a1d8

data/CHANGELOG.md

@@ -1,3 +1,58 @@
+## 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
+
+* 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/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/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/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