hexapdf 0.27.0 → 0.28.0

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

@@ -73,6 +73,8 @@ module HexaPDF
       # See: PDF1.7 s12.7.4.3
       class TextField < VariableTextField
 
+        define_type :XXAcroFormField
+
         define_field :MaxLen, type: Integer
 
         # All inheritable dictionary fields for text fields.
@@ -220,7 +222,15 @@ module HexaPDF
           current_value = field_value
           appearance_generator_class = document.config.constantize('acro_form.appearance_generator')
           each_widget do |widget|
-            next if !force && widget.cached?(:last_value) && widget.cache(:last_value) == current_value
+            is_cached = widget.cached?(:last_value)
+            unless force
+              if is_cached && widget.cache(:last_value) == current_value
+                next
+              elsif !is_cached && widget.appearance?
+                widget.cache(:last_value, current_value, update: true)
+                next
+              end
+            end
             widget.cache(:last_value, current_value, update: true)
             appearance_generator_class.new(widget).create_text_appearances
           end
@@ -228,7 +238,7 @@ module HexaPDF
 
         # Updates the widgets so that they reflect the current field value.
         def update_widgets
-          create_appearances
+          create_appearances(force: true)
         end
 
         private

data/lib/hexapdf/type/annotations/widget.rb

@@ -224,6 +224,9 @@ module HexaPDF
           # The kind of marker that is shown inside the widget. Can either be one of the symbols
           # +:check+, +:circle+, +:cross+, +:diamond+, +:square+ or +:star+, or a one character
           # string. The latter is interpreted using the ZapfDingbats font.
+          #
+          # If an empty string is set, it is treated as if +nil+ was set, i.e. it shows the default
+          # marker for the field type.
           attr_reader :style
 
           # The size of the marker in PDF points that is shown inside the widget. The special value

data/lib/hexapdf/type/font_true_type.rb

@@ -35,6 +35,7 @@
 #++
 
 require 'hexapdf/type/font_simple'
+require 'hexapdf/font/true_type_wrapper'
 
 module HexaPDF
   module Type
@@ -45,6 +46,19 @@ module HexaPDF
       define_field :Subtype, type: Symbol, required: true, default: :TrueType
       define_field :BaseFont, type: Symbol, required: true
 
+      # Overrides the default to provide a font wrapper in case none is set and a complete TrueType
+      # is embedded.
+      #
+      # See: Font#font_wrapper
+      def font_wrapper
+        if (tmp = super)
+          tmp
+        elsif (font_file = self.font_file) && self[:BaseFont].to_s !~ /\A[A-Z]{6}\+/
+          font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_file.stream))
+          @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(document, font, subset: true)
+        end
+      end
+
       private
 
       def perform_validation

data/lib/hexapdf/type/object_stream.rb

@@ -179,7 +179,7 @@ module HexaPDF
           # Due to a bug in Adobe Acrobat, the Catalog may not be in an object stream if the
           # document is encrypted
           if obj.nil? || obj.null? || obj.gen != 0 || obj.kind_of?(Stream) || obj == encrypt_dict ||
-              (encrypt_dict && obj.type == :Catalog) ||
+              obj.type == :Catalog ||
               obj.type == :Sig || obj.type == :DocTimeStamp ||
               (obj.respond_to?(:key?) && obj.key?(:ByteRange) && obj.key?(:Contents))
             delete_object(objects[index])
@@ -220,7 +220,7 @@ module HexaPDF
 
       # Returns the container with the to-be-stored objects.
       def objects
-        @objects ||= 
+        @objects ||=
           begin
             @objects = {}
             parse_stream

data/lib/hexapdf/type/outline.rb

@@ -128,7 +128,7 @@ module HexaPDF
           node, dir = first ? [first, :Next] : [last, :Prev]
           node = node[dir] while node.key?(dir)
           self[dir == :Next ? :Last : :First] = node
-        elsif !first && !last && self[:Count]
+        elsif !first && !last && self[:Count] && self[:Count] != 0
           yield('Outline dictionary key /Count set but no items exist', true)
           delete(:Count)
         end

data/lib/hexapdf/type/page.rb

@@ -267,6 +267,7 @@ module HexaPDF
           raise ArgumentError, "Page rotation has to be multiple of 90 degrees"
         end
 
+        # /Rotate and therefore cw_angle is angle in clockwise orientation
         cw_angle = (self[:Rotate] - angle) % 360
 
         if flatten
@@ -274,27 +275,41 @@ module HexaPDF
           return if cw_angle == 0
 
           matrix = case cw_angle
-                   when 90
-                     HexaPDF::Content::TransformationMatrix.new(0, -1, 1, 0)
-                   when 180
-                     HexaPDF::Content::TransformationMatrix.new(-1, 0, 0, -1)
-                   when 270
-                     HexaPDF::Content::TransformationMatrix.new(0, 1, -1, 0)
+                   when 90  then Content::TransformationMatrix.new(0, -1, 1, 0, -box.bottom, box.right)
+                   when 180 then Content::TransformationMatrix.new(-1, 0, 0, -1, box.right, box.top)
+                   when 270 then Content::TransformationMatrix.new(0, 1, -1, 0, box.top, -box.left)
                    end
 
-          [:MediaBox, :CropBox, :BleedBox, :TrimBox, :ArtBox].each do |box_name|
-            next unless key?(box_name)
-            box = self[box_name]
+          rotate_box = lambda do |box|
             llx, lly, urx, ury = \
               case cw_angle
-              when 90
-                [box.right, box.bottom, box.left, box.top]
-              when 180
-                [box.right, box.top, box.left, box.bottom]
-              when 270
-                [box.left, box.top, box.right, box.bottom]
+              when 90  then [box.right, box.bottom, box.left, box.top]
+              when 180 then [box.right, box.top, box.left, box.bottom]
+              when 270 then [box.left, box.top, box.right, box.bottom]
               end
-            self[box_name].value = matrix.evaluate(llx, lly).concat(matrix.evaluate(urx, ury))
+            box.value.replace(matrix.evaluate(llx, lly).concat(matrix.evaluate(urx, ury)))
+          end
+
+          [:MediaBox, :CropBox, :BleedBox, :TrimBox, :ArtBox].each do |box_name|
+            next unless key?(box_name)
+            rotate_box.call(self[box_name])
+          end
+
+          each_annotation do |annot|
+            rotate_box.call(annot[:Rect])
+            if (quad_points = annot[:QuadPoints])
+              quad_points = quad_points.value if quad_points.respond_to?(:value)
+              result = []
+              quad_points.each_slice(2) {|x, y| result.concat(matrix.evaluate(x, y)) }
+              quad_points.replace(result)
+            end
+            if (appearance = annot.appearance)
+              appearance[:Matrix] = matrix.dup.premultiply(*appearance[:Matrix].value).to_a
+            end
+            if annot[:Subtype] == :Widget
+              app_ch = annot[:MK] ||= document.wrap({}, type: :XXAppearanceCharacteristics)
+              app_ch[:R] = (app_ch[:R] + 360 - cw_angle) % 360
+            end
           end
 
           before_contents = document.add({}, stream: " q #{matrix.to_a.join(' ')} cm ")
@@ -519,15 +534,15 @@ module HexaPDF
       # If an annotation is a form field widget, only the widget will be deleted but not the form
       # field itself.
       def flatten_annotations(annotations = self[:Annots])
-        return [] unless key?(:Annots)
+        not_flattened = (annotations || []).to_ary
+        return not_flattened unless key?(:Annots)
 
-        not_flattened = annotations.to_ary
         annotations = not_flattened & self[:Annots] if annotations != self[:Annots]
         return not_flattened if annotations.empty?
 
         canvas = self.canvas(type: :overlay)
-        canvas.save_graphics_state
         if (pos = canvas.graphics_state.ctm.evaluate(0, 0)) != [0, 0]
+          canvas.save_graphics_state
           canvas.translate(-pos[0], -pos[1])
         end
 
@@ -546,36 +561,31 @@ module HexaPDF
 
           rect = annotation[:Rect]
           box = appearance.box
-          matrix = appearance[:Matrix]
-
-          # Adjust position based on matrix
-          pos = [rect.left - matrix[4], rect.bottom - matrix[5]]
-
-          # In case of a rotation we need to counter the default translation in #xobject by adding
-          # box.left and box.bottom, and then translate the origin for the rotation
-          angle = (-Math.atan2(matrix[2], matrix[0]) * 180 / Math::PI).to_i
-          case angle
-          when 0
-            # Nothing to do, no rotation
-          when 90
-            pos[0] += box.top + box.left
-            pos[1] += -box.left + box.bottom
-          when -90
-            pos[0] += -box.bottom + box.left
-            pos[1] += box.right + box.bottom
-          when 180, -180
-            pos[0] += box.right + box.left
-            pos[1] += box.top + box.bottom
-          else
-            not_flattened << annotation
-            next
-          end
 
-          width, height = (angle.abs == 90 ? [rect.height, rect.width] : [rect.width, rect.height])
-          canvas.xobject(appearance, at: pos, width: width, height: height)
+          # PDF1.7 12.5.5 algorithm
+          # Step a) Calculate smallest rectangle containing transformed bounding box
+          matrix = HexaPDF::Content::TransformationMatrix.new(*appearance[:Matrix].value)
+          llx, lly = matrix.evaluate(box.left, box.bottom)
+          ulx, uly = matrix.evaluate(box.left, box.top)
+          lrx, lry = matrix.evaluate(box.right, box.bottom)
+          left, right = [llx, ulx, lrx, lrx + (ulx - llx)].minmax
+          bottom, top = [lly, uly, lry, lry + (uly - lly)].minmax
+
+          # Step b) Fit calculated rectangle to annotation rectangle by translating/scaling
+          a = HexaPDF::Content::TransformationMatrix.new
+          a.translate(rect.left - left, rect.bottom - bottom)
+          a.scale(rect.width.fdiv(right - left), rect.height.fdiv(top - bottom))
+
+          # Step c) Premultiply form matrix - done implicitly when drawing the XObject
+
+          canvas.transform(*a) do
+            # Use [box.left, box.bottom] to counter default translation in #xobject since that
+            # is already taken care of in matrix a
+            canvas.xobject(appearance, at: [box.left, box.bottom])
+          end
           to_delete << annotation
         end
-        canvas.restore_graphics_state
+        canvas.restore_graphics_state unless pos == [0, 0]
 
         to_delete.each do |annotation|
           if annotation[:Subtype] == :Widget

data/lib/hexapdf/version.rb

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

data/lib/hexapdf/writer.rb

@@ -114,7 +114,7 @@ module HexaPDF
         @document.catalog[:Version] = @document.version.to_sym
       end
       @document.revisions.each do |rev|
-        rev.each_modified_object {|obj| revision.send(:add_without_check, obj) }
+        rev.each_modified_object(all: true) {|obj| revision.send(:add_without_check, obj) }
       end
 
       write_revision(revision, parser.startxref_offset)
@@ -135,8 +135,7 @@ module HexaPDF
 
       revision = @document.revisions.add
       @document.revisions.all[0..-2].each do |rev|
-        rev.each_modified_object {|obj| revision.send(:add_without_check, obj) }
-        rev.reset_objects
+        rev.each_modified_object(delete: true) {|obj| revision.send(:add_without_check, obj) }
       end
       @document.revisions.merge(-2..-1)
     end

data/test/hexapdf/content/test_canvas.rb

@@ -934,6 +934,11 @@ describe HexaPDF::Content::Canvas do
                                         [:restore_graphics_state]])
     end
 
+    it "correctly serializes the form when no transformation is needed" do
+      @canvas.image(@form, at: [100, 50])
+      assert_operators(@page.contents, [[:paint_xobject, [:XO1]]])
+    end
+
     it "doesn't do anything if the form's width or height is zero" do
       @form[:BBox] = [100, 50, 100, 200]
       @canvas.xobject(@form, at: [0, 0])

data/test/hexapdf/document/test_pages.rb

@@ -166,7 +166,7 @@ describe HexaPDF::Document::Pages do
     it "works for a single page label entry" do
       @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}]}
       result = @doc.pages.each_labelling_range.to_a
-      assert_equal([[0, 10, {S: :r}]], result.map {|s, c, l| [s, c, l.value]})
+      assert_equal([[0, 10, {S: :r}]], result.map {|s, c, l| [s, c, l.value] })
       assert_equal(:lowercase_roman, result[0].last.numbering_style)
     end
 
@@ -174,7 +174,7 @@ describe HexaPDF::Document::Pages do
       @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}]],
-                   result.map {|s, c, l| [s, c, l.value]})
+                   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

data/test/hexapdf/encryption/test_aes.rb

@@ -122,7 +122,7 @@ describe HexaPDF::Encryption::AES do
       [4, 20, 40].each do |length|
         assert_raises(HexaPDF::EncryptionError) do
           collector(@algorithm_class.decryption_fiber('some' * 4,
-                                                                 Fiber.new { 'a' * length }))
+                                                      Fiber.new { 'a' * length }))
         end
       end
     end

data/test/hexapdf/filter/test_predictor.rb

