hexapdf 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 139f1864e4decd05c57468dc3b326a9cc4e749f1d35d4b5dadb3e0549215afd6
-  data.tar.gz: e7a0d34979abe6738a084dec2334f449ebc1db3eb479dd5f2374a81eeabd83d7
+  metadata.gz: 7a32d8f7558ea14ae5dc40849c690b79f5ed4a797cffb85253e7fd6d00c54736
+  data.tar.gz: 92713168ee64efc59f86ff1d4f8989054ab02653ccaf84795aed3fea02a4811d
 SHA512:
-  metadata.gz: 339c38737585eafdf447f7516a52ba7ce40b7e2e476336a2404e97a97645d5043b2956835d874296841b8b68d5935c53d97244ac90a2fd621d0471ce85ae8809
-  data.tar.gz: 4a4c843a32859c639fdf724ca1c6492fa3d387a1c8a92335a2341e82de42a5b9bc30663a3226c1cc0f2ca116dd638071e24b595b323e64fa1e0342d8681199bd
+  metadata.gz: 43b05643d9a59e9656a464eda221fa28e04bb4fe8ba1f97d0e31e434fbce64ffb9ed551689ce68957c8b4a7b82fbc85ecd91c1eac6d177b0109d4b9b5d275a6c
+  data.tar.gz: 780e7051327b0463e800ca4ea3b9f1ac1c3723d960154a2ac27c9e9bed867d0a257c48c20762cd0947f8638dc1f72b598a33ff76e1f0d1d2b0f1ff843497eb29

data/CHANGELOG.md

