hexapdf 0.46.0 → 1.6.0

data/lib/hexapdf/layout/style.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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
@@ -150,14 +150,15 @@ module HexaPDF
         end
 
         # :call-seq:
-        #   quad.set(value)
-        #   quad.set(array)
-        #   quad.set(quad)
+        #   quad.set(value)     -> quad
+        #   quad.set(array)     -> quad
+        #   quad.set(hash)      -> quad
+        #   quad.set(quad)      -> quad
         #
-        # Sets all values of the quad.
+        # Sets all values of the quad and returns it.
         #
-        # * If a single value is provided that is neither a Quad nor an array, it is handled as if
-        #   an array with one value was given.
+        # * If a single value is provided that is neither a Quad nor an array nor a hash, it is
+        #   handled as if an array with one value was given.
         #
         # * If a Quad is provided, its values are used.
         #
@@ -170,6 +171,9 @@ module HexaPDF
         #     third value.
         #   * Four or more values: Top is set to the first, right to the second, bottom to the third
         #     and left to the fourth value.
+        #
+        # * If a hash is provided, the keys +:top+, +:bottom+, +:left+ and +:right+ are used to set
+        #   the respective value. All unspecified keys that have not been set before are set to 0.
         def set(obj)
           case obj
           when Quad
@@ -182,9 +186,15 @@ module HexaPDF
             @bottom = obj[2] || obj[0]
             @left = obj[3] || obj[1] || obj[0]
             @right = obj[1] || obj[0]
+          when Hash
+            @top = obj[:top] || @top || 0
+            @bottom = obj[:bottom] || @bottom || 0
+            @left = obj[:left] || @left || 0
+            @right = obj[:right] || @right || 0
           else
             @top = @bottom = @left = @right = obj
           end
+          self
         end
 
         # Returns +true+ if the quad effectively contains only one value.
@@ -265,7 +275,9 @@ module HexaPDF
             miter_limit(10).
             line_cap_style(line_cap_style(:top))
 
-          canvas.rectangle(x, y, w, h).clip_path.end_path
+          if width.top > w || width.top > h
+            canvas.rectangle(x, y, w, h).clip_path.end_path
+          end
           if style.top == :solid
             canvas.line_dash_pattern(0).
               rectangle(x + offset, y + offset, w - 2 * offset, h - 2 * offset).stroke
@@ -396,6 +408,9 @@ module HexaPDF
       # bottom-left corner of the box during the drawing operations.
       class Layers
 
+        # The array holding all raw layer definitions.
+        attr_reader :layers
+
         # Creates a new Layers object popuplated with the given +layers+.
         def initialize(layers = nil)
           @layers = []
@@ -601,11 +616,36 @@ module HexaPDF
       #   style.update(**properties)    -> style
       #
       # Updates the style's properties using the key-value pairs specified by the +properties+ hash.
+      #
+      # Also see: #merge
       def update(**properties)
         properties.each {|key, value| send(key, value) }
         self
       end
 
+      # Yields all set properties.
+      def each_property # :yield: property, value
+        return to_enum(__method__) unless block_given?
+        instance_variables.each do |iv|
+          (val = PROPERTIES[iv]) && yield(val, instance_variable_get(iv))
+        end
+      end
+
+      # :call-seq:
+      #   style.merge(other_style)   -> style
+      #
+      # Merges the set properties of the +other_style+ object into this one.
+      #
+      # Note that merging is done on a per-property basis. So if a complex property is set on
+      # +other_style+ and also on +self+, the +other_style+ value completely overwrites the one from
+      # +self+.
+      #
+      # Also see: #update
+      def merge(other)
+        other.each_property {|property, value| send(property, value) }
+        self
+      end
+
       ##
       # :method: font
       # :call-seq:
@@ -613,8 +653,9 @@ 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 anything else with the style object.
+      # HexaPDF::Document::Layout handles this property - together with #font_bold and #font_italic
+      # - specially in that it resolves a set string or array to a font wrapper object before doing
+      # anything else with the style object.
       #
       # This is the only style property without a default value!
       #
@@ -631,6 +672,48 @@ module HexaPDF
       #   composer.text("Courier Bold", font: "Courier bold")
       #   composer.text("Courier Bold also", font: ["Courier", variant: :bold])
 
