hexapdf 0.20.4 → 0.21.0

data/test/hexapdf/common_tokenizer_tests.rb

@@ -60,9 +60,9 @@ module CommonTokenizerTests
       'obj', 'endobj', 'f*', '*f', '{', '}',
       "parentheses ( ) and (\nspecial \0053++characters\n (*!&}^% and so on).\n", '',
       "Nov shmoz ka pop.", "\x90\x1F\xA3", "\x90\x1F\xA0",
-      :Name1, :ASomewhatLongerName, :"A;Name_With-Various***Characters?",
-      :"1.2", :"$$", :"@pattern", :".notdef", :"lime Green", :"paired()parentheses",
-      :"The_Key_of_F#_Minor", :AB, :"",
+      :Name1, :ASomewhatLongerName, :'A;Name_With-Various***Characters?',
+      :'1.2', :$$, :@pattern, :'.notdef', :'lime Green', :'paired()parentheses',
+      :'The_Key_of_F#_Minor', :AB, :"",
       '[', 5, 6, :Name, ']', '[', 5, 6, :Name, ']',
       '<<', :Name, 5, '>>'
     ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding) }
@@ -85,12 +85,12 @@ module CommonTokenizerTests
 
     create_tokenizer("/Hößgang")
     token = @tokenizer.next_token
-    assert_equal(:"Hößgang", token)
+    assert_equal(:Hößgang, token)
     assert_equal(Encoding::UTF_8, token.encoding)
 
     create_tokenizer('/H#c3#b6#c3#9fgang')
     token = @tokenizer.next_token
-    assert_equal(:"Hößgang", token)
+    assert_equal(:Hößgang, token)
     assert_equal(Encoding::UTF_8, token.encoding)
 
     create_tokenizer('/H#E8lp')

data/test/hexapdf/content/test_graphics_state.rb

@@ -156,4 +156,5 @@ class GraphicsStateWrapper < Minitest::Spec
       assert_equal(0.02, @gs.scaled_font_size)
     end
   end
+
 end

data/test/hexapdf/content/test_operator.rb

@@ -391,7 +391,7 @@ describe_operator :CurveToNoSecondControlPoint, :y do
   end
 end
 
-[:S, :s, :f, :F, 'f*'.intern, :B, 'B*'.intern, :b, 'b*'.intern, :n].each do |sym|
+[:S, :s, :f, :F, :'f*', :B, :'B*', :b, :'b*', :n].each do |sym|
   describe_operator :EndPath, sym do
     it "changes the graphics object to none" do
       @processor.graphics_object = :path
@@ -401,7 +401,7 @@ end
   end
 end
 
-[:W, 'W*'.intern].each do |sym|
+[:W, :'W*'].each do |sym|
   describe_operator :ClipPath, sym do
     it "changes the graphics object to clipping_path for clip path operations" do
       invoke

data/test/hexapdf/content/test_processor.rb

@@ -119,7 +119,7 @@ describe HexaPDF::Content::Processor do
       @processor.process(:BT)
       @processor.graphics_state.font = @font = @doc.add({Type: :Font, Subtype: :Type1,
                                                          Encoding: :WinAnsiEncoding,
-                                                         BaseFont: :"Times-Roman"})
+                                                         BaseFont: :'Times-Roman'})
       @processor.graphics_state.font_size = 10
       @processor.graphics_state.text_rise = 10
       @processor.graphics_state.character_spacing = 1

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -62,29 +62,25 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   test_files.each do |file|
     basename = File.basename(file)
     it "can decrypt, encrypt and decrypt the encrypted file #{basename} with the user password" do
