hexapdf 0.20.4 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f88aacce2ba9f2df02fdeaf17019871c9f8e1f7ab9202aa4dd8af89b86394c5e
-  data.tar.gz: bca3c34f6f71da1ae6df8f81c98c69e3bdda09f71f195b46979e16be91a7e1b7
+  metadata.gz: b666a69330b87a3ad7a5c937a1113a66a3b5ed3d0cb4f4478ee24f97bed0e411
+  data.tar.gz: 460c3cd90b8f76d3e4d32fdd6f1bc8fd71ddfef5d18799c6a207f562773371f8
 SHA512:
-  metadata.gz: 2ac8a3205b04705614dfa42fb0e73994aa7ccca90f23c73a0e7b8ba9f9932d18059ced2a62ecefd68c8f5425e3a354f51d8101e3b1b642d11312dbd3510ff1a6
-  data.tar.gz: 410c1cac0e07dfeda869d70a69370af74f255dcd17feb057064b39448b61d4494ea0bc7a05e99eefaa7a2459cc32bab4c01240b00dad9a6f63c83b32bc2176c2
+  metadata.gz: a9135019912d8c3d1e282797054dfbc99c028f26aa28f8412a138ab3d8d67124c4e9c52ad104eeb4289487e47dd850e3ff4211b5e928cdb0a8aab2d8ea773930
+  data.tar.gz: 070d0facdb6576fb6a0377a7139609ee648a580be879dabfd10e943bd2f62d66d9d5077058edcecf9ca3eb4e7969a2427c7a4af26bbb4d8f734e238f7022c7cd

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 0.21.0 - 2022-03-04
+
+### Added
+
+* [HexaPDF::Parser#reconstructed?] which returns true if the cross-reference
+  table was reconstructed
+- [HexaPDF::Layout::Style::create] for easier creation of style objects
+* The ability to view revisions of a PDF document or extract a single revision
+  via `hexapdf inspect`
+
+### Changed
+
+* **Breaking change**: Refactored [HexaPDF::Composer] for better and more
+  consistent style support
+* **Breaking change**: Arguments for configuration option
+  'font.on_missing_glyph' have changed to allow access to the document instance
+
+### Fixed
+
+* Setter for [HexaPDF::Layout::Style#line_spacing] to allow usage of numeric
+  arguments
+* Digital Signature validation for 'adbe.pkcs7.detached' certifiates in case no
+  key usage was defined
+* Removed caching of configuration 'font.on_missing_glyph' in font wrappers to
+  avoid problems
+
+
 ## 0.20.4 - 2022-01-26
 
 ### Fixed

data/README.md

@@ -7,13 +7,12 @@ short, it allows
 * **manipulating** existing PDF files,
 * **merging** multiple PDF files into one,
 * **extracting** meta information, text, images and files from PDF files,
-* **securing** PDF files by encrypting them and
+* **securing** PDF files by encrypting or signing them and
 * **optimizing** PDF files for smaller file size or other criteria.
 
 HexaPDF was designed with ease of use and performance in mind. It uses lazy loading and lazy
 computing when possible and tries to produce small PDF files by default.
 
-
 ## Usage
 
 The HexaPDF distribution provides the library as well as the `hexapdf` application. The application
@@ -46,9 +45,12 @@ with example graphics and PDF files and tightly integrated into the rest of the
 ## Requirements and Installation
 
 Since HexaPDF is written in Ruby, a working Ruby installation is needed - see the
-[official installation documentation][rbinstall] for details. Note that you need Ruby version 2.4 or
+[official installation documentation][rbinstall] for details. Note that you need Ruby version 2.5 or
 higher as prior versions are not supported!
 
+HexaPDF works on all Ruby implementations that are CRuby compatible, e.g. TruffleRuby, and on any
+platform supported by Ruby (Linux, macOS, Windows, ...).
+
 Apart from Ruby itself the HexaPDF library has only one external dependency `geom2d` which is
 written and provided by the HexaPDF authors. The `hexapdf` application has an additional dependency
 on `cmdparse`, a command line parsing library.

data/Rakefile

@@ -46,8 +46,17 @@ namespace :dev do
     puts 'done'
   end
 
+  task :test_all do
+    versions = `rbenv versions --bare | grep -i 2.[567]\\\\\\|3.`.split("\n")
+    versions.each do |version|
+      sh "rbenv shell #{version} &>/dev/null && rake test"
+    end
+    puts "Looks okay? (enter to continue, Ctrl-c to abort)"
+    $stdin.gets
+  end
+
   desc 'Release HexaPDF version ' + HexaPDF::VERSION
-  task release: [:clobber, :package, :publish_files]
+  task release: [:clobber, :test_all, :package, :publish_files]
 
   desc "Set-up everything for development"
   task :setup do

data/examples/018-composer.rb

@@ -3,9 +3,10 @@
 # This example shows how [HexaPDF::Composer] simplifies the creation of PDF
 # documents by providing a high-level interface to the box layouting engine.
 #
-# Basic style properties can be set on the [HexaPDF::Composer#base_style] style.
-# These properties are reused by every box and can be adjusted on a box-by-box
-# basis.
+# Basic style properties can be set using the [HexaPDF::Composer#style] method
+# and the style name `:basic`. These properties are reused by every box and can
+# be adjusted on a box-by-box basis. Newly defined styles also inherit the
+# properties from the `:basic` style.
 #
 # Various methods allow the easy creation of boxes, for example, text and image
 # boxes. All these boxes are automatically drawn on the page. If the page has
@@ -24,21 +25,20 @@ dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exer\u{00AD}citation
 ullamco laboris nisi ut aliquip ex ea commodo consequat. ".tr("\n", " ")
 
 HexaPDF::Composer.create('composer.pdf') do |pdf|
-  pdf.base_style.update(line_spacing: {type: :proportional, value: 1.5},
-                        last_line_gap: true, align: :justify)
-  image_style = pdf.base_style.dup.update(border: {width: 1}, padding: 5, margin: 10)
-  link_style = pdf.base_style.dup.update(fill_color: [6, 158, 224], underline: true)
+  pdf.style(:base, line_spacing: 1.5, last_line_gap: true, align: :justify)
+  pdf.style(:image, border: {width: 1}, padding: 5, margin: 10)
+  pdf.style(:link, fill_color: [6, 158, 224], underline: true)
   image = File.join(__dir__, 'machupicchu.jpg')
 
   pdf.text(lorem_ipsum * 2)
-  pdf.image(image, style: image_style, width: 200, position: :float)
-  pdf.image(image, style: image_style, width: 200, position: :absolute,
+  pdf.image(image, style: :image, width: 200, position: :float)
+  pdf.image(image, style: :image, width: 200, position: :absolute,
             position_hint: [200, 300])
   pdf.text(lorem_ipsum * 20, position: :flow)
 
   pdf.formatted_text(["Produced by ",
                       {link: "https://hexapdf.gettalong.org", text: "HexaPDF",
-                       style: link_style},
+                       style: :link},
                       " via HexaPDF::Composer"],
                       font_size: 15, align: :center, padding: 15)
 end

data/lib/hexapdf/cli/batch.rb

@@ -59,12 +59,10 @@ module HexaPDF
       def execute(command, *files) #:nodoc:
         args = Shellwords.split(command)
         files.each do |file|
-          begin
-            HexaPDF::CLI::Application.new.parse(args.map {|a| a.gsub(/{}/, file) })
-          rescue StandardError
-            if command_parser.verbosity_warning?
-              $stderr.puts "Error processing '#{file}': #{$!.message}"
-            end
+          HexaPDF::CLI::Application.new.parse(args.map {|a| a.gsub(/{}/, file) })
+        rescue StandardError
+          if command_parser.verbosity_warning?
+            $stderr.puts "Error processing '#{file}': #{$!.message}"
           end
         end
       end

data/lib/hexapdf/cli/info.rb

@@ -112,7 +112,8 @@ module HexaPDF
           output_line("File name", file)
           output_line("File size", File.stat(file).size.to_s << " bytes")
           @auto_decrypt && INFO_KEYS.each do |name|
-            next unless doc.trailer.info.key?(name)
+            value = doc.trailer.info[name]
+            next if !value || (value.kind_of?(String) && value.empty?)
             output_line(name.to_s, doc.trailer.info[name].to_s)
           end
 
@@ -152,6 +153,9 @@ module HexaPDF
 
           output_line("Pages", doc.pages.count.to_s)
           output_line("Version", doc.version)
+          if doc.revisions.parser.reconstructed?
+            output_line("Reconstructed", "yes (use --check for details)")
+          end
         end
       rescue HexaPDF::EncryptionError
         if @auto_decrypt

data/lib/hexapdf/cli/inspect.rb

@@ -216,6 +216,28 @@ module HexaPDF
               end
             end
 
+          when 'rev', 'revision'
+            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")
+                next
+              end
+              length = 0
+              revision_information do |_, index, _, _, end_offset|
+                length = end_offset if index == rev_index
+              end
+              IO.copy_stream(@doc.revisions.parser.io, $stdout, length, 0)
+            else
+              puts "Document has #{@doc.revisions.size} revision#{@doc.revisions.size == 1 ? '' : 's'}"
+              revision_information do |_, index, count, signature, end_offset|
+                puts "Revision #{index + 1}"
+                puts "  Objects   : #{count}"
+                puts "  Signed    : yes" if signature
+                puts "  Byte range: 0-#{end_offset}"
+              end
+            end
+
           when 'q', 'quit'
             return true
 
@@ -294,11 +316,48 @@ module HexaPDF
         puts if indent == 0
       end
 
+      # Yields information about the document's revisions.
+      #
+      # Returns an array of arrays that include the following information:
+      #
+      # - The revision object itself
+      # - The index of the revision in terms of all revisions of the document
+      # - The number of objects in the revision
+      # - The signature dictionary if this revision was signed
+      # - The byte offset from the start of the file to the end of the revision
+      def revision_information
+        signatures = @doc.signatures.map do |sig|
+          [@doc.revisions.find {|rev| rev.object(sig) == sig }, sig]
+        end.to_h
+        io = @doc.revisions.parser.io
+
+        startxrefs = @doc.revisions.map {|rev| rev.trailer[:Prev] }
+        io.seek(0, IO::SEEK_END)
+        startxrefs.push(@doc.revisions.parser.startxref_offset, io.pos).shift
+
+        @doc.revisions.each_with_index.map do |rev, index|
+          end_index = 0
+          sig = signatures[rev]
+          if sig
+            end_index = sig[:ByteRange][-2] + sig[:ByteRange][-1]
+          else
+            io.seek(startxrefs[index], IO::SEEK_SET)
+            while io.pos < startxrefs[index + 1]
+              if io.gets =~ /^\s*%%EOF\s*$/
+                end_index = io.pos
+              end
+            end
+          end
+          yield(rev, index, rev.next_free_oid - 1, sig, end_index)
+        end
+      end
+
       COMMAND_DESCRIPTIONS = [ #:nodoc:
         ["OID[,GEN] | o[bject] OID[,GEN]", "Print object"],
         ["r[ecursive] OID[,GEN]", "Print object recursively"],
         ["s[tream] OID[,GEN]", "Print filtered stream"],
         ["raw[-stream] OID[,GEN]", "Print raw stream"],
+        ["rev[ision] [NUMBER]", "Print or extract revision"],
         ["x[ref] OID[,GEN]", "Print the cross-reference entry"],
         ["c[atalog]", "Print the catalog dictionary"],
         ["t[railer]", "Print the trailer dictionary"],

data/lib/hexapdf/cli/split.rb

@@ -136,7 +136,7 @@ module HexaPDF
         end
 
         @page_name_cache[media_box] =
-          paper_size ? paper_size[0] : "%.0fx%.0f" % media_box.values_at(2, 3)
+          paper_size ? paper_size[0] : sprintf("%.0fx%.0f", *media_box.values_at(2, 3))
       end
 
     end

data/lib/hexapdf/composer.rb

@@ -39,8 +39,9 @@ require 'hexapdf/layout'
 
 module HexaPDF
 
-  # The composer class can be used to create PDF documents from scratch. It uses Frame and Box
-  # objects underneath.
+  # The composer class can be used to create PDF documents from scratch. It uses
+  # HexaPDF::Layout::Frame and HexaPDF::Layout::Box objects underneath and binds them together to
+  # provide a convenient interface for working with them.
   #
   # == Usage
   #
@@ -57,10 +58,23 @@ module HexaPDF
   # page. Behind the scenes HexaPDF::Layout::Box (and subclass) objects are created and drawn on the
   # page via the frame.
   #
-  # The base style that is used by all these boxes can be defined using the #base_style method which
-  # returns a HexaPDF::Layout::Style object. The only style property that is set by default is the
-  # font (Times) because otherwise there would be problems with text drawing operations (font is the
-  # only style property that has no valid default value).
+  # All drawing methods accept HexaPDF::Layout::Style objects or names for style objects (defined
+  # via #style). The HexaPDF::Layout::Style#font is handled specially:
+  #
+  # * If no font is set on a style, the font "Times" is automatically set because otherwise there
+  #   would be problems with text drawing operations (font is the only style property that has no
+  #   valid default value).
+  #
+  # * Standard style objects only allow font wrapper objects to be set via the
+  #   HexaPDF::Layout::Style#font method. Composer makes usage easier by allowing strings or an
+  #   array [name, options_hash] to be used, like with e.g Content::Canvas. So using Helvetica as
+  #   font, one could just do this by saying
+  #
+  #     style.font = 'Helvetica'
+  #
+  #   And if Helvetica bold should be used it would be
+  #
+  #     style.font = ['Helvetica', variant: :bold]
   #
   # If the frame of a page is full and a box doesn't fit anymore, a new page is automatically
   # created. The box is either split into two boxes where one fits on the first page and the other
@@ -105,12 +119,9 @@ module HexaPDF
     # The Content::Canvas of the current page. Can be used to perform arbitrary drawing operations.
     attr_reader :canvas
 
-    # The Layout::Frame for automatic box placement.
+    # The HexaPDF::Layout::Frame for automatic box placement.
     attr_reader :frame
 
-    # The base style which is used when no explicit style is provided to methods (e.g. to #text).
-    attr_reader :base_style
-
     # Creates a new Composer object and optionally yields it to the given block.
     #
     # page_size::
@@ -122,15 +133,22 @@ module HexaPDF
     #     +page_size+ is one of the predefined page sizes.
     #
     # margin::
-    #     The margin to use. See Layout::Style::Quad#set for possible values.
+    #     The margin to use. See HexaPDF::Layout::Style::Quad#set for possible values.
+    #
+    # Example:
+    #
+    #   composer = HexaPDF::Composer.new            # uses the default values
+    #   HexaPDF::Composer.new(page_size: :Letter, margin: 72) do |composer|
+    #     #...
+    #   end
     def initialize(page_size: :A4, page_orientation: :portrait, margin: 36) #:yields: composer
       @document = HexaPDF::Document.new
       @page_size = page_size
       @page_orientation = page_orientation
       @margin = Layout::Style::Quad.new(margin)
+      @styles = {base: Layout::Style.new}
 
       new_page
-      @base_style = Layout::Style.new(font: 'Times')
       yield(self) if block_given?
     end
 
@@ -170,32 +188,85 @@ module HexaPDF
       @document.write(output, optimize: optimize, **options)
     end
 
+    # :call-seq:
+    #    composer.style(:header)                              -> style
+    #    composer.style(:header, base: :base, **properties)   -> style
+    #
+    # Creates or updates the HexaPDF::Layout::Style object called +name+ with the given property
+    # values and returns it. Such a style can then be used by name in the various box drawing
+    # methods, e.g. #text or #image.
+    #
+    # If neither +base+ nor any style properties are specified, the style +name+ is just returned.
+    #
+    # If the style +name+ does not exist yet and the argument +base+ specifies the name of another
+    # style, that style is duplicated and used as basis for the style.
+    #
+    # The special name :base should be used for setting the base style which is used when no
+    # specific style is set. It is best to fully initialize the base style before creating any
+    # other styles.
+    #
+    # Note that the style property 'font' is handled specially by Composer, see the class
+    # documentation for details.
+    #
+    # Example:
+    #
+    #   composer.style(:base, font_size: 12, leading: 1.2)
+    #   composer.style(:header, font: 'Helvetica', fill_color: "008")
+    #   composer.style(:header1, base: :header, font_size: 30)
+    #
+    # See: HexaPDF::Layout::Style
+    def style(name, base: :base, **properties)
+      style = @styles[name] ||= (@styles.key?(base) ? @styles[base].dup : Layout::Style.new)
+      style.update(**properties) unless properties.empty?
+      style
+    end
+
     # Draws the given text at the current position into the current frame.
     #
-    # This method is the main method for displaying text on a PDF page. It uses a Layout::TextBox
-    # behind the scenes to do the actual work.
+    # This method is the main method for displaying text on a PDF page. It uses a
+    # HexaPDF::Layout::TextBox behind the scenes to do the actual work.
     #
     # The text will be positioned at the current position if possible. Otherwise the next best
     # position is used. If the text doesn't fit onto the current page or only partially, new pages
     # are created automatically.
     #
-    # The arguments +width+ and +height+ are used as constraints and are respected when fitting the
-    # box.
+    # +width+, +height+::
+    #     The arguments +width+ and +height+ are used as constraints and are respected when fitting
+    #     the box. The default value of 0 means that no constraints are set.
     #
-    # The text is styled using the given +style+ object (see Layout::Style) or, if no style object
-    # is specified, the base style (see #base_style). If any additional style +options+ are
-    # specified, the used style is copied and the additional styles are applied.
+    # +style+, +style_properties+::
+    #     The box and the text are styled using the given +style+. This can either be a style name
+    #     set via #style or anything HexaPDF::Layout::Style::create accepts. If any additional
+    #     +style_properties+ are specified, the style is duplicated and the additional styles are
+    #     applied.
     #
-    # See HexaPDF::Layout::TextBox for details.
-    def text(str, width: 0, height: 0, style: nil, **options)
-      style = update_style(style, options)
+    # +box_style+::
+    #     Sometimes it is necessary for the box to have a different style than the text, e.g. when
+    #     using overlays. In such a case use +box_style+ for specifiying the style of the box (a
+    #     style name set via #style or anything HexaPDF::Layout::Style::create accepts). The +style+
+    #     together with the +style_properties+ will be used for the text style.
+    #
+    # Examples:
+    #
+    #   #>pdf-composer
+    #   composer.text("Test " * 15)
+    #   composer.text("Now " * 7, width: 100)
+    #   composer.text("Another test", font_size: 15, fill_color: "green")
+    #   composer.text("Different box style", fill_color: 'white', box_style: {
+    #     underlays: [->(c, b) { c.rectangle(0, 0, b.content_width, b.content_height).fill }]
+    #   })
+    #
+    # See HexaPDF::HexaPDF::Layout::TextBox for details.
+    def text(str, width: 0, height: 0, style: nil, box_style: nil, **style_properties)
+      style = retrieve_style(style, style_properties)
+      box_style = (box_style ? retrieve_style(box_style) : style)
       draw_box(Layout::TextBox.new([Layout::TextFragment.create(str, style)],
-                                   width: width, height: height, style: style))
+                                   width: width, height: height, style: box_style))
     end
 
-    # Draws text like #text but where parts of it can be formatted differently.
+    # Draws text like #text but allows parts of the text to be formatted differently.
     #
-    # The argument +data+ needs to be an array of String or Hash objects:
+    # The argument +data+ needs to be an array of String and/or Hash objects:
     #
     # * A String object is treated like {text: data}.
     #
@@ -206,48 +277,58 @@ module HexaPDF
     #   link:: A URL that should be linked to. If no text is provided but a link, the link is used
     #          as text.
     #
-    #   style:: A Layout::Style object to use as basis instead of the style created from the +style+
-    #           and +options+ arguments.
+    #   style:: The style to be use as basis instead of the style created from the +style+ and
+    #           +style_properties+ arguments. See HexaPDF::Layout::Style::create for allowed values.
     #
     #   If any style properties are set, the used style is copied and the additional properties
     #   applied.
     #
+    # See #text for details on +width+, +height+, +style+, +style_properties+ and +box_style+.
+    #
     # Examples:
     #
-    #   composer.formatted_text(["Some string"])   # The same as #text
-    #   composer.formatted_text(["Some ", {text: "string", fill_color: 128}]
-    #   composer.formatted_text(["Some ", {link: "https://example.com", text: "Example"}])
-    #   composer.formatted_text(["Some ", {text: "string", style: my_style}])
-    def formatted_text(data, width: 0, height: 0, style: nil, **options)
-      style = update_style(style, options)
+    #   #>pdf-composer
+    #   composer.formatted_text(["Some string"])
+    #   composer.formatted_text(["Some ", {text: "string", fill_color: 128}])
+    #   composer.formatted_text(["Some ", {link: "https://example.com",
+    #                                      fill_color: 'blue', text: "Example"}])
+    #   composer.formatted_text(["Some ", {text: "string", style: {font_size: 20}}])
+    #
+    # See: #text, HexaPDF::Layout::TextBox, HexaPDF::Layout::TextFragment
+    def formatted_text(data, width: 0, height: 0, style: nil, box_style: nil, **style_properties)
+      style = retrieve_style(style, style_properties)
+      box_style = (box_style ? retrieve_style(box_style) : style)
       data.map! do |hash|
         if hash.kind_of?(String)
           Layout::TextFragment.create(hash, style)
         else
           link = hash.delete(:link)
+          (hash[:overlays] ||= []) << [:link, {uri: link}] if link
           text = hash.delete(:text) || link || ""
-          used_style = update_style(hash.delete(:style), options) || style
-          if link || !hash.empty?
-            used_style = used_style.dup
-            hash.each {|key, value| used_style.send(key, value) }
-            used_style.overlays.add(:link, uri: link) if link
-          end
-          Layout::TextFragment.create(text, used_style)
+          Layout::TextFragment.create(text, retrieve_style(hash.delete(:style) || style, hash))
         end
       end
-      draw_box(Layout::TextBox.new(data, width: width, height: height, style: style))
+      draw_box(Layout::TextBox.new(data, width: width, height: height, style: box_style))
     end
 
-    # Draws the given image file at the current position.
+    # Draws the given image at the current position.
+    #
+    # The +file+ argument can be anything that is accepted by HexaPDF::Document::Images#add.
+    #
+    # See #text for details on +width+, +height+, +style+ and +style_properties+.
+    #
+    # Examples:
     #
-    # See #text for details on +width+, +height+, +style+ and +options+.
-    def image(file, width: 0, height: 0, style: nil, **options)
-      style = update_style(style, options)
+    #   #>pdf-composer
+    #   composer.image(machu_picchu, border: {width: 3})
+    #   composer.image(machu_picchu, height: 30)
+    def image(file, width: 0, height: 0, style: nil, **style_properties)
+      style = retrieve_style(style, style_properties)
       image = document.images.add(file)
       draw_box(Layout::ImageBox.new(image, width: width, height: height, style: style))
     end
 
-    # Draws the given Layout::Box.
+    # Draws the given HexaPDF::Layout::Box.
     #
     # The box is drawn into the current frame if possible. If it doesn't fit, the box is split. If
     # it still doesn't fit, a new region of the frame is determined and then the process starts
@@ -291,13 +372,26 @@ module HexaPDF
                                  media_box.height - @margin.bottom - @margin.top)
     end
 
