hexapdf 0.17.2 → 0.19.1

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

@@ -37,7 +37,7 @@
 require 'hexapdf/dictionary'
 require 'hexapdf/stream'
 require 'hexapdf/error'
-require 'hexapdf/content/parser'
+require 'hexapdf/content'
 
 module HexaPDF
   module Type
@@ -61,14 +61,53 @@ module HexaPDF
 
         UNSET_ARG = ::Object.new # :nodoc:
 
-        # Parses the given appearance string. If no block is given, the appearance string is
-        # searched for font name and font size both of which are returend. Otherwise the block is
-        # called with each found content stream operator and has to handle them themselves.
+        # Creates an AcroForm appearance string for the HexaPDF +document+ from the given arguments
+        # and returns it.
+        #
+        # +font+::
+        #     The name of the font.
+        #
+        # +font_options+::
+        #     Additional font options like :variant used when loading the font. See
+        #     HexaPDF::Document::Fonts#add
+        #
+        # +font_size+::
+        #     The font size. If this is set to 0, the font size is calculated using the height/width
+        #     of the field.
+        #
+        # +font_color+::
+        #     The font color. See HexaPDF::Content::ColorSpace.device_color_from_specification for
+        #     allowed values.
+        def self.create_appearance_string(document, font: 'Helvetica', font_options: {},
+                                          font_size: 0, font_color: 0)
+          name = document.acro_form(create: true).default_resources.
+            add_font(document.fonts.add(font, **font_options).pdf_object)
+          font_color = HexaPDF::Content::ColorSpace.device_color_from_specification(font_color)
+          color_string = HexaPDF::Content::ColorSpace.serialize_device_color(font_color)
+          "#{color_string.chomp} /#{name} #{font_size} Tf"
+        end
+
+        # :call-seq:
+        #   VariableTextField.parse_appearance_string(string)  -> [font_name, font_size, font_color]
+        #   VariableTextField.parse_appearance_string(string) {|obj, params| block }   -> nil
+        #
+        # Parses the given appearance string.
+        #
+        # If no block is given, the appearance string is searched for font name, font size and font
+        # color all of which are returned. Otherwise the block is called with each found content
+        # stream operator and has to handle them itself.
         def self.parse_appearance_string(appearance_string, &block) # :yield: obj, params
-          font_params = nil
-          block ||= lambda {|obj, params| font_params = params.dup if obj == :Tf }
+          font_params = [nil, nil, nil]
+          block ||= lambda do |obj, params|
+            case obj
+            when :Tf
+              font_params[0, 2] = params
+            when :rg, :g, :k
+              font_params[2] = HexaPDF::Content::ColorSpace.prenormalized_device_color(params)
+            end
+          end
           HexaPDF::Content::Parser.parse(appearance_string.sub(/\/\//, '/'), &block)
-          font_params
+          block_given? ? nil : font_params
         end
 
         # :call-seq:
@@ -99,21 +138,20 @@ module HexaPDF
           end
         end
 
-        # Sets the default appearance string using the provided values.
-        #
-        # The default argument values are a sane default. If +font_size+ is set to 0, the font size
-        # is calculated using the height/width of the field.
+        # Sets the default appearance string using the provided values or the default values which
+        # provide a sane default.
         #
-        # Use the +font_options+ hash to provide font options like :variant, see
-        # HexaPDF::Document::Fonts#add.
-        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0)
-          name = document.acro_form(create: true).default_resources.
-            add_font(document.fonts.add(font, **font_options).pdf_object)
-          self[:DA] = "0 g /#{name} #{font_size} Tf"
+        # See ::create_appearance_string for information on the arguments.
+        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0,
+                                          font_color: 0)
+          self[:DA] = self.class.create_appearance_string(document, font: font,
+                                                          font_options: font_options,
+                                                          font_size: font_size,
+                                                          font_color: font_color)
         end
 
         # Parses the default appearance string and returns an array containing [font_name,