-      begin
-        doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                    decryption_opts: {password: user_password})
-        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
-
-        out = StringIO.new(''.b)
-        HexaPDF::Writer.new(doc, out).write
-        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: user_password})
-        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
-      rescue HexaPDF::EncryptionError => e
-        flunk("Error processing #{basename}: #{e}")
-      end
+      doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
+                                  decryption_opts: {password: user_password})
+      assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+
+      out = StringIO.new(''.b)
+      HexaPDF::Writer.new(doc, out).write
+      doc = HexaPDF::Document.new(io: out, decryption_opts: {password: user_password})
+      assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+    rescue HexaPDF::EncryptionError => e
+      flunk("Error processing #{basename}: #{e}")
     end
 
     unless basename.start_with?("userpwd")
       it "can decrypt the encrypted file #{basename} with the owner password" do
-        begin
-          doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                      decryption_opts: {password: owner_password})
-          assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
-        rescue HexaPDF::EncryptionError => e
-          flunk("Error processing #{basename}: #{e}")
-        end
+        doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
+                                    decryption_opts: {password: owner_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+      rescue HexaPDF::EncryptionError => e
+        flunk("Error processing #{basename}: #{e}")
       end
     end
   end
@@ -97,16 +93,14 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   it "can encrypt and then decrypt with all encryption variations" do
     {arc4: [40, 48, 128], aes: [128, 256]}.each do |algorithm, key_lengths|
       key_lengths.each do |key_length|
-        begin
-          doc = HexaPDF::Document.new
-          doc.encrypt(algorithm: algorithm, key_length: key_length)
-          sio = StringIO.new
-          doc.write(sio)
-          doc = HexaPDF::Document.new(io: sio)
-          assert_kind_of(Time, doc.trailer.info[:ModDate], "alg: #{algorithm} #{key_length} bits")
-        rescue HexaPDF::Error => e
-          flunk("Error using variation: #{algorithm} #{key_length} bits\n" << e.message)
-        end
+        doc = HexaPDF::Document.new
+        doc.encrypt(algorithm: algorithm, key_length: key_length)
+        sio = StringIO.new
+        doc.write(sio)
+        doc = HexaPDF::Document.new(io: sio)
+        assert_kind_of(Time, doc.trailer.info[:ModDate], "alg: #{algorithm} #{key_length} bits")
+      rescue HexaPDF::Error => e
+        flunk("Error using variation: #{algorithm} #{key_length} bits\n" << e.message)
       end
     end
   end

data/test/hexapdf/filter/test_predictor.rb

@@ -106,17 +106,15 @@ describe HexaPDF::Filter::Predictor do
       end
 
       it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
-        begin
-          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
-          assert_raises(HexaPDF::FilterError) do
-            data = @testcases['up']
-            encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Predictor],
-                                       data[:Colors], data[:BitsPerComponent], data[:Columns])
-            collector(encoder)
-          end
-        ensure
-          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+        HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['up']
+          encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Predictor],
+                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
+          collector(encoder)
         end
+      ensure
+        HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
       end
     end
 
@@ -139,17 +137,15 @@ describe HexaPDF::Filter::Predictor do
       end
 
       it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
-        begin
-          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
-          assert_raises(HexaPDF::FilterError) do
-            data = @testcases['up']
-            encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Predictor],
-                                       data[:Colors], data[:BitsPerComponent], data[:Columns])
-            collector(encoder)
-          end
-        ensure
-          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+        HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+        assert_raises(HexaPDF::FilterError) do
+          data = @testcases['up']
+          encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Predictor],
+                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
+          collector(encoder)
         end
+      ensure
+        HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
       end
     end
   end

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -14,7 +14,7 @@ describe HexaPDF::Font::Type1Wrapper do
 
   it "can be used with an existing PDF object" do
     font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: {Differences: [65, :B]},
-                     BaseFont: :"Times-Roman"})
+                     BaseFont: :'Times-Roman'})
     wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_TIMES, pdf_object: font)
     assert_equal([:B, :E, :A, :S, :T], wrapper.decode_utf8("BEAST").map(&:name))
     assert_equal("A", wrapper.encode(wrapper.glyph(:A)))

data/test/hexapdf/font/true_type/table/common.rb

@@ -16,7 +16,7 @@ module TestHelper
   end
 
   def create_table(name, data = nil, standalone: false)