@@ -4,7 +4,6 @@ require_relative 'common'
 require 'hexapdf/filter/predictor'
 
 describe HexaPDF::Filter::Predictor do
-
   module CommonPredictorTests
     def test_decoding_through_decoder_method
       @testcases.each do |name, data|

data/test/hexapdf/layout/test_box.rb

@@ -131,7 +131,8 @@ describe HexaPDF::Layout::Box do
       assert_equal([nil, box], box.split(150, 150, nil))
     end
 
-    it "can't be split if it doesn't (completely) fit as the default implementation knows nothing about the content" do
+    it "can't be split if it doesn't (completely) fit as the default implementation " \
+      "knows nothing about the content" do
       @box.style.position = :flow # make sure we would generally be splitable
       @box.fit(90, 100, nil)
       assert_equal([nil, @box], @box.split(150, 150, nil))

data/test/hexapdf/layout/test_column_box.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Layout::ColumnBox do
     @text_boxes = 5.times.map do
       HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
     end
-    draw_block = lambda do |canvas, box|
+    draw_block = lambda do |canvas, _box|
       canvas.move_to(0, 0).end_path
     end
     @fixed_size_boxes = 15.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }

data/test/hexapdf/layout/test_list_box.rb

@@ -222,7 +222,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "allows drawing custom markers" do
-      marker = lambda do |doc, list_box, index|
+      marker = lambda do |_doc, _list_box, _index|
         HexaPDF::Layout::Box.create(width: 10, height: 10) {}
       end
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)

data/test/hexapdf/test_document.rb

@@ -163,14 +163,8 @@ describe HexaPDF::Document do
       refute_equal(0, obj.oid)
     end
 
-    it "fails if the given object is not a PDF object" do
-      assert_raises(ArgumentError) { @doc.import(5) }
-    end
-
-    it "fails if the given object is associated with no or the destination document" do
-      assert_raises(ArgumentError) { @doc.import(HexaPDF::Object.new(5)) }
-      obj = @doc.add(5)
-      assert_raises(ArgumentError) { @doc.import(obj) }
+    it "works if the given object is not a PDF object" do
+      assert_equal(5, @doc.import(5))
     end
   end
 

data/test/hexapdf/test_importer.rb

@@ -31,12 +31,12 @@ describe HexaPDF::Importer do
     @source.pages.add
     @source.pages.root[:Rotate] = 90
     @dest = HexaPDF::Document.new
-    @importer = HexaPDF::Importer.for(source: @source, destination: @dest)
+    @importer = HexaPDF::Importer.for(@dest)
   end
 
   describe "::for" do
     it "caches the importer" do
-      assert_same(@importer, HexaPDF::Importer.for(source: @source, destination: @dest))
+      assert_same(@importer, HexaPDF::Importer.for(@dest))
     end
   end
 
@@ -61,8 +61,14 @@ describe HexaPDF::Importer do
     end
 
     it "can import a direct object" do
-      obj = @importer.import(key: @obj)
-      assert(@dest.object?(obj[:key]))
+      assert_nil(@importer.import(nil))
+      assert_equal(5, @importer.import(5))
+      assert(@dest.object?(@importer.import({key: @obj})[:key]))
+    end
+
+    it "determines the source document dynamically" do
+      obj = @importer.import(@obj.value)
+      assert_equal("test", obj[:ref].value)
     end
 
     it "copies the data of the imported objects" do
@@ -120,10 +126,11 @@ describe HexaPDF::Importer do
       assert_equal(90, page[:Rotate])
     end
 
-    it "raise an error if the given object doesn't belong to the source document" do
+    it "works for importing objects from different documents" do
       other_doc = HexaPDF::Document.new
       other_obj = other_doc.add("test")
-      assert_raises(HexaPDF::Error) { @importer.import(other_obj) }
+      imported = @importer.import(other_obj)
+      assert_equal("test", imported.value)
     end
   end
 end

data/test/hexapdf/test_parser.rb

@@ -54,6 +54,23 @@ describe HexaPDF::Parser do
     @parser = HexaPDF::Parser.new(@parse_io, @document)
   end
 
+  describe "linearized?" do
+    it "can determine whether a document is linearized" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Linearized 1/H [2 4]/O 1/E 1/N 1/T 1>>\nendobj")
+      assert(@parser.linearized?)
+    end
+
+    it "returns false if the first object is not a linearization dictionary" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Length 2 0 R>>\nstream\nhallo\nendstream\nendobj")
+      refute(@parser.linearized?)
+    end
+
+    it "returns false if there is a parse error" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 a obj thing")
+      refute(@parser.linearized?)
+    end
+  end
+
   describe "parse_indirect_object" do
     it "reads indirect objects sequentially" do
       object, oid, gen, stream = @parser.parse_indirect_object

data/test/hexapdf/test_revision.rb

@@ -199,6 +199,14 @@ describe HexaPDF::Revision do
       deleted = @rev.object(6)
       @rev.delete(6)
       assert_equal([obj, @obj, deleted], @rev.each_modified_object.to_a)
+      assert_same(obj, @rev.object(3))
+    end
+
+    it "optionally deletes the modified objects from the revision" do
+      obj = @rev.object(3)
+      obj.value = :other
+      assert_equal([obj], @rev.each_modified_object(delete: true).to_a)
+      refute_same(obj, @rev.object(3))
     end
 
     it "ignores object and xref streams that were deleted" do
@@ -207,6 +215,13 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
 
+    it "handles object and xref streams that were added appropriately depending on the 'all' arg" do
+      xref = @rev.add(HexaPDF::Dictionary.new({Type: :XRef}, oid: 8))
+      objstm = @rev.add(HexaPDF::Dictionary.new({Type: :ObjStm}, oid: 9))
+      assert_equal([], @rev.each_modified_object.to_a)
+      assert_equal([xref, objstm], @rev.each_modified_object(all: true).to_a)
+    end
+
     it "doesn't return non-modified objects" do
       @rev.object(2)
       assert_equal([], @rev.each_modified_object.to_a)
@@ -230,18 +245,4 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
   end
-
-  describe "reset_objects" do
-    it "deletes loaded objects" do
-      @rev.object(2)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-
-    it "deletes added objects" do
-      @rev.add(@obj)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-  end
 end

data/test/hexapdf/test_revisions.rb

@@ -356,4 +356,47 @@ describe HexaPDF::Revisions do
       HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
     end
   end
+
+  it "merges the two revisions of a linearized PDF into one" do
+    io = StringIO.new(<<~EOF)
+      %PDF-1.2
+      5 0 obj
+      <</Linearized 1>>
+      endobj
+      xref
+      5 1
+      0000000009 00000 n
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 6/Prev 394>>
+      %
+      1 0 obj
+      <</ModDate(D:20221205233910+01'00')/Producer(HexaPDF version 0.27.0)>>
+      endobj
+      2 0 obj
+      <</Type/Catalog/Pages 3 0 R>>
+      endobj
+      3 0 obj
+      <</Type/Pages/Kids[4 0 R]/Count 1>>
+      endobj
+      4 0 obj
+      <</Type/Page/MediaBox[0 0 595 842]/Parent 3 0 R/Resources<<>>>>
+      endobj
+      xref
+      0 5
+      0000000000 65535 f 
+      0000000133 00000 n 
+      0000000219 00000 n 
+      0000000264 00000 n 
+      0000000315 00000 n 
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 5>>
+      startxref
+      41
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    assert(doc.revisions.parser.linearized?)
+    assert_equal(1, doc.revisions.count)
+    assert_same(5, doc.revisions.current.xref_section.max_oid)
+  end
 end

data/test/hexapdf/test_stream.rb

@@ -142,7 +142,7 @@ describe HexaPDF::Stream do
   def encoded_data(str, encoders = [])
     map = @document.config['filter.map']
     tmp = feeder(str)
-    encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp) }
+    encoders.each {|e| tmp = Object.const_get(map[e]).encoder(tmp) }
     collector(tmp)
   end
 

data/test/hexapdf/test_tokenizer.rb

@@ -14,15 +14,14 @@ describe HexaPDF::Tokenizer do
 
   it "handles object references" do
     #HexaPDF::Reference.new(1, 0), HexaPDF::Reference.new(1, 2), 2, -1, 'R', 0, 0, 'R', -1, 0, 'R',
-    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R -1 0 R")
+    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R 0 10 R -1 0 R")
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_token)
     assert_equal(2, @tokenizer.next_token)
     assert_equal(-1, @tokenizer.next_token)
     assert_equal('R', @tokenizer.next_token)
-    assert_equal(0, @tokenizer.next_token)
-    assert_equal(0, @tokenizer.next_token)
-    assert_equal('R', @tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
     assert_equal(-1, @tokenizer.next_token)
     assert_equal(0, @tokenizer.next_token)
     assert_equal('R', @tokenizer.next_token)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -214,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.28.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream