hexapdf 0.29.0 → 0.31.0

data/lib/hexapdf/task/optimize.rb

@@ -38,6 +38,8 @@ require 'set'
 require 'hexapdf/serializer'
 require 'hexapdf/content/parser'
 require 'hexapdf/content/operator'
+require 'hexapdf/type/xref_stream'
+require 'hexapdf/type/object_stream'
 
 module HexaPDF
   module Task
@@ -124,7 +126,7 @@ module HexaPDF
         if object_streams == :generate
           process_object_streams(doc, :generate, xref_streams)
         elsif xref_streams == :generate
-          doc.add({Type: :XRef})
+          doc.add({}, type: Type::XRefStream)
         end
       end
 
@@ -150,14 +152,14 @@ module HexaPDF
             end
             objects_to_delete.each {|obj| rev.delete(obj) }
             if xref_streams == :generate && !xref_stream
-              rev.add(doc.wrap({Type: :XRef}, oid: doc.revisions.next_oid))
+              rev.add(doc.wrap({}, type: Type::XRefStream, oid: doc.revisions.next_oid))
             end
           end
         when :generate
           doc.revisions.each do |rev|
             xref_stream = false
             count = 0
-            objstms = [doc.wrap({Type: :ObjStm})]
+            objstms = [doc.wrap({}, type: Type::ObjectStream)]
             old_objstms = []
             rev.each do |obj|
               case obj.type
@@ -173,7 +175,7 @@ module HexaPDF
               objstms[-1].add_object(obj)
               count += 1
               if count == 200
-                objstms << doc.wrap({Type: :ObjStm})
+                objstms << doc.wrap({}, type: Type::ObjectStream)
                 count = 0
               end
             end
@@ -182,7 +184,7 @@ module HexaPDF
               objstm.data.oid = doc.revisions.next_oid
               rev.add(objstm)
             end
-            rev.add(doc.wrap({Type: :XRef}, oid: doc.revisions.next_oid)) unless xref_stream
+            rev.add(doc.wrap({}, type: Type::XRefStream, oid: doc.revisions.next_oid)) unless xref_stream
           end
         end
       end
@@ -207,7 +209,7 @@ module HexaPDF
               xref_stream = true if obj.type == :XRef
               delete_fields_with_defaults(obj)
             end
-            rev.add(doc.wrap({Type: :XRef}, oid: doc.revisions.next_oid)) unless xref_stream
+            rev.add(doc.wrap({}, type: Type::XRefStream, oid: doc.revisions.next_oid)) unless xref_stream
           end
         end
       end

data/lib/hexapdf/type/font_simple.rb

@@ -171,9 +171,21 @@ module HexaPDF
           yield("Required field #{field} is not set", false) if self[field].nil?
         end
 
+        widths = self[:Widths]
         if key?(:Widths) && key?(:LastChar) && key?(:FirstChar) &&
-            self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)
-          yield("Invalid number of entries in field Widths", false)
+            widths.length != (self[:LastChar] - self[:FirstChar] + 1)
+          yield("Invalid number of entries in field Widths", true)
+          difference = self[:LastChar] - self[:FirstChar] + 1 - widths.length
+          if difference > 0
+            missing_value = if widths.count(widths[0]) == widths.length
+                              widths[0]
+                            else
+                              self[:FontDescriptor]&.[](:MissingWidth) || 0
+                            end
+            difference.times { widths << missing_value }
+          else
+            widths.slice!(difference, -difference)
+          end
         end
       end
 

data/lib/hexapdf/type/object_stream.rb

@@ -101,8 +101,8 @@ module HexaPDF
       define_type :ObjStm
 
       define_field :Type,    type: Symbol, required: true, default: type, version: '1.5'
-      define_field :N,       type: Integer # not required, will be auto-filled on #write_objects
-      define_field :First,   type: Integer # not required, will be auto-filled on #write_objects
+      define_field :N,       type: Integer, required: true
+      define_field :First,   type: Integer, required: true
       define_field :Extends, type: Stream
 
       # Parses the stream and returns an ObjectStream::Data object that can be used for retrieving
