hexapdf 0.32.2 → 0.33.0

data/lib/hexapdf/type/xref_stream.rb

@@ -65,7 +65,7 @@ module HexaPDF
     # cross-reference section and trailer information and then written. Otherwise a normal
     # cross-reference section plus trailer are written.
     #
-    # See: PDF1.7 s7.5.8
+    # See: PDF2.0 s7.5.8
     class XRefStream < HexaPDF::Stream
 
       define_type :XRef
@@ -161,7 +161,7 @@ module HexaPDF
             when TYPE_COMPRESSED
               xref.add_compressed_entry(oid, field2, field3)
             else
-              nil # Ignore entry as per PDF1.7 s7.5.8.3
+              nil # Ignore entry as per PDF2.0 s7.5.8.3
             end
             start_pos = end_pos
           end

data/lib/hexapdf/utils/pdf_doc_encoding.rb

@@ -49,7 +49,7 @@ module HexaPDF
     # When a PDF file is written, text strings are automatically encoded in either PDFDocEncoding
     # or UTF-16BE depending on the characters in the text string.
     #
-    # See: PDF1.7 s7.9.2, D.1, D.3
+    # See: PDF2.0 s7.9.2, D.1, D.3
     module PDFDocEncoding
 
       # :nodoc:

data/lib/hexapdf/version.rb

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

data/lib/hexapdf/writer.rb

@@ -124,7 +124,7 @@ module HexaPDF
 
     # Writes the PDF file header.
     #
-    # See: PDF1.7 s7.5.2
+    # See: PDF2.0 s7.5.2
     def write_file_header
       @io << "%PDF-#{@document.version}\n%\xCF\xEC\xFF\xE8\xD7\xCB\xCD\n"
     end
@@ -225,7 +225,7 @@ module HexaPDF
 
     # Writes the cross-reference section.
     #
-    # See: PDF1.7 s7.5.4
+    # See: PDF2.0 s7.5.4
     def write_xref_section(xref_section)
       @io << "xref\n"
       xref_section.each_subsection do |entries|
@@ -245,14 +245,14 @@ module HexaPDF
 
     # Writes the trailer dictionary.
     #
-    # See: PDF1.7 s7.5.5
+    # See: PDF2.0 s7.5.5
     def write_trailer(trailer)
       @io << "trailer\n#{@serializer.serialize(trailer)}\n"
     end
 
     # Writes the startxref line needed for cross-reference sections and cross-reference streams.
     #
-    # See: PDF1.7 s7.5.5, s7.5.8
+    # See: PDF2.0 s7.5.5, s7.5.8
     def write_startxref(startxref)
       @io << "startxref\n#{startxref}\n%%EOF\n"
     end

data/lib/hexapdf/xref_section.rb

@@ -46,7 +46,7 @@ module HexaPDF
   #
   # Note that a cross-reference section may contain a single object number only once.
   #
-  # See: HexaPDF::Revision, PDF1.7 s7.5.4, s7.5.8
+  # See: HexaPDF::Revision, PDF2.0 s7.5.4, s7.5.8
   class XRefSection < Utils::ObjectHash
 
     # One entry of a cross-reference section or stream.
@@ -69,7 +69,7 @@ module HexaPDF
     #
     #               Objects in an object stream always have a generation number of 0!
     #
-    # See: PDF1.7 s7.5.4, s7.5.8
+    # See: PDF2.0 s7.5.4, s7.5.8
     Entry = Struct.new(:type, :oid, :gen, :pos, :objstm) do
       def free?
         type == :free

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -16,13 +16,15 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
       assert_equal(0, arc.inclination)
       assert(arc.large_arc)
       refute(arc.clockwise)
+      assert_nil(arc.max_curves)
     end
   end
 
   describe "configure" do
     it "changes the values" do
       arc = HexaPDF::Content::GraphicObject::EndpointArc.new
-      arc.configure(x: 1, y: 2, a: 3, b: 4, inclination: 5, large_arc: false, clockwise: true)
+      arc.configure(x: 1, y: 2, a: 3, b: 4, inclination: 5, large_arc: false, clockwise: true,
+                    max_curves: 8)
       assert_equal(1, arc.x)
       assert_equal(2, arc.y)
       assert_equal(3, arc.a)
