hexapdf 0.37.2 → 0.39.0

data/lib/hexapdf/layout/list_box.rb

@@ -227,12 +227,12 @@ module HexaPDF
             remove_indent_from_frame_shape(shape) unless shape.polygons.empty?
           end
 
-          item_frame = Frame.new(item_frame_left, top - height, item_frame_width, height,
-                                 shape: shape, context: frame.context)
+          item_frame = frame.child_frame(item_frame_left, top - height, item_frame_width, height,
+                                         shape: shape, box: self)
 
           if index != 0 || !split_box? || @split_box == :show_first_marker
             box = item_marker_box(frame.document, index)
-            marker_frame = Frame.new(0, 0, content_indentation, height, context: frame.context)
+            marker_frame = frame.child_frame(0, 0, content_indentation, height, box: self)
             break unless box.fit(content_indentation, height, marker_frame)
             item_result.marker = box
             item_result.marker_pos_x = item_frame.x - content_indentation
@@ -325,27 +325,30 @@ module HexaPDF
         return @marker_type.call(document, self, index) if @marker_type.kind_of?(Proc)
         return @item_marker_box if defined?(@item_marker_box)
 
+        marker_style = {
+          font: style.font? ? style.font : document.fonts.add("Times"),
+          font_size: style.font_size || 10, fill_color: style.fill_color
+        }
         fragment = case @marker_type
                    when :disc
-                     TextFragment.create("•", font: document.fonts.add("Times"),
-                                         font_size: style.font_size, fill_color: style.fill_color)
+                     TextFragment.create("•", marker_style)
                    when :circle
-                     TextFragment.create("❍", font: document.fonts.add("ZapfDingbats"),
+                     unless marker_style[:font].decode_codepoint("❍".ord).valid?
+                       marker_style[:font] = document.fonts.add("ZapfDingbats")
+                     end
+                     TextFragment.create("❍", **marker_style,
                                          font_size: style.font_size / 2.0,
-                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :square
-                     TextFragment.create("■", font: document.fonts.add("ZapfDingbats"),
+                     unless marker_style[:font].decode_codepoint("■".ord).valid?
+                       marker_style[:font] = document.fonts.add("ZapfDingbats")
+                     end
+                     TextFragment.create("■", **marker_style,
                                          font_size: style.font_size / 2.0,
-                                         fill_color: style.fill_color,
                                          text_rise: -style.font_size / 1.8)
                    when :decimal
                      text = (@start_number + index).to_s << "."
-                     decimal_style = {
-                       font: (style.font? ? style.font : document.fonts.add("Times")),
-                       font_size: style.font_size || 10, fill_color: style.fill_color
-                     }
-                     TextFragment.create(text, decimal_style)
+                     TextFragment.create(text, marker_style)
                    else
                      raise HexaPDF::Error, "Unknown list marker type #{@marker_type.inspect}"
                    end

data/lib/hexapdf/layout/style.rb

@@ -1084,6 +1084,25 @@ module HexaPDF
       #                            'Centered',
       #                            {text: "\u{00a0}", fill_horizontal: 1, overlays: overlays}])
 
+      ##
+      # :method: text_overflow
+      # :call-seq:
+      #   text_overflow(mode = nil)
+      #
+      # Specifies how text overflowing a box with a given initial height should be handled:
+      #
+      # Possible values:
+      #
+      # :error::    An error is raised (default).
+      # :truncate:: Truncates the overflowing text.
+      #
+      # Examples:
+      #
+      #   #>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)
+
       ##
       # :method: background_color
       # :call-seq:
@@ -1435,6 +1454,7 @@ module HexaPDF
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
         [:fill_horizontal, nil],
+        [:text_overflow, :error],
         [:background_color, nil],
         [:background_alpha, 1],
         [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],

data/lib/hexapdf/layout/table_box.rb

@@ -218,7 +218,7 @@ module HexaPDF
           height = available_height - reserved_height
           return false if width <= 0 || height <= 0
 
-          frame = Frame.new(0, 0, width, height, context: frame.context)
+          frame = frame.child_frame(0, 0, width, height, box: self)
           case children
           when Box
             fit_result = frame.fit(children)
@@ -607,6 +607,7 @@ module HexaPDF
         columns = calculate_column_widths(width)
         return false if columns.empty?
 
+        frame = frame.child_frame(box: self)
         @special_cells_fit_not_successful = false
         [@header_cells, @footer_cells].each do |special_cells|
           next unless special_cells

data/lib/hexapdf/layout/text_box.rb

@@ -79,6 +79,7 @@ module HexaPDF
         return false if (@initial_width > 0 && @initial_width > available_width) ||
           (@initial_height > 0 && @initial_height > available_height)
 
+        frame = frame.child_frame(box: self)
         @width = @height = 0
         @result = if style.position == :flow
                     @tl.fit(@items, frame.width_specification, frame.shape.bbox.height,
@@ -104,7 +105,8 @@ module HexaPDF
           @height += style.line_spacing.gap(@result.lines.last, @result.lines.last)
         end
 
-        @result.status == :success
+        @result.status == :success ||
+          (@result.status == :height && @initial_height > 0 && style.text_overflow == :truncate)
       end
 
       # Splits the text box into two boxes if necessary and possible.
@@ -132,7 +134,14 @@ module HexaPDF
 
       # Draws the text into the box.
       def draw_content(canvas, x, y)
-        return unless @result && !@result.lines.empty?
+        return unless @result
+
+        if @result.status == :height && @initial_height > 0 && style.text_overflow == :error
+          raise HexaPDF::Error, "Text doesn't fit into box with limited height and " \
+            "style property text_overflow is set to :error"
+        end
+
+        return if @result.lines.empty?
         @result.draw(canvas, x, y + content_height)
       end
 

data/lib/hexapdf/layout/text_layouter.rb

@@ -307,10 +307,15 @@ module HexaPDF
       class SimpleLineWrapping
 
         # :call-seq:
-        #   SimpleLineWrapping.call(items, width_block) {|line, item| block }   -> rest
+        #   SimpleLineWrapping.call(items, width_block, frame = nil) {|line, item| block }   -> rest
         #
         # Arranges the items into lines.
         #
+        # The optional +frame+ argument needs to be a Frame object that is used when fitting inline
+        # boxes. If not provided, a custom Frame object is used. However, if the items contain
+        # inline boxes that need to access a frame's context object, it is mandatory to provide an
+        # appropriate Frame object.
+        #
         # The +width_block+ argument has to be a callable object that returns the width of the line:
         #
         # * If the line width doesn't depend on the height or the vertical position of the line
@@ -340,7 +345,7 @@ module HexaPDF
         # current start of the line index should be stored for later use.
         #
         # After the algorithm is finished, it returns the unused items.
-        def self.call(items, width_block, frame, &block)
+        def self.call(items, width_block, frame = nil, &block)
           obj = new(items, width_block, frame)
           if width_block.arity == 1
             obj.variable_width_wrapping(&block)
@@ -507,7 +512,7 @@ module HexaPDF
         #
         # Returns +true+ if the item could be added and +false+ otherwise.
         def add_box_item(item)
-          item.fit_wrapped_box(@frame&.context) if item.kind_of?(InlineBox)
+          item.fit_wrapped_box(@frame) if item.kind_of?(InlineBox)
           return false unless @width + item.width <= @available_width
           @line_items.concat(@glue_items).push(item)
           @width += item.width
@@ -718,6 +723,10 @@ module HexaPDF
       #     Specifies whether style.text_indent should be applied to the first line. This should be
       #     set to +false+ if the items start with a continuation of a paragraph instead of starting
       #     a new paragraph (e.g. after a page break).
+      #
+      # +frame+::
+      #     If used with the document layout functionality, this should be the frame into which the
+      #     text is laid out.
       def fit(items, width, height, apply_first_text_indent: true, frame: nil)
         unless items.empty? || items[0].respond_to?(:type)
           items = style.text_segmentation_algorithm.call(items)

data/lib/hexapdf/task/pdfa.rb

@@ -0,0 +1,87 @@
+# -*- 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 'set'
+require 'hexapdf/serializer'
+require 'hexapdf/content/parser'
+require 'hexapdf/content/operator'
+require 'hexapdf/type/xref_stream'
+require 'hexapdf/type/object_stream'
+
+module HexaPDF
+  module Task
+
+    # Task for creating a PDF/A compliant document.
+    #
+    # It automatically
+    #
+    # * prevents the Standard 14 PDF fonts to be used.
+    # * adds an appropriate output intent if none is set.
+    # * adds the necessary PDF/A metadata properties.
+    module PDFA
+
+      # Performs the necessary tasks to make the document PDF/A compatible.
+      #
+      # +level+::
+      #     Specifies the PDF/A conformance level that should be used. Can be one of the following
+      #     strings: 2b, 2u, 3b, 3u.
+      def self.call(doc, level: '3u')
+        unless level.match?(/\A[23][bu]\z/)
+          raise ArgumentError, "The given PDF/A conformance level '#{level}' is not supported"
+        end
+        doc.config['font_loader'].delete('HexaPDF::FontLoader::Standard14')
+        doc.register_listener(:complete_objects) do
+          part, conformance = level.chars
+          doc.metadata.property('pdfaid', 'part', part)
+          doc.metadata.property('pdfaid', 'conformance', conformance.upcase)
+          add_srgb_icc_output_intent(doc) unless doc.catalog.key?(:OutputIntents)
+        end
+      end
+
+      SRGB_ICC = 'sRGB2014.icc' # :nodoc:
+
+      def self.add_srgb_icc_output_intent(doc) # :nodoc:
+        icc = doc.add({N: 3}, stream: File.binread(File.join(HexaPDF.data_dir, SRGB_ICC)))
+        doc.catalog[:OutputIntents] = [
+          doc.add({S: :GTS_PDFA1, OutputConditionIdentifier: SRGB_ICC, Info: SRGB_ICC,
+                   RegistryName: 'https://www.color.org', DestOutputProfile: icc}),
+        ]
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/task.rb

@@ -64,6 +64,7 @@ module HexaPDF
 
     autoload(:Optimize, 'hexapdf/task/optimize')
     autoload(:Dereference, 'hexapdf/task/dereference')
+    autoload(:PDFA, 'hexapdf/task/pdfa')
 
   end
 

data/lib/hexapdf/type/optional_content_properties.rb

@@ -136,7 +136,7 @@ module HexaPDF
         if hash
           self[:D] = hash
         else
-          self[:D] ||= {Creator: 'HexaPDF'}
+          self[:D] ||= {Name: 'Default', Creator: 'HexaPDF'}
         end
         self[:D]
       end
@@ -146,7 +146,7 @@ module HexaPDF
       def perform_validation(&block) # :nodoc:
         unless key?(:D)
           yield('The OptionalContentProperties dictionary needs a default configuration', true)
-          self[:D] = {Creator: 'HexaPDF'}
+          self[:D] = {Name: 'Default', Creator: 'HexaPDF'}
         end
         super
       end

data/lib/hexapdf/type/output_intent.rb

@@ -0,0 +1,85 @@
+# -*- 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/dictionary'
+
+module HexaPDF
+  module Type
+
+    # Represents an output intent dictionary.
+    #
+    # Such a dictionary may be referenced from the catalog's /OutputIntents entry or from the
+    # /OutputIntents entry of a page object.
+    #
+    # See: PDF2.0 s14.11.5, Catalog
+    class OutputIntent < Dictionary
+
+      # Represents a destination output profile reference dictionary.
+      #
+      # Such a dictionary is referenced from the /DestOutputProfileRef entry of an OutputIntent
+      # dictionary.
+      #
+      # See: PDF2.0 s14.11.5
+      class DestOutputProfileRef < Dictionary
+
+        define_type :XXDestOutputProfileRef
+
+        define_field :CheckSum,      type: String,   version: "2.0"
+        define_field :ColorantTable, type: PDFArray, version: "2.0"
+        define_field :ICCVersion,    type: String,   version: "2.0"
+        define_field :ProfileCS,     type: String,   version: "2.0"
+        define_field :ProfileName,   type: String,   version: "2.0"
+        define_field :URLs,          type: PDFArray, version: "2.0"
+
+      end
+
+      define_type :OutputIntent
+
+      define_field :Type, type: Symbol, required: false, default: type
+      define_field :S,    type: Symbol, required: true
+      define_field :OutputCondition,           type: String
+      define_field :OutputConditionIdentifier, type: String, required: true
+      define_field :RegistryName, type: String
+      define_field :Info,         type: String
+      define_field :DestOutputProfile,    type: Stream
+      define_field :DestOutputProfileRef, type: :XXDestOutputProfileRef, version: "2.0"
+      define_field :MixingHints,          type: Dictionary, version: "2.0"
+      define_field :SpectralData,         type: Dictionary, version: "2.0"
+
+    end
+
+  end
+end

data/lib/hexapdf/type.rb

@@ -81,6 +81,7 @@ module HexaPDF
     autoload(:OptionalContentProperties, 'hexapdf/type/optional_content_properties')
     autoload(:OptionalContentConfiguration, 'hexapdf/type/optional_content_configuration')
     autoload(:Metadata, 'hexapdf/type/metadata')
+    autoload(:OutputIntent, 'hexapdf/type/output_intent')
 
   end
 

data/lib/hexapdf/version.rb

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

data/test/hexapdf/document/test_layout.rb

@@ -104,6 +104,13 @@ describe HexaPDF::Document::Layout::CellArgumentCollector do
       @args[5, 6] = {e: :f}
       assert_equal({key: :value, a: :c, e: :f}, @args.retrieve_arguments_for(5, 6))
     end
+
+    it "deep merges the :cell keys" do
+      @args[] = {cell: {a: :b, c: :d}}
+      @args[3..7] = {cell: {a: :y, e: :f}}
+      @args[5, 6] = {cell: {a: :z}}
+      assert_equal({cell: {a: :z, c: :d, e: :f}}, @args.retrieve_arguments_for(5, 6))
+    end
   end
 end
 
@@ -229,6 +236,12 @@ describe HexaPDF::Document::Layout do
       assert_equal(20, box.style.font_size)
 
       box = @layout.text_box("Test", style: {font_size: 20})
+      assert_same(@doc.fonts.add("Times"), box.style.font)
+      assert_equal(20, box.style.font_size)
+
+      @layout.style(:base, font: ['Times', {variant: :bold}])
+      box = @layout.text_box("Test", style: {font_size: 20})
+      assert_same(@doc.fonts.add("Times", variant: :bold), box.style.font)
       assert_equal(20, box.style.font_size)
 
       @layout.style(:named, font_size: 20)

data/test/hexapdf/document/test_metadata.rb

@@ -27,8 +27,8 @@ describe HexaPDF::Document::Metadata do
       assert_equal("de", HexaPDF::Document::Metadata.new(@doc).default_language)
     end
 
-    it "falls back to English if the document doesn't have a default language set" do
-      assert_equal('en', @metadata.default_language)
+    it "falls back to the default language if the document doesn't have a default language set" do
+      assert_equal('x-default', @metadata.default_language)
     end
 
     it "allows changing the default language" do
@@ -80,6 +80,25 @@ describe HexaPDF::Document::Metadata do
     refute(@metadata.instance_variable_get(:@metadata)[@metadata.namespace('dc')].key?('title'))
   end
 
+  describe "delete" do
+    it "deletes all properties" do
+      @metadata.delete
+      assert(@metadata.instance_variable_get(:@metadata).empty?)
+    end
+
+    it "deletes all properties of a single namespace" do
+      @metadata.creator('Test')
+      @metadata.delete('dc')
+      assert_equal('Test', @metadata.creator)
+      refute(@metadata.instance_variable_get(:@metadata).key?(@metadata.namespace('dc')))
+    end
+
+    it "deletes a specific property" do
+      @metadata.delete('dc', 'title')
+      assert_nil(@metadata.title)
+    end
+  end
+
   it "allows reading and setting all info dictionary properties" do
     [['title', 'dc', 'title'], ['author', 'dc', 'creator'], ['subject', 'dc', 'description'],
      ['keywords', 'pdf', 'Keywords'], ['creator', 'xmp', 'CreatorTool'],
@@ -120,6 +139,17 @@ describe HexaPDF::Document::Metadata do
       assert_equal(:True, info[:Trapped])
     end
 
+    it "omits values in the info dictionary that are not set" do
+      @metadata.delete('pdf', 'Trapped')
+      @metadata.delete('dc', 'title')
+      @metadata.delete('dc', 'creator')
+      @doc.write(StringIO.new, update_fields: false)
+      info = @doc.trailer.info
+      refute(info.key?(:Title))
+      refute(info.key?(:Author))
+      refute(info.key?(:Trapped))
+    end
+
     it "uses a correctly updated modification date if set so by Document#write" do
       info = @doc.trailer.info
       sleep(0.1)
@@ -140,6 +170,23 @@ describe HexaPDF::Document::Metadata do
       assert_equal('Subject', info[:Subject])
     end
 
+    it "omits rdf:Description elements without values" do
+      @metadata.delete
+      @doc.write(StringIO.new, update_fields: false)
+      metadata = <<~XMP
+        <?xpacket begin="" id=""?>
+        <x:xmpmeta xmlns:x="adobe:ns:meta/">
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
+        <pdf:Producer>HexaPDF version #{HexaPDF::VERSION}</pdf:Producer>
+        </rdf:Description>
+        </rdf:RDF>
+        </x:xmpmeta>
+        <?xpacket end="r"?>
+      XMP
+      assert_equal(metadata, @doc.catalog[:Metadata].stream.sub(/(?<=id=")\w+/, ''))
+    end
+
     it "writes the XMP metadata" do
       title = HexaPDF::Document::Metadata::LocalizedString.new('Der Titel')
       title.language = 'de'
@@ -147,13 +194,16 @@ describe HexaPDF::Document::Metadata do
       @metadata.author(['Author 1', 'Author 2'])
       @metadata.register_property_type('dc', 'other', 'URI')
       @metadata.property('dc', 'other', 'https://test.org/example')
+      @metadata.property('pdfaid', 'part', 3)
+      @metadata.property('pdfaid', 'conformance', 'b')
       @doc.write(StringIO.new, update_fields: false)
       metadata = <<~XMP
         <?xpacket begin="" id=""?>
+        <x:xmpmeta xmlns:x="adobe:ns:meta/">
         <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
         <rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">
         <dc:title><rdf:Alt>
-        <rdf:li xml:lang="en">Title</rdf:li>
+        <rdf:li xml:lang="x-default">Title</rdf:li>
         <rdf:li xml:lang="de">Der Titel</rdf:li>
         </rdf:Alt></dc:title>
         <dc:creator><rdf:Seq>
@@ -161,13 +211,13 @@ describe HexaPDF::Document::Metadata do
         <rdf:li>Author 2</rdf:li>
         </rdf:Seq></dc:creator>
         <dc:description><rdf:Alt>
-        <rdf:li xml:lang="en">Subject</rdf:li>
+        <rdf:li xml:lang="x-default">Subject</rdf:li>
         </rdf:Alt></dc:description>
         <dc:other rdf:resource="https://test.org/example" />
         </rdf:Description>
         <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
         <pdf:Keywords>Keywords</pdf:Keywords>
-        <pdf:Producer>Producer</pdf:Producer>
+        <pdf:Producer>HexaPDF version #{HexaPDF::VERSION}</pdf:Producer>
         <pdf:Trapped>True</pdf:Trapped>
         </rdf:Description>
         <rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
@@ -175,7 +225,12 @@ describe HexaPDF::Document::Metadata do
         <xmp:CreateDate>#{@metadata.send(:xmp_date, @time)}</xmp:CreateDate>
         <xmp:ModifyDate>#{@metadata.send(:xmp_date, @time)}</xmp:ModifyDate>
         </rdf:Description>
+        <rdf:Description rdf:about="" xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/">
+        <pdfaid:part>3</pdfaid:part>
+        <pdfaid:conformance>b</pdfaid:conformance>
+        </rdf:Description>
         </rdf:RDF>
+        </x:xmpmeta>
         <?xpacket end="r"?>
       XMP
       assert_equal(metadata, @doc.catalog[:Metadata].stream.sub(/(?<=id=")\w+/, ''))

data/test/hexapdf/layout/test_frame.rb

@@ -10,7 +10,8 @@ describe HexaPDF::Layout::Frame::FitResult do
     doc = HexaPDF::Document.new(config: {'debug' => true})
     canvas = doc.pages.add.canvas
     box = HexaPDF::Layout::Box.create(width: 20, height: 20) {}
-    result = HexaPDF::Layout::Frame::FitResult.new(box)
+    frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
+    result = HexaPDF::Layout::Frame::FitResult.new(frame, box)
     result.mask = Geom2D::Rectangle(0, 0, 20, 20)
     result.x = result.y = 0
     result.draw(canvas, dx: 10, dy: 15)
@@ -30,7 +31,8 @@ describe HexaPDF::Layout::Frame::FitResult do
       Q
     CONTENTS
     ocg = doc.optional_content.ocgs.first
-    assert_equal([['Debug', ocg]], doc.optional_content.default_configuration[:Order])
+    assert_equal([['Debug', ['Page 1', ocg]]], doc.optional_content.default_configuration[:Order])
+    assert_match(/10,15-20x20/, ocg.name)
   end
 end
 
@@ -61,6 +63,11 @@ describe HexaPDF::Layout::Frame do
     assert_equal(150, @frame.available_height)
   end
 
+  it "allows access to the frame's parent boxes" do
+    frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150, parent_boxes: [:a])
+    assert_equal([:a], frame.parent_boxes)
+  end
+
   it "allows setting the shape of the frame on initialization" do
     shape = Geom2D::Polygon([50, 10], [55, 100], [105, 100], [105, 10])
     frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150, shape: shape)
@@ -71,6 +78,27 @@ describe HexaPDF::Layout::Frame do
     assert_equal(90, frame.available_height)
   end
 
+  describe "child_frame" do
+    before do
+      @frame = HexaPDF::Layout::Frame.new(10, 10, 100, 100, parent_boxes: [:a])
+    end
+
+    it "duplicates the frame setting the parent boxes appropriately" do
+      assert_same(@frame.parent_boxes, @frame.child_frame.parent_boxes)
+      frame = @frame.child_frame(box: :b)
+      assert_equal([:a, :b], frame.parent_boxes)
+    end
+
+    it "creates a new frame, optionally adding a parent box" do
+      shape = Geom2D::Rectangle(0, 0, 20, 20)
+      frame = @frame.child_frame(0, 0, 20, 20, shape: shape)
+      assert_same(@frame.parent_boxes, frame.parent_boxes)
+      assert_equal(shape, frame.shape)
+      frame = @frame.child_frame(0, 0, 20, 20, box: :b)
+      assert_equal([:a, :b], frame.parent_boxes)
+    end
+  end
+
   it "returns an appropriate width specification object" do
     ws = @frame.width_specification(10)
     assert_kind_of(HexaPDF::Layout::WidthFromPolygon, ws)
@@ -97,6 +125,7 @@ describe HexaPDF::Layout::Frame do
       @canvas.expect(:translate, nil, pos)
       fit_result = @frame.fit(@box)
       refute_nil(fit_result)
+      assert_same(@frame, fit_result.frame)
       @frame.draw(@canvas, fit_result)
       assert_equal(mask, fit_result.mask.bbox.to_a)
       if @frame.shape.respond_to?(:polygons)

data/test/hexapdf/layout/test_inline_box.rb

@@ -31,7 +31,14 @@ describe HexaPDF::Layout::InlineBox do
   end
 
   describe "fit_wrapped_box" do
-    it "automatically fits the provided box into a frame" do
+    it "automatically fits the provided box into the given frame" do
+      ibox = inline_box(HexaPDF::Document.new.layout.text("test is going good", width: 20))
+      ibox.fit_wrapped_box(HexaPDF::Layout::Frame.new(0, 0, 50, 50))
+      assert_equal(20, ibox.width)
+      assert_equal(45, ibox.height)
+    end
+
+    it "automatically fits the provided box into a custom frame" do
       ibox = inline_box(HexaPDF::Document.new.layout.text("test is going good", width: 20))
       ibox.fit_wrapped_box(nil)
       assert_equal(20, ibox.width)