hexapdf 0.20.3 → 0.21.1

data/lib/hexapdf/layout/image_box.rb

@@ -56,7 +56,7 @@ module HexaPDF
       # Creates a new Image box object for the given +image+ argument which needs to be an image
       # object (e.g. returned by HexaPDF::Document::Images#add).
       def initialize(image, **kwargs)
-        super(**kwargs, &:unused_draw_block)
+        super(**kwargs)
         @image = image
       end
 

data/lib/hexapdf/layout/style.rb

@@ -518,6 +518,27 @@ module HexaPDF
 
       UNSET = ::Object.new # :nodoc:
 
+      # :call-seq:
+      #   Style.create(style)     -> style
+      #   Style.create(properties_hash)   -> style
+      #
+      # Creates a Style object based on the +style+ argument and returns it:
+      #
+      # * If +style+ is already a Style object, it is just returned.
+      #
+      # * If +style+ is a hash, a new Style object with the style properties specified by the hash
+      # * is created.
+      #
+      # * If +style+ is +nil+, a new Style object with only default values is created.
+      def self.create(style)
+        case style
+        when self then style
+        when Hash then new(**style)
+        when nil then new
+        else raise ArgumentError, "Invalid argument class #{style.class}"
+        end
+      end
+
       # Creates a new Style object.
       #
       # The +properties+ hash may be used to set the initial values of properties by using keys