@@ -1,4 +1,31 @@
-## 0.30.0 - 2023-01-13
+## 0.31.0 - 2023-02-22
+
+### Added
+
+* [HexaPDF::Layout::PageStyle] for collecting all styling information for pages
+* [HexaPDF::Composer#page_style] for configuring different page styles
+
+### Changed
+
+* **Breaking change**: [HexaPDF::Composer] uses page styles underneath
+* **Breaking change**: Configuration options `filter.flate_compression` and
+  `filter.flate_memory` are changed to `filter.flate.compression` and
+  `filter.flate.memory`
+* **Breaking change**: [HexaPDF::Document#wrap] handles cross-reference and
+  object stream specially to avoid problems with invalid PDFs
+* [HexaPDF::Composer::new] to allow skipping the initial page creation
+* CLI command `hexapdf info --check` to process streams to reveal stream errors
+* CLI commands to output the name of created PDF files in verbose mode
+
+### Fixed
+
+* Validation of document outline items in case the first or last item got
+  deleted
+* `HexaPDF::Type::Page#perform_validation` to set a /MediaBox for invalid pages
+  that don't have one
+
+
+## 0.30.0 - 2023-02-13
 
 ### Added
 

data/lib/hexapdf/cli/command.rb

@@ -101,6 +101,17 @@ module HexaPDF
       def pdf_options(password)
         hash = {decryption_opts: {password: password}, config: {}}
         HexaPDF::GlobalConfiguration['filter.predictor.strict'] = command_parser.strict
+        HexaPDF::GlobalConfiguration['filter.flate.on_error'] =
+          if command_parser.strict
+            proc { true }
+          else
+            proc do |_, error|
+              if command_parser.verbosity_info?
+                $stderr.puts "Ignoring error in flate encoded stream: #{error}"
+              end
+              false
+            end
+          end
         hash[:config]['parser.try_xref_reconstruction'] = !command_parser.strict
         hash[:config]['parser.on_correctable_error'] =
           if command_parser.strict
@@ -120,6 +131,7 @@ module HexaPDF
       # Writes the document to the given file or does nothing if +out_file+ is +nil+.
       def write_document(doc, out_file, incremental: false)
         if out_file
+          doc.trailer.update_id
           doc.validate(auto_correct: true) do |msg, correctable, object|
             if command_parser.strict && !correctable
               raise "Validation error for object (#{object.oid},#{object.gen}): #{msg}"
@@ -128,6 +140,9 @@ module HexaPDF
                 "for object (#{object.oid},#{object.gen}): #{msg}"
             end
           end
+          if command_parser.verbosity_info?
+            puts "Creating output document #{out_file}"
+          end
           doc.write(out_file, validate: false, incremental: incremental)
         end
       end
@@ -331,7 +346,7 @@ module HexaPDF
             rotation = ROTATE_MAP[$4]
             start_nr.step(to: end_nr, by: step) {|n| arr << [n, rotation] }
           else
-            raise OptionParser::InvalidArgument, "invalid page range format: #{str}"
+            raise OptionParser::InvalidArgument, "invalid page range format: #{str.inspect}"
           end
         end
       end

data/lib/hexapdf/cli/info.rb

@@ -106,6 +106,13 @@ module HexaPDF
             doc.each(only_loaded: false) do |obj|
               indirect_object = obj
               obj.validate(auto_correct: true, &validation_block)
+              if obj.data.stream
+                begin
+                  obj.stream
+                rescue StandardError
+                  puts "ERROR: Stream of object (#{obj.oid},#{obj.gen}) invalid: #{$!.message}"
+                end
+              end
             end
           end
 
@@ -177,7 +184,8 @@ module HexaPDF
       def pdf_options(password)
         if @check_file
           options = {decryption_opts: {password: password}, config: {}}
-          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+          HexaPDF::GlobalConfiguration['filter.flate.on_error'] = proc { true }
           options[:config]['parser.try_xref_reconstruction'] = true
           options[:config]['parser.on_correctable_error'] = lambda do |_, msg, pos|
             puts "WARNING: Parse error at position #{pos}: #{msg}"

data/lib/hexapdf/cli/inspect.rb

@@ -166,8 +166,8 @@ module HexaPDF
           when 'p', 'pages'
             begin
               pages = parse_pages_specification(data.shift || '1-e', @doc.pages.count)
-            rescue StandardError
-              $stderr.puts("Error: Invalid page range argument")
+            rescue StandardError => e
+              $stderr.puts("Error: #{e}")
               next
             end
             page_list = @doc.pages.to_a

data/lib/hexapdf/composer.rb

@@ -106,6 +106,14 @@ module HexaPDF
 
     # Creates a new Composer object and optionally yields it to the given block.
     #
+    # skip_page_creation::
+    #     If this argument is +true+ (the default), the arguments +page_size+, +page_orientation+
+    #     and +margin+ are used to create a page style with the name :default and an initial page is
+    #     created as well.
+    #
+    #     Otherwise, i.e. when this argument is +false+, no initial page or default page style is
+    #     created. This has to be done manually using the #page_style and #new_page methods.
+    #
     # page_size::
     #     Can be any valid predefined page size (see Type::Page::PAPER_SIZE) or an array [llx, lly,
     #     urx, ury] specifying a custom page size.
@@ -120,36 +128,53 @@ module HexaPDF
     # Example:
     #
     #   composer = HexaPDF::Composer.new            # uses the default values
+    #
     #   HexaPDF::Composer.new(page_size: :Letter, margin: 72) do |composer|
     #     #...
     #   end
-    def initialize(page_size: :A4, page_orientation: :portrait, margin: 36) #:yields: composer
+    #
+    #   HexaPDF::Composer.new(skip_page_creation: true) do |composer|
+    #     page_template = lambda {|canvas, style| style.create_frame(canvas.context, 36) }
+    #     page_style(:default, template: page_template)
+    #     new_page
+    #     # ...
+    #   end
+    def initialize(skip_page_creation: false, page_size: :A4, page_orientation: :portrait,
+                   margin: 36) #:yields: composer
       @document = HexaPDF::Document.new
-      @page_size = page_size
-      @page_orientation = page_orientation
-      @margin = Layout::Style::Quad.new(margin)
-
-      new_page
+      @page_styles = {}
+      @page_style = :default
+      unless skip_page_creation
+        page_style(:default, page_size: page_size, orientation: page_orientation) do |canvas, style|
+          style.frame = style.create_frame(canvas.context, margin)
+        end
+        new_page
+      end
       yield(self) if block_given?
     end
 
     # Creates a new page, making it the current one.
     #
-    # If any of +page_size+, +page_orientation+ or +margin+ are set, they will be used instead of
-    # the default values and will become the default values.
+    # The page style to use for the new page can be set via the +style+ argument. If not provided,
+    # the currently set page style is used.
+    #
+    # The used page style determines the page style that should be used for the following new pages.
+    # If this information is not provided, the used page style is used again.
     #
     # Examples:
     #
-    #   composer.new_page  # uses the default values
-    #   composer.new_page(page_size: :A5, margin: [72, 36])
-    def new_page(page_size: nil, page_orientation: nil, margin: nil)
-      @page_size = page_size if page_size
-      @page_orientation = page_orientation if page_orientation
-      @margin = Layout::Style::Quad.new(margin) if margin
-
-      @page = @document.pages.add(@page_size, orientation: @page_orientation)
+    #   composer.page_style(:cover, page_size: :A4).next_style = :content
+    #   composer.page_style(:content, page_size: :A4)
+    #   composer.new_page(:cover)           # uses the :cover style, set next style to :content
+    #   composer.new_page                   # uses the :content style, next style again :content
+    def new_page(style = @page_style)
+      page_style = @page_styles.fetch(style) do |key|
+        raise ArgumentError, "Page style #{key} has not been defined"
+      end
+      @page = @document.pages.add(page_style.create_page(@document))
       @canvas = @page.canvas
-      create_frame
+      @frame = page_style.frame
+      @page_style = page_style.next_style || style
     end
 
     # The x-position of the cursor inside the current frame.
@@ -190,6 +215,40 @@ module HexaPDF
       @document.layout.style(name, base: base, **properties)
     end
 
+    # :call-seq:
+    #    composer.page_style(name)                                 -> page_style
+    #    composer.page_style(name, **attributes, &template_block)  -> page_style
+    #
+    # Creates and/or returns the page style +name+.
+    #
+    # If no attributes are given, the page style +name+ is returned. In case it does not exist,
+    # +nil+ is returned.
+    #
+    # If one or more page style attributes are given, a new HexaPDF::Layout::PageStyle object with
+    # those attribute values is created, stored under +name+ and returned. If a block is provided,
+    # it is used to define the page template.
+    #
+    # Example:
+    #
+    #   composer.page_style(:default)
+    #   composer.page_style(:cover, page_size: :A4) do |canvas, style|
+    #     page_box = canvas.context.box
+    #     canvas.fill_color("fd0") do
+    #       canvas.rectangle(0, 0, page_box.width, page_box.height).
+    #         fill
+    #     end
+    #     style.frame = style.create_frame(canvas.context, 36)
+    #   end
+    #
+    # See: HexaPDF::Layout::PageStyle
+    def page_style(name, **attributes, &block)
+      if attributes.empty?
+        @page_styles[name]
+      else
+        @page_styles[name] = HexaPDF::Layout::PageStyle.new(**attributes, &block)
+      end
+    end
+
     # Draws the given text at the current position into the current frame.
     #
     # The text will be positioned at the current position if possible. Otherwise the next best
@@ -325,17 +384,6 @@ module HexaPDF
       stamp
     end
 
-    private
-
-    # Creates the frame into which boxes are layed out when a new page is created.
-    def create_frame
-      media_box = @page.box
-      @frame = Layout::Frame.new(media_box.left + @margin.left,
-                                 media_box.bottom + @margin.bottom,
-                                 media_box.width - @margin.left - @margin.right,
-                                 media_box.height - @margin.bottom - @margin.top)
-    end
-
   end
 
 end

data/lib/hexapdf/configuration.rb

@@ -350,6 +350,9 @@ module HexaPDF
   #    The media box that is used for new pages that don't define a media box. Default value is
   #    A4. See HexaPDF::Type::Page::PAPER_SIZE for a list of predefined paper sizes.
   #
+  #    This configuration option (together with 'page.default_media_orientation') is also used when
+  #    validating pages and a page without a media box is found.
+  #
   #    The value can either be a rectangle defining the paper size or a Symbol referencing one of
   #    the predefined paper sizes.
   #
@@ -511,11 +514,20 @@ module HexaPDF
   #
   #    See PDF1.7 s8.6
   #
-  # filter.flate_compression::
+  # filter.flate.compression::
   #    Specifies the compression level that should be used with the FlateDecode filter. The level
   #    can range from 0 (no compression), 1 (best speed) to 9 (best compression, default).
   #
-  # filter.flate_memory::
+  # filter.flate.on_error::
+  #    Callback hook when a potentially recoverable Zlib error occurs in the FlateDecode filter.
+  #
+  #    The value needs to be an object that responds to \#call(stream, error) where stream is the
+  #    Zlib stream object and error is the thrown error. The method needs to return +true+ if an
+  #    error should be raised.
+  #
+  #    The default implementation prevents errors from being raised.
+  #
+  # filter.flate.memory::
   #    Specifies the memory level that should be used with the FlateDecode filter. The level can
   #    range from 1 (minimum memory usage; slow, reduces compression) to 9 (maximum memory usage).
   #
@@ -543,8 +555,9 @@ module HexaPDF
   #    This mapping is used to provide automatic wrapping of objects in the HexaPDF::Document#wrap
   #    method.
   GlobalConfiguration =
-    Configuration.new('filter.flate_compression' => 9,
-                      'filter.flate_memory' => 6,
+    Configuration.new('filter.flate.compression' => 9,
+                      'filter.flate.on_error' => proc { false },
+                      'filter.flate.memory' => 6,
                       'filter.predictor.strict' => false,
                       'color_space.map' => {
                         DeviceRGB: 'HexaPDF::Content::ColorSpace::DeviceRGB',

data/lib/hexapdf/document/pages.rb

@@ -94,11 +94,7 @@ module HexaPDF
       def create(media_box: nil, orientation: nil)
         media_box ||= @document.config['page.default_media_box']
         orientation ||= @document.config['page.default_media_orientation']
-        box = if media_box.kind_of?(Array)
-                media_box
-              else
-                Type::Page.media_box(media_box, orientation: orientation)
-              end
+        box = Type::Page.media_box(media_box, orientation: orientation)
         @document.add({Type: :Page, MediaBox: box})
       end
 

data/lib/hexapdf/document.rb

@@ -325,7 +325,14 @@ module HexaPDF
         type = (klass <= HexaPDF::Dictionary ? klass.type : nil)
       else
         type ||= deref(data.value[:Type]) if data.value.kind_of?(Hash)
-        klass = GlobalConfiguration.constantize('object.type_map', type) { nil } if type
+        if type
+          klass = GlobalConfiguration.constantize('object.type_map', type) { nil }
+          if (type == :ObjStm || type == :XRef) &&
+              klass.each_field.any? {|name, field| field.required? && !data.value.key?(name) }
+            data.value.delete(:Type)
+            klass = nil
+          end
+        end
       end
 
       if data.value.kind_of?(Hash)

data/lib/hexapdf/filter/flate_decode.rb

@@ -55,21 +55,33 @@ module HexaPDF
       def self.decoder(source, options = nil)
         fib = Fiber.new do
           inflater = Zlib::Inflate.new
+          error_raised = nil
+
           while source.alive? && (data = source.resume)
             next if data.empty?
             begin
-              data = inflater.inflate(data)
-            rescue StandardError => e
-              raise FilterError, "Problem while decoding Flate encoded stream: #{e}"
+              Fiber.yield(inflater.inflate(data))
+            rescue Zlib::DataError, Zlib::BufError => e
+              # Only swallow the error if it appears at the end of the stream
+              if error_raised || HexaPDF::GlobalConfiguration['filter.flate.on_error'].call(inflater, e)
+                raise FilterError, "Problem while decoding Flate encoded stream: #{e}"
+              else
+                Fiber.yield(inflater.flush_next_out)
+                error_raised = e
+              end
             end
-            Fiber.yield(data)
           end
+
           begin
             data = inflater.total_in == 0 || (data = inflater.finish).empty? ? nil : data
             inflater.close
             data
-          rescue StandardError => e
-            raise FilterError, "Problem while decoding Flate encoded stream: #{e}"
+          rescue Zlib::DataError, Zlib::BufError => e
+            if HexaPDF::GlobalConfiguration['filter.flate.on_error'].call(inflater, e)
+              raise FilterError, "Problem while decoding Flate encoded stream: #{e}"
+            else
+              Fiber.yield(inflater.flush_next_out)
+            end
           end
         end
 
@@ -87,9 +99,9 @@ module HexaPDF
         end
 
         Fiber.new do
-          deflater = Zlib::Deflate.new(HexaPDF::GlobalConfiguration['filter.flate_compression'],
+          deflater = Zlib::Deflate.new(HexaPDF::GlobalConfiguration['filter.flate.compression'],
                                        Zlib::MAX_WBITS,
-                                       HexaPDF::GlobalConfiguration['filter.flate_memory'])
+                                       HexaPDF::GlobalConfiguration['filter.flate.memory'])
           while source.alive? && (data = source.resume)
             data = deflater.deflate(data)
             Fiber.yield(data)

data/lib/hexapdf/layout/page_style.rb

@@ -0,0 +1,144 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2023 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/error'
+require 'hexapdf/layout/style'
+require 'hexapdf/layout/frame'
+
+module HexaPDF
+  module Layout
+
+    # A PageStyle defines the initial look of a page and the placement of one or more frames.
+    class PageStyle
+
+      # The page size.
+      #
+      # Can be any valid predefined page size (see HexaPDF::Type::Page::PAPER_SIZE) or an array
+      # [llx, lly, urx, ury] specifying a custom page size.
+      #
+      # Example:
+      #
+      #   style.page_size = :A4
+      #   style.page_size = [0, 0, 200, 200]
+      attr_accessor :page_size
+
+      # The page orientation, either +:portrait+ or +:landscape+.
+      #
+      # Only used if #page_size is one of the predefined page sizes and not an array.
+      attr_accessor :orientation
+
+      # A callable object that defines the initial content of a page created with #create_page.
+      #
+      # The callable object is given a canvas and the page style as arguments. It needs to draw the
+      # initial content of the page. Note that the graphics state of the canvas is *not* saved
+      # before executing the template code and restored afterwards. If this is needed, the object
+      # needs to do it itself.
+      #
+      # Furthermore it should set the #frame and #next_style attributes appropriately, if not done
+      # beforehand. The #create_frame method can be used for easily creating a rectangular frame.
+      #
+      # Example:
+      #
+      #   page_style.template = lambda do |canvas, style
+      #     box = canvas.context.box
+      #     canvas.fill_color("fd0") do
+      #       canvas.rectangle(0, 0, box.width, box.height).fill
+      #     end
+      #     style.frame = style.create_frame(canvas.context, 72)
+      #   end
+      attr_accessor :template
+
+      # The HexaPDF::Layout::Frame object that defines the area on the page where content should be
+      # placed.
+      #
+      # This can either be set beforehand or during execution of the #template.
+      #
+      # If no frame has been set, a frame covering the page except for a default margin on all sides
+      # is set during #create_page.
+      attr_accessor :frame
+
+      # Defines the name of the page style that should be used for the next page.
+      #
+      # If this attribute is +nil+ (the default), it means that this style should be used again.
+      attr_accessor :next_style
+
+      # Creates a new page style instance for the given page size and orientation. If a block is
+      # given, it is used as template for defining the initial content.
+      #
+      # Example:
+      #
+      #   PageStyle.new(page_size: :Letter) do |canvas, style|
+      #     style.frame = style.create_frame(canvas.context, 72)
+      #     style.next_style = :other
+      #     canvas.fill_color("fd0") { canvas.circle(100, 100, 50).fill }
+      #   end
+      def initialize(page_size: :A4, orientation: :portrait, &block)
+        @page_size = page_size
+        @orientation = orientation
+        @template = block
+        @frame = nil
+        @next_style = nil
+      end
+
+      # Creates a new page in the given document with this page style and returns it.
+      #
+      # If #frame has not been set beforehand or during execution of the #template, a default frame
+      # covering the whole page except a margin of 36 is created.
+      def create_page(document)
+        page = document.pages.create(media_box: page_size, orientation: orientation)
+        template&.call(page.canvas, self)
+        self.frame ||= create_frame(page, 36)
+        page
+      end
+
+      # Creates a frame based on the given page's box and margin.
+      #
+      # The +margin+ can be any value allowed by HexaPDF::Layout::Style::Quad#set.
+      #
+      # *Note*: This is a helper method for use inside the #template callable.
+      def create_frame(page, margin = 36)
+        box = page.box
+        margin = Layout::Style::Quad.new(margin)
+        Layout::Frame.new(box.left + margin.left,
+                          box.bottom + margin.bottom,
+                          box.width - margin.left - margin.right,
+                          box.height - margin.bottom - margin.top)
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/layout.rb

@@ -56,6 +56,7 @@ module HexaPDF
     autoload(:ImageBox, 'hexapdf/layout/image_box')
     autoload(:ColumnBox, 'hexapdf/layout/column_box')
     autoload(:ListBox, 'hexapdf/layout/list_box')
+    autoload(:PageStyle, 'hexapdf/layout/page_style')
 
   end
 

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/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.30.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/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_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.30.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.30.0)>>
+      <</Producer(HexaPDF version 0.31.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -171,7 +171,7 @@ describe HexaPDF::Writer do
 
   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.30.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_object_stream.rb

@@ -123,12 +123,21 @@ describe HexaPDF::Type::ObjectStream do
     end
   end
 
-  it "fails validation if gen != 0" do
-    assert(@obj.validate(auto_correct: false))
-    @obj.gen = 1
-    refute(@obj.validate(auto_correct: false) do |msg, correctable|
-             assert_match(/invalid generation/, msg)
-             refute(correctable)
-           end)
+  describe "perform_validation" do
+    it "fails validation if gen != 0" do
+      assert(@obj.validate(auto_correct: false))
+      @obj.gen = 1
+      refute(@obj.validate(auto_correct: false) do |msg, correctable|
+        assert_match(/invalid generation/, msg)
+        refute(correctable)
+      end)
+    end
+
+    it "sets the /N and /First entries to dummy values so that validation works" do
+      @obj = HexaPDF::Type::ObjectStream.new({}, oid: 1, document: @doc)
+      assert(@obj.validate(auto_correct: false))
+      assert_equal(0, @obj[:N])
+      assert_equal(0, @obj[:First])
+    end
   end
 end

data/test/hexapdf/type/test_outline.rb

@@ -30,11 +30,12 @@ describe HexaPDF::Type::Outline do
 
   describe "perform_validation" do
     before do
-      5.times { @outline.add_item("Test1") }
+      @outline_items = 5.times.map { @outline.add_item("Test1") }
     end
 
     it "fixes a missing /First entry" do
       @outline.delete(:First)
+      @outline_items[0][:Prev] = HexaPDF::Reference.new(100)
       called = false
       @outline.validate do |msg, correctable, _|
         called = true
@@ -46,6 +47,7 @@ describe HexaPDF::Type::Outline do
 
     it "fixes a missing /Last entry" do
       @outline.delete(:Last)
+      @outline_items[4][:Next] = HexaPDF::Reference.new(100)
       called = false
       @outline.validate do |msg, correctable, _|
         called = true

data/test/hexapdf/type/test_outline_item.rb

@@ -276,12 +276,13 @@ describe HexaPDF::Type::OutlineItem do
 
   describe "perform_validation" do
     before do
-      5.times { @item.add_item("Test1") }
+      @outline_items = 5.times.map { @item.add_item("Test1") }
       @item[:Parent] = @doc.add({})
     end
 
     it "fixes a missing /First entry" do
       @item.delete(:First)
+      @outline_items[0][:Prev] = HexaPDF::Reference.new(100)
       called = false
       @item.validate do |msg, correctable, _|
         called = true
@@ -293,6 +294,7 @@ describe HexaPDF::Type::OutlineItem do
 
     it "fixes a missing /Last entry" do
       @item.delete(:Last)
+      @outline_items[4][:Next] = HexaPDF::Reference.new(100)
       called = false
       @item.validate do |msg, correctable, _|
         called = true

data/test/hexapdf/type/test_page.rb

@@ -19,9 +19,21 @@ describe HexaPDF::Type::Page do
       assert_equal([0, 0, 842, 595], HexaPDF::Type::Page.media_box(:A4, orientation: :landscape))
     end
 
+    it "works with a paper size array" do
+      assert_equal([0, 0, 842, 595], HexaPDF::Type::Page.media_box([0, 0, 842, 595]))
+    end
+
     it "fails if the paper size is unknown" do
       assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box(:Unknown) }
     end
+
+    it "fails if the array doesn't contain four numbers" do
+      assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box([0, 1, 2]) }
+    end
+
+    it "fails if the array doesn't contain only numbers" do
+      assert_raises(HexaPDF::Error) { HexaPDF::Type::Page.media_box([0, 1, 2, 'a']) }
+    end
   end
 
   # Asserts that the page's contents contains the operators.
@@ -70,22 +82,41 @@ describe HexaPDF::Type::Page do
     end
   end
 
-  describe "validation" do
+  describe "perform_validation" do
     it "only does validation if the page is in the document's page tree" do
       page = @doc.add({Type: :Page})
+      assert(page.validate(auto_correct: false))
+      page[:Parent] = @doc.add({Type: :Pages, Kids: [page], Count: 1})
+      assert(page.validate(auto_correct: false))
+      @doc.pages.add(page)
+      refute(page.validate(auto_correct: false))
+    end
+
+    it "validates that the required inheritable field /Resources is set" do
+      page = @doc.pages.add
+      page.delete(:Resources)
+      refute(page.validate(auto_correct: false))
       assert(page.validate)
-      page[:Parent] = @doc.add({Type: :Pages, Kids: [page]})
-      assert(page.validate)
-      page[:Parent] = @doc.catalog.pages
-      refute(page.validate)
+      assert_kind_of(HexaPDF::Dictionary, page[:Resources])
     end
 
-    it "fails if a required inheritable field is not set" do
-      root = @doc.catalog[:Pages] = @doc.add({Type: :Pages})
-      page = @doc.add({Type: :Page, Parent: root})
-      message = ''
-      refute(page.validate {|m, _| message = m })
-      assert_match(/inheritable.*MediaBox/i, message)
+    it "validates that the required inheritable field /MediaBox is set" do
+      page1 = @doc.pages.add(:Letter)
+      page2 = @doc.pages.add(:Letter)
+      page3 = @doc.pages.add(:Letter)
+
+      [page1, page2, page3].each do |page|
+        page.delete(:MediaBox)
+        refute(page.validate(auto_correct: false))
+        assert(page.validate)
+        assert_equal([0, 0, 612, 792], page[:MediaBox])
+      end
+
+      page2.delete(:MediaBox)
+      page1[:MediaBox] = [0, 0, 1, 1]
+      refute(page2.validate(auto_correct: false))
+      assert(page2.validate)
+      assert_equal([0, 0, 595, 842], page2[:MediaBox])
     end
   end
 

data/test/hexapdf/type/test_xref_stream.rb

@@ -6,9 +6,10 @@ require 'hexapdf/type/xref_stream'
 describe HexaPDF::Type::XRefStream do
   before do
     @doc = Object.new
+    @doc.instance_variable_set(:@version, '1.5')
     def (@doc).deref(obj); obj; end
     def (@doc).wrap(obj, **); obj; end
-    @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc)
+    @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc, stream: '')
   end
 
   describe "xref_section" do
@@ -141,4 +142,8 @@ describe HexaPDF::Type::XRefStream do
       assert_raises(HexaPDF::Error) { @obj.update_with_xref_section_and_trailer(@section, {}) }
     end
   end
+
+  it "sets /Size and /W to dummy values to make validation work" do
+    assert(@obj.validate(auto_correct: false))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-13 00:00:00.000000000 Z
+date: 2023-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -428,6 +428,7 @@ files:
 - lib/hexapdf/layout/line.rb
 - lib/hexapdf/layout/list_box.rb
 - lib/hexapdf/layout/numeric_refinements.rb
+- lib/hexapdf/layout/page_style.rb
 - lib/hexapdf/layout/style.rb
 - lib/hexapdf/layout/text_box.rb
 - lib/hexapdf/layout/text_fragment.rb
@@ -679,6 +680,7 @@ files:
 - test/hexapdf/layout/test_inline_box.rb
 - test/hexapdf/layout/test_line.rb
 - test/hexapdf/layout/test_list_box.rb
+- test/hexapdf/layout/test_page_style.rb
 - test/hexapdf/layout/test_style.rb
 - test/hexapdf/layout/test_text_box.rb
 - test/hexapdf/layout/test_text_fragment.rb