hexapdf 0.40.0 → 0.42.0

data/lib/hexapdf/cli/info.rb

@@ -192,6 +192,10 @@ module HexaPDF
             puts "WARNING: Parse error at position #{pos}: #{msg}"
             false
           end
+          options[:config]['encryption.on_decryption_error'] = lambda do |obj, msg|
+            puts "WARNING: Decryption problem for object (#{obj.oid},#{obj.gen}): #{msg}"
+            false
+          end
           options
         else
           super

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

@@ -255,6 +255,12 @@ module HexaPDF
   #    PDF defines a standard security handler that is implemented
   #    (HexaPDF::Encryption::StandardSecurityHandler) and assigned the :Standard name.
   #
+  # encryption.on_decryption_error::
+  #    Callback hook when HexaPDF encounters a decryption error that can potentially be ignored.
+  #
+  #    The value needs to be an object that responds to \#call(obj, message) and returns +true+ if
+  #    an error should be raised.
+  #
   # encryption.sub_filter_map::
   #    A mapping from a PDF name (a Symbol) to a security handler class (see
   #    HexaPDF::Encryption::SecurityHandler). If the value is a String, it should contain the name
@@ -475,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,
@@ -488,6 +494,9 @@ module HexaPDF
                       'encryption.filter_map' => {
                         Standard: 'HexaPDF::Encryption::StandardSecurityHandler',
                       },
+                      'encryption.on_decryption_error' => proc do |_obj, _error|
+                        false
+                      end,
                       'encryption.sub_filter_map' => {},
                       'filter.map' => {
                         ASCIIHexDecode: 'HexaPDF::Filter::ASCIIHexDecode',
@@ -523,6 +532,7 @@ module HexaPDF
                         'HexaPDF::FontLoader::Standard14',
                         'HexaPDF::FontLoader::FromConfiguration',
                         'HexaPDF::FontLoader::FromFile',
+                        'HexaPDF::FontLoader::VariantFromName',
                       ],
                       'graphic_object.arc.max_curves' => 6,
                       'graphic_object.map' => {

data/lib/hexapdf/content/canvas.rb

@@ -2245,6 +2245,8 @@ module HexaPDF
       #   canvas.text("Times at size 10", at: [10, 150])
       #   canvas.font("Times", variant: :bold_italic, size: 15)
       #   canvas.text("Times bold+italic at size 15", at: [10, 100])
+      #   canvas.font("Times bold")
+      #   canvas.text("Times bold using the variant-from-name method", at: [10, 50])
       #
       # See: PDF2.0 s9.2.2, #font_size, #text
       def font(name = nil, size: nil, **options)

data/lib/hexapdf/document/layout.rb

@@ -92,6 +92,13 @@ module HexaPDF
     #
     #     style.font = ['Helvetica', variant: :bold]
     #
+    #   Helvetica in bold could also be set the conventional way:
+    #
+    #     style.font = 'Helvetica bold'
+    #
+    #   However, using an array it is also possible to specify other options when setting a font,
+    #   like the :subset option.
+    #
     class Layout
 
       # This class is used when a box can contain child boxes and the creation of such boxes should
@@ -539,7 +546,7 @@ module HexaPDF
       #     # assign the predefined style :cell_text to all texts
       #     args[] = {style: :cell_text}
       #     # row 0 has a grey background and bold text
-      #     args[0] = {font: ['Helvetica', variant: :bold], cell: {background_color: 'eee'}}
+      #     args[0] = {font: 'Helvetica bold', cell: {background_color: 'eee'}}
       #     # text in last column is right aligned
       #     args[0..-1, -1] = {text_align: :right}
       #   end

data/lib/hexapdf/encryption/aes.rb

@@ -112,11 +112,15 @@ module HexaPDF
         # It is assumed that the initialization vector is included in the first BLOCK_SIZE bytes
         # of the data. After the decryption the PKCS#5 padding is removed.
         #
+        # If a problem is encountered, an error message is yielded. If no block is given or if the
+        # supplied block returns +true+, an error is raised.
+        #
         # See: PDF2.0 s7.6.3
-        def decrypt(key, data)
+        def decrypt(key, data) # :yields: error_message
           return data if data.empty? # Handle invalid files with empty strings
           if data.length % BLOCK_SIZE != 0 || data.length < BLOCK_SIZE
-            raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
+            msg = "Invalid data for decryption, need 32 + 16*n bytes"
+            (!block_given? || yield(msg)) && raise(HexaPDF::EncryptionError, msg)
           end
           iv = data.slice!(0, BLOCK_SIZE)
           # Handle invalid files with missing padding
@@ -126,8 +130,9 @@ module HexaPDF
         # Returns a Fiber object that decrypts the data from the given source fiber with the
         # +key+.
         #
-        # Padding and the initialization vector are handled like in #decrypt.
-        def decryption_fiber(key, source)
+        # Padding, the initialization vector and an optionally given block are handled like in
+        # #decrypt.
+        def decryption_fiber(key, source) # :yields: error_message
           Fiber.new do
             data = ''.b
             while data.length < BLOCK_SIZE && source.alive? && (new_data = source.resume)
@@ -145,8 +150,10 @@ module HexaPDF
             end
 
             if data.length % BLOCK_SIZE != 0
-              raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
-            elsif data.empty?
+              msg = "Invalid data for decryption, need 32 + 16*n bytes"
+              (!block_given? || yield(msg)) && raise(HexaPDF::EncryptionError, msg)
+            end
+            if data.empty?
               data # Handle invalid files with missing padding
             else
               unpad(algorithm.process(data))

data/lib/hexapdf/encryption/security_handler.rb

@@ -153,17 +153,18 @@ module HexaPDF
 
         # Creates a new encrypted stream data object by utilizing the given stream data object +obj+
         # as template. The arguments +key+ and +algorithm+ are used for decrypting purposes.
-        def initialize(obj, key, algorithm)
+        def initialize(obj, key, algorithm, &error_block)
           obj.instance_variables.each {|v| instance_variable_set(v, obj.instance_variable_get(v)) }
           @key = key
           @algorithm = algorithm
+          @error_block = error_block
         end
 
         alias undecrypted_fiber fiber
 
         # Returns a fiber like HexaPDF::StreamData#fiber, but one wrapped in a decrypting fiber.
         def fiber(*args)
-          @algorithm.decryption_fiber(@key, super(*args))
+          @algorithm.decryption_fiber(@key, super(*args), &@error_block)
         end
 
       end
@@ -268,17 +269,18 @@ module HexaPDF
       def decrypt(obj)
         return obj if @is_encrypt_dict[obj] || obj.type == :XRef
 
+        error_proc = proc {|msg| document.config['encryption.on_decryption_error'].call(obj, msg) }
         key = object_key(obj.oid, obj.gen, string_algorithm)
         each_string_in_object(obj.value) do |str|
           next if str.empty? || (obj.type == :Sig && obj[:Contents].equal?(str))
-          str.replace(string_algorithm.decrypt(key, str))
+          str.replace(string_algorithm.decrypt(key, str, &error_proc))
         end
 
         if obj.kind_of?(HexaPDF::Stream) && obj.raw_stream.filter[0] != :Crypt
           unless string_algorithm == stream_algorithm
             key = object_key(obj.oid, obj.gen, stream_algorithm)
           end
-          obj.data.stream = EncryptedStreamData.new(obj.raw_stream, key, stream_algorithm)
+          obj.data.stream = EncryptedStreamData.new(obj.raw_stream, key, stream_algorithm, &error_proc)
         end
 
         obj

data/lib/hexapdf/font/cmap/parser.rb

@@ -163,11 +163,7 @@ module HexaPDF
             dest = tokenizer.next_object
 
             if dest.kind_of?(String)
-              codepoint = dest.force_encoding(::Encoding::UTF_16BE).ord
-              code1.upto(code2) do |code|
-                cmap.add_unicode_mapping(code, +'' << codepoint)
-                codepoint += 1
-              end
+              cmap.add_unicode_range_mapping(code1, code2, dest.unpack("n*"))
             elsif dest.kind_of?(Array)
               code1.upto(code2) do |code|
                 str = dest[code - code1].encode!(::Encoding::UTF_8, ::Encoding::UTF_16BE)

data/lib/hexapdf/font/cmap.rb

@@ -100,8 +100,10 @@ module HexaPDF
       # The writing mode of the CMap: 0 for horizontal, 1 for vertical writing.
       attr_accessor :wmode
 
-      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping # :nodoc:
-      protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping
+      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping,
+                  :unicode_range_mappings # :nodoc:
+      protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping,
+                :unicode_range_mappings
 
       # Creates a new CMap object.
       def initialize
@@ -109,6 +111,7 @@ module HexaPDF
         @cid_mapping = {}
         @cid_range_mappings = []
         @unicode_mapping = {}
+        @unicode_range_mappings = []
       end
 
       # Add all mappings from the given CMap to this CMap.
@@ -117,6 +120,7 @@ module HexaPDF
         @cid_mapping.merge!(cmap.cid_mapping)
         @cid_range_mappings.concat(cmap.cid_range_mappings)
         @unicode_mapping.merge!(cmap.unicode_mapping)
+        @unicode_range_mappings.concat(cmap.unicode_range_mappings)
       end
 
       # Add a codespace range using an array of ranges for the individual bytes.
@@ -193,10 +197,25 @@ module HexaPDF
         @unicode_mapping[code] = string
       end
 
+      # Adds a mapping from a range of character codes to strings starting with the given 16-bit
+      # integer values (representing the raw UTF-16BE characters).
+      def add_unicode_range_mapping(start_code, end_code, start_values)
+        @unicode_range_mappings << [start_code..end_code, start_values]
+      end
+
       # Returns the Unicode string in UTF-8 encoding for the given character code, or +nil+ if no
       # mapping was found.
       def to_unicode(code)
-        unicode_mapping[code]
+        @unicode_mapping.fetch(code) do
+          @unicode_range_mappings.reverse_each do |range, start_values|
+            if range.cover?(code)
+              str = start_values[0..-2].append(start_values[-1] + code - range.first).
+                pack('n*').encode(::Encoding::UTF_8, ::Encoding::UTF_16BE)
+              return @unicode_mapping[code] = str
+            end
+          end
+          nil
+        end
       end
 
     end

data/lib/hexapdf/font_loader/from_configuration.rb

@@ -62,7 +62,7 @@ module HexaPDF
       #     Specifies whether the font should be subset if possible.
       #
       # This method uses the FromFile font loader behind the scenes.
-      def self.call(document, name, variant: :none, subset: true)
+      def self.call(document, name, variant: :none, subset: true, **)
         file = document.config['font.map'].dig(name, variant)
         return nil if file.nil?
 

data/lib/hexapdf/font_loader/variant_from_name.rb

@@ -0,0 +1,72 @@
+# -*- 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/font/true_type_wrapper'
+require 'hexapdf/font_loader/from_file'
+
+module HexaPDF
+  module FontLoader
+
+    # This module translates font names like 'Helvetica bold' into the arguments 'Helvetica' and
+    # {variant: :bold}.
+    #
+    # This eases the usage of font names where specifying a font variant is not straight-forward.
+    # The actual loading of the font is deferred to Document::Fonts#add.
+    #
+    # Note that this should be the last entry in the list of font loaders to ensure correct
+    # operation.
+    module VariantFromName
+
+      # Returns a font wrapper for the given font by splitting the font name into the font name part
+      # and variant selector part. If the the resulting font cannot be resolved, +nil+ is returned.
+      #
+      # A font name should have the form 'Fontname selector' where selector can be 'bold', 'italic'
+      # or 'bold_italic', for example 'Helvetica bold'.
+      #
+      # Note that a supplied :variant keyword argument is ignored!
+      def self.call(document, name, recursive_invocation: false, **options)
+        return if recursive_invocation
+        name, variant = name.split(/ (?=(?:bold|italic|bold_italic)\z)/, 2)
+        return if variant.nil?
+
+        options[:variant] = variant.to_sym
+        document.fonts.add(name, **options, recursive_invocation: true) rescue nil
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/font_loader.rb

@@ -88,6 +88,7 @@ module HexaPDF
     autoload(:Standard14, 'hexapdf/font_loader/standard14')
     autoload(:FromConfiguration, 'hexapdf/font_loader/from_configuration')
     autoload(:FromFile, 'hexapdf/font_loader/from_file')
+    autoload(:VariantFromName, 'hexapdf/font_loader/variant_from_name')
 
   end
 

data/lib/hexapdf/layout/style.rb

@@ -614,7 +614,7 @@ module HexaPDF
       # The font to be used, must be set to a valid font wrapper object before it can be used.
       #
       # HexaPDF::Composer handles this property specially in that it resolves a set string or array
-      # to a font wrapper object before doing else with the style object.
+      # to a font wrapper object before doing anything else with the style object.
       #
       # This is the only style property without a default value!
       #
@@ -624,11 +624,12 @@ module HexaPDF
       #
       #   #>pdf-composer100
       #   composer.text("Helvetica", font: composer.document.fonts.add("Helvetica"))
-      #   composer.text("Courier", font: "Courier") # works only with composer
+      #   composer.text("Courier", font: "Courier")
       #
       #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :bold)
       #   composer.text("Helvetica Bold", font: helvetica_bold)
-      #   composer.text("Courier Bold", font: ["Courier", variant: :bold]) # only composer
+      #   composer.text("Courier Bold", font: "Courier bold")
+      #   composer.text("Courier Bold also", font: ["Courier", variant: :bold])
 
       ##
       # :method: font_size
@@ -1413,7 +1414,7 @@ module HexaPDF
       #   #>pdf-composer100
       #   composer.text("This is some longer text that does appear in two lines.")
       #   composer.text("This is some longer text that does not appear in two lines.",
-      #                 height: 15, text_overflow: :truncate)
+      #                 height: 15, overflow: :truncate)
 
       [
         [:font, "raise HexaPDF::Error, 'No font set'"],