-        # font_size].
+        # font_size, font_color].
         #
         # The default appearance string is taken from the field or, if not set, the default
         # appearance string of the form.

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

@@ -268,6 +268,7 @@ module HexaPDF
             style ||= (field.check_box? ? :check : :cicrle)
             size ||= 0
             color = Content::ColorSpace.device_color_from_specification(color || 0)
+            serialized_color = Content::ColorSpace.serialize_device_color(color)
 
             self[:MK] ||= {}
             self[:MK][:CA] = case style
@@ -281,13 +282,6 @@ module HexaPDF
                              else
                                raise ArgumentError, "Unknown value #{style} for argument 'style'"
                              end
-            operator = case color.color_space.family
-                       when :DeviceRGB then :rg
-                       when :DeviceGray then :g
-                       when :DeviceCMYK then :k
-                       end
-            serialized_color = Content::Operator::DEFAULT_OPERATORS[operator].
-              serialize(HexaPDF::Serializer.new, *color.components)
             self[:DA] = "/ZaDb #{size} Tf #{serialized_color}".strip
           else
             style = case self[:MK]&.[](:CA)
@@ -306,16 +300,10 @@ module HexaPDF
                       end
                     end
             size = 0
-            color = [0]
+            color = HexaPDF::Content::ColorSpace.prenormalized_device_color([0])
             if (da = self[:DA] || field[:DA])
-              HexaPDF::Type::AcroForm::VariableTextField.parse_appearance_string(da) do |obj, params|
-                case obj
-                when :rg, :g, :k then color = params.dup
-                when :Tf then size = params[1]
-                end
-              end
+              _, size, color = HexaPDF::Type::AcroForm::VariableTextField.parse_appearance_string(da)
             end
-            color = HexaPDF::Content::ColorSpace.prenormalized_device_color(color)
 
             MarkerStyle.new(style, size, color)
           end

data/lib/hexapdf/type/font.rb

@@ -98,6 +98,11 @@ module HexaPDF
         embedded?
       end
 
+      # Returns the glyph scaling factor for transforming from glyph space to text space.
+      def glyph_scaling_factor
+        0.001
+      end
+
       private
 
       # Parses and caches the ToUnicode CMap.

data/lib/hexapdf/type/font_type3.rb

@@ -41,6 +41,10 @@ module HexaPDF
 
     # Represents a Type 3 font.
     #
+    # Note: We assume the /FontMatrix is only used for scaling, i.e. of the form [x 0 0 +/-x 0 0].
+    # If it is of a different form, things won't work correctly. This will be handled once such a
+    # case is found.
+    #
     # See: PDF1.7 s9.6.5
     class FontType3 < FontSimple
 
@@ -51,6 +55,22 @@ module HexaPDF
       define_field :CharProcs,  type: Dictionary, required: true
       define_field :Resources,  type: Dictionary, version: '1.2'
 
+      # Returns the bounding box of the font.
+      def bounding_box
+        matrix = self[:FontMatrix]
+        bbox = self[:FontBBox].value
+        if matrix[3] < 0    # Some writers invert the y-axis
+          bbox = bbox.dup
+          bbox[1], bbox[3] = -bbox[3], -bbox[1]
+        end
+        bbox
+      end
+
+      # Returns the glyph scaling factor for transforming from glyph space to text space.
+      def glyph_scaling_factor
+        self[:FontMatrix][0]
+      end
+
       private
 
       def perform_validation

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

@@ -0,0 +1,125 @@
+# -*- 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-2021 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 'openssl'
+require 'hexapdf/type/signature'
+
+module HexaPDF
+  module Type
+    class Signature
+
+      # The signature handler for the adbe.pkcs7.detached sub-filter.
+      class AdbePkcs7Detached < Handler
+
+        # Creates a new signature handler for the given signature dictionary.
+        def initialize(signature_dict)
+          super
+          @pkcs7 = OpenSSL::PKCS7.new(signature_dict.contents)
+        end
+
+        # Returns the common name of the signer.
+        def signer_name
+          signer_certificate.subject.to_a.assoc("CN")&.[](1) || super
+        end
+
+        # Returns the time of signing.
+        def signing_time
+          signer_info.signed_time rescue super
+        end
+
+        # Returns the certificate chain.
+        def certificate_chain
+          @pkcs7.certificates
+        end
+
+        # Returns the signer certificate (an instance of OpenSSL::X509::Certificate).
+        def signer_certificate
+          info = signer_info
+          certificate_chain.find {|cert| cert.issuer == info.issuer && cert.serial == info.serial }
+        end
+
+        # Returns the signer information object (an instance of OpenSSL::PKCS7::SignerInfo).
+        def signer_info
+          @pkcs7.signers.first
+        end
+
+        # Verifies the signature using the provided OpenSSL::X509::Store object.
+        def verify(store, allow_self_signed: false)
+          result = VerificationResult.new
+
+          signer_info = self.signer_info
+          signer_certificate = self.signer_certificate
+          certificate_chain = self.certificate_chain
+
+          if certificate_chain.empty?
+            result.log(:error, "No certificates found in signature")
+            return result
+          end
+
+          if @pkcs7.signers.size != 1
+            result.log(:error, "Exactly one signer needed, found #{@pkcs7.signers.size}")
+          end
+
+          unless signer_certificate
+            result.log(:error, "Signer serial=#{signer_info.serial} issuer=#{signer_info.issuer} " \
+                       "not found in certificates stored in PKCS7 object")
+            return result
+          end
+
+          key_usage = signer_certificate.extensions.find {|ext| ext.oid == 'keyUsage' }
+          unless key_usage && key_usage.value.split(', ').include?("Digital Signature")
+            result.log(:error, "Certificate key usage is missing 'Digital Signature'")
+          end
+
+          verify_signing_time(result)
+
+          store.verify_callback = store_verification_callback(result,
+                                                              allow_self_signed: allow_self_signed)
+          if @pkcs7.verify(certificate_chain, store, signature_dict.signed_data,
+                           OpenSSL::PKCS7::DETACHED | OpenSSL::PKCS7::BINARY)
+            result.log(:info, "Signature valid")
+          else
+            result.log(:error, "Signature verification failed")
+          end
+
+          result
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/version.rb

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

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -55,21 +55,29 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
 
     it "draws the arc onto the canvas" do
       {
-        [false, false] => {cx: 100, cy: 50, start_angle: 180, end_angle: 270, clockwise: false},
-        [false, true] => {cx: 50, cy: 25, start_angle: 90, end_angle: 0, clockwise: true},
-        [true, false] => {cx: 50, cy: 25, start_angle: 90, end_angle: 360, clockwise: false},
-        [true, true] => {cx: 100, cy: 50, start_angle: 180, end_angle: -90, clockwise: true},
+        [false, false] => {cx: 100, cy: 50, a: 50, b: 25, start_angle: 180, end_angle: 270, clockwise: false},
+        [false, true] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 0, clockwise: true},
+        [true, false] => {cx: 50, cy: 25, a: 50, b: 25, start_angle: 90, end_angle: 360, clockwise: false},
+        [true, true] => {cx: 0, cy: 0, a: 40, b: 30, start_angle: 60, end_angle: 120},
       }.each do |(large_arc, clockwise), data|
         @page.delete(:Contents)
         canvas = @page.canvas
-        canvas.draw(:arc, a: 50, b: 25, inclination: 0, **data)
+        arc = canvas.graphic_object(:arc, **data)
+        canvas.draw(arc)
         arc_data = @page.contents
 
         canvas.contents.clear
         assert(@page.contents.empty?)
-        canvas.move_to(50.0, 50.0)
-        canvas.draw(:endpoint_arc, x: 100, y: 25, a: 50, b: 25, inclination: 0,
-                    large_arc: large_arc, clockwise: clockwise)
+        canvas.move_to(*arc.start_point)
+        earc = canvas.graphic_object(:endpoint_arc, x: arc.end_point[0], y: arc.end_point[1],
+                                     a: data[:a], b: data[:b], inclination: data[:inclination] || 0,
+                                     large_arc: large_arc, clockwise: clockwise)
+        canvas.draw(earc)
+        narc = canvas.graphic_object(:arc, **earc.send(:compute_arc_values, *arc.start_point))
+        assert_in_delta(arc.start_point[0], narc.start_point[0], 0.0001)
+        assert_in_delta(arc.start_point[1], narc.start_point[1], 0.0001)
+        assert_in_delta(arc.end_point[0], narc.end_point[0], 0.0001)
+        assert_in_delta(arc.end_point[1], narc.end_point[1], 0.0001)
         assert_equal(arc_data, @page.contents)
       end
     end

data/test/hexapdf/content/test_color_space.rb

@@ -99,6 +99,32 @@ describe HexaPDF::Content::ColorSpace do
     end
   end
 
+  describe "self.serialize_device_color" do
+    it "works for device gray colors" do
+      color = @class.device_color_from_specification(0.5)
+      assert_equal("0.5 g\n", @class.serialize_device_color(color))
+      assert_equal("0.5 G\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "works for device RGB colors" do
+      color = @class.device_color_from_specification("red")
+      assert_equal("1.0 0.0 0.0 rg\n", @class.serialize_device_color(color))
+      assert_equal("1.0 0.0 0.0 RG\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "works for device CMYK colors" do
+      color = @class.device_color_from_specification([100, 100, 100, 0])
+      assert_equal("1.0 1.0 1.0 0.0 k\n", @class.serialize_device_color(color))
+      assert_equal("1.0 1.0 1.0 0.0 K\n", @class.serialize_device_color(color, type: :stroke))
+    end
+
+    it "fails if no device color is provided" do
+      assert_raises(ArgumentError) do
+        @class.serialize_device_color(@class::Universal.new([]).default_color)
+      end
+    end
+  end
+
   it "returns a device color object for prenormalized color values" do
     assert_equal([5, 6, 7], @class.prenormalized_device_color([5, 6, 7]).components)
   end

data/test/hexapdf/content/test_graphics_state.rb

@@ -2,6 +2,7 @@
 
 require 'test_helper'
 require 'hexapdf/content/graphics_state'
+require 'ostruct'
 
 # Dummy class used as wrapper so that constant lookup works correctly
 class GraphicsStateWrapper < Minitest::Spec
@@ -146,6 +147,13 @@ class GraphicsStateWrapper < Minitest::Spec
     it "fails when restoring the graphics state if the stack is empty" do
       assert_raises(HexaPDF::Error) { @gs.restore }
     end
-  end
 
+    it "uses the correct glyph to text space scaling" do
+      font = OpenStruct.new
+      font.glyph_scaling_factor = 0.002
+      @gs.font = font
+      @gs.font_size = 10
+      assert_equal(0.02, @gs.scaled_font_size)
+    end
+  end
 end

data/test/hexapdf/content/test_operator.rb

@@ -4,6 +4,7 @@ require 'test_helper'
 require 'hexapdf/content/operator'
 require 'hexapdf/content/processor'
 require 'hexapdf/serializer'
+require 'ostruct'
 
 describe HexaPDF::Content::Operator::BaseOperator do
   before do
@@ -190,9 +191,11 @@ end
 
 describe_operator :SetGraphicsStateParameters, :gs do
   it "applies parameters from an ExtGState dictionary" do
+    font = OpenStruct.new
+    font.glyph_scaling_factor = 0.01
     @processor.resources[:ExtGState] = {Name: {LW: 10, LC: 2, LJ: 2, ML: 2, D: [[3, 5], 2],
                                                RI: 2, SA: true, BM: :Multiply, CA: 0.5, ca: 0.5,
-                                               AIS: true, TK: false, Font: [:Test, 10]}}
+                                               AIS: true, TK: false, Font: [font, 10]}}
     @processor.resources.define_singleton_method(:document) do
       Object.new.tap {|obj| obj.define_singleton_method(:deref) {|o| o } }
     end
@@ -210,7 +213,7 @@ describe_operator :SetGraphicsStateParameters, :gs do
     assert_equal(0.5, gs.stroke_alpha)
     assert_equal(0.5, gs.fill_alpha)
     assert(gs.alpha_source)
-    assert_equal(:Test, gs.font)
+    assert_equal(font, gs.font)
     assert_equal(10, gs.font_size)
     refute(gs.text_knockout)
   end
@@ -448,7 +451,9 @@ describe_operator :SetFontAndSize, :Tf do
       self[:Font] && self[:Font][name]
     end
 
-    @processor.resources[:Font] = {F1: :test}
+    font = OpenStruct.new
+    font.glyph_scaling_factor = 0.01
+    @processor.resources[:Font] = {F1: font}
     invoke(:F1, 10)
     assert_equal(@processor.resources.font(:F1), @processor.graphics_state.font)
     assert_equal(10, @processor.graphics_state.font_size)

data/test/hexapdf/encryption/test_security_handler.rb

@@ -107,9 +107,11 @@ describe HexaPDF::Encryption::SecurityHandler do
       end
 
       it "updates the trailer's /Encrypt entry to be wrapped by an encryption dictionary" do
-        @document.trailer[:Encrypt] = {Filter: :Test, V: 1}
+        @document.trailer[:Encrypt] = {Filter: :Test,
+                                       V: HexaPDF::Object.new(1, oid: 1, document: @document)}
         HexaPDF::Encryption::SecurityHandler.set_up_decryption(@document)
         assert_kind_of(HexaPDF::Encryption::EncryptionDictionary, @document.trailer[:Encrypt])
+        assert_equal({Filter: :Test, V: 1}, @document.trailer[:Encrypt].value)
       end
 
       it "returns the frozen security handler" do

data/test/hexapdf/layout/test_style.rb

@@ -597,6 +597,11 @@ end
 describe HexaPDF::Layout::Style do
   before do
     @style = HexaPDF::Layout::Style.new
+    @style.font = Object.new.tap do |obj|
+      obj.define_singleton_method(:pdf_object) do
+        Object.new.tap {|pdf| pdf.define_singleton_method(:glyph_scaling_factor) { 0.001 } }
+      end
+    end
   end
 
   it "can assign values on initialization" do
@@ -644,6 +649,7 @@ describe HexaPDF::Layout::Style do
   end
 
   it "has several simple and dynamically generated properties with default values" do
+    @style = HexaPDF::Layout::Style.new
     assert_raises(HexaPDF::Error) { @style.font }
     assert_equal(10, @style.font_size)
     assert_equal(0, @style.character_spacing)
@@ -725,6 +731,11 @@ describe HexaPDF::Layout::Style do
       font = Object.new
       font.define_singleton_method(:scaling_factor) { 1 }
       font.define_singleton_method(:wrapped_font) { wrapped_font }
+      font.define_singleton_method(:pdf_object) do
+        obj = Object.new
+        obj.define_singleton_method(:glyph_scaling_factor) { 0.001 }
+        obj
+      end
       @style.font = font
     end
 

data/test/hexapdf/task/test_optimize.rb

@@ -159,4 +159,30 @@ describe HexaPDF::Task::Optimize do
       assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)
     end
   end
+
+  describe "prune_page_resources" do
+    it "removes all unused XObject references" do
+      [false, true].each do |compress_pages|
+        page1 = @doc.pages.add
+        page1.resources[:XObject] = {}
+        page1.resources[:XObject][:test] = @doc.add({})
+        page1.resources[:XObject][:used_on_page2] = @doc.add({})
+        page1.resources[:XObject][:unused] = @doc.add({})
+        page1.contents = "/test Do"
+        page2 = @doc.pages.add
+        page2.resources[:XObject] = {}
+        page2.resources[:XObject][:used_on2] = page1.resources[:XObject][:used_on_page2]
+        page2.resources[:XObject][:also_unused] = page1.resources[:XObject][:unused]
+        page2.contents = "/used_on2 Do"
+
+        @doc.task(:optimize, prune_page_resources: true, compress_pages: compress_pages)
+
+        assert(page1.resources[:XObject].key?(:test))
+        assert(page1.resources[:XObject].key?(:used_on_page2))
+        refute(page1.resources[:XObject].key?(:unused))
+        assert(page2.resources[:XObject].key?(:used_on2))
+        refute(page2.resources[:XObject].key?(:also_unused))
+      end
+    end
+  end
 end

data/test/hexapdf/test_dictionary.rb

@@ -20,6 +20,7 @@ describe HexaPDF::Dictionary do
   end
 
   def delete(_obj)
+    _obj.data.value = nil
   end
 
   def wrap(obj, type:)

data/test/hexapdf/test_dictionary_fields.rb

@@ -135,12 +135,12 @@ describe HexaPDF::DictionaryFields do
     end
 
     def configuration
-      {'document.on_invalid_string' => proc {|str| str }}
+      HexaPDF::Configuration.with_defaults
     end
 
     it "calls document.on_invalid_string if the provided string is invalid" do
       str = "\xfe\xff\xD8\x00\x00s\x00t".b
-      assert_equal("\xD8\x00\x00s\x00t".force_encoding("UTF-16BE"), @field.convert(str, self))
+      assert_equal("st", @field.convert(str, self))
     end
   end
 
@@ -173,6 +173,7 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Time object from a binary string" do
       refute(@field.convert('test'.b, self))
+      refute(@field.convert('D:01211016165909+00\'64'.b, self))
 
       [
         ["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],

data/test/hexapdf/test_object.rb

@@ -45,6 +45,34 @@ describe HexaPDF::Object do
     end
   end
 
+  describe "class.make_direct" do
+    before do
+      @doc = HexaPDF::Document.new
+    end
+
+    it "doesn't touch wrapped direct objects" do
+      obj = HexaPDF::Object.new(5)
+      assert_same(obj, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for simple values" do
+      obj = HexaPDF::Object.new(5, oid: 1, document: @doc)
+      assert_same(5, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for hashes" do
+      obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)},
+                                    oid: 1, document: @doc)
+      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj))
+    end
+
+    it "works for arrays" do
+      obj = HexaPDF::PDFArray.new([:b, HexaPDF::Object.new(:a, oid: 3, document: @doc)],
+                                    oid: 1, document: @doc)
+      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj))
+    end
+  end
+
   describe "initialize" do
     it "uses a simple value as is" do
       obj = HexaPDF::Object.new(5)

data/test/hexapdf/test_parser.rb

@@ -607,11 +607,22 @@ describe HexaPDF::Parser do
       assert_equal(4, @parser.load_object(@xref).value)
     end
 
+    it "handles an invalid object as first object" do
+      create_parser("2 0 obj\n(a(b\nendobj\n1 0 obj\n6\nendobj #)(\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
+    end
+
     it "ignores invalid lines" do
       create_parser("1 0 obj\n5\nendobj\nhello there\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
+    it "resets the header offset" do
+      create_parser("1 0 obj\n5\nendobj\ntrailer\n<</Size 1>>")
+      @parser.instance_variable_set(:@header_offset, 5)
+      assert_equal(5, @parser.load_object(@xref).value)
+    end
+
     it "uses the last trailer" do
       create_parser("trailer <</Size 1>>\ntrailer <</Size 2/Prev 342>>")
       assert_equal({Size: 2}, @parser.reconstructed_revision.trailer.value)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.17.2)>>
+      <</Producer(HexaPDF version 0.19.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.17.2)>>
+      <</Producer(HexaPDF version 0.19.1)>>
       endobj
       2 0 obj
       <</Length 10>>stream