-    # Updates the Layout::Style object +style+ if one is provided, or the base style, with the style
-    # options to make it work in all cases.
-    def update_style(style, options = {})
-      style ||= base_style
-      style = style.dup.update(**options) unless options.empty?
-      style.font(base_style.font) unless style.font?
-      style.font(@document.fonts.add(style.font)) unless style.font.respond_to?(:pdf_object)
+    # Retrieves the appropriate HexaPDF::Layout::Style object based on the +style+ and +properties+
+    # arguments.
+    #
+    # The +style+ argument specifies the style to retrieve. It can either be a registered style name
+    # (see #style), a hash with style properties or +nil+. In the latter case the registered style
+    # :base is used
+    #
+    # If the +properties+ hash is not empty, the retrieved style is duplicated and the properties
+    # hash is applied to it.
+    #
+    # Finally, a default font is set if necessary to ensure that the style object works in all
+    # cases.
+    def retrieve_style(style, properties = nil)
+      style = Layout::Style.create(@styles[style] || style || @styles[:base])
+      style = style.dup.update(**properties) unless properties.nil? || properties.empty?
+      style.font('Times') unless style.font?
+      unless style.font.respond_to?(:pdf_object)
+        name, options = *style.font
+        style.font(@document.fonts.add(name, **(options || {})))
+      end
       style
     end
 