-    font, entry = !standalone ? [@font, @entry] : set_up_stub_true_type_font(register_vars: false)
+    font, entry = standalone ? set_up_stub_true_type_font(register_vars: false) : [@font, @entry]
     if data
       font.io.string = data
       entry.length = font.io.length

data/test/hexapdf/font/true_type/table/test_cmap.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Font::TrueType::Table::Cmap do
       [0, 1, 28],
       [3, 1, 28 + f0.length],
       [1, 0, 28],
-    ].map {|a| a.pack('n2N') }.join('') << f0 << [10, 22, 0, 0, 2, 10, 13].pack('nN2N2n2')
+    ].map {|a| a.pack('n2N') }.join << f0 << [10, 22, 0, 0, 2, 10, 13].pack('nN2N2n2')
     set_up_stub_true_type_font(data)
   end
 

data/test/hexapdf/font/true_type/table/test_cmap_subtable.rb

@@ -55,7 +55,7 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
 
     it "works for format 2" do
       f2 = ([0, 8] + [0] * 254).pack('n*') + \
-        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n') }.join('') + \
+        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n') }.join + \
         ((0..255).to_a + [35, 65534, 0]).pack('n*')
       t = table([2, f2.length + 6, 0].pack('n3') << f2)
       assert_nil(t[0x0132])

data/test/hexapdf/image_loader/test_pdf.rb

@@ -33,14 +33,12 @@ describe HexaPDF::ImageLoader::PDF do
     end
 
     it "works for PDF files using a string object and use_stringio=false" do
-      begin
-        @doc.config['image_loader.pdf.use_stringio'] = false
-        form = @loader.load(@doc, @pdf)
-        assert_equal(:Form, form[:Subtype])
-      ensure
-        ObjectSpace.each_object(File) do |file|
-          file.close if file.path == @pdf && !file.closed?
-        end
+      @doc.config['image_loader.pdf.use_stringio'] = false
+      form = @loader.load(@doc, @pdf)
+      assert_equal(:Form, form[:Subtype])
+    ensure
+      ObjectSpace.each_object(File) do |file|
+        file.close if file.path == @pdf && !file.closed?
       end
     end
   end

data/test/hexapdf/image_loader/test_png.rb

@@ -30,11 +30,11 @@ describe HexaPDF::ImageLoader::PNG do
     assert_equal(height, image[:Height])
     assert_equal(bpc, image[:BitsPerComponent])
     assert_equal(color_space, @doc.unwrap(image[:ColorSpace])) if color_space
-    data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0') }.join("")].pack('B*') }.join("")
+    data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0') }.join].pack('B*') }.join
     assert_equal(data, image.stream)
   end
 