+      ##
+      # :method: font_bold
+      # :call-seq:
+      #   font_bold(bold = false)
+      #
+      # Specifies whether the bold variant of the font is used.
+      #
+      # Note that this property only has affect if #font is not already set to a font wrapper
+      # object and if it is set explicitly (i.e. #font_bold? returns +true+).
+      #
+      # See #font, #font_italic
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.text("Helvetica bold", font: "Helvetica", font_bold: true)
+      #
+      #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :bold)
+      #   composer.text("Helvetica bold", font: helvetica_bold, font_bold: false)
+      #   composer.text("Helvetica", font: ["Helvetica", {variant: :bold}], font_bold: false)
+
+      ##
+      # :method: font_italic
+      # :call-seq:
+      #   font_italic(bold = false)
+      #
+      # Specifies whether the italic variant of the font is used.
+      #
+      # Note that this property only has affect if #font is not already set to a font wrapper
+      # object and if it is set explicitly (i.e. #font_italic? returns +true+).
+      #
+      # See #font, #font_bold.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.text("Helvetica italic", font: "Helvetica", font_italic: true)
+      #
+      #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :italic)
+      #   composer.text("Helvetica italic", font: helvetica_bold, font_italic: false)
+      #   composer.text("Helvetica", font: ["Helvetica", {variant: :italic}], font_italic: false)
+
       ##
       # :method: font_size
       # :call-seq:
@@ -1019,7 +1102,7 @@ module HexaPDF
       #
       # This method can set the line spacing in two ways:
       #
-      # * Using two positional arguments +type+ and +value+.
+      # * Using the positional, mandatory argument +type+ and the optional +value+.
       # * Or a hash with the keys +type+ and +value+.
       #
       # Note that the last line has no additional spacing after it by default. Set #last_line_gap
@@ -1420,8 +1503,33 @@ module HexaPDF
       #   composer.text("This is some longer text that does not appear in two lines.",
       #                 height: 15, overflow: :truncate)
 