@@ -230,6 +230,11 @@ module HexaPDF
 
       # Validates that the generation number of the object stream is zero.
       def perform_validation
+        # Assign dummy values so that the validation for required values works since those values
+        # are only set on #write_objects
+        self[:N] ||= 0
+        self[:First] ||= 0
+
         super
         yield("Object stream has invalid generation number > 0", false) if gen != 0
       end

data/lib/hexapdf/type/outline.rb

@@ -126,7 +126,7 @@ module HexaPDF
         if (first && !last) || (!first && last)
           yield('Outline dictionary is missing an endpoint reference', true)
           node, dir = first ? [first, :Next] : [last, :Prev]
-          node = node[dir] while node.key?(dir)
+          node = node[dir] while node[dir]
           self[dir == :Next ? :Last : :First] = node
         elsif !first && !last && self[:Count] && self[:Count] != 0
           yield('Outline dictionary key /Count set but no items exist', true)

data/lib/hexapdf/type/outline_item.rb

@@ -397,7 +397,7 @@ module HexaPDF
         if (first && !last) || (!first && last)
           yield('Outline item dictionary is missing an endpoint reference', true)
           node, dir = first ? [first, :Next] : [last, :Prev]
-          node = node[dir] while node.key?(dir)
+          node = node[dir] while node[dir]
           self[dir == :Next ? :Last : :First] = node
         elsif !first && !last && self[:Count] && self[:Count] != 0
           yield('Outline item dictionary key /Count set but no descendants exist', true)

data/lib/hexapdf/type/page.rb

@@ -104,8 +104,16 @@ module HexaPDF
         Executive: [0, 0, 522, 756].freeze,
       }.freeze
 
-      # Returns the media box for the given paper size. See PAPER_SIZE for the defined paper sizes.
+      # Returns the media box for the given paper size or array.
+      #
+      # If an array is specified, it needs to contain exactly four numbers. The +orientation+
+      # argument is not used in this case.
+      #
+      # See PAPER_SIZE for the defined paper sizes.
       def self.media_box(paper_size, orientation: :portrait)
+        return paper_size if paper_size.kind_of?(Array) && paper_size.size == 4 &&
+          paper_size.all?(Numeric)
+
         unless PAPER_SIZE.key?(paper_size)
           raise HexaPDF::Error, "Invalid paper size specified: #{paper_size}"
         end
@@ -118,9 +126,6 @@ module HexaPDF
       # The inheritable fields.
       INHERITABLE_FIELDS = [:Resources, :MediaBox, :CropBox, :Rotate].freeze
 
-      # The required inheritable fields.
-      REQUIRED_INHERITABLE_FIELDS = [:Resources, :MediaBox].freeze
-
       define_type :Page
 
       define_field :Type,                 type: Symbol, required: true, default: type
@@ -609,10 +614,26 @@ module HexaPDF
         return unless parent_node
 
         super
-        REQUIRED_INHERITABLE_FIELDS.each do |name|
-          next if self[name]
-          yield("Inheritable page field #{name} not set", name == :Resources)
-          resources.validate(&block) if name == :Ressources
+
+        unless self[:Resources]
+          yield("Required inheritable page field Resources not set", true)
+          resources.validate(&block)
+        end
+
+        unless self[:MediaBox]
+          yield("Required inheritable page field MediaBox not set", true)
+          index = self.index
+          box_before = index == 0 ? nil : document.pages[index - 1][:MediaBox]
+          box_after = index == document.pages.count - 1 ? nil : document.pages[index + 1]&.[](:MediaBox)
+          self[:MediaBox] =
+            if box_before && (box_before&.value == box_after&.value || box_after.nil?)
+              box_before.dup
+            elsif box_after && box_before.nil?
+              box_after
+            else
+              self.class.media_box(document.config['page.default_media_box'],
+                                   orientation: document.config['page.default_media_orientation'])
+            end
         end
       end
 

data/lib/hexapdf/type/xref_stream.rb

@@ -72,12 +72,10 @@ module HexaPDF
 
       define_field :Type,  type: Symbol, default: type, required: true, indirect: false,
                            version: '1.5'
