hexapdf 0.33.0 → 0.34.0

data/lib/hexapdf/type/page_label.rb

@@ -103,8 +103,7 @@ module HexaPDF
         end
       end
 
-      # :nodoc:
-      NUMBERING_STYLE_MAPPING = {
+      NUMBERING_STYLE_MAPPING = { # :nodoc:
         decimal: :D, D: :D,
         uppercase_roman: :R, R: :R,
         lowercase_roman: :r, r: :r,
@@ -113,8 +112,7 @@ module HexaPDF
         none: nil
       }
 
-      # :nodoc:
-      REVERSE_NUMBERING_STYLE_MAPPING = Hash[*NUMBERING_STYLE_MAPPING.flatten.reverse]
+      REVERSE_NUMBERING_STYLE_MAPPING = Hash[*NUMBERING_STYLE_MAPPING.flatten.reverse] # :nodoc:
 
       # :call-seq:
       #   page_label.numbering_style             -> numbering_style
@@ -174,8 +172,7 @@ module HexaPDF
 
       private
 
-      # :nodoc:
-      ALPHABET = ('A'..'Z').to_a
+      ALPHABET = ('A'..'Z').to_a # :nodoc:
 
       # Maps the given number to uppercase (or, if +lowercase+ is +true+, lowercase) letters (e.g. 1
       # -> A, 27 -> AA, 28 -> AB, ...).
@@ -188,8 +185,7 @@ module HexaPDF
         lowercase ? result.downcase : result
       end
 
-      # :nodoc:
-      ROMAN_NUMERAL_MAPPING = {
+      ROMAN_NUMERAL_MAPPING = { # :nodoc:
         1000 => "M",
         900 => "CM",
         500 => "D",

data/lib/hexapdf/type.rb

@@ -76,6 +76,10 @@ module HexaPDF
     autoload(:OutlineItem, 'hexapdf/type/outline_item')
     autoload(:PageLabel, 'hexapdf/type/page_label')
     autoload(:MarkInformation, 'hexapdf/type/mark_information')
+    autoload(:OptionalContentGroup, 'hexapdf/type/optional_content_group')
+    autoload(:OptionalContentMembership, 'hexapdf/type/optional_content_membership')
+    autoload(:OptionalContentProperties, 'hexapdf/type/optional_content_properties')
+    autoload(:OptionalContentConfiguration, 'hexapdf/type/optional_content_configuration')
 
   end
 

data/lib/hexapdf/utils/pdf_doc_encoding.rb

@@ -52,7 +52,6 @@ module HexaPDF
     # See: PDF2.0 s7.9.2, D.1, D.3
     module PDFDocEncoding
 
-      # :nodoc:
       CHARACTER_MAP = %W[\uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD
                          \uFFFD \u0009 \u000A \uFFFD \uFFFD \u000D \uFFFD \uFFFD
                          \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD \uFFFD

data/lib/hexapdf/version.rb

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

data/test/hexapdf/content/test_canvas.rb

@@ -71,6 +71,13 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "pos" do
+    it "returns the transformed position" do
+      @canvas.translate(9, 4)
+      assert_equal([10, 5], @canvas.pos(1, 1))
+    end
+  end
+
   describe "save_graphics_state" do
     it "invokes the operator implementation" do
       assert_operator_invoked(:q) { @canvas.save_graphics_state }
@@ -1280,6 +1287,48 @@ describe HexaPDF::Content::Canvas do
     end
   end
 
+  describe "optional_content" do
+    it "invokes the marked-sequence operator implementation" do
+      assert_operator_invoked(:BDC, :OC, :P1) { @canvas.optional_content('Test') }
+    end
+
+    it "is serialized correctly when no block is used" do
+      @canvas.optional_content('Test')
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]]])
+    end
+
+    it "is serialized correctly when a block is used" do
+      @canvas.optional_content('Test') {}
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]],
+                                          [:end_marked_content]])
+    end
+
+    it "uses the provided OCG dictionary" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content(ocg)
+      assert_equal(ocg, @page.resources.property_list(:P1))
+    end
+
+    it "uses an existing OCG specified by name" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content('Test')
+      assert_equal(ocg, @page.resources.property_list(:P1))
+    end
+
+    it "creates an OCG if the named one doesn't yet exist" do
+      @canvas.optional_content('Test')
+      assert_equal(@doc.optional_content.ocg('Test'), @page.resources.property_list(:P1))
+    end
+
+    it "always creates a new OCG if use_existing_ocg is false" do
+      ocg = @doc.optional_content.add_ocg('Test')
+      @canvas.optional_content('Test', use_existing_ocg: false)
+      pl_item = @page.resources.property_list(:P1)
+      refute_equal(ocg, pl_item)
+      assert_equal(@doc.optional_content.ocgs.last, pl_item)
+    end
+  end
+
   describe "color_from_specification "do
     it "accepts a color string" do
       assert_equal([1, 0, 0], @canvas.color_from_specification("red").components)

data/test/hexapdf/document/test_layout.rb

@@ -219,6 +219,10 @@ describe HexaPDF::Document::Layout do
       box = @layout.text_box("Test", box_style: :named)
       assert_equal(20, box.style.font_size)
     end
+
+    it "raises an error if the to-be-used style doesn't exist" do
+      assert_raises(HexaPDF::Error) { @layout.text_box("Test", style: :unknown) }
+    end
   end
 
   describe "formatted_text" do
@@ -305,9 +309,10 @@ describe HexaPDF::Document::Layout do
 
     it "allows creating an inline box through a hash with a :box key" do
       block = lambda {|item| item.box(:base, width: 5, height: 15) }
-      box = @layout.formatted_text_box([{box: :list, width: 10, block: block}])
+      box = @layout.formatted_text_box([{box: :column, columns: 1, width: 100, block: block}])
       ibox = box.instance_variable_get(:@items).first
-      assert_equal(10, ibox.width)
+      ibox.fit_wrapped_box(nil)
+      assert_equal(100, ibox.width)
       assert_equal(15, ibox.height)
     end
 

data/test/hexapdf/document/test_pages.rb

@@ -196,15 +196,15 @@ describe HexaPDF::Document::Pages do
     end
 
     it "works for multiple page label entries" do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :d}, 7, {S: :A}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :D}, 7, {S: :A}]}
       result = @doc.pages.each_labelling_range.to_a
-      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :d}], [7, 3, {S: :A}]],
+      assert_equal([[0, 2, {S: :r}], [2, 5, {S: :D}], [7, 3, {S: :A}]],
                    result.map {|s, c, l| [s, c, l.value] })
     end
 
     it "returns a zero or negative count for the last range if there aren't enough pages" do
       assert_equal(10, @doc.pages.count)
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :d}, 10, {S: :r}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :D}, 10, {S: :r}]}
       assert_equal(0, @doc.pages.each_labelling_range.to_a[-1][1])
       @doc.catalog[:PageLabels][:Nums][2] = 11
       assert_equal(-1, @doc.pages.each_labelling_range.to_a[-1][1])
@@ -221,19 +221,19 @@ describe HexaPDF::Document::Pages do
 
     it "adds an entry for the range starting at 0 if it doesn't exist" do
       label = @doc.pages.add_labelling_range(5)
-      assert_equal([{S: :d}, label],
+      assert_equal([{S: :D}, label],
                    @doc.catalog.page_labels[:Nums].value.values_at(1, 3))
     end
   end
 
   describe "delete_labelling_range" do
     before do
-      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :d}]}
+      @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 5, {S: :D}]}
     end
 
     it "deletes the labelling range for a given start index" do
       label = @doc.pages.delete_labelling_range(5)
-      assert_equal({S: :d}, label)
+      assert_equal({S: :D}, label)
     end
 
     it "deletes the labelling range for 0 if it is the last, together with the number tree" do

data/test/hexapdf/layout/test_box.rb

@@ -56,8 +56,8 @@ describe HexaPDF::Layout::Box do
     end
 
     it "allows setting custom properties" do
-      box = create_box(properties: {'key' => :value})
-      assert_equal({'key' => :value}, box.properties)
+      assert_equal({}, create_box(properties: nil).properties)
+      assert_equal({'key' => :value}, create_box(properties: {'key' => :value}).properties)
     end
   end
 
@@ -150,6 +150,10 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "draw" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
     it "draws the box onto the canvas" do
       box = create_box(width: 150, height: 130) do |canvas, _|
         canvas.line_width(15)
@@ -161,7 +165,6 @@ describe HexaPDF::Layout::Box do
       box.style.underlays.add {|canvas, _| canvas.line_width(10) }
       box.style.overlays.add {|canvas, _| canvas.line_width(20) }
 
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [[:save_graphics_state],
                                           [:set_graphics_state_parameters, [:GS1]],
@@ -195,7 +198,6 @@ describe HexaPDF::Layout::Box do
     end
 
     it "draws nothing onto the canvas if the box is empty" do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
       box = create_box
       box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [])
@@ -204,6 +206,13 @@ describe HexaPDF::Layout::Box do
       refute(box.style.border?)
       refute(box.style.overlays?)
     end
+
+    it "wraps the box in optional content markers if the optional_content property is set" do
+      box = create_box(properties: {'optional_content' => 'Text'})
+      box.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:OC, :P1]],
+                                          [:end_marked_content]])
+    end
   end
 
   describe "empty?" do

data/test/hexapdf/layout/test_frame.rb

@@ -5,7 +5,7 @@ require 'hexapdf/layout/frame'
 require 'hexapdf/layout/box'
 require 'hexapdf/document'
 
-describe HexaPDF::Layout::Frame do
+describe HexaPDF::Layout::Frame::FitResult do
   it "shows the box's mask area on #draw when using debug output" do
     doc = HexaPDF::Document.new(config: {'debug' => true})
     canvas = doc.pages.add.canvas
@@ -15,6 +15,7 @@ describe HexaPDF::Layout::Frame do
     result.x = result.y = 0
     result.draw(canvas)
     assert_equal(<<~CONTENTS, canvas.contents)
+      /OC /P1 BDC
       q
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
@@ -22,10 +23,13 @@ describe HexaPDF::Layout::Frame do
       0 0 20 20 re
       B
       Q
+      EMC
       q
       1 0 0 1 0 0 cm
       Q
     CONTENTS
+    ocg = doc.optional_content.ocgs.first
+    assert_equal([['Debug', ocg]], doc.optional_content.default_configuration[:Order])
   end
 end
 
@@ -34,6 +38,14 @@ describe HexaPDF::Layout::Frame do
     @frame = HexaPDF::Layout::Frame.new(5, 10, 100, 150)
   end
 
+  it "allows accessing the context's document" do
+    assert_nil(@frame.document)
+    context = Minitest::Mock.new
+    context.expect(:document, :document)
+    assert_equal(:document, HexaPDF::Layout::Frame.new(0, 0, 10, 10, context: context).document)
+    context.verify
+  end
+
   it "allows access to the bounding box attributes" do
     assert_equal(5, @frame.left)
     assert_equal(10, @frame.bottom)

data/test/hexapdf/layout/test_inline_box.rb

@@ -24,25 +24,28 @@ describe HexaPDF::Layout::InlineBox do
       assert_equal(:top, ibox.valign)
     end
 
+    it "fails if the wrapped box has not width set" do
+      box = HexaPDF::Document.new.layout.text("test is not going good")
+      assert_raises(HexaPDF::Error) { inline_box(box) }
+    end
+  end
+
+  describe "fit_wrapped_box" do
     it "automatically fits the provided box into a 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)
       assert_equal(45, ibox.height)
     end
 
-    it "fails if the wrapped box has not width set" do
-      box = HexaPDF::Document.new.layout.text("test is not going good")
-      assert_raises(HexaPDF::Error) { inline_box(box) }
-    end
-
     it "fails if the wrapped box could not be fit" do
       box = HexaPDF::Document.new.layout.text("test is not going good", width: 1)
-      assert_raises(HexaPDF::Error) { inline_box(box) }
+      assert_raises(HexaPDF::Error) { inline_box(box).fit_wrapped_box(nil) }
     end
 
     it "fails if the height is not set explicitly and during fitting" do
       assert_raises(HexaPDF::Error) do
-        inline_box(HexaPDF::Layout::Box.create(width: 10))
+        inline_box(HexaPDF::Layout::Box.create(width: 10)).fit_wrapped_box(nil)
       end
     end
   end
@@ -50,7 +53,9 @@ describe HexaPDF::Layout::InlineBox do
   it "draws the wrapped box at the correct position" do
     doc = HexaPDF::Document.new
     canvas = doc.pages.add.canvas
-    inline_box(doc.layout.text("", width: 20, margin: [15, 10])).draw(canvas, 100, 200)
+    box = inline_box(doc.layout.text("", width: 20, margin: [15, 10]))
+    box.fit_wrapped_box(nil)
+    box.draw(canvas, 100, 200)
     assert_equal("q\n1 0 0 1 110 -99785 cm\nQ\n", canvas.contents)
   end
 
@@ -59,6 +64,10 @@ describe HexaPDF::Layout::InlineBox do
     refute(HexaPDF::Layout::InlineBox.create(width: 10, height: 15) {}.empty?)
   end
 
+  it "returns the style of the box" do
+    assert_same(@box.box.style, @box.style)
+  end
+
   describe "valign" do
     it "has a default value of :baseline" do
       assert_equal(:baseline, @box.valign)

data/test/hexapdf/layout/test_list_box.rb

@@ -6,7 +6,9 @@ require 'hexapdf/layout/list_box'
 
 describe HexaPDF::Layout::ListBox do
   before do
-    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100, context: @page)
     inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
     @text_boxes = 5.times.map do
       HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
@@ -23,8 +25,8 @@ describe HexaPDF::Layout::ListBox do
     assert_equal(height, box.height, "box height")
     if fit_pos
       results = box.instance_variable_get(:@results)
-      results.each_with_index do |box_fitter, item_index|
-        box_fitter.fit_results.each_with_index do |fit_result, result_index|
+      results.each_with_index do |item_result, item_index|
+        item_result.box_fitter.fit_results.each_with_index do |fit_result, result_index|
           x, y = fit_pos.shift
           assert_equal(x, fit_result.x, "item #{item_index}, result #{result_index}, x")
           assert_equal(y, fit_result.y, "item #{item_index}, result #{result_index}, y")
@@ -55,7 +57,7 @@ describe HexaPDF::Layout::ListBox do
     it "is empty if nothing could be fit" do
       box = create_box(children: [@text_boxes[0]], width: 5)
       box.fit(@frame.available_width, @frame.available_height, @frame)
-      assert(create_box.empty?)
+      assert(box.empty?)
     end
   end
 
@@ -90,6 +92,12 @@ describe HexaPDF::Layout::ListBox do
       check_box(box, 100, 90, [[10, 80], [10, 60], [10, 40], [50, 10]])
     end
 
+    it "calculates the correct height if the marker is higher than the content" do
+      box = create_box(children: @text_boxes[0, 1], content_indentation: 20,
+                       style: {font_size: 30})
+      check_box(box, 100, 27, [[20, 80]])
+    end
+
     it "respects the content indentation" do
       box = create_box(children: @text_boxes[0, 1], content_indentation: 30)
       check_box(box, 100, 30, [[30, 70]])
@@ -99,6 +107,11 @@ describe HexaPDF::Layout::ListBox do
       box = create_box(children: @text_boxes[0, 2], item_spacing: 30)
       check_box(box, 100, 70, [[10, 80], [10, 30]])
     end
+
+    it "fails for unknown item types" do
+      box = create_box(children: @text_boxes[0, 1], item_type: :unknown)
+      assert_raises(HexaPDF::Error) { box.fit(100, 100, @frame) }
+    end
   end
 
   describe "split" do
@@ -108,7 +121,7 @@ describe HexaPDF::Layout::ListBox do
       box_a, box_b = box.split(100, 100, @frame)
       assert_same(box, box_a)
       assert_equal(:show_first_marker, box_b.split_box?)
-      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
       assert_equal(1, box_b.children.size)
       assert_equal(2, box_b.start_number)
     end
@@ -119,7 +132,7 @@ describe HexaPDF::Layout::ListBox do
       box_a, box_b = box.split(100, 100, @frame)
       assert_same(box, box_a)
       assert_equal(:hide_first_marker, box_b.split_box?)
-      assert_equal(1, box_a.instance_variable_get(:@results)[0].fit_results.size)
+      assert_equal(1, box_a.instance_variable_get(:@results)[0].box_fitter.fit_results.size)
       assert_equal(2, box_b.children.size)
       assert_equal(1, box_b.start_number)
     end
@@ -127,20 +140,22 @@ describe HexaPDF::Layout::ListBox do
 
   describe "draw" do
     before do
-      @canvas = HexaPDF::Document.new.pages.add.canvas
+      @canvas = @page.canvas
       draw_block = lambda {|canvas, box| }
       @fixed_size_boxes = 5.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }
     end
 
     it "draws the result" do
-      box = create_box(children: @fixed_size_boxes[0, 2])
+      box = create_box(children: @fixed_size_boxes[0, 2],
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.5, 93.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 1.15, 92.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -149,9 +164,10 @@ describe HexaPDF::Layout::ListBox do
         [:restore_graphics_state],
 
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.5, 83.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 1.15, 82.487]],
         [:show_text, ["\x95".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -162,16 +178,18 @@ describe HexaPDF::Layout::ListBox do
       assert_operators(@canvas.contents, operators)
     end
 
-    it "draws a cicle as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle)
+    it "draws a circle as marker" do
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :circle,
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 5]],
-        [:set_text_rise, [-5.555556]],
+        [:set_font_and_size, [:F1, 5.5]],
+        [:set_text_rise, [-6.111111]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 0.635, 100]],
+        [:set_text_matrix, [1, 0, 0, 1, 0.1985, 100]],
         [:show_text, ["m".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -183,15 +201,17 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "draws a square as marker" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square)
+      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :square,
+                       style: {font_size: 11, fill_color: 0.5})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 5]],
-        [:set_text_rise, [-5.555556]],
+        [:set_font_and_size, [:F1, 5.5]],
+        [:set_text_rise, [-6.111111]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 1.195, 100]],
+        [:set_text_matrix, [1, 0, 0, 1, 0.8145, 100]],
         [:show_text, ["n".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -204,14 +224,16 @@ describe HexaPDF::Layout::ListBox do
 
     it "draws decimal numbers as marker" do
       box = create_box(children: @fixed_size_boxes[0, 2], item_type: :decimal,
+                       style: {font_size: 11, fill_color: 0.5},
                        content_indentation: 20)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 100 - box.height)
       operators = [
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 7.5, 93.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 6.75, 92.487]],
         [:show_text, ["1.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -220,9 +242,10 @@ describe HexaPDF::Layout::ListBox do
         [:restore_graphics_state],
 
         [:save_graphics_state],
-        [:set_font_and_size, [:F1, 10]],
+        [:set_font_and_size, [:F1, 11]],
+        [:set_device_gray_non_stroking_color, [0.5]],
         [:begin_text],
-        [:set_text_matrix, [1, 0, 0, 1, 7.5, 83.17]],
+        [:set_text_matrix, [1, 0, 0, 1, 6.75, 82.487]],
         [:show_text, ["2.".b]],
         [:end_text],
         [:restore_graphics_state],
@@ -272,11 +295,5 @@ describe HexaPDF::Layout::ListBox do
       ]
       assert_operators(@canvas.contents, operators)
     end
-
-    it "fails for unknown item types" do
-      box = create_box(children: @fixed_size_boxes[0, 1], item_type: :unknown)
-      box.fit(100, 100, @frame)
-      assert_raises(HexaPDF::Error) { box.draw(@canvas, 0, 0) }
-    end
   end
 end

data/test/hexapdf/layout/test_style.rb

@@ -580,7 +580,10 @@ describe HexaPDF::Layout::Style::LinkLayer do
     it "fails if more than one possible target is chosen" do
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, uri: true) }
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, file: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(dest: true, action: true) }
       assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(uri: true, file: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(uri: true, action: true) }
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style::LinkLayer.new(file: true, action: true) }
     end
 
     it "fails if an invalid border is provided" do
@@ -656,6 +659,12 @@ describe HexaPDF::Layout::Style::LinkLayer do
       assert_nil(annot[:Dest])
     end
 
+    it "works for actions" do
+      annot = call_link(action: {Type: :Action, S: :SetOCGState})
+      assert_equal({Type: :Action, S: :SetOCGState}, annot[:A].value)
+      assert_nil(annot[:Dest])
+    end
+
     it "works for destinations set via the 'link' custom box property" do
       @box.properties['link'] = [@canvas.context, :FitH]
       annot = call_link({})
@@ -773,6 +782,7 @@ describe HexaPDF::Layout::Style do
     refute(@style.subscript)
     refute(@style.superscript)
     refute(@style.last_line_gap)
+    refute(@style.fill_horizontal)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.underlays)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.overlays)
   end