@@ -30,6 +32,7 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
       assert_equal(5, arc.inclination)
       refute(arc.large_arc)
       assert(arc.clockwise)
+      assert_equal(8, arc.max_curves)
     end
   end
 
@@ -94,5 +97,12 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
                   clockwise: false)
       assert_equal(arc_data, @page.contents)
     end
+
+    it "assigns the max curves to the generated arc" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      arc.configure(a: 1, b: 1, x: -1, y: 0, max_curves: 10)
+      hash = arc.send(:compute_arc_values, 1, 0)
+      assert_equal(10, hash[:max_curves])
+    end
   end
 end

data/test/hexapdf/content/graphic_object/test_geom2d.rb

@@ -51,6 +51,13 @@ describe HexaPDF::Content::GraphicObject::Geom2D do
                        [[:move_to, [5, 6]], [:line_to, [10, 11]], [:stroke_path]])
     end
 
+    it "draws a Geom2D::Rectangle onto the canvas" do
+      @obj.object = Geom2D::Rectangle(5, 6, 20, 50)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:append_rectangle, [5, 6, 20, 50]], [:stroke_path]])
+    end
+
     it "draws a Geom2D::Polygon onto the canvas" do
       @obj.object = Geom2D::Polygon([5, 6], [10, 11], [7, 9])
       @obj.draw(@canvas)

data/test/hexapdf/content/test_canvas.rb

@@ -1193,7 +1193,6 @@ describe HexaPDF::Content::Canvas do
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 10]],
                                           [:begin_text],
                                           [:set_text_matrix, [1, 0, 0, 1, 100, 100]],
-                                          [:set_leading, [10]],
                                           [:show_text_with_positioning, [["Hallo"]]]])
     end
 

data/test/hexapdf/digital_signature/test_signatures.rb

@@ -107,6 +107,28 @@ describe HexaPDF::DigitalSignature::Signatures do
       assert_equal(1, field.each_widget.count)
     end
 
+    it "creates an empty widget on the first page for the signature field if necessary" do
+      @doc.pages.add
+      field = @doc.acro_form(create: true).create_signature_field('Signature2')
+      field.field_value = sig = @doc.add({Type: :Sig, key: :value})
+      @doc.signatures.add(@io, @handler, signature: sig)
+      widgets = field.each_widget.to_a
+      assert_equal(1, widgets.size)
+      assert_equal(@doc.pages[0], widgets[0][:P])
+      assert_equal([0, 0, 0, 0], widgets[0][:Rect])
+    end
+
+    it "handles a bug in Adobe Acrobat related to images not showing without a /Resources entry" do
+      field = @doc.acro_form(create: true).create_signature_field('Signature')
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, ColorSpace: :DeviceGray,
+                        BitsPerComponent: 8}, stream: 'A')
+      field.create_widget(@doc.pages[0], Rect: [0, 0, 100, 100]).create_appearance.
+        canvas.xobject(image, at: [0, 0])
+      @doc.signatures.add(@io, @handler, signature: field)
+      assert(image.key?(:Resources))
+      assert_equal({}, image[:Resources])
+    end
+
     it "handles different xref section types correctly when determing the offsets" do
       @doc.delete(7)
       sig = @doc.signatures.add(@io, @handler, write_options: {update_fields: false})

data/test/hexapdf/document/test_files.rb