-      # Size is not required because it will be auto-filled before the object is written
-      define_field :Size,  type: Integer, indirect: false
+      define_field :Size,  type: Integer, indirect: false, required: true
       define_field :Index, type: PDFArray, indirect: false
       define_field :Prev,  type: Integer, indirect: false
-      # W is not required because it will be auto-filled on #update_with_xref_section_and_trailer
-      define_field :W,     type: PDFArray, indirect: false
+      define_field :W,     type: PDFArray, indirect: false, required: true
 
       # Returns an XRefSection that represents the content of this cross-reference stream.
       #
@@ -219,6 +217,15 @@ module HexaPDF
         [[1, middle, 2], pack_string]
       end
 
+      def perform_validation #:nodoc
+        # Size is not required because it will be auto-filled before the object is written
+        # W is not required because it will be auto-filled on #update_with_xref_section_and_trailer
+        # Set both here to dummy values to make validation work for the required values
+        self[:Size] ||= 1
+        self[:W] ||= [1, 1, 1]
+        super
+      end
+
     end
 
   end

data/lib/hexapdf/version.rb

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

data/lib/hexapdf/writer.rb

@@ -207,7 +207,7 @@ module HexaPDF
       end
 
       if (!object_streams.empty? || @use_xref_streams) && xref_stream.nil?
-        xref_stream = @document.wrap({Type: :XRef}, oid: @document.revisions.next_oid)
+        xref_stream = @document.wrap({}, type: Type::XRefStream, oid: @document.revisions.next_oid)
         rev.add(xref_stream)
       end
 

data/test/hexapdf/document/test_pages.rb

@@ -14,6 +14,31 @@ describe HexaPDF::Document::Pages do
     end
   end
 
+  describe "create" do
+    it "uses the defaults from the configuration for missing arguments" do
+      page = @doc.pages.create
+      assert_equal([0, 0, 595, 842], page.box(:media).value)
+    end
+
+    it "allows specifying a reference to a predefined page size" do
+      page = @doc.pages.create(media_box: :A3)
+      assert_equal([0, 0, 842, 1191], page.box(:media).value)
+    end
+
+    it "allows specifying the orientation for a predefined page size" do
+      page = @doc.pages.create(media_box: :A4, orientation: :landscape)
+      assert_equal([0, 0, 842, 595], page.box(:media).value)
+
+      page = @doc.pages.create(orientation: :landscape)
+      assert_equal([0, 0, 842, 595], page.box(:media).value)
+    end
+
+    it "allows using a media box array" do
+      page = @doc.pages.create(media_box: [0, 0, 12, 24], orientation: :landscape)
+      assert_equal([0, 0, 12, 24], page.box(:media).value)
+    end
+  end
+
   describe "add" do
     it "adds a new empty page when no page is given" do
       page = @doc.pages.add

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -213,14 +213,14 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
         @handler.set_up_decryption({Filter: :NonStandard, V: 2})
       end
-      assert_match(/Invalid \/Filter/i, exp.message)
+      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})
       end
-      assert_match(/Invalid \/R/i, exp.message)
+      assert_match(/Invalid \/R value 5/i, exp.message)
     end
 
     it "fails if the supplied password is invalid" do

data/test/hexapdf/filter/test_flate_decode.rb

@@ -26,12 +26,26 @@ describe HexaPDF::Filter::FlateDecode do
       assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded_predictor), @predictor_opts)))
     end
 
-    it "fails on invalid input" do
-      assert_raises(HexaPDF::FilterError) do
-        collector(@obj.decoder(feeder(@encoded[0..-2], @encoded.length - 3)))
+    describe "invalid input is handled as good as possible" do
+      def strict_mode
+        HexaPDF::GlobalConfiguration['filter.flate.on_error'] = proc { true }
+        yield
+      ensure
+        HexaPDF::GlobalConfiguration['filter.flate.on_error'] = proc { false }
       end
-      assert_raises(HexaPDF::FilterError) do
-        collector(@obj.decoder(feeder("some data")))
+
+      it "handles completely invalid data" do
+        assert_equal('', collector(@obj.decoder(feeder("some data"))))
+        assert_raises(HexaPDF::FilterError) do
+          strict_mode { collector(@obj.decoder(feeder("some data"))) }
+        end
+      end
+
+      it "handles missing data" do
+        assert_equal('abcdefg', collector(@obj.decoder(feeder(@encoded[0..-2]))))
+        assert_raises(HexaPDF::FilterError) do
+          strict_mode { collector(@obj.decoder(feeder(@encoded[0..-2]))) }
+        end
       end
     end
   end

data/test/hexapdf/layout/test_page_style.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/page_style'
+require 'hexapdf/document'
+
+describe HexaPDF::Layout::PageStyle do
+  it "allows assigning the page size, orientation and template on initialization" do
+    block = lambda {}
+    style = HexaPDF::Layout::PageStyle.new(page_size: :A3, orientation: :landscape, &block)
+    assert_equal(:A3, style.page_size)
+    assert_equal(:landscape, style.orientation)
+    assert_same(block, style.template)
+  end
+
+  it "uses defaults for all values" do
+    style = HexaPDF::Layout::PageStyle.new
+    assert_equal(:A4, style.page_size)
+    assert_equal(:portrait, style.orientation)
+    assert_nil(style.template)
+    assert_nil(style.frame)
+    assert_nil(style.next_style)
+  end
+
+  describe "create_page" do
+    before do
+      @doc = HexaPDF::Document.new
+    end
+
+    it "creates a new page object" do
+      style = HexaPDF::Layout::PageStyle.new do |canvas, istyle|
+        canvas.rectangle(0, 0, 10, 10).stroke
+        istyle.frame = :frame
+        istyle.next_style = :other
+      end
+      page = style.create_page(@doc)
+      assert_equal([0, 0, 595, 842], page.box(:media))
+      assert_equal("0 0 10 10 re\nS\n", page.contents)
+      assert_equal(:frame, style.frame)
+      assert_equal(:other, style.next_style)
+      assert_equal(0, @doc.pages.count)
+    end
+
+    it "works when no template is set" do
+      style = HexaPDF::Layout::PageStyle.new
+      page = style.create_page(@doc)
+      assert_equal("", page.contents)
+    end
+
+    it "creates a default frame if none is set beforehand or during template execution" do
+      style = HexaPDF::Layout::PageStyle.new
+      style.create_page(@doc)
+      assert_kind_of(HexaPDF::Layout::Frame, style.frame)
+      assert_equal(36, style.frame.left)
+      assert_equal(36, style.frame.bottom)
+      assert_equal(523, style.frame.width)
+      assert_equal(770, style.frame.height)
+    end
+  end
+
+  it "creates new frame objects given a page and a margin specification" do
+    doc = HexaPDF::Document.new
+    style = HexaPDF::Layout::PageStyle.new
+    frame = style.create_frame(style.create_page(doc), [15, 10])
+    assert_equal(10, frame.left)
+    assert_equal(15, frame.bottom)
+    assert_equal(575, frame.width)
+    assert_equal(812, frame.height)
+  end
+end

data/test/hexapdf/task/test_optimize.rb

@@ -81,8 +81,10 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "compacts and deletes xref streams" do
-      @doc.revisions.all[0].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
-      @doc.revisions.all[1].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
+      @doc.revisions.all[0].add(@doc.wrap({}, type: HexaPDF::Type::XRefStream,
+                                          oid: @doc.revisions.next_oid))
+      @doc.revisions.all[1].add(@doc.wrap({}, type: HexaPDF::Type::XRefStream,
+                                          oid: @doc.revisions.next_oid))
       @doc.task(:optimize, compact: true, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted
@@ -92,8 +94,8 @@ describe HexaPDF::Task::Optimize do
   describe "object_streams" do
     def reload_document_with_objstm_from_io
       io = StringIO.new
-      objstm = @doc.add({Type: :ObjStm})
-      @doc.add({Type: :XRef})
+      objstm = @doc.add({}, type: HexaPDF::Type::ObjectStream)
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       objstm.add_object(@doc.add({Type: :Test}))
       @doc.write(io)
       io.rewind
@@ -102,7 +104,7 @@ describe HexaPDF::Task::Optimize do
 
     it "generates object streams" do
       210.times { @doc.add(5) }
-      objstm = @doc.add({Type: :ObjStm})
+      objstm = @doc.add({}, type: HexaPDF::Type::ObjectStream)
       reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :generate)
       assert_objstms_generated
@@ -122,8 +124,8 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "deletes object and generates xref streams" do
-      @doc.add({Type: :ObjStm})
-      xref = @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::ObjectStream)
+      xref = @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
       assert_no_objstms
       assert_xrefstms_generated
@@ -140,13 +142,13 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "reuses an xref stream in generatation mode" do
-      @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, xref_streams: :generate)
       assert_xrefstms_generated
     end
 
     it "deletes xref streams" do
-      @doc.add({Type: :XRef})
+      @doc.add({}, type: HexaPDF::Type::XRefStream)
       @doc.task(:optimize, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted

data/test/hexapdf/test_composer.rb

@@ -39,6 +39,14 @@ describe HexaPDF::Composer do
       assert_equal(682, composer.frame.height)
     end
 
+    it "allows skipping the initial page creation" do
+      composer = HexaPDF::Composer.new(skip_page_creation: true)
+      assert_nil(composer.page)
+      assert_nil(composer.canvas)
+      assert_nil(composer.frame)
+      assert_nil(composer.page_style(:default))
+    end
+
     it "yields itself" do
       yielded = nil
       composer = HexaPDF::Composer.new {|c| yielded = c }
@@ -56,7 +64,7 @@ describe HexaPDF::Composer do
   end
 
   describe "new_page" do
-    it "creates a new page with the stored information" do
+    it "creates a new page" do
       c = HexaPDF::Composer.new(page_size: [0, 0, 50, 100], margin: 10)
       c.new_page
       assert_equal([0, 0, 50, 100], c.page.box.value)
@@ -64,16 +72,33 @@ describe HexaPDF::Composer do
       assert_equal(10, c.frame.bottom)
     end
 
-    it "uses the provided information for the new and all following pages" do
-      @composer.new_page(page_size: [0, 0, 50, 100], margin: 10)
-      assert_equal([0, 0, 50, 100], @composer.page.box.value)
-      assert_equal(10, @composer.frame.left)
-      assert_equal(10, @composer.frame.bottom)
+    it "uses the named page style for the new page" do
+      @composer.page_style(:other, page_size: [0, 0, 100, 100])
+      @composer.new_page(:other)
+      assert_equal([0, 0, 100, 100], @composer.page.box.value)
+    end
+
+    it "sets the next page's style to the next_style value of the used page style" do
+      @composer.page_style(:one, page_size: [0, 0, 1, 1]).next_style = :two
+      @composer.page_style(:two, page_size: [0, 0, 2, 2]).next_style = :one
+      @composer.new_page(:one)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+      @composer.new_page
+      assert_equal([0, 0, 2, 2], @composer.page.box.value)
+      @composer.new_page
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+    end
+
+    it "uses the current page style for new pages if no next_style value is set" do
+      @composer.page_style(:one, page_size: [0, 0, 1, 1])
+      @composer.new_page(:one)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
       @composer.new_page
-      assert_same(@composer.document.pages[2], @composer.page)
-      assert_equal([0, 0, 50, 100], @composer.page.box.value)
-      assert_equal(10, @composer.frame.left)
-      assert_equal(10, @composer.frame.bottom)
+      assert_equal([0, 0, 1, 1], @composer.page.box.value)
+    end
+
+    it "fails if the specified page style has not been defined" do
+      assert_raises(ArgumentError) { @composer.new_page(:unknown) }
     end
   end
 

data/test/hexapdf/test_dictionary_fields.rb

@@ -188,10 +188,15 @@ describe HexaPDF::DictionaryFields do
         ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
         ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
         ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
-        ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
-        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
-        ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], # non-standard, TZ hour to large
-        ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # non-standard, TZ min to large
+        ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
+        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
+        ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], #  TZ hour too large
+        ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # TZ min too large
+        ["D:19982423195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]], # months too large
+        ["D:19981273195210-08'00'", [1998, 12, 31, 19, 52, 10, "-08:00"]], # day too large
+        ["D:19981223275210-08'00'", [1998, 12, 23, 23, 52, 10, "-08:00"]], # hour too large
+        ["D:19981223197710-08'00'", [1998, 12, 23, 19, 59, 10, "-08:00"]], # minute too large
+        ["D:19981223195280-08'00'", [1998, 12, 23, 19, 52, 59, "-08:00"]], # seconds too large
       ].each do |str, data|
         obj = @field.convert(str, self)
         assert_equal(Time.new(*data), obj, "date str used: #{str}")

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.29.0)>>
+      <</Producer(HexaPDF version 0.31.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.29.0)>>
+      <</Producer(HexaPDF version 0.31.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -164,14 +164,14 @@ describe HexaPDF::Writer do
 
     document = HexaPDF::Document.new(io: io)
     assert_equal(3, document.revisions.count)
-    assert_equal(1, document.revisions.all[0].object(2)[:Kids].length)
-    assert_equal(2, document.revisions.all[1].object(2)[:Kids].length)
-    assert_equal(3, document.revisions.all[2].object(2)[:Kids].length)
+    assert_equal(1, document.revisions.all[0].object(3)[:Kids].length)
+    assert_equal(2, document.revisions.all[1].object(3)[:Kids].length)
+    assert_equal(3, document.revisions.all[2].object(3)[:Kids].length)
   end
 
   it "creates an xref stream if no xref stream is in a revision but object streams are" do
     document = HexaPDF::Document.new
-    document.add({Type: :ObjStm})
+    document.add({}, type: HexaPDF::Type::ObjectStream)
     HexaPDF::Writer.new(document, StringIO.new).write
     assert_equal(:XRef, document.object(4).type)
   end
@@ -184,7 +184,7 @@ describe HexaPDF::Writer do
 
     document = HexaPDF::Document.new(io: io)
     document.pages.add
-    document.add({Type: :ObjStm})
+    document.add({}, type: HexaPDF::Type::ObjectStream)
     io2 = StringIO.new
     HexaPDF::Writer.new(document, io2).write_incremental
 
@@ -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.29.0)>>
+      <</Producer(HexaPDF version 0.31.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

data/test/hexapdf/type/test_font_simple.rb

@@ -15,7 +15,7 @@ describe HexaPDF::Type::FontSimple do
     EOF
     font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
                                 FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                                Descent: -100, CapHeight: 800, StemV: 20})
+                                MissingWidth: 500, Descent: -100, CapHeight: 800, StemV: 20})
     @font = @doc.add({Type: :Font, Encoding: :WinAnsiEncoding,
                       BaseFont: :Embedded, FontDescriptor: font_descriptor, ToUnicode: cmap,
                       FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]},
@@ -130,9 +130,7 @@ describe HexaPDF::Type::FontSimple do
     end
 
     it "returns the /MissingWidth of a /FontDescriptor if available and the width was not found" do
-      assert_equal(0, @font.width(0))
-      @font[:FontDescriptor][:MissingWidth] = 99
-      assert_equal(99, @font.width(0))
+      assert_equal(500, @font.width(0))
     end
 
     it "returns 0 for a missing code point when FontDescriptor is not available" do
@@ -169,8 +167,22 @@ describe HexaPDF::Type::FontSimple do
     end
 
     it "validates the lengths of the /Widths field" do
-      @font[:Widths] = [65]
-      refute(@font.validate)
+      @font[:Widths] = [65, 65]
+      assert(@font.validate)
+      assert_equal([65, 65, 65], @font[:Widths])
+
+      @font[:Widths] = [65, 70]
+      assert(@font.validate)
+      assert_equal([65, 70, 500], @font[:Widths])
+
+      @font[:Widths] = [65, 70]
+      @font.delete(:FontDescriptor)
+      assert(@font.validate)
+      assert_equal([65, 70, 0], @font[:Widths])
+
+      @font[:Widths] = [65, 65, 70, 90, 100]
+      assert(@font.validate)
+      assert_equal([65, 65, 70], @font[:Widths])
     end
   end
 end