@@ -945,7 +966,8 @@ module HexaPDF
         [:valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) ? " \
+           "{type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
         [:background_color, nil],
@@ -1115,13 +1137,11 @@ module HexaPDF
       # inside a TextFragment.
       def scaled_item_width(item)
         @scaled_item_widths[item] ||=
-          begin
-            if item.kind_of?(Numeric)
-              -item * scaled_font_size
-            else
-              item.width * scaled_font_size + scaled_character_spacing +
-                (item.apply_word_spacing? ? scaled_word_spacing : 0)
-            end
+          if item.kind_of?(Numeric)
+            -item * scaled_font_size
+          else
+            item.width * scaled_font_size + scaled_character_spacing +
+              (item.apply_word_spacing? ? scaled_word_spacing : 0)
           end
       end
 

data/lib/hexapdf/layout/text_fragment.rb

@@ -61,11 +61,11 @@ module HexaPDF
 
       # Creates a new TextFragment object for the given text, shapes it and returns it.
       #
-      # The needed style of the text fragment can either be specified by the +style+ argument or via
-      # the +options+ (in which case a new Style object is created). Regardless of the way, the
-      # resulting style object needs at least the font set.
-      def self.create(text, style = nil, **options)
-        style = (style.nil? ? Style.new(**options) : style)
+      # The needed style of the text fragment is specified by the +style+ argument (see
+      # Style::create for details). Note that the resulting style object needs at least the font
+      # set.
+      def self.create(text, style)
+        style = Style.create(style)
         fragment = new(style.font.decode_utf8(text), style)
         TextShaper.new.shape_text(fragment)
       end
@@ -97,16 +97,17 @@ module HexaPDF
       # * Style#stroke_join_style
       # * Style#stroke_miter_limit
       # * Style#stroke_dash_pattern
-      # * Style#underlay_callback
-      # * Style#overlay_callback
+      # * Style#underlays
+      # * Style#overlays
       attr_reader :style
 
       # Creates a new TextFragment object with the given items and style.
       #
-      # The argument +style+ can either be a Style object or a hash of style options.
+      # The argument +style+ can either be a Style object or a hash of style properties, see
+      # Style::create for details.
       def initialize(items, style)
         @items = items
-        @style = (style.kind_of?(Style) ? style : Style.new(**style))
+        @style = Style.create(style)
       end
 
       # The precision used to determine whether two floats represent the same value.

data/lib/hexapdf/parser.rb

@@ -71,6 +71,11 @@ module HexaPDF
       @contains_xref_streams
     end
 
+    # Returns +true+ if the PDF file was damaged and could be reconstructed.
+    def reconstructed?
+      !@reconstructed_revision.nil?
+    end
+
     # Loads the indirect (potentially compressed) object specified by the given cross-reference
     # entry.
     #

data/lib/hexapdf/tokenizer.rb

@@ -125,11 +125,11 @@ module HexaPDF
       elsif byte == 40 # (
         parse_literal_string
       elsif byte == 60 # <
-        if @ss.string.getbyte(@ss.pos + 1) != 60
-          parse_hex_string
-        else
+        if @ss.string.getbyte(@ss.pos + 1) == 60
           @ss.pos += 2
           TOKEN_DICT_START
+        else
+          parse_hex_string
         end
       elsif byte == 62 # >
         unless @ss.string.getbyte(@ss.pos + 1) == 62

data/lib/hexapdf/type/acro_form/appearance_generator.rb

@@ -260,9 +260,10 @@ module HexaPDF
               canvas.save_graphics_state do
                 canvas.rectangle(padding, padding, rect.width - 2 * padding,
                                  rect.height - 2 * padding).clip_path.end_path
-                if @field.concrete_field_type == :multiline_text_field
+                case @field.concrete_field_type
+                when :multiline_text_field
                   draw_multiline_text(canvas, rect, style, padding)
-                elsif @field.concrete_field_type == :list_box
+                when :list_box
                   draw_list_box(canvas, rect, style, padding)
                 else
                   draw_single_line_text(canvas, rect, style, padding)
@@ -503,9 +504,10 @@ module HexaPDF
         # appearance string, the annotation rectangle and the border style.
         def calculate_font_size(font, font_size, rect, border_style)
           if font_size == 0
-            if @field.concrete_field_type == :multiline_text_field
+            case @field.concrete_field_type
+            when :multiline_text_field
               0 # Handled by multiline drawing code
-            elsif @field.concrete_field_type == :list_box
+            when :list_box
               12 # Seems to be Adobe's default
             else
               unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *

data/lib/hexapdf/type/acro_form/choice_field.rb

@@ -128,8 +128,8 @@ module HexaPDF
           items = option_items
           array_value = [value].flatten
           all_included = array_value.all? {|v| items.include?(v) }
-          self[:V] = if (combo_box? && value.kind_of?(String) &&
-                         (flagged?(:edit) || all_included))
+          self[:V] = if combo_box? && value.kind_of?(String) &&
+                         (flagged?(:edit) || all_included)
                        delete(:I)
                        value
                      elsif list_box? && all_included &&

data/lib/hexapdf/type/acro_form/field.rb

@@ -258,7 +258,7 @@ module HexaPDF
         #
         # See: HexaPDF::Type::Annotations::Widget
         def each_widget(direct_only: false, &block) # :yields: widget
-          return to_enum(__method__) unless block_given?
+          return to_enum(__method__, direct_only: direct_only) unless block_given?
 
           if embedded_widget?
             yield(document.wrap(self))
@@ -336,7 +336,7 @@ module HexaPDF
 
           if embedded_widget?
             WIDGET_FIELDS.each {|key| delete(key) }
-            document.revisions.each {|revision| break if revision.update(self)}
+            document.revisions.each {|revision| break if revision.update(self) }
           else
             self[:Kids].delete_at(widget_index)
             document.delete(widget)

data/lib/hexapdf/type/font_type0.rb

@@ -141,7 +141,7 @@ module HexaPDF
           registry = system_info[:Registry]
           ordering = system_info[:Ordering]
           if (encoding.kind_of?(Symbol) && HexaPDF::Font::CMap.predefined?(encoding.to_s) &&
-            encoding != :"Identity-H" && encoding != :"Identity-V") ||
+            encoding != :'Identity-H' && encoding != :'Identity-V') ||
               (registry == "Adobe" && ['GB1', 'CNS1', 'Japan1', 'Korea1'].include?(ordering))
             HexaPDF::Font::CMap.for_name("#{registry}-#{ordering}-UCS2")
           end