data/lib/hexapdf/configuration.rb

@@ -266,10 +266,14 @@ module HexaPDF
   # font.on_missing_glyph::
   #    Callback hook when an UTF-8 character cannot be mapped to a glyph of a font.
   #
-  #    The value needs to be an object that responds to \#call(character, font_type, font) where
+  #    The value needs to be an object that responds to \#call(character, font_wrapper) where
   #    +character+ is the Unicode character for the missing glyph and returns a substitute glyph to
   #    be used instead.
   #
+  #    The +font_wrapper+ argument is the used font wrapper object, e.g.
+  #    HexaPDF::Font::TrueTypeWrapper. To access the HexaPDF::Document instance from which this hook
+  #    was called, you can use +font_wrapper.pdf_object.document+.
+  #
   #    The default implementation returns an object of class HexaPDF::Font::InvalidGlyph which, when
   #    not removed before encoding, will raise an error.
   #
@@ -431,8 +435,8 @@ module HexaPDF
                         Encryption: 'HexaPDF::Filter::Encryption',
                       },
                       'font.map' => {},
-                      'font.on_missing_glyph' => proc do |char, _type, font|
-                        HexaPDF::Font::InvalidGlyph.new(font, char)
+                      'font.on_missing_glyph' => proc do |char, font_wrapper|
+                        HexaPDF::Font::InvalidGlyph.new(font_wrapper.wrapped_font, char)
                       end,
                       'font.on_missing_unicode_mapping' => proc do |code_point, font|
                         raise HexaPDF::Error, "No Unicode mapping for code point #{code_point} " \