@@ -55,8 +55,8 @@ describe HexaPDF::Document::Files do
       spec2 = @doc.add({Type: :Filespec})
       @doc.pages.add # page without annot
       @doc.pages.add[:Annots] = [
-        {Subtype: :FileAttachment, FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
-        {Subtype: :FileAttachment, FS: spec2},
+        {Subtype: :FileAttachment, Rect: [0, 0, 0, 0], FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
+        {Subtype: :FileAttachment, Rect: [0, 0, 0, 0], FS: spec2},
         {},
       ]
       assert_equal([spec1, spec2], @doc.files.to_a)

data/test/hexapdf/document/test_layout.rb

@@ -59,6 +59,54 @@ describe HexaPDF::Document::Layout::ChildrenCollector do
   end
 end
 
+describe HexaPDF::Document::Layout::CellArgumentCollector do
+  before do
+    @args = HexaPDF::Document::Layout::CellArgumentCollector.new(20, 10)
+  end
+
+  describe "[]" do
+    def check_argument_info(info, rows, cols, args)
+      assert_equal(rows, info.rows)
+      assert_equal(cols, info.cols)
+      assert_equal(args, info.args)
+    end
+
+    it "allows assigning to all cells" do
+      @args[] = {key: :value}
+      check_argument_info(@args.argument_infos.first, 0..19, 0..9, {key: :value})
+    end
+
+    it "allows assigning to all columns of a range of rows" do
+      @args[1..4] = {key: :value}
+      check_argument_info(@args.argument_infos.first, 1..4, 0..9, {key: :value})
+    end
+
+    it "allows assigning to the intersection of a range of rows with a range of columns" do
+      @args[1..4, 3..5] = {key: :value}
+      check_argument_info(@args.argument_infos.first, 1..4, 3..5, {key: :value})
+    end
+
+    it "allows selecting a single row or column" do
+      @args[1, 3] = {key: :value}
+      check_argument_info(@args.argument_infos.first, 1..1, 3..3, {key: :value})
+    end
+
+    it "allows using negative indices" do
+      @args[-3..-1, -5..-2] = {key: :value}
+      check_argument_info(@args.argument_infos.first, 17..19, 5..8, {key: :value})
+    end
+  end
+
+  describe "retrieve_arguments_for" do
+    it "merges all argument hashes, with later defined ones overridding prior ones" do
+      @args[] = {key: :value, a: :b}
+      @args[3..7] = {a: :c}
+      @args[5, 6] = {e: :f}
+      assert_equal({key: :value, a: :c, e: :f}, @args.retrieve_arguments_for(5, 6))
+    end
+  end
+end
+
 describe HexaPDF::Document::Layout do
   before do
     @doc = HexaPDF::Document.new
@@ -290,6 +338,56 @@ describe HexaPDF::Document::Layout do
     end
   end
 
+  describe "table_box" do
+    it "creates a table box" do
+      box = @layout.table_box([['m']], column_widths: [100], header: proc { [['a']] },
+                              footer: proc { [['b']] }, cell_style: {background_color: "red"},
+                              width: 100, height: 300, style: {background_color: "blue"},
+                              properties: {key: :value}, border: {width: 1})
+      assert_equal(100, box.width)
+      assert_equal(300, box.height)
+      assert_equal("blue", box.style.background_color)
+      assert_equal(1, box.style.border.width.left)
+      assert_equal({key: :value}, box.properties)
+      assert_equal(HexaPDF::Layout::TextBox, box.cells[0, 0].children.class)
+      assert_equal([100], box.column_widths)
+      assert_equal('a', box.header_cells[0, 0].children)
+      assert_equal('b', box.footer_cells[0, 0].children)
+    end
+
+    it "doesn't modify the children of cells if they are already in the correct form" do
+      image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
+      cell0 = @layout.text('a')
+      cell1 = [@layout.text('b'), @layout.image(image_path)]
+      box = @layout.table_box([[cell0, cell1]])
+      assert_same(cell0, box.cells[0, 0].children)
+      assert_same(cell1, box.cells[0, 1].children)
+    end
+
+    it "converts cells containing other than Box and Array instances" do
+      box = @layout.table_box([['a', 5]])
+      assert_kind_of(HexaPDF::Layout::TextBox, box.cells[0, 0].children)
+      assert_kind_of(HexaPDF::Layout::TextBox, box.cells[0, 1].children)
+    end
+
+    it "allows customizing the creation arguments" do
+      box = @layout.table_box([['a']]) do |args|
+        args[] = {font_size: 20}
+      end
+      assert_equal(20, box.cells[0, 0].children.style.font_size)
+      refute_equal(20, box.cells[0, 0].style.font_size)
+    end
+
+    it "allows styling table cells themselves" do
+      box = @layout.table_box([['a', @layout.text('b')]]) do |args|
+        args[] = {cell: {background_color: "green"}}
+      end
+      assert_equal('green', box.cells[0, 0].style.background_color)
+      assert_nil(box.cells[0, 0].children.style.background_color)
+      assert_equal('green', box.cells[0, 1].style.background_color)
+    end
+  end
+
   describe "lorem_ipsum_box" do
     it "creates a standard lorem ipsum box" do
       box = @layout.lorem_ipsum_box(width: 10, height: 15, font_size: 15)

data/test/hexapdf/encryption/test_security_handler.rb

@@ -17,13 +17,6 @@ describe HexaPDF::Encryption::EncryptionDictionary do
     assert(@dict.must_be_indirect?)
   end
 
-  it "validates the /V value" do
-    @dict[:V] = 1
-    assert(@dict.validate)
-    @dict[:V] = 3
-    refute(@dict.validate)
-  end
-
   it "validates the /Length field when /V=2" do
     @dict[:V] = 2
     refute(@dict.validate)
@@ -240,6 +233,7 @@ describe HexaPDF::Encryption::SecurityHandler do
         [:identity, 128, {V: 4, StrF: :Mine, CF: {Mine: {CFM: :None}}}],
         [:identity, 128, {V: 4, CF: {Mine: {CFM: :AESV2}}}],
       ].each do |alg, length, dict|
+        dict[:Filter] = :Test
         @enc.strf = alg
         @enc.set_up_encryption(key_length: length, algorithm: (alg == :identity ? :aes : alg))
         @obj[:X] = @enc.encrypt_string('data', @obj)
@@ -249,7 +243,7 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "selects the correct algorithm for string, stream and embedded file decryption" do
-      @handler.set_up_decryption({V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
+      @handler.set_up_decryption({Filter: :Test, V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
                                   CF: {Mine: {CFM: :V2}}})
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:embedded_file_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:string_algorithm))
@@ -263,16 +257,23 @@ describe HexaPDF::Encryption::SecurityHandler do
                    @handler.encryption_details)
     end
 
+    it "fails if the encryption dictionary is not valid" do
+      exp = assert_raises(HexaPDF::Error) do
+        @handler.set_up_decryption({V: 5})
+      end
+      assert_match(/Validation error for encryption dictionary.*Required field Filter/i, exp.message)
+    end
+
     it "fails for unsupported /V values in the dict" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({V: 3})
+        @handler.set_up_decryption({Filter: :Text, V: 3})
       end
       assert_match(/Unsupported encryption version/i, exp.message)
     end
 
     it "fails for unsupported crypt filter encryption methods" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}}})
+        @handler.set_up_decryption({Filter: :Test, V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}}})
       end
       assert_match(/Unsupported encryption method/i, exp.message)
     end
@@ -280,7 +281,7 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   describe "decrypt" do
     before do
-      @handler.set_up_decryption({V: 1})
+      @handler.set_up_decryption({Filter: :Test, V: 1})
       @encrypted = @handler.encrypt_string('string', @obj)
       @obj.value = {Key: @encrypted.dup, Array: [@encrypted.dup], Hash: {Another: @encrypted.dup}}
     end

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -21,13 +21,6 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
     @dict[:Perms] = 'test' * 8
   end
 
-  it "validates the /R value" do
-    @dict[:R] = 2
-    assert(@dict.validate)
-    @dict[:R] = 5
-    refute(@dict.validate)
-  end
-
   [:U, :O].each do |field|
     it "validates the length of /#{field} field for R <= 4" do
       @dict[field] = 'test'
@@ -35,19 +28,36 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
     end
   end
 
-  [:U, :O, :UE, :OE, :Perms].each do |field|
-    it "validates the length of /#{field} field for R=6" do
+  describe "validation for R=6" do
+    before do
       @dict[:R] = 6
-      @dict[field] = 'test'
-      refute(@dict.validate)
+      @dict[:U] = 't' * 48
+      @dict[:O] = 't' * 48
+      @dict[:UE] = 't' * 32
+      @dict[:OE] = 't' * 32
+      @dict[:Perms] = 't' * 16
     end
-  end
 
-  [:UE, :OE, :Perms].each do |field|
-    it "validates the existence of the /#{field} field for R=6" do
-      @dict[:R] = 6
-      @dict.delete(field)
-      refute(@dict.validate)
+    [:U, :O, :UE, :OE, :Perms].each do |field|
+      it "validates the length of /#{field}" do
+        @dict[field] = 'test'
+        refute(@dict.validate)
+      end
+    end
+
+    [:U, :O].each do |field|
+      it "auto-corrects /#{field} if it is larger and only padded with 0 bytes" do
+        @dict[field] = 't' * 48 + "\x00" * 20
+        assert(@dict.validate)
+        assert_equal('t' * 48, @dict[field])
+      end
+    end
+
+    [:UE, :OE, :Perms].each do |field|
+      it "validates the existence of the /#{field} field" do
+        @dict.delete(field)
+        refute(@dict.validate)
+      end
     end
   end
 end
@@ -211,22 +221,24 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   describe "prepare_decryption" do
     it "fails if the /Filter value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({Filter: :NonStandard, V: 2})
+        @handler.set_up_decryption({Filter: :NonStandard, V: 2, R: 4, O: 't' * 32, U: 't' * 32, P: 0,
+                                   Length: 128})
       end
       assert_match(/Invalid \/Filter value NonStandard/i, exp.message)
     end
 
     it "fails if the /R value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5})
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5, O: 't' * 32, U: 't' * 32, P: 0,
+                                    Length: 128})
       end
       assert_match(/Invalid \/R value 5/i, exp.message)
     end
 
     it "fails if the supplied password is invalid" do
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 6, U: 'a' * 48, O: 'a' * 48,
-                                    UE: 'a' * 32, OE: 'a' * 32})
+        @handler.set_up_decryption({Filter: :Standard, V: 5, R: 6, U: 'a' * 48, O: 'a' * 48,
+                                    UE: 'a' * 32, OE: 'a' * 32, P: 0, Perms: 'a' * 16})
       end
       assert_match(/Invalid password/i, exp.message)
     end
@@ -234,7 +246,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     it "assigns empty strings to the trailer's ID field if it is missing" do
       refute(@document.trailer.key?(:ID))
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption({Filter: :Standard, V: 1, R: 2, U: 'a' * 48, O: 'a' * 48, P: 15})
+        @handler.set_up_decryption({Filter: :Standard, V: 1, R: 2, U: 'a' * 32, O: 'a' * 32, P: 15})
       end
       assert_match(/Invalid password/i, exp.message)
       assert_equal(['', ''], @document.trailer[:ID].value)
@@ -286,7 +298,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   it "returns an array of permission symbols" do
     perms = @handler.class::Permissions::MODIFY_CONTENT | @handler.class::Permissions::COPY_CONTENT
     @handler.set_up_encryption(permissions: perms)
-    assert_equal([:copy_content, :modify_content], @handler.permissions.sort)
+    assert_equal([:copy_content, :extract_content, :modify_content], @handler.permissions.sort)
   end
 
   describe "handling of metadata streams" do

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -66,6 +66,20 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
+  describe "custom_glyph" do
+    it "returns the specified glyph object" do
+      glyph = @font_wrapper.custom_glyph(0, "str")
+      assert_equal(0, glyph.id)
+      assert_equal("str", glyph.str)
+    end
+
+    it "fails if an invalid glyph id is specified" do
+      exp = assert_raises(HexaPDF::Error) { @font_wrapper.custom_glyph(-5, 'c') }
+      assert_match(/Glyph ID -5 is invalid for font 'Ubuntu-Title'/, exp.message)
+      assert_raises(HexaPDF::Error) { @font_wrapper.custom_glyph(9999, 'c') }
+    end
+  end
+
   describe "encode" do
     it "returns the encoded glyph ID for fonts that are subset" do
       code = @font_wrapper.encode(@font_wrapper.glyph(3))
@@ -83,7 +97,10 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
 
     it "raises an error if an InvalidGlyph is encoded" do
-      assert_raises(HexaPDF::Error) { @font_wrapper.encode(@font_wrapper.glyph(9999)) }
+      exp = assert_raises(HexaPDF::MissingGlyphError) do
+        @font_wrapper.encode(@font_wrapper.decode_utf8("ö").first)
+      end
+      assert_match(/No glyph for "ö" in font 'Ubuntu-Title'/, exp.message)
     end
   end
 

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -65,6 +65,19 @@ describe HexaPDF::Font::Type1Wrapper do
     end
   end
 
+  describe "custom_glyph" do
+    it "returns the specified glyph object" do
+      glyph = @times_wrapper.custom_glyph(:question, "str")
+      assert_equal(:question, glyph.name)
+      assert_equal("str", glyph.str)
+    end
+
+    it "fails if the provided glyph name is not available for the font" do
+      exp = assert_raises(HexaPDF::Error) { @times_wrapper.custom_glyph(:handicap, 'c') }
+      assert_match(/Glyph named :handicap not found in font 'Times Roman'/, exp.message)
+    end
+  end
+
   describe "encode" do
     describe "uses WinAnsiEncoding as initial encoding for non-symbolic fonts" do
       it "returns the PDF font dictionary using WinAnsiEncoding and encoded glyph" do
@@ -75,7 +88,8 @@ describe HexaPDF::Font::Type1Wrapper do
       end
 
       it "fails if an InvalidGlyph is encoded" do
-        assert_raises(HexaPDF::Error) { @times_wrapper.encode(@times_wrapper.glyph(:ffi)) }
+        exp = assert_raises(HexaPDF::MissingGlyphError) { @times_wrapper.encode(@times_wrapper.glyph(:ffi)) }
+        assert_match(/No glyph for "ffi" in font 'Times Roman'/, exp.message)
       end
 
       it "fails if the encoding does not support the given glyph" do

data/test/hexapdf/layout/test_box.rb

@@ -207,7 +207,7 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "empty?" do
-    it "is only empty when no drawing operation is specified" do
+    it "is empty when no drawing operation is specified" do
       assert(create_box.empty?)
       refute(create_box {}.empty?)
       refute(create_box(style: {background_color: [5]}).empty?)

data/test/hexapdf/layout/test_column_box.rb

@@ -22,7 +22,7 @@ describe HexaPDF::Layout::ColumnBox do
   end
 
   def check_box(box, width, height, fit_pos = nil)
-    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box fit?")
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
     assert_equal(width, box.width, "box width")
     assert_equal(height, box.height, "box height")
     if fit_pos
@@ -46,6 +46,24 @@ describe HexaPDF::Layout::ColumnBox do
     end
   end
 
+  describe "empty?" do
+    it "is empty if nothing is fit yet" do
+      assert(create_box.empty?)
+    end
+
+    it "is empty if no box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [10])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.empty?)
+    end
+
+    it "is not empty if at least one box fits" do
+      box = create_box(children: [@fixed_size_boxes[0]], columns: [30])
+      check_box(box, 30, 10)
+      refute(box.empty?)
+    end
+  end
+
   describe "fit" do
     [:default, :flow].each do |position|
       it "respects the set initial width, position #{position}" do
@@ -132,27 +150,53 @@ describe HexaPDF::Layout::ColumnBox do
     assert_equal(5, box_b.children.size)
   end
 
-  it "draws the result onto the canvas" do
-    box = create_box(children: @fixed_size_boxes)
-    box.fit(100, 100, @frame)
+  describe "draw_content" do
+    before do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+    end
+
+    it "draws the result onto the canvas" do
+      box = create_box(children: @fixed_size_boxes)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 100 - box.height)
+      operators = 90.step(to: 20, by: -10).map do |y|
+        [[:save_graphics_state],
+         [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
+         [:move_to, [0, 0]],
+         [:end_path],
+         [:restore_graphics_state]]
+      end
+      operators.concat(90.step(to: 30, by: -10).map do |y|
+          [[:save_graphics_state],
+           [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
+           [:move_to, [0, 0]],
+           [:end_path],
+           [:restore_graphics_state]]
+      end)
+      operators.flatten!(1)
+      assert_operators(@canvas.contents, operators)
+    end
 
-    @canvas = HexaPDF::Document.new.pages.add.canvas
-    box.draw(@canvas, 0, 0)
-    operators = 90.step(to: 20, by: -10).map do |y|
-      [[:save_graphics_state],
-       [:concatenate_matrix, [1, 0, 0, 1, 0, y]],
-       [:move_to, [0, 0]],
-       [:end_path],
-       [:restore_graphics_state]]
+    it "takes a different final location into account" do
+      box = create_box(children: @fixed_size_boxes[0, 2])
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 20, 10)
+      operators = [
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, -80]],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:save_graphics_state],
+        [:concatenate_matrix, [1, 0, 0, 1, 55, 90]],
+        [:move_to, [0, 0]],
+        [:end_path],
+        [:restore_graphics_state],
+        [:restore_graphics_state],
+      ]
+      assert_operators(@canvas.contents, operators)
     end
-    operators.concat(90.step(to: 30, by: -10).map do |y|
-                       [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
-                        [:move_to, [0, 0]],
-                        [:end_path],
-                        [:restore_graphics_state]]
-                     end)
-    operators.flatten!(1)
-    assert_operators(@canvas.contents, operators)
   end
 end