data/lib/hexapdf/type/font_type3.rb

@@ -59,7 +59,7 @@ module HexaPDF
       def bounding_box
         matrix = self[:FontMatrix]
         bbox = self[:FontBBox].value
-        if matrix[3] < 0    # Some writers invert the y-axis
+        if matrix[3] < 0 # Some writers invert the y-axis
           bbox = bbox.dup
           bbox[1], bbox[3] = -bbox[3], -bbox[1]
         end

data/lib/hexapdf/type/resources.rb

@@ -218,10 +218,7 @@ module HexaPDF
       def perform_validation
         super
         val = self[:ProcSet]
-        if !val
-          yield("No procedure set specified", true)
-          self[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
-        else
+        if val
           if val.kind_of?(Symbol)
             yield("Procedure set is a single value instead of an Array", true)
             val = value[:ProcSet] = [val]
@@ -235,6 +232,9 @@ module HexaPDF
               true
             end
           end
+        else
+          yield("No procedure set specified", true)
+          self[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
         end
       end
 

data/lib/hexapdf/type/signature/adbe_pkcs7_detached.rb

@@ -100,7 +100,7 @@ module HexaPDF
           end
 
           key_usage = signer_certificate.extensions.find {|ext| ext.oid == 'keyUsage' }
-          unless key_usage.value.split(', ').include?("Digital Signature")
+          unless key_usage && key_usage.value.split(', ').include?("Digital Signature")
             result.log(:error, "Certificate key usage is missing 'Digital Signature'")
           end
 

data/lib/hexapdf/type/signature.rb

@@ -75,7 +75,7 @@ module HexaPDF
 
         # For DocMDP, also used by UR
         define_field :P, type: [Integer, Boolean]
-        define_field :V, type: Symbol, allowed_values: [:"1.2", :"2.2"]
+        define_field :V, type: Symbol, allowed_values: [:'1.2', :'2.2']
 
         # For UR
         define_field :Document,  type: PDFArray

data/lib/hexapdf/type/trailer.rb

@@ -87,10 +87,10 @@ module HexaPDF
       # Updates the second part of the /ID field (the first part should always be the same for a
       # PDF file, the second part should change with each write).
       def update_id
-        if !self[:ID].kind_of?(PDFArray)
-          set_random_id
-        else
+        if self[:ID].kind_of?(PDFArray)
           value[:ID][1] = Digest::MD5.digest(rand.to_s)
+        else
+          set_random_id
         end
       end
 

data/lib/hexapdf/version.rb

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

data/lib/hexapdf/xref_section.rb

@@ -109,7 +109,7 @@ module HexaPDF
 
     # Make the assignment method private so that only the provided convenience methods can be
     # used.
-    private :"[]="
+    private :'[]='
 
     # Adds an in-use entry to the cross-reference section.
     #

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_aes.rb

@@ -48,6 +48,10 @@ describe HexaPDF::Encryption::AES do
       end
     end
 
+    it "handles invalid files with missing 16 byte padding" do
+      assert_equal('', @algorithm_class.decrypt('some key' * 2, 'iv' * 8))
+    end
+
     it "fails on decryption if not enough bytes are provided" do
       assert_raises(HexaPDF::EncryptionError) do
         @algorithm_class.decrypt('some' * 4, 'no iv')
@@ -97,6 +101,10 @@ describe HexaPDF::Encryption::AES do
     end
 
     it "decryption works if the padding is invalid" do
+      f = Fiber.new { 'a' * 16 }
+      result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
+      assert_equal('', result)
+
       f = Fiber.new { 'a' * 32 }
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 16, result)

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)))
@@ -103,5 +103,9 @@ describe HexaPDF::Font::Type1Wrapper do
     it "sets the circular reference" do
       assert_same(@times_wrapper, @times_wrapper.pdf_object.font_wrapper)
     end
+
+    it "makes sure that the PDF dictionaries are indirect" do
+      assert(@times_wrapper.pdf_object.indirect?)
+    end
   end
 end

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],