data/lib/hexapdf/content/canvas.rb

@@ -2015,7 +2015,7 @@ module HexaPDF
             invoke2(:Td, offset[0], offset[1])
           end
         else
-          invoke0(:"T*")
+          invoke0(:'T*')
         end
         self
       end

data/lib/hexapdf/content/color_space.rb

@@ -296,7 +296,7 @@ module HexaPDF
           spec = if first_item.match?(/\A\h{6}\z/)
                    first_item.scan(/../).map!(&:hex)
                  elsif first_item.match?(/\A\h{3}\z/)
-                   first_item.each_char.map {|x| (x*2).hex}
+                   first_item.each_char.map {|x| (x * 2).hex }
                  elsif CSS_COLOR_NAMES.key?(first_item)
                    CSS_COLOR_NAMES[first_item]
                  else

data/lib/hexapdf/content/operator.rb

@@ -1036,14 +1036,14 @@ module HexaPDF
         s: EndPath.new('s'),
         f: EndPath.new('f'),
         F: EndPath.new('F'),
-        'f*'.to_sym => EndPath.new('f*'),
+        'f*': EndPath.new('f*'),
         B: EndPath.new('B'),
-        'B*'.to_sym => EndPath.new('B*'),
+        'B*': EndPath.new('B*'),
         b: EndPath.new('b'),
-        'b*'.to_sym => EndPath.new('b*'),
+        'b*': EndPath.new('b*'),
         n: EndPath.new('n'),
         W: ClipPath.new('W'),
-        'W*'.to_sym => ClipPath.new('W*'),
+        'W*': ClipPath.new('W*'),
 
         BI: InlineImage.new,
 
@@ -1059,10 +1059,10 @@ module HexaPDF
         Td: MoveText.new,
         TD: MoveTextAndSetLeading.new,
         Tm: SetTextMatrix.new,
-        'T*'.to_sym => MoveTextNextLine.new,
+        'T*': MoveTextNextLine.new,
         Tj: ShowText.new,
-        '\''.to_sym => MoveTextNextLineAndShowText.new,
-        '"'.to_sym => SetSpacingMoveTextNextLineAndShowText.new,
+        "'": MoveTextNextLineAndShowText.new,
+        '"': SetSpacingMoveTextNextLineAndShowText.new,
         TJ: ShowTextWithPositioning.new,
       }
       DEFAULT_OPERATORS.default_proc = proc {|h, k| h[k] = BaseOperator.new(k.to_s) }

data/lib/hexapdf/content/parser.rb

@@ -94,11 +94,11 @@ module HexaPDF
         elsif byte == 40 # (
           parse_literal_string
         elsif byte == 60 # <
-          if @string.getbyte(@ss.pos + 1) != 60
-            parse_hex_string
-          else
+          if @string.getbyte(@ss.pos + 1) == 60
             @ss.pos += 2
             TOKEN_DICT_START
+          else
+            parse_hex_string
           end
         elsif byte == 62 # >
           unless @string.getbyte(@ss.pos + 1) == 62