-  # Note: colors and image data for comparisons were extracted using GIMP and its color tools
+  # NOTE: colors and image data for comparisons were extracted using GIMP and its color tools
   describe "load" do
     before do
       @greyscale_1bit_data = [[1, 1, 0, 0, 0],

data/test/hexapdf/layout/test_box.rb

@@ -17,11 +17,21 @@ describe HexaPDF::Layout::Box do
       assert_same(block, box.instance_eval { @draw_block })
     end
 
-    it "allows specifying style options" do
+    it "allows specifying a style object" do
+      box = HexaPDF::Layout::Box.create(style: {background_color: 20})
+      assert_equal(20, box.style.background_color)
+    end
+
+    it "allows specifying style properties" do
       box = HexaPDF::Layout::Box.create(background_color: 20)
       assert_equal(20, box.style.background_color)
     end
 
+    it "applies the additional style properties to the style object" do
+      box = HexaPDF::Layout::Box.create(style: {background_color: 20}, background_color: 15)
+      assert_equal(15, box.style.background_color)
+    end
+
     it "takes content width and height" do
       box = HexaPDF::Layout::Box.create(width: 100, height: 200, content_box: true,
                                         padding: [10, 8, 6, 4],

data/test/hexapdf/layout/test_style.rb

@@ -604,6 +604,26 @@ describe HexaPDF::Layout::Style do
     end
   end
 
+  describe "self.create" do
+    it "returns the provided style argument" do
+      assert_same(@style, HexaPDF::Layout::Style.create(@style))
+    end
+
+    it "creates a new Style object based on the passed hash" do
+      style = HexaPDF::Layout::Style.create(font_size: 10, fill_color: 'green')
+      assert_equal(10, style.font_size)
+      assert_equal('green', style.fill_color)
+    end
+
+    it "creates an empty Style object if nil is passed" do
+      assert_kind_of(HexaPDF::Layout::Style, HexaPDF::Layout::Style.create(nil))
+    end
+
+    it "raises an error if an invalid object is provided" do
+      assert_raises(ArgumentError) { HexaPDF::Layout::Style.create(5) }
+    end
+  end
+
   it "can assign values on initialization" do
     style = HexaPDF::Layout::Style.new(font_size: 10)
     assert_equal(10, style.font_size)
@@ -692,6 +712,9 @@ describe HexaPDF::Layout::Style do
 
     @style.stroke_dash_pattern(5, 2)
     assert_equal([[5], 2], @style.stroke_dash_pattern.to_operands)
+
+    @style.line_spacing(1.2)
+    assert_equal([:proportional, 1.2], [@style.line_spacing.type, @style.line_spacing.value])
   end
 
   it "allows checking for valid values" do

data/test/hexapdf/layout/test_text_fragment.rb

@@ -20,7 +20,7 @@ describe HexaPDF::Layout::TextFragment do
   end
 
   describe "create" do
-    it "creates a TextFragment from text and options" do
+    it "creates a TextFragment from text and style" do
       frag = HexaPDF::Layout::TextFragment.create("Tom", font: @font, font_size: 20,
                                                   font_features: {kern: true})
       assert_equal(4, frag.items.length)
@@ -180,16 +180,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:end_text],
-               [:save_graphics_state],
-               [:set_device_gray_stroking_color, [0]],
-               [:set_line_width, [@fragment.style.calculated_underline_thickness]],
-               [:set_line_cap_style, [0]],
-               [:set_line_dash_pattern, [[], 0]],
-               [:move_to, [10, 15]],
-               [:line_to, [40.88, 15]],
-               [:stroke_path],
-               [:restore_graphics_state]])
+                            back: [[:end_text],
+                                   [:save_graphics_state],
+                                   [:set_device_gray_stroking_color, [0]],
+                                   [:set_line_width, [@fragment.style.calculated_underline_thickness]],
+                                   [:set_line_cap_style, [0]],
+                                   [:set_line_dash_pattern, [[], 0]],
+                                   [:move_to, [10, 15]],
+                                   [:line_to, [40.88, 15]],
+                                   [:stroke_path],
+                                   [:restore_graphics_state]])
     end
 
     it "draws the strikeout line" do
@@ -201,16 +201,16 @@ describe HexaPDF::Layout::TextFragment do
                                      [:set_line_width, [5]],
                                      [:set_line_cap_style, [1]],
                                      [:set_line_dash_pattern, [[5], 0]]],
-        back: [[:end_text],
-               [:save_graphics_state],
-               [:set_device_gray_stroking_color, [0]],
-               [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
-               [:set_line_cap_style, [0]],
-               [:set_line_dash_pattern, [[], 0]],
-               [:move_to, [10, 21.01]],
-               [:line_to, [40.88, 21.01]],
-               [:stroke_path],
-               [:restore_graphics_state]])
+                            back: [[:end_text],
+                                   [:save_graphics_state],
+                                   [:set_device_gray_stroking_color, [0]],
+                                   [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
+                                   [:set_line_cap_style, [0]],
+                                   [:set_line_dash_pattern, [[], 0]],
+                                   [:move_to, [10, 21.01]],
+                                   [:line_to, [40.88, 21.01]],
+                                   [:stroke_path],
+                                   [:restore_graphics_state]])
     end
   end
 