-      [
+      ##
+      # :method: box_options
+      # :call-seq:
+      #   box_options(**options)
+      #
+      # Contains initialization arguments for the box instance that is created with this
+      # style. Together with the other style properties this allows the complete specification of a
+      # box instance just via a Style instance.
+      #
+      # Note that this property is only used by the HexaPDF::Document::Layout methods when a box
+      # instance is created. If a box instance is created directly, this property has no effect.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.style(:my_list, box_options: {marker_type: :decimal, item_spacing: 15})
+      #   composer.list(style: :my_list) do |list|
+      #     list.text("This is some text.")
+      #     list.text("This is some other text.")
+      #   end
+
+
+      # :nodoc:
+      PROPERTIES = [
         [:font, "raise HexaPDF::Error, 'No font set'"],
+        [:font_bold, false],
+        [:font_italic, false],
         [:font_size, 10],
         [:line_height, nil],
         [:character_spacing, 0],
@@ -1432,10 +1540,10 @@ module HexaPDF
         [:text_rendering_mode, "Content::TextRenderingMode::FILL",
          {setter: "Content::TextRenderingMode.normalize(value)"}],
         [:subscript, false,
-         {setter: "value; superscript(false) if superscript",
+         {setter: "value; superscript(false) if value && superscript? && superscript",
           valid_values: [true, false]}],
         [:superscript, false,
-         {setter: "value; subscript(false) if subscript",
+         {setter: "value; subscript(false) if value && subscript? && subscript",
           valid_values: [true, false]}],
         [:underline, false, {valid_values: [true, false]}],
         [:strikeout, false, {valid_values: [true, false]}],
@@ -1455,15 +1563,17 @@ module HexaPDF
         [:text_valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) ? " \
-           "{type: value, value: extra_arg} : value))",
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) || " \
+           "value.kind_of?(LineSpacing) ? {type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
         [:fill_horizontal, nil],
         [:background_color, nil],
         [:background_alpha, 1],
-        [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],
-        [:margin, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:padding, "Quad.new(0)",
+         {setter: "value.kind_of?(Hash) && @name ? @name.set(value) : Quad.new(value)"}],
+        [:margin, "Quad.new(0)",
+         {setter: "value.kind_of?(Hash) && @name ? @name.set(value) : Quad.new(value)"}],
         [:border, "Border.new", {setter: "Border.new(**value)"}],
         [:overlays, "Layers.new", {setter: "Layers.new(value)"}],
         [:underlays, "Layers.new", {setter: "Layers.new(value)"}],
@@ -1473,6 +1583,7 @@ module HexaPDF
         [:mask_mode, :default, {valid_values: [:default, :none, :box, :fill_horizontal,
                                                :fill_frame_horizontal, :fill_vertical, :fill]}],
         [:overflow, :error],
+        [:box_options, {}],
       ].each do |name, default, options = {}|
         default = default.inspect unless default.kind_of?(String)
         setter = options.delete(:setter) || "value"
@@ -1498,7 +1609,7 @@ module HexaPDF
           end
         EOF
         alias_method("#{name}=", name)
-      end
+      end.each_with_object({}) {|arr, hash| hash[:"@#{arr.first}"] = arr.first }
 
       ##
       # :method: text_segmentation_algorithm
@@ -1545,9 +1656,9 @@ module HexaPDF
 
       # The calculated text rise, taking superscript and subscript into account.
       def calculated_text_rise
-        if superscript
+        if superscript? && superscript
           text_rise + font_size * 0.33
-        elsif subscript
+        elsif subscript? && subscript
           text_rise - font_size * 0.20
         else
           text_rise
@@ -1556,7 +1667,7 @@ module HexaPDF
 
       # The calculated font size, taking superscript and subscript into account.
       def calculated_font_size
-        (superscript || subscript ? 0.583 : 1) * font_size
+        ((superscript? && superscript) || (subscript? && subscript) ? 0.583 : 1) * font_size
       end
 
       # Returns the correct offset from the baseline for the underline.

data/lib/hexapdf/layout/table_box.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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
@@ -85,6 +85,13 @@ module HexaPDF
     #  #>pdf-composer
     #  composer.table([['A', 'B'], ['C', 'D']])
     #
+    # Each cell can hold zero or more boxes:
+    #
+    #  #>pdf-composer
+    #  cells = [[[layout.text('A'), layout.image(machu_picchu, height: 40)], layout.text('B')],
+    #           [nil, layout.text('D')]]
+    #  composer.table(cells)
+    #
     # The style of the cells can be customized, e.g. to avoid drawing borders:
     #
     #  #>pdf-composer
@@ -104,7 +111,7 @@ module HexaPDF
     # It is also possible to use row and column spans:
     #
     #  #>pdf-composer
-    #  cells = [[{content: layout.text('A'), col_span: 2}, {content: layout.text('B'), row_span: 2}],
+    #  cells = [[{content: layout.text('A'), col_span: 2}, {content: layout.text("B\nB\nB"), row_span: 2}],
     #           [{content: layout.text('C'), col_span: 2, row_span: 2}],
     #           [layout.text('D')]]
     #  composer.table(cells)
@@ -119,6 +126,15 @@ module HexaPDF
     #           [layout.text('E'), layout.text('F')]]
     #  composer.column(height: 90) {|col| col.table(cells, header: header, footer: footer) }
     #
+    # While the width of a cell is determined by the #column_widths array, the height is
+    # automatically determined during fitting of the content. However, it is also possible to use a
+    # fixed height (only if the actual content is smaller or equal than it):
+    #
+    #  #>pdf-composer
+    #  cells = [[{content: layout.text('A'), min_height: 5}, layout.text('B')],
+    #           [{content: layout.text('C'), min_height: 40}, layout.text('D')]]
+    #  composer.table(cells)
+    #
     # The cells can be styled using a callable object for more complex styling:
     #
     #  #>pdf-composer
@@ -184,13 +200,14 @@ module HexaPDF
         attr_accessor :children
 
         # Creates a new Cell instance.
-        def initialize(row:, column:, children: nil, row_span: nil, col_span: nil, **kwargs)
+        def initialize(row:, column:, children: nil, min_height: nil, row_span: nil, col_span: nil, **kwargs)
           super(**kwargs, width: 0, height: 0)
           @children = children
           @row = row
           @column = column
           @row_span = row_span || 1
           @col_span = col_span || 1
+          @min_height = min_height
           style.border.width.set(1) unless style.border?
           style.border.draw_on_bounds = true
           style.padding.set(5) unless style.padding?
@@ -250,6 +267,11 @@ module HexaPDF
             @fit_results = []
             fit_result.success!
           end
+
+          if @min_height && @height < @min_height
+            @height = @preferred_height = @min_height
+            fit_result.failure! if available_height < @height
+          end
         end
 
         # Draws the content of the cell.
@@ -291,6 +313,8 @@ module HexaPDF
       #
       #   +:col_span+:: An integer specifying the number of columsn this cell should span.
       #
+      #   +:min_height+:: A number specifying the minimum height of the table cell.
+      #
       #   +:properties+:: A hash of properties (see Box#properties) to be set on the cell itself.
       #
       #   All other key-value pairs are taken to be cell styling information (like
@@ -382,7 +406,14 @@ module HexaPDF
         def fit_rows(start_row, available_height, column_info, frame)
           height = available_height
           last_fitted_row_index = -1
+          row_heights = {}
+          zero_height_rows = {}
+          row_spans = []
+
           @cells[start_row..-1].each.with_index(start_row) do |columns, row_index|
+            # 1. Fit all columns of the row and record the max height of all non-row-span cells. If
+            #    a row has zero height (usually because it only has row-span cells), record that
+            #    information. Additionally store all cells with row-spans.
             row_fit = true
             row_height = 0
             columns.each_with_index do |cell, col_index|
@@ -396,27 +427,67 @@ module HexaPDF
                 row_fit = false
                 break
               end
-              cell.left = column_info[cell.column].first
-              cell.top = height - available_height
-              row_height = cell.preferred_height if row_height < cell.preferred_height
+              if row_height < cell.preferred_height && cell.row_span == 1
+                row_height = cell.preferred_height
+              end
+              row_spans << cell if cell.row_span > 1
             end
 
-            if row_fit
-              seen = {}
-              columns.each do |cell|
-                next if seen[cell]
-                cell.update_height(cell.row == row_index ? row_height : cell.height + row_height)
-                seen[cell] = true
-              end
+            zero_height_rows[row_index] = true if row_height == 0
 
+            if row_fit
+              # 2. If all cells of the row fit, we subtract the recorded row height of the
+              #    non-row-span cells from the available height for the next pass.
               last_fitted_row_index = row_index
+              row_heights[row_index] = row_height
               available_height -= row_height
+
+              # 3. We look at all row-span cells that end at the current row index. If the row-span
+              #    cell is larger than the sum of the row heights, we proportionally enlarge the
+              #    stored height of each spanned row and subtract the difference from the available
+              #    height for the next pass. If the row span contains initially zero-height rows,
+              #    only those rows are enlarged. Row-span cells themselves are not updated at this
+              #    point!
+              row_spans.each do |cell|
+                upper_row_index = cell.row + cell.row_span - 1
+                next unless upper_row_index == row_index
+
+                rows = cell.row.upto(upper_row_index)
+                row_span_height = rows.sum {|ri| row_heights[ri] }
+                if row_span_height < cell.preferred_height
+                  zero_height_rows_in_span = rows.select {|ri| zero_height_rows[ri] }
+                  rows = zero_height_rows_in_span if zero_height_rows_in_span.size > 0
+                  adjustment = (cell.preferred_height - row_span_height) / rows.size.to_f
+                  rows.each {|ri| row_heights[ri] += adjustment }
+                  available_height -= cell.preferred_height - row_span_height
+                end
+              end
             else
               last_fitted_row_index = columns.min_by(&:row).row - 1 if height != available_height
               break
             end
           end
 
+          if last_fitted_row_index >= 0
+            # 4. Once all possible rows have been fitted and the heights of the rows are fixed, the
+            #    final height and top-left corner of each cell needs to be set.
+            running_height = 0
+            @cells[start_row..last_fitted_row_index].each.with_index(start_row) do |columns, row_index|
+              columns.each_with_index do |cell, col_index|
+                next if cell.row != row_index || cell.column != col_index
+                cell.left = column_info[cell.column].first
+                cell.top = running_height
+                if cell.row_span == 1
+                  cell.update_height(row_heights[row_index])
+                else
+                  new_height = cell.row.upto(cell.row + cell.row_span - 1).sum {|ri| row_heights[ri] }
+                  cell.update_height(new_height)
+                end
+              end
+              running_height += row_heights[row_index]
+            end
+          end
+
           [height - available_height, last_fitted_row_index < start_row ? -1 : last_fitted_row_index]
         end
 
@@ -459,11 +530,12 @@ module HexaPDF
                 children = content.delete(:content)
                 row_span = content.delete(:row_span)
                 col_span = content.delete(:col_span)
+                min_height = content.delete(:min_height)
                 properties = content.delete(:properties)
                 style = content
               end
               cell = Cell.new(children: children, row: row_index, column: col_index,
-                              row_span: row_span, col_span: col_span)
+                              row_span: row_span, col_span: col_span, min_height: min_height)
               cell_style_block&.call(cell)
               cell.style.update(**style) if style
               cell.properties.update(properties) if properties

data/lib/hexapdf/layout/text_box.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/layout/text_fragment.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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
@@ -55,6 +55,10 @@ module HexaPDF
     # The rectangle with the bottom-left corner (#x_min, #y_min) and the top-right corner (#x_max,
     # #y_max) describes the minimum bounding box of the whole text fragment and is usually *not*
     # equal to the box (0, 0)-(#width, #height).
+    #
+    # *Note*: This class should not be used directly but via
+    # HexaPDF::Document::Layout#text_fragments. This way the whole document layout infrastructure
+    # like font fallback and such is automatically used.
     class TextFragment
 
       using NumericRefinements
@@ -64,6 +68,8 @@ module HexaPDF
       # The needed style of the text fragment is specified by the +style+ argument (see
       # Style::create for details). Note that the resulting style object needs at least the font
       # set.
+      #
+      # For internal use, see the note under TextFragment for details.
       def self.create(text, style)
         style = Style.create(style)
         fragment = new(style.font.decode_utf8(text), style)
@@ -90,6 +96,8 @@ module HexaPDF
       # The needed style of the text fragments is specified by the +style+ argument (see
       # Style::create for details). Note that the resulting style object needs at least the font
       # set.
+      #
+      # For internal use, see the note under TextFragment for details.
       def self.create_with_fallback_glyphs(text, style)
         return [create(text, style)] if !block_given? || text.empty?
 