data/test/hexapdf/test_composer.rb

@@ -19,7 +19,7 @@ describe HexaPDF::Composer do
       assert_equal(36, @composer.frame.bottom)
       assert_equal(523, @composer.frame.width)
       assert_equal(770, @composer.frame.height)
-      assert_equal("Times", @composer.base_style.font)
+      assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
     end
 
     it "allows the customization of the page size" do
@@ -86,83 +86,144 @@ describe HexaPDF::Composer do
     assert_equal(806, @composer.y)
   end
 
+  describe "style" do
+    it "creates a new style if it does not exist based on the base argument" do
+      @composer.style(:base, font_size: 20)
+      assert_equal(20, @composer.style(:newstyle, subscript: true).font_size)
+      refute( @composer.style(:base).subscript)
+      assert_equal(10, @composer.style(:another_new, base: nil).font_size)
+      assert(@composer.style(:yet_another_new, base: :newstyle).subscript)
+    end
+
+    it "returns the named style" do
+      assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
+    end
+
+    it "updates the style with the given properties" do
+      assert_equal(20, @composer.style(:base, font_size: 20).font_size)
+    end
+  end
+
   describe "text" do
-    it "creates a text box and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    before do
+      test_self = self
+      @composer.define_singleton_method(:draw_box) do |arg|
+        test_self.instance_variable_set(:@box, arg)
+      end
+    end
 
+    it "creates a text box and draws it on the canvas" do
       @composer.text("Test", width: 10, height: 15)
-      assert_equal(10, box.width)
-      assert_equal(15, box.height)
-      assert_same(@composer.document.fonts.add("Times"), box.style.font)
-      items = box.instance_variable_get(:@items)
+      assert_equal(10, @box.width)
+      assert_equal(15, @box.height)
+      assert_same(@composer.document.fonts.add("Times"), @box.style.font)
+      items = @box.instance_variable_get(:@items)
       assert_equal(1, items.length)
-      assert_same(box.style, items.first.style)
+      assert_same(@box.style, items.first.style)
     end
 
     it "allows setting of a custom style" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
-
-      @composer.text("Test", style: HexaPDF::Layout::Style.new(font_size: 20))
-      assert_same(@composer.document.fonts.add("Times"), box.style.font)
-      assert_equal(20, box.style.font_size)
+      style = HexaPDF::Layout::Style.new(font_size: 20, font: ['Times', {variant: :bold}])
+      @composer.text("Test", style: style)
+      assert_same(@box.style, style)
+      assert_same(@composer.document.fonts.add("Times", variant: :bold), @box.style.font)
+      assert_equal(20, @box.style.font_size)
+
+      @composer.text("Test", style: {font_size: 20})
+      assert_equal(20, @box.style.font_size)
+
+      @composer.style(:named, font_size: 20)
+      @composer.text("Test", style: :named)
+      assert_equal(20, @box.style.font_size)
     end
 
     it "updates the used style with the provided options" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      @composer.text("Test", style: {subscript: true}, font_size: 20)
+      assert_equal(20, @box.style.font_size)
+    end
 
-      @composer.text("Test", style: HexaPDF::Layout::Style.new, font_size: 20)
-      assert_equal(20, box.style.font_size)
+    it "allows using a box style different from the text style" do
+      style = HexaPDF::Layout::Style.new(font_size: 20)
+      @composer.text("Test", box_style: style)
+      refute_same(@box.instance_variable_get(:@items).first.style, style)
+      assert_same(@box.style, style)
+
+      @composer.style(:named, font_size: 20)
+      @composer.text("Test", box_style: :named)
+      assert_equal(20, @box.style.font_size)
     end
   end
 
   describe "formatted_text" do
-    it "creates a text box with the formatted text and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    before do
+      test_self = self
+      @composer.define_singleton_method(:draw_box) do |arg|
+        test_self.instance_variable_set(:@box, arg)
+      end
+    end
 
+    it "creates a text box with the given text and draws it on the canvas" do
       @composer.formatted_text(["Test"], width: 10, height: 15)
-      assert_equal(10, box.width)
-      assert_equal(15, box.height)
-      assert_equal(1, box.instance_variable_get(:@items).length)
+      assert_equal(10, @box.width)
+      assert_equal(15, @box.height)
+      assert_equal(1, @box.instance_variable_get(:@items).length)
     end
 
-    it "a hash can be used for custom style properties" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows using a hash with :text key instead of a simple string" do
+      @composer.formatted_text([{text: "Test"}])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(4, items[0].items.length)
+    end
 
-      @composer.formatted_text([{text: "Test", font_size: 20}], align: :center)
-      items = box.instance_variable_get(:@items)
-      assert_equal(1, items.length)
-      assert_equal(20, items.first.style.font_size)
-      assert_equal(:center, items.first.style.align)
-      assert_equal(10, box.style.font_size)
+    it "uses an empty string if the :text key for a hash is not specified" do
+      @composer.formatted_text([{font_size: "Test"}])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(0, items[0].items.length)
     end
 
-    it "a hash can be used to provide a custom style" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows setting a custom base style for all parts" do
+      @composer.formatted_text(["Test", "other"], font_size: 20)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(20, @box.style.font_size)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(20, items[1].style.font_size)
+    end
+
+    it "allows using custom style properties for a single part" do
+      @composer.formatted_text([{text: "Test", font_size: 20}, "test"], align: :center)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(10, @box.style.font_size)
 
-      @composer.formatted_text([{text: "Test", style: HexaPDF::Layout::Style.new(fill_color: 128),
-                                 font_size: 20}], align: :center)
-      items = box.instance_variable_get(:@items)
-      assert_equal(20, items.first.style.font_size)
-      assert_equal(128, items.first.style.fill_color)
-      assert_equal(:center, items.first.style.align)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:center, items[0].style.align)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
     end
 
-    it "a hash can be used to link to an URL" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "allows using a custom style as basis for a single part" do
+      @composer.formatted_text([{text: "Test", style: {font_size: 20}, subscript: true}, "test"],
+                               align: :center)
+      items = @box.instance_variable_get(:@items)
+      assert_equal(10, @box.style.font_size)
 
-      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}])
-      items = box.instance_variable_get(:@items)
-      assert_equal(2, items.length)
-      assert_equal(4, items[0].items.length)
-      assert_equal(3, items[1].items.length)
+      assert_equal(20, items[0].style.font_size)
+      assert_equal(:left, items[0].style.align)
+      assert(items[0].style.subscript)
+
+      assert_equal(10, items[1].style.font_size)
+      assert_equal(:center, items[1].style.align)
+      refute(items[1].style.subscript)
+    end
+
+    it "allows specifying a link to an URL via the :link key" do
+      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}, "test"])
+      items = @box.instance_variable_get(:@items)
+      assert_equal(3, items.length)
+      assert_equal(4, items[0].items.length, "text should be Test")
+      assert_equal(3, items[1].items.length, "text should be URI")
       assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
+      refute(items[2].style.overlays?)
     end
   end
 
@@ -172,9 +233,11 @@ describe HexaPDF::Composer do
       @composer.define_singleton_method(:draw_box) {|arg| box = arg }
       image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
 
-      @composer.image(image_path, width: 10, height: 15)
+      @composer.image(image_path, width: 10, height: 15, style: {font_size: 20}, subscript: true)
       assert_equal(10, box.width)
       assert_equal(15, box.height)
+      assert_equal(20, box.style.font_size)
+      assert(box.style.subscript)
       assert_same(@composer.document.images.add(image_path), box.image)
     end
   end

data/test/hexapdf/test_dictionary.rb

@@ -19,8 +19,8 @@ describe HexaPDF::Dictionary do
     klass.new(obj, oid: 1)
   end
 
-  def delete(_obj)
-    _obj.data.value = nil
+  def delete(obj)
+    obj.data.value = nil
   end
 
   def wrap(obj, type:)