@@ -155,6 +163,8 @@ module HexaPDF
       #
       # The argument +style+ can either be a Style object or a hash of style properties, see
       # Style::create for details.
+      #
+      # For internal use, see the note under TextFragment for details.
       def initialize(items, style, properties: nil)
         @items = items
         @style = Style.create(style)
@@ -235,6 +245,7 @@ module HexaPDF
           end
         end
 
+        in_text_object = (canvas.graphics_object == :text)
         canvas.begin_text
         tlm = canvas.graphics_state.tlm
         tx = x - tlm.e
@@ -248,7 +259,7 @@ module HexaPDF
         elsif ty.abs < PRECISION
           canvas.move_text_cursor(offset: [tx, 0], absolute: false)
         else
-          canvas.move_text_cursor(offset: [x, y])
+          canvas.move_text_cursor(offset: [x, y], absolute: in_text_object)
         end
         canvas.show_glyphs_only(items)
 

data/lib/hexapdf/layout/text_layouter.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/layout/text_shaper.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/layout/width_from_polygon.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/layout.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/name_tree_node.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/number_tree_node.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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

data/lib/hexapdf/object.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2024 Thomas Leitner
+# Copyright (C) 2014-2025 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
@@ -305,8 +305,8 @@ module HexaPDF
       result
     rescue HexaPDF::Error
       raise
-    rescue StandardError
-      yield("Error: Unexpected value encountered", false, self) if block_given?
+    rescue StandardError => e
+      yield("Unexpected error encountered: #{e.message}", false, self) if block_given?
       false
     end
 
@@ -372,7 +372,7 @@ module HexaPDF
 
     # Computes the hash value based on the object and generation numbers.
     def hash
-      oid.hash ^ gen.hash
+      [oid, gen].hash
     end
 
     def inspect #:nodoc: