origami-docspring 2.2.0 → 2.3.0

data/lib/origami/pdf.rb

@@ -1,22 +1,22 @@
-=begin
-
-    This file is part of Origami, PDF manipulation framework for Ruby
-    Copyright (C) 2016	Guillaume Delugré.
-
-    Origami is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    Origami 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 Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
-
-=end
+# frozen_string_literal: true
+
+#
+#     This file is part of Origami, PDF manipulation framework for Ruby
+#     Copyright (C) 2016	Guillaume Delugré.
+#
+#     Origami is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Lesser General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     Origami 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 Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public License
+#     along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+#
 
 require 'origami/object'
 require 'origami/compound'
@@ -62,1047 +62,1037 @@ require 'origami/parsers/pdf/linear'
 require 'origami/parsers/pdf/lazy'
 
 module Origami
-
-    class InvalidPDFError < Error #:nodoc:
+  class InvalidPDFError < Error # :nodoc:
+  end
+
+  #
+  # Main class representing a PDF file and its inner contents.
+  # A PDF file contains a set of Revision.
+  #
+  class PDF
+    #
+    # Class representing a particular revision in a PDF file.
+    # Revision contains :
+    # * A Body, which is a sequence of Object.
+    # * A XRef::Section, holding XRef information about objects in body.
+    # * A Trailer.
+    #
+    class Revision
+      attr_accessor :pdf
+      attr_accessor :body, :xreftable, :xrefstm
+      attr_reader :trailer
+
+      def initialize(doc)
+        @document = doc
+        @body = {}
+        @xreftable = nil
+        @xrefstm = nil
+        @trailer = nil
+      end
+
+      def trailer=(trl)
+        trl.document = @document
+
+        @trailer = trl
+      end
+
+      def xreftable?
+        !@xreftable.nil?
+      end
+
+      def xrefstm?
+        !@xrefstm.nil?
+      end
+
+      def each_object(&b)
+        @body.each_value(&b)
+      end
+
+      def objects
+        @body.values
+      end
     end
 
     #
-    # Main class representing a PDF file and its inner contents.
-    # A PDF file contains a set of Revision.
+    # Document header and revisions.
     #
-    class PDF
-
-        #
-        # Class representing a particular revision in a PDF file.
-        # Revision contains :
-        # * A Body, which is a sequence of Object.
-        # * A XRef::Section, holding XRef information about objects in body.
-        # * A Trailer.
-        #
-        class Revision
-            attr_accessor :pdf
-            attr_accessor :body, :xreftable, :xrefstm
-            attr_reader :trailer
-
-            def initialize(doc)
-                @document = doc
-                @body = {}
-                @xreftable = nil
-                @xrefstm = nil
-                @trailer = nil
-            end
-
-            def trailer=(trl)
-                trl.document = @document
-
-                @trailer = trl
-            end
-
-            def xreftable?
-                not @xreftable.nil?
-            end
-
-            def xrefstm?
-                not @xrefstm.nil?
-            end
-
-            def each_object(&b)
-                @body.each_value(&b)
-            end
-
-            def objects
-                @body.values
-            end
+    attr_accessor :header, :revisions
+
+    class << self
+      #
+      # Reads and parses a PDF file from disk.
+      #
+      def read(path, options = {})
+        path = File.expand_path(path) if path.is_a?(::String)
+        lazy = options[:lazy]
+
+        parser_class = if lazy
+          PDF::LazyParser
+        else
+          PDF::LinearParser
         end
 
-        #
-        # Document header and revisions.
-        #
-        attr_accessor :header, :revisions
-
-        class << self
-            #
-            # Reads and parses a PDF file from disk.
-            #
-            def read(path, options = {})
-                path = File.expand_path(path) if path.is_a?(::String)
-                lazy = options[:lazy]
-
-                if lazy
-                    parser_class = PDF::LazyParser
-                else
-                    parser_class = PDF::LinearParser
-                end
-
-                parser_class.new(options).parse(path)
-            end
+        parser_class.new(options).parse(path)
+      end
+
+      #
+      # Creates a new PDF and saves it.
+      # If a block is passed, the PDF instance can be processed before saving.
+      #
+      def create(output, options = {})
+        pdf = PDF.new
+        yield(pdf) if block_given?
+        pdf.save(output, options)
+      end
+      alias_method :write, :create
+    end
 
-            #
-            # Creates a new PDF and saves it.
-            # If a block is passed, the PDF instance can be processed before saving.
-            #
-            def create(output, options = {})
-                pdf = PDF.new
-                yield(pdf) if block_given?
-                pdf.save(output, options)
-            end
-            alias write create
-        end
+    #
+    # Creates a new PDF instance.
+    # _parser_:: The Parser object creating the document.
+    #            If none is specified, some default structures are automatically created to get a minimal working document.
+    #
+    def initialize(parser = nil)
+      @header = PDF::Header.new
+      @revisions = []
+      @parser = parser
+      @loaded = false
 
-        #
-        # Creates a new PDF instance.
-        # _parser_:: The Parser object creating the document.
-        #            If none is specified, some default structures are automatically created to get a minimal working document.
-        #
-        def initialize(parser = nil)
-            @header = PDF::Header.new
-            @revisions = []
-            @parser = parser
-            @loaded = false
+      add_new_revision
+      @revisions.first.trailer = Trailer.new
 
-            add_new_revision
-            @revisions.first.trailer = Trailer.new
+      init if parser.nil?
+    end
 
-            init if parser.nil?
-        end
+    #
+    # Original file name if parsed from disk, nil otherwise.
+    #
+    def original_filename
+      @parser&.target_filename
+    end
 
-        #
-        # Original file name if parsed from disk, nil otherwise.
-        #
-        def original_filename
-            @parser.target_filename if @parser
-        end
+    #
+    # Original file size if parsed from a data stream, nil otherwise.
+    #
+    def original_filesize
+      @parser&.target_filesize
+    end
 
-        #
-        # Original file size if parsed from a data stream, nil otherwise.
-        #
-        def original_filesize
-            @parser.target_filesize if @parser
-        end
+    #
+    # Original data parsed to create this document, nil if created from scratch.
+    #
+    def original_data
+      @parser&.target_data
+    end
 
-        #
-        # Original data parsed to create this document, nil if created from scratch.
-        #
-        def original_data
-            @parser.target_data if @parser
-        end
+    #
+    # Saves the current document.
+    # _filename_:: The path where to save this PDF.
+    #
+    def save(path, params = {})
+      options =
+        {
+          delinearize: true,
+          recompile: true,
+          decrypt: false
+        }
+      options.update(params)
+
+      if frozen? # incompatible flags with frozen doc (signed)
+        options[:recompile] =
+          options[:rebuild_xrefs] =
+            options[:noindent] =
+              options[:obfuscate] = false
+      end
+
+      if path.respond_to?(:write)
+        fd = path
+      else
+        path = File.expand_path(path)
+        fd = File.open(path, 'w').binmode
+        close = true
+      end
+
+      load_all_objects unless loaded?
+
+      intents_as_pdfa1 if options[:intent] =~ /pdf[\/-]?A1?/i
+      delinearize! if options[:delinearize] && linearized?
+      compile(options) if options[:recompile]
+
+      fd.write output(options)
+      fd.close if close
+
+      self
+    end
+    alias_method :write, :save
 
-        #
-        # Saves the current document.
-        # _filename_:: The path where to save this PDF.
-        #
-        def save(path, params = {})
-            options =
-            {
-                delinearize: true,
-                recompile: true,
-                decrypt: false
-            }
-            options.update(params)
-
-            if self.frozen? # incompatible flags with frozen doc (signed)
-                options[:recompile] =
-                options[:rebuild_xrefs] =
-                options[:noindent] =
-                options[:obfuscate] = false
-            end
+    #
+    # Saves the file up to given revision number.
+    # This can be useful to visualize the modifications over different incremental updates.
+    # _revision_:: The revision number to save.
+    # _filename_:: The path where to save this PDF.
+    #
+    def save_upto(revision, filename)
+      save(filename, up_to_revision: revision)
+    end
 
-            if path.respond_to?(:write)
-                fd = path
-            else
-                path = File.expand_path(path)
-                fd = File.open(path, 'w').binmode
-                close = true
-            end
+    #
+    # Returns an array of strings, names and streams matching the given pattern.
+    # _streams_: Search into decoded stream data.
+    # _object_streams_: Search into objects inside object streams.
+    #
+    def grep(pattern, streams: true, object_streams: true) # :nodoc:
+      pattern = /#{Regexp.escape(pattern)}/i if pattern.is_a?(::String)
+      raise TypeError, "Expected a String or Regexp" unless pattern.is_a?(Regexp)
 
-            load_all_objects unless loaded?
+      result = []
 
-            intents_as_pdfa1 if options[:intent] =~ /pdf[\/-]?A1?/i
-            self.delinearize! if options[:delinearize] and self.linearized?
-            compile(options) if options[:recompile]
+      indirect_objects.each do |object|
+        result.concat search_object(object, pattern,
+          streams: streams, object_streams: object_streams)
+      end
 
-            fd.write output(options)
-            fd.close if close
+      result
+    end
 
-            self
-        end
-        alias write save
+    #
+    # Returns an array of Objects whose name (in a Dictionary) is matching _pattern_.
+    #
+    def ls(pattern, follow_references: true)
+      pattern = /#{Regexp.escape(pattern)}/i if pattern.is_a?(::String)
+      raise TypeError, "Expected a String or Regexp" unless pattern.is_a?(Regexp)
+
+      grep(pattern, streams: false, object_streams: true)
+        .select { |object| object.is_a?(Name) and object.parent.is_a?(Dictionary) and object.parent.key?(object) }
+        .collect { |object|
+        result = object.parent[object]
+        follow_references ? result.solve : result
+      }
+    end
 
-        #
-        # Saves the file up to given revision number.
-        # This can be useful to visualize the modifications over different incremental updates.
-        # _revision_:: The revision number to save.
-        # _filename_:: The path where to save this PDF.
-        #
-        def save_upto(revision, filename)
-            save(filename, up_to_revision: revision)
-        end
+    #
+    # Iterates over the objects of the document.
+    # _compressed_: iterates over the objects inside object streams.
+    # _recursive_: iterates recursively inside objects like arrays and dictionaries.
+    #
+    def each_object(compressed: false, recursive: false, &block)
+      unless block_given?
+        return enum_for(__method__, compressed: compressed,
+          recursive: recursive)
+      end
 
-        #
-        # Returns an array of strings, names and streams matching the given pattern.
-        # _streams_: Search into decoded stream data.
-        # _object_streams_: Search into objects inside object streams.
-        #
-        def grep(pattern, streams: true, object_streams: true) #:nodoc:
+      @revisions.each do |revision|
+        revision.each_object do |object|
+          block.call(object)
 
-            pattern = /#{Regexp.escape(pattern)}/i if pattern.is_a?(::String)
-            raise TypeError, "Expected a String or Regexp" unless pattern.is_a?(Regexp)
+          walk_object(object, &block) if recursive
 
-            result = []
+          if object.is_a?(ObjectStream) && compressed
+            object.each do |child_obj|
+              block.call(child_obj)
 
-            self.indirect_objects.each do |object|
-                result.concat search_object(object, pattern,
-                                            streams: streams, object_streams: object_streams)
+              walk_object(child_obj) if recursive
             end
-
-            result
+          end
         end
+      end
+    end
 
-        #
-        # Returns an array of Objects whose name (in a Dictionary) is matching _pattern_.
-        #
-        def ls(pattern, follow_references: true)
-
-            pattern = /#{Regexp.escape(pattern)}/i if pattern.is_a?(::String)
-            raise TypeError, "Expected a String or Regexp" unless pattern.is_a?(Regexp)
-
-            self.grep(pattern, streams: false, object_streams: true)
-                .select {|object| object.is_a?(Name) and object.parent.is_a?(Dictionary) and object.parent.key?(object) }
-                .collect {|object| result = object.parent[object]; follow_references ? result.solve : result }
-        end
+    #
+    # Return an array of indirect objects.
+    #
+    def indirect_objects
+      @revisions.inject([]) do |set, rev| set.concat(rev.objects) end
+    end
+    alias_method :root_objects, :indirect_objects
 
-        #
-        # Iterates over the objects of the document.
-        # _compressed_: iterates over the objects inside object streams.
-        # _recursive_: iterates recursively inside objects like arrays and dictionaries.
-        #
-        def each_object(compressed: false, recursive: false, &block)
-            return enum_for(__method__, compressed: compressed,
-                                        recursive: recursive
-                           ) unless block_given?
+    #
+    # Adds a new object to the PDF file.
+    # If this object has no version number, then a new one will be automatically
+    # computed and assignated to him.
+    #
+    # It returns a Reference to this Object.
+    # _object_:: The object to add.
+    #
+    def <<(object)
+      owner = object.document
+
+      #
+      # Does object belongs to another PDF ?
+      #
+      if owner && !owner.equal?(self)
+        import object
+      else
+        add_to_revision(object, @revisions.last)
+      end
+    end
+    alias_method :insert, :<<
 
-            @revisions.each do |revision|
-                revision.each_object do |object|
-                    block.call(object)
+    #
+    # Similar to PDF#insert or PDF#<<, but for an object belonging to another document.
+    # Object will be recursively copied and new version numbers will be assigned.
+    # Returns the new reference to the imported object.
+    # _object_:: The object to import.
+    #
+    def import(object)
+      insert(object.export)
+    end
 
-                    walk_object(object, &block) if recursive
+    #
+    # Adds a new object to a specific revision.
+    # If this object has no version number, then a new one will be automatically
+    # computed and assignated to him.
+    #
+    # It returns a Reference to this Object.
+    # _object_:: The object to add.
+    # _revision_:: The revision to add the object to.
+    #
+    def add_to_revision(object, revision)
+      object.set_indirect(true)
+      object.set_document(self)
 
-                    if object.is_a?(ObjectStream) and compressed
-                        object.each do |child_obj|
-                            block.call(child_obj)
+      object.no, object.generation = allocate_new_object_number if object.no == 0
 
-                            walk_object(child_obj) if recursive
-                        end
-                    end
-                end
-            end
-        end
+      revision.body[object.reference] = object
 
-        #
-        # Return an array of indirect objects.
-        #
-        def indirect_objects
-            @revisions.inject([]) do |set, rev| set.concat(rev.objects) end
-        end
-        alias root_objects indirect_objects
+      object.reference
+    end
 
-        #
-        # Adds a new object to the PDF file.
-        # If this object has no version number, then a new one will be automatically
-        # computed and assignated to him.
-        #
-        # It returns a Reference to this Object.
-        # _object_:: The object to add.
-        #
-        def <<(object)
-            owner = object.document
-
-            #
-            # Does object belongs to another PDF ?
-            #
-            if owner and not owner.equal?(self)
-                import object
-            else
-                add_to_revision(object, @revisions.last)
-            end
-        end
-        alias insert <<
+    #
+    # Ends the current Revision, and starts a new one.
+    #
+    def add_new_revision
+      root = @revisions.last.trailer[:Root] unless @revisions.empty?
 
-        #
-        # Similar to PDF#insert or PDF#<<, but for an object belonging to another document.
-        # Object will be recursively copied and new version numbers will be assigned.
-        # Returns the new reference to the imported object.
-        # _object_:: The object to import.
-        #
-        def import(object)
-            self.insert(object.export)
-        end
+      @revisions << Revision.new(self)
+      @revisions.last.trailer = Trailer.new
+      @revisions.last.trailer.Root = root
 
-        #
-        # Adds a new object to a specific revision.
-        # If this object has no version number, then a new one will be automatically
-        # computed and assignated to him.
-        #
-        # It returns a Reference to this Object.
-        # _object_:: The object to add.
-        # _revision_:: The revision to add the object to.
-        #
-        def add_to_revision(object, revision)
-            object.set_indirect(true)
-            object.set_document(self)
+      self
+    end
 
-            object.no, object.generation = allocate_new_object_number if object.no == 0
+    #
+    # Removes a whole document revision.
+    # _index_:: Revision index, first is 0.
+    #
+    def remove_revision(index)
+      if (index < 0) || (index > @revisions.size)
+        raise IndexError, "Not a valid revision index"
+      end
 
-            revision.body[object.reference] = object
+      if @revisions.size == 1
+        raise InvalidPDFError, "Cannot remove last revision"
+      end
 
-            object.reference
-        end
+      @revisions.delete_at(index)
+      self
+    end
 
-        #
-        # Ends the current Revision, and starts a new one.
-        #
-        def add_new_revision
-            root = @revisions.last.trailer[:Root] unless @revisions.empty?
+    #
+    # Looking for an object present at a specified file offset.
+    #
+    def get_object_by_offset(offset) # :nodoc:
+      each_object.find { |obj| obj.file_offset == offset }
+    end
 
-            @revisions << Revision.new(self)
-            @revisions.last.trailer = Trailer.new
-            @revisions.last.trailer.Root = root
+    #
+    # Remove an object.
+    #
+    def delete_object(no, generation = 0)
+      case no
+      when Reference
+        target = no
+      when ::Integer
+        target = Reference.new(no, generation)
+      else
+        raise TypeError, "Invalid parameter type : #{no.class}"
+      end
+
+      @revisions.each do |rev|
+        rev.body.delete(target)
+      end
+    end
 
-            self
+    #
+    # Search for an indirect object in the document.
+    # _no_:: Reference or number of the object.
+    # _generation_:: Object generation.
+    #
+    def get_object(no, generation = 0, use_xrefstm: true) # :nodoc:
+      case no
+      when Reference
+        target = no
+      when ::Integer
+        target = Reference.new(no, generation)
+      when Origami::Object
+        return no
+      else
+        raise TypeError, "Invalid parameter type : #{no.class}"
+      end
+
+      #
+      # Search through accessible indirect objects.
+      #
+      @revisions.reverse_each do |rev|
+        return rev.body[target] if rev.body.include?(target)
+      end
+
+      #
+      # Search through xref sections.
+      #
+      @revisions.reverse_each do |rev|
+        next unless rev.xreftable?
+
+        xref = rev.xreftable.find(target.refno)
+        next if xref.nil? || xref.free?
+
+        # Try loading the object if it is not present.
+        object = load_object_at_offset(rev, xref.offset)
+        return object unless object.nil?
+      end
+
+      return nil unless use_xrefstm
+
+      # Search through xref streams.
+      @revisions.reverse_each do |rev|
+        next unless rev.xrefstm?
+
+        xrefstm = rev.xrefstm
+
+        xref = xrefstm.find(target.refno)
+        next if xref.nil?
+
+        #
+        # We found a matching XRef.
+        #
+        if xref.is_a?(XRefToCompressedObject)
+          objstm = get_object(xref.objstmno, 0, use_xrefstm: use_xrefstm)
+
+          object = objstm.extract_by_index(xref.index)
+          if object.is_a?(Origami::Object) && (object.no == target.refno)
+            return object
+          else
+            return objstm.extract(target.refno)
+          end
+        elsif xref.is_a?(XRef)
+          object = load_object_at_offset(rev, xref.offset)
+          return object unless object.nil?
         end
+      end
 
-        #
-        # Removes a whole document revision.
-        # _index_:: Revision index, first is 0.
-        #
-        def remove_revision(index)
-            if index < 0 or index > @revisions.size
-                raise IndexError, "Not a valid revision index"
-            end
-
-            if @revisions.size == 1
-                raise InvalidPDFError, "Cannot remove last revision"
-            end
+      #
+      # Lastly search directly into Object streams (might be very slow).
+      #
+      @revisions.reverse_each do |rev|
+        stream = rev.objects.find { |obj| obj.is_a?(ObjectStream) and obj.include?(target.refno) }
+        return stream.extract(target.refno) unless stream.nil?
+      end
 
-            @revisions.delete_at(index)
-            self
-        end
+      nil
+    end
+    alias_method :[], :get_object
 
-        #
-        # Looking for an object present at a specified file offset.
-        #
-        def get_object_by_offset(offset) #:nodoc:
-            self.each_object.find { |obj| obj.file_offset == offset }
-        end
+    #
+    # Casts a PDF object into another object type.
+    # The target type must be a subtype of the original type.
+    #
+    def cast_object(reference, type) # :nodoc:
+      @revisions.each do |rev|
+        if rev.body.include?(reference)
+          object = rev.body[reference]
+          return object if object.is_a?(type)
 
-        #
-        # Remove an object.
-        #
-        def delete_object(no, generation = 0)
-            case no
-            when Reference
-                target = no
-            when ::Integer
-                target = Reference.new(no, generation)
-            else
-                raise TypeError, "Invalid parameter type : #{no.class}"
-            end
+          if type < rev.body[reference].class
+            rev.body[reference] = object.cast_to(type, @parser)
 
-            @revisions.each do |rev|
-                rev.body.delete(target)
-            end
+            return rev.body[reference]
+          end
         end
+      end
 
-        #
-        # Search for an indirect object in the document.
-        # _no_:: Reference or number of the object.
-        # _generation_:: Object generation.
-        #
-        def get_object(no, generation = 0, use_xrefstm: true) #:nodoc:
-            case no
-            when Reference
-                target = no
-            when ::Integer
-                target = Reference.new(no, generation)
-            when Origami::Object
-                return no
-            else
-                raise TypeError, "Invalid parameter type : #{no.class}"
-            end
-
-            #
-            # Search through accessible indirect objects.
-            #
-            @revisions.reverse_each do |rev|
-                return rev.body[target] if rev.body.include?(target)
-            end
-
-            #
-            # Search through xref sections.
-            #
-            @revisions.reverse_each do |rev|
-                next unless rev.xreftable?
-
-                xref = rev.xreftable.find(target.refno)
-                next if xref.nil? or xref.free?
-
-                # Try loading the object if it is not present.
-                object = load_object_at_offset(rev, xref.offset)
-                return object unless object.nil?
-            end
+      nil
+    end
 
-            return nil unless use_xrefstm
-
-            # Search through xref streams.
-            @revisions.reverse_each do |rev|
-                next unless rev.xrefstm?
-
-                xrefstm = rev.xrefstm
-
-                xref = xrefstm.find(target.refno)
-                next if xref.nil?
-
-                #
-                # We found a matching XRef.
-                #
-                if xref.is_a?(XRefToCompressedObject)
-                    objstm = get_object(xref.objstmno, 0, use_xrefstm: use_xrefstm)
-
-                    object = objstm.extract_by_index(xref.index)
-                    if object.is_a?(Origami::Object) and object.no == target.refno
-                        return object
-                    else
-                        return objstm.extract(target.refno)
-                    end
-                elsif xref.is_a?(XRef)
-                    object = load_object_at_offset(rev, xref.offset)
-                    return object unless object.nil?
-                end
-            end
+    #
+    # Returns a new number/generation for future object.
+    #
+    def allocate_new_object_number
+      last_object = each_object(compressed: true).max_by { |object| object.no }
+      no = if last_object.nil?
+        1
+      else
+        last_object.no + 1
+      end
+
+      [no, 0]
+    end
 
-            #
-            # Lastly search directly into Object streams (might be very slow).
-            #
-            @revisions.reverse_each do |rev|
-                stream = rev.objects.find{|obj| obj.is_a?(ObjectStream) and obj.include?(target.refno)}
-                return stream.extract(target.refno) unless stream.nil?
-            end
+    #
+    # Mark the document as complete.
+    # No more objects needs to be fetched by the parser.
+    #
+    def loaded!
+      @loaded = true
+    end
 
-            nil
-        end
-        alias [] get_object
+    #
+    # Returns if the document as been fully loaded by the parser.
+    #
+    def loaded?
+      @loaded
+    end
 
-        #
-        # Casts a PDF object into another object type.
-        # The target type must be a subtype of the original type.
-        #
-        def cast_object(reference, type) #:nodoc:
-            @revisions.each do |rev|
-                if rev.body.include?(reference)
-                    object = rev.body[reference]
-                    return object if object.is_a?(type)
-
-                    if type < rev.body[reference].class
-                        rev.body[reference] = object.cast_to(type, @parser)
-
-                        return rev.body[reference]
-                    end
-                end
-            end
+    ##########################
+    private
 
-            nil
-        end
+    ##########################
 
-        #
-        # Returns a new number/generation for future object.
-        #
-        def allocate_new_object_number
+    #
+    # Iterates over the children of an object, avoiding cycles.
+    #
+    def walk_object(object, excludes: [], &block)
+      return enum_for(__method__, object, excludes: excludes) unless block_given?
 
-            last_object = self.each_object(compressed: true).max_by {|object| object.no }
-            if last_object.nil?
-                no = 1
-            else
-                no = last_object.no + 1
-            end
+      return if excludes.include?(object)
+      excludes.push(object)
 
-            [ no, 0 ]
+      case object
+      when CompoundObject
+        object.each_value do |value|
+          yield(value)
+          walk_object(value, excludes: excludes, &block)
         end
 
-        #
-        # Mark the document as complete.
-        # No more objects needs to be fetched by the parser.
-        #
-        def loaded!
-            @loaded = true
-        end
+      when Stream
+        yield(object.dictionary)
+        walk_object(object.dictionary, excludes: excludes, &block)
+      end
+    end
 
-        #
-        # Returns if the document as been fully loaded by the parser.
-        #
-        def loaded?
-            @loaded
+    #
+    # Searches through an object, possibly going into object streams.
+    # Returns an array of matching strings, names and streams.
+    #
+    def search_object(object, pattern, streams: true, object_streams: true)
+      result = []
+
+      case object
+      when Stream
+        result.concat object.dictionary.strings_cache.select { |str| str.match(pattern) }
+        result.concat object.dictionary.names_cache.select { |name| name.value.match(pattern) }
+
+        begin
+          result.push object if streams && object.data.match(pattern)
+        rescue Filter::Error
+          return result # Skip object if a decoding error occured.
         end
 
-        ##########################
-        private
-        ##########################
+        return result unless object.is_a?(ObjectStream) && object_streams
 
-        #
-        # Iterates over the children of an object, avoiding cycles.
-        #
-        def walk_object(object, excludes: [], &block)
-            return enum_for(__method__, object, excludes: excludes) unless block_given?
-
-            return if excludes.include?(object)
-            excludes.push(object)
-
-            case object
-            when CompoundObject
-                object.each_value do |value|
-                    yield(value)
-                    walk_object(value, excludes: excludes, &block)
-                end
-
-            when Stream
-                yield(object.dictionary)
-                walk_object(object.dictionary, excludes: excludes, &block)
-            end
+        object.each do |child|
+          result.concat search_object(child, pattern,
+            streams: streams, object_streams: object_streams)
         end
 
-        #
-        # Searches through an object, possibly going into object streams.
-        # Returns an array of matching strings, names and streams.
-        #
-        def search_object(object, pattern, streams: true, object_streams: true)
-            result = []
-
-            case object
-            when Stream
-                result.concat object.dictionary.strings_cache.select{|str| str.match(pattern) }
-                result.concat object.dictionary.names_cache.select{|name| name.value.match(pattern) }
-
-                begin
-                    result.push object if streams and object.data.match(pattern)
-                rescue Filter::Error
-                    return result # Skip object if a decoding error occured.
-                end
+      when Name, String
+        result.push object if object.value.match(pattern)
 
-                return result unless object.is_a?(ObjectStream) and object_streams
+      when ObjectCache
+        result.concat object.strings_cache.select { |str| str.match(pattern) }
+        result.concat object.names_cache.select { |name| name.value.match(pattern) }
+      end
 
-                object.each do |child|
-                    result.concat search_object(child, pattern,
-                                                streams: streams, object_streams: object_streams)
-                end
+      result
+    end
 
-            when Name, String
-                result.push object if object.value.match(pattern)
+    #
+    # Load an object from its given file offset.
+    # The document must have an associated Parser.
+    #
+    def load_object_at_offset(revision, offset)
+      return nil if loaded? || @parser.nil?
+      pos = @parser.pos
 
-            when ObjectCache
-                result.concat object.strings_cache.select{|str| str.match(pattern) }
-                result.concat object.names_cache.select{|name| name.value.match(pattern) }
-            end
+      begin
+        object = @parser.parse_object(offset)
+        return nil if object.nil?
 
-            result
+        if is_a?(Encryption::EncryptedDocument)
+          make_encrypted_object(object)
         end
 
-        #
-        # Load an object from its given file offset.
-        # The document must have an associated Parser.
-        #
-        def load_object_at_offset(revision, offset)
-            return nil if loaded? or @parser.nil?
-            pos = @parser.pos
-
-            begin
-                object = @parser.parse_object(offset)
-                return nil if object.nil?
+        add_to_revision(object, revision)
+      ensure
+        @parser.pos = pos
+      end
 
-                if self.is_a?(Encryption::EncryptedDocument)
-                    make_encrypted_object(object)
-                end
+      object
+    end
 
-                add_to_revision(object, revision)
-            ensure
-                @parser.pos = pos
-            end
+    #
+    # Method called on encrypted objects loaded into the document.
+    #
+    def make_encrypted_object(object)
+      case object
+      when String
+        object.extend(Encryption::EncryptedString)
+      when Stream
+        object.extend(Encryption::EncryptedStream)
+      when ObjectCache
+        object.strings_cache.each do |string|
+          string.extend(Encryption::EncryptedString)
+        end
+      end
+    end
 
-            object
+    #
+    # Force the loading of all objects in the document.
+    #
+    def load_all_objects
+      return if loaded? || @parser.nil?
+
+      @revisions.each do |revision|
+        if revision.xreftable?
+          xrefs = revision.xreftable
+        elsif revision.xrefstm?
+          xrefs = revision.xrefstm
+        else
+          next
         end
 
-        #
-        # Method called on encrypted objects loaded into the document.
-        #
-        def make_encrypted_object(object)
-            case object
-            when String
-                object.extend(Encryption::EncryptedString)
-            when Stream
-                object.extend(Encryption::EncryptedStream)
-            when ObjectCache
-                object.strings_cache.each do |string|
-                    string.extend(Encryption::EncryptedString)
-                end
-            end
+        xrefs.each_with_number do |xref, no|
+          get_object(no) unless xref.free?
         end
+      end
 
-        #
-        # Force the loading of all objects in the document.
-        #
-        def load_all_objects
-            return if loaded? or @parser.nil?
-
-            @revisions.each do |revision|
-                if revision.xreftable?
-                    xrefs = revision.xreftable
-                elsif revision.xrefstm?
-                    xrefs = revision.xrefstm
-                else
-                    next
-                end
-
-                xrefs.each_with_number do |xref, no|
-                    self.get_object(no) unless xref.free?
-                end
-            end
+      loaded!
+    end
+
+    #
+    # Compute and update XRef::Section for each Revision.
+    #
+    def rebuild_xrefs
+      size = 0
+      startxref = @header.to_s.size
 
-            loaded!
+      @revisions.each do |revision|
+        revision.each_object do |object|
+          startxref += object.to_s.size
         end
 
-        #
-        # Compute and update XRef::Section for each Revision.
-        #
-        def rebuild_xrefs
-            size = 0
-            startxref = @header.to_s.size
+        size += revision.body.size
+        revision.xreftable = build_xrefs(revision.objects)
 
-            @revisions.each do |revision|
-                revision.each_object do |object|
-                    startxref += object.to_s.size
-                end
+        revision.trailer ||= Trailer.new
+        revision.trailer.Size = size + 1
+        revision.trailer.startxref = startxref
 
-                size += revision.body.size
-                revision.xreftable = build_xrefs(revision.objects)
+        startxref += revision.xreftable.to_s.size + revision.trailer.to_s.size
+      end
 
-                revision.trailer ||= Trailer.new
-                revision.trailer.Size = size + 1
-                revision.trailer.startxref = startxref
+      self
+    end
 
-                startxref += revision.xreftable.to_s.size + revision.trailer.to_s.size
-            end
+    #
+    # This method is meant to recompute, verify and correct main PDF structures, in order to output a proper file.
+    # * Allocates objects references.
+    # * Sets some objects missing required values.
+    #
+    def compile(options = {})
+      load_all_objects unless loaded?
+
+      #
+      # A valid document must have at least one page.
+      #
+      append_page if pages.empty?
+
+      #
+      # Allocates object numbers and creates references.
+      # Invokes object finalization methods.
+      #
+      physicalize(options)
+
+      #
+      # Sets the PDF version header.
+      #
+      version, level = version_required
+      @header.major_version = version[0, 1].to_i
+      @header.minor_version = version[2, 1].to_i
+
+      set_extension_level(version, level) if level > 0
+
+      self
+    end
 
-            self
+    #
+    # Converts a logical PDF view into a physical view ready for writing.
+    #
+    def physicalize(options = {})
+      @revisions.each do |revision|
+        # Do not use each_object here as build_object may modify the iterator.
+        revision.objects.each do |obj|
+          build_object(obj, revision, options)
         end
+      end
 
-        #
-        # This method is meant to recompute, verify and correct main PDF structures, in order to output a proper file.
-        # * Allocates objects references.
-        # * Sets some objects missing required values.
-        #
-        def compile(options = {})
-
-            load_all_objects unless loaded?
-
-            #
-            # A valid document must have at least one page.
-            #
-            append_page if pages.empty?
+      self
+    end
 
-            #
-            # Allocates object numbers and creates references.
-            # Invokes object finalization methods.
-            #
-            physicalize(options)
+    def build_object(object, revision, options)
+      # Build any compressed object before building the object stream.
+      if object.is_a?(ObjectStream)
+        object.each do |compressed_obj|
+          build_object(compressed_obj, revision, options)
+        end
+      end
 
-            #
-            # Sets the PDF version header.
-            #
-            version, level = version_required
-            @header.major_version = version[0,1].to_i
-            @header.minor_version = version[2,1].to_i
+      object.pre_build
 
-            set_extension_level(version, level) if level > 0
+      case object
+      when Stream
+        build_object(object.dictionary, revision, options)
+      when CompoundObject
+        build_compound_object(object, revision, options)
+      end
 
-            self
-        end
+      object.post_build
+    end
 
-        #
-        # Converts a logical PDF view into a physical view ready for writing.
-        #
-        def physicalize(options = {})
+    def build_compound_object(object, revision, options)
+      return unless object.is_a?(CompoundObject)
 
-            @revisions.each do |revision|
-                # Do not use each_object here as build_object may modify the iterator.
-                revision.objects.each do |obj|
-                    build_object(obj, revision, options)
-                end
-            end
+      # Flatten the object by adding indirect objects to the revision and
+      # replacing them with their reference.
+      object.update_values! do |child|
+        next(child) unless child.indirect?
 
-            self
+        if get_object(child.reference)
+          child.reference
+        else
+          reference = add_to_revision(child, revision)
+          build_object(child, revision, options)
+          reference
         end
+      end
 
-        def build_object(object, revision, options)
-            # Build any compressed object before building the object stream.
-            if object.is_a?(ObjectStream)
-                object.each do |compressed_obj|
-                    build_object(compressed_obj, revision, options)
-                end
-            end
+      # Finalize all the children objects.
+      object.each_value do |child|
+        build_object(child, revision, options)
+      end
+    end
 
-            object.pre_build
+    #
+    # Returns the final binary representation of the current document.
+    #
+    def output(params = {})
+      has_objstm = each_object.any? { |obj| obj.is_a?(ObjectStream) }
+
+      options =
+        {
+          eol: $/,
+          rebuild_xrefs: true,
+          noindent: false,
+          obfuscate: false,
+          use_xrefstm: has_objstm,
+          use_xreftable: !has_objstm,
+          up_to_revision: @revisions.size
+        }
+      options.update(params)
+
+      # Ensures we are using a valid EOL delimiter.
+      assert_valid_eol(options[:eol])
+
+      # Do not emit more revisions than present in the document.
+      options[:up_to_revision] = [@revisions.size, options[:up_to_revision]].min
+
+      # Reset to default params if no xrefs are chosen (hybrid files not supported yet)
+      if options[:use_xrefstm] == options[:use_xreftable]
+        options[:use_xrefstm] = has_objstm
+        options[:use_xreftable] = !has_objstm
+      end
+
+      # Indent level for objects.
+      indent = ((options[:noindent] == true) ? 0 : 1)
+
+      # Get trailer dictionary
+      trailer_dict = trailer.dictionary
+
+      prev_xref_offset = nil
+      xrefstm_offset = nil
+
+      # Header
+      bin = +""  # Use mutable string
+      bin << @header.to_s(eol: options[:eol])
+
+      # For each revision
+      @revisions[0, options[:up_to_revision]].each do |rev|
+        # Create xref table/stream.
+        if options[:rebuild_xrefs] == true
+          lastno_table, lastno_stm = 0, 0
+          brange_table, brange_stm = 0, 0
+
+          xrefs_stm = [XRef.new(0, 0, XRef::FREE)]
+          xrefs_table = [XRef.new(0, XRef::FIRSTFREE, XRef::FREE)]
+
+          if options[:use_xreftable] == true
+            xrefsection = XRef::Section.new
+          end
 
-            case object
-            when Stream
-                build_object(object.dictionary, revision, options)
-            when CompoundObject
-                build_compound_object(object, revision, options)
+          if options[:use_xrefstm] == true
+            xrefstm = rev.xrefstm || XRefStream.new
+            if xrefstm == rev.xrefstm
+              xrefstm.clear
+            else
+              add_to_revision(xrefstm, rev)
             end
-
-            object.post_build
+          end
         end
 
-        def build_compound_object(object, revision, options)
-            return unless object.is_a?(CompoundObject)
-
-            # Flatten the object by adding indirect objects to the revision and
-            # replacing them with their reference.
-            object.update_values! do |child|
-                next(child) unless child.indirect?
-
-                if get_object(child.reference)
-                    child.reference
-                else
-                    reference = add_to_revision(child, revision)
-                    build_object(child, revision, options)
-                    reference
-                end
-            end
+        objset = rev.objects
 
-            # Finalize all the children objects.
-            object.each_value do |child|
-                build_object(child, revision, options)
-            end
+        if (options[:rebuild_xrefs] == true) && (options[:use_xrefstm] == true)
+          objset.find_all { |obj| obj.is_a?(ObjectStream) }.each do |objstm|
+            objset.concat objstm.objects
+          end
         end
 
-        #
-        # Returns the final binary representation of the current document.
-        #
-        def output(params = {})
-
-            has_objstm = self.each_object.any?{|obj| obj.is_a?(ObjectStream)}
-
-            options =
-            {
-                eol: $/,
-                rebuild_xrefs: true,
-                noindent: false,
-                obfuscate: false,
-                use_xrefstm: has_objstm,
-                use_xreftable: (not has_objstm),
-                up_to_revision: @revisions.size
-            }
-            options.update(params)
-
-            # Ensures we are using a valid EOL delimiter.
-            assert_valid_eol(options[:eol])
-
-            # Do not emit more revisions than present in the document.
-            options[:up_to_revision] = [ @revisions.size, options[:up_to_revision] ].min
-
-            # Reset to default params if no xrefs are chosen (hybrid files not supported yet)
-            if options[:use_xrefstm] == options[:use_xreftable]
-                options[:use_xrefstm] = has_objstm
-                options[:use_xreftable] = (not has_objstm)
+        previous_obj = nil
+
+        # For each object, in number order
+        # Move any XRefStream to the end of the revision.
+        objset.sort_by { |obj| [obj.is_a?(XRefStream) ? 1 : 0, obj.no, obj.generation] }
+          .each do |obj|
+          # Ensures that every object has a unique reference number.
+          # Duplicates should never happen in a well-formed revision and will cause breakage of xrefs.
+          if previous_obj && (previous_obj.reference == obj.reference)
+            raise InvalidPDFError, "Duplicate object detected, reference #{obj.reference}"
+          else
+            previous_obj = obj
+          end
+
+          # Create xref entry.
+          if options[:rebuild_xrefs] == true
+
+            # Adding subsections if needed
+            if options[:use_xreftable] && ((obj.no - lastno_table).abs > 1)
+              xrefsection << XRef::Subsection.new(brange_table, xrefs_table)
+
+              xrefs_table.clear
+              brange_table = obj.no
             end
 
-            # Indent level for objects.
-            indent = (options[:noindent] == true ? 0 : 1)
-
-            # Get trailer dictionary
-            trailer_dict = self.trailer.dictionary
-
-            prev_xref_offset = nil
-            xrefstm_offset = nil
-
-            # Header
-            bin = ""
-            bin << @header.to_s(eol: options[:eol])
-
-            # For each revision
-            @revisions[0, options[:up_to_revision]].each do |rev|
+            if options[:use_xrefstm] && ((obj.no - lastno_stm).abs > 1)
+              xrefs_stm.each do |xref| xrefstm << xref end
+              xrefstm.Index ||= []
+              xrefstm.Index << brange_stm << xrefs_stm.length
 
-                # Create xref table/stream.
-                if options[:rebuild_xrefs] == true
-                    lastno_table, lastno_stm = 0, 0
-                    brange_table, brange_stm = 0, 0
-
-                    xrefs_stm = [ XRef.new(0, 0, XRef::FREE) ]
-                    xrefs_table = [ XRef.new(0, XRef::FIRSTFREE, XRef::FREE) ]
-
-                    if options[:use_xreftable] == true
-                        xrefsection = XRef::Section.new
-                    end
-
-                    if options[:use_xrefstm] == true
-                        xrefstm = rev.xrefstm || XRefStream.new
-                        if xrefstm == rev.xrefstm
-                            xrefstm.clear
-                        else
-                            add_to_revision(xrefstm, rev)
-                        end
-                    end
-                end
-
-                objset = rev.objects
+              xrefs_stm.clear
+              brange_stm = obj.no
+            end
 
-                objset.find_all{|obj| obj.is_a?(ObjectStream)}.each do |objstm|
-                    objset.concat objstm.objects
-                end if options[:rebuild_xrefs] == true and options[:use_xrefstm] == true
+            # Process embedded objects
+            if options[:use_xrefstm] && (obj.parent != obj) && obj.parent.is_a?(ObjectStream)
+              index = obj.parent.index(obj.no)
 
-                previous_obj = nil
+              xrefs_stm << XRefToCompressedObject.new(obj.parent.no, index)
 
-                # For each object, in number order
-                # Move any XRefStream to the end of the revision.
-                objset.sort_by {|obj| [obj.is_a?(XRefStream) ? 1 : 0, obj.no, obj.generation] }
-                      .each do |obj|
+              lastno_stm = obj.no
+            else
+              xrefs_stm << XRef.new(bin.size, obj.generation, XRef::USED)
+              xrefs_table << XRef.new(bin.size, obj.generation, XRef::USED)
 
-                    # Ensures that every object has a unique reference number.
-                    # Duplicates should never happen in a well-formed revision and will cause breakage of xrefs.
-                    if previous_obj and previous_obj.reference == obj.reference
-                        raise InvalidPDFError, "Duplicate object detected, reference #{obj.reference}"
-                    else
-                        previous_obj = obj
-                    end
+              lastno_table = lastno_stm = obj.no
+            end
+          end
 
-                    # Create xref entry.
-                    if options[:rebuild_xrefs] == true
+          if (obj.parent == obj) || !obj.parent.is_a?(ObjectStream)
 
-                        # Adding subsections if needed
-                        if options[:use_xreftable] and (obj.no - lastno_table).abs > 1
-                            xrefsection << XRef::Subsection.new(brange_table, xrefs_table)
+            # Finalize XRefStm
+            if (options[:rebuild_xrefs] == true) && (options[:use_xrefstm] == true) && (obj == xrefstm)
+              xrefstm_offset = bin.size
 
-                            xrefs_table.clear
-                            brange_table = obj.no
-                        end
+              xrefs_stm.each do |xref| xrefstm << xref end
 
-                        if options[:use_xrefstm] and (obj.no - lastno_stm).abs > 1
-                            xrefs_stm.each do |xref| xrefstm << xref end
-                            xrefstm.Index ||= []
-                            xrefstm.Index << brange_stm << xrefs_stm.length
+              xrefstm.W = [1, (xrefstm_offset.to_s(2).size + 7) >> 3, 2]
+              if xrefstm.DecodeParms.is_a?(Dictionary) && xrefstm.DecodeParms.has_key?(:Columns)
+                xrefstm.DecodeParms[:Columns] = xrefstm.W[0] + xrefstm.W[1] + xrefstm.W[2]
+              end
 
-                            xrefs_stm.clear
-                            brange_stm = obj.no
-                        end
+              xrefstm.Index ||= []
+              xrefstm.Index << brange_stm << xrefs_stm.size
 
-                        # Process embedded objects
-                        if options[:use_xrefstm] and obj.parent != obj and obj.parent.is_a?(ObjectStream)
-                            index = obj.parent.index(obj.no)
+              xrefstm.dictionary = xrefstm.dictionary.merge(trailer_dict)
+              xrefstm.Prev = prev_xref_offset
+              rev.trailer.dictionary = nil
 
-                            xrefs_stm << XRefToCompressedObject.new(obj.parent.no, index)
+              add_to_revision(xrefstm, rev)
 
-                            lastno_stm = obj.no
-                        else
-                            xrefs_stm << XRef.new(bin.size, obj.generation, XRef::USED)
-                            xrefs_table << XRef.new(bin.size, obj.generation, XRef::USED)
+              xrefstm.pre_build
+              xrefstm.post_build
+            end
 
-                            lastno_table = lastno_stm = obj.no
-                        end
-                    end
+            # Output object code
+            bin << if obj.is_a?(Dictionary) || obj.is_a?(Stream)
+              obj.to_s(eol: options[:eol], indent: indent)
+            else
+              obj.to_s(eol: options[:eol])
+            end
+          end
+        end # end each object
 
-                    if obj.parent == obj or not obj.parent.is_a?(ObjectStream)
+        rev.trailer ||= Trailer.new
 
-                        # Finalize XRefStm
-                        if options[:rebuild_xrefs] == true and options[:use_xrefstm] == true and obj == xrefstm
-                            xrefstm_offset = bin.size
+        # XRef table
+        if options[:rebuild_xrefs] == true
 
-                            xrefs_stm.each do |xref| xrefstm << xref end
+          if options[:use_xreftable] == true
+            table_offset = bin.size
 
-                            xrefstm.W = [ 1, (xrefstm_offset.to_s(2).size + 7) >> 3, 2 ]
-                            if xrefstm.DecodeParms.is_a?(Dictionary) and xrefstm.DecodeParms.has_key?(:Columns)
-                                xrefstm.DecodeParms[:Columns] = xrefstm.W[0] + xrefstm.W[1] + xrefstm.W[2]
-                            end
+            xrefsection << XRef::Subsection.new(brange_table, xrefs_table)
+            rev.xreftable = xrefsection
 
-                            xrefstm.Index ||= []
-                            xrefstm.Index << brange_stm << xrefs_stm.size
+            rev.trailer.dictionary = trailer_dict
+            rev.trailer.Size = objset.size + 1
+            rev.trailer.Prev = prev_xref_offset
 
-                            xrefstm.dictionary = xrefstm.dictionary.merge(trailer_dict)
-                            xrefstm.Prev = prev_xref_offset
-                            rev.trailer.dictionary = nil
+            rev.trailer.XRefStm = xrefstm_offset if options[:use_xrefstm] == true
+          end
 
-                            add_to_revision(xrefstm, rev)
+          startxref = (options[:use_xreftable] == true) ? table_offset : xrefstm_offset
+          rev.trailer.startxref = prev_xref_offset = startxref
 
-                            xrefstm.pre_build
-                            xrefstm.post_build
-                        end
+        end
 
-                        # Output object code
-                        if (obj.is_a?(Dictionary) or obj.is_a?(Stream))
-                            bin << obj.to_s(eol: options[:eol], indent: indent)
-                        else
-                            bin << obj.to_s(eol: options[:eol])
-                        end
-                    end
-                end # end each object
+        # Trailer
+        bin << rev.xreftable.to_s(eol: options[:eol]) if options[:use_xreftable] == true
+        bin << ((options[:obfuscate] == true) ? rev.trailer.to_obfuscated_str : rev.trailer.to_s(eol: options[:eol], indent: indent))
+      end # end each revision
 
-                rev.trailer ||= Trailer.new
+      bin
+    end
 
-                # XRef table
-                if options[:rebuild_xrefs] == true
+    def assert_valid_eol(d)
+      allowed = ["\n", "\r", "\r\n"]
+      unless allowed.include?(d)
+        raise ArgumentError, "Invalid EOL delimiter #{d.inspect}, allowed: #{allowed.inspect}"
+      end
+    end
 
-                    if options[:use_xreftable] == true
-                        table_offset = bin.size
+    #
+    # Instanciates basic structures required for a valid PDF file.
+    #
+    def init
+      catalog = (self.Catalog = (trailer_key(:Root) || Catalog.new))
+      @revisions.last.trailer.Root = catalog.reference
 
-                        xrefsection << XRef::Subsection.new(brange_table, xrefs_table)
-                        rev.xreftable = xrefsection
+      loaded!
 
-                        rev.trailer.dictionary = trailer_dict
-                        rev.trailer.Size = objset.size + 1
-                        rev.trailer.Prev = prev_xref_offset
+      self
+    end
 
-                        rev.trailer.XRefStm = xrefstm_offset if options[:use_xrefstm] == true
-                    end
+    def filesize # :nodoc:
+      output(rebuild_xrefs: false).size
+    end
 
-                    startxref = options[:use_xreftable] == true ? table_offset : xrefstm_offset
-                    rev.trailer.startxref = prev_xref_offset = startxref
+    def version_required # :nodoc:
+      each_object.max_by { |obj| obj.version_required }.version_required
+    end
 
-                end
+    #
+    # Compute and update XRef::Section for each Revision.
+    #
+    def rebuild_dummy_xrefs # :nodoc
+      build_dummy_xrefs = ->(objects) do
+        lastno = 0
+        brange = 0
 
-                # Trailer
-                bin << rev.xreftable.to_s(eol: options[:eol]) if options[:use_xreftable] == true
-                bin << (options[:obfuscate] == true ? rev.trailer.to_obfuscated_str : rev.trailer.to_s(eol: options[:eol], indent: indent))
+        xrefs = [XRef.new(0, XRef::FIRSTFREE, XRef::FREE)]
 
-            end # end each revision
+        xrefsection = XRef::Section.new
+        objects.sort_by { |object| object.reference }
+          .each do |object|
+          if (object.no - lastno).abs > 1
+            xrefsection << XRef::Subsection.new(brange, xrefs)
+            brange = object.no
+            xrefs.clear
+          end
 
-            bin
-        end
+          xrefs << XRef.new(0, 0, XRef::FREE)
 
-        def assert_valid_eol(d)
-            allowed = [ "\n", "\r", "\r\n" ]
-            unless allowed.include?(d)
-                raise ArgumentError, "Invalid EOL delimiter #{d.inspect}, allowed: #{allowed.inspect}"
-            end
+          lastno = object.no
         end
 
-        #
-        # Instanciates basic structures required for a valid PDF file.
-        #
-        def init
-            catalog = (self.Catalog = (trailer_key(:Root) || Catalog.new))
-            @revisions.last.trailer.Root = catalog.reference
-
-            loaded!
+        xrefsection << XRef::Subsection.new(brange, xrefs)
 
-            self
-        end
+        xrefsection
+      end
 
-        def filesize #:nodoc:
-            output(rebuild_xrefs: false).size
-        end
+      size = 0
+      startxref = @header.to_s.size
 
-        def version_required #:nodoc:
-            self.each_object.max_by {|obj| obj.version_required}.version_required
+      @revisions.each do |revision|
+        revision.each_object do |object|
+          startxref += object.to_s.size
         end
 
-        #
-        # Compute and update XRef::Section for each Revision.
-        #
-        def rebuild_dummy_xrefs #:nodoc
-
-            build_dummy_xrefs = -> (objects) do
-                lastno = 0
-                brange = 0
-
-                xrefs = [ XRef.new(0, XRef::FIRSTFREE, XRef::FREE) ]
-
-                xrefsection = XRef::Section.new
-                objects.sort_by {|object| object.reference }
-                       .each do |object|
-
-                    if (object.no - lastno).abs > 1
-                        xrefsection << XRef::Subsection.new(brange, xrefs)
-                        brange = object.no
-                        xrefs.clear
-                    end
-
-                    xrefs << XRef.new(0, 0, XRef::FREE)
-
-                    lastno = object.no
-                end
-
-                xrefsection << XRef::Subsection.new(brange, xrefs)
-
-                xrefsection
-            end
-
-            size = 0
-            startxref = @header.to_s.size
+        size += revision.body.size
+        revision.xreftable = build_dummy_xrefs.call(revision.objects)
 
-            @revisions.each do |revision|
-                revision.each_object do |object|
-                    startxref += object.to_s.size
-                end
+        revision.trailer ||= Trailer.new
+        revision.trailer.Size = size + 1
+        revision.trailer.startxref = startxref
 
-                size += revision.body.size
-                revision.xreftable = build_dummy_xrefs.call(revision.objects)
+        startxref += revision.xreftable.to_s.size + revision.trailer.to_s.size
+      end
 
-                revision.trailer ||= Trailer.new
-                revision.trailer.Size = size + 1
-                revision.trailer.startxref = startxref
-
-                startxref += revision.xreftable.to_s.size + revision.trailer.to_s.size
-            end
+      self
+    end
 
-            self
+    #
+    # Build a xref section from a set of objects.
+    #
+    def build_xrefs(objects) # :nodoc:
+      lastno = 0
+      brange = 0
+
+      xrefs = [XRef.new(0, XRef::FIRSTFREE, XRef::FREE)]
+
+      xrefsection = XRef::Section.new
+      objects.sort_by { |object| object.reference }
+        .each do |object|
+        if (object.no - lastno).abs > 1
+          xrefsection << XRef::Subsection.new(brange, xrefs)
+          brange = object.no
+          xrefs.clear
         end
 
-        #
-        # Build a xref section from a set of objects.
-        #
-        def build_xrefs(objects) #:nodoc:
-
-            lastno = 0
-            brange = 0
-
-            xrefs = [ XRef.new(0, XRef::FIRSTFREE, XRef::FREE) ]
-
-            xrefsection = XRef::Section.new
-            objects.sort_by {|object| object.reference}
-                   .each do |object|
+        xrefs << XRef.new(get_object_offset(object.no, object.generation), object.generation, XRef::USED)
 
-                if (object.no - lastno).abs > 1
-                    xrefsection << XRef::Subsection.new(brange, xrefs)
-                    brange = object.no
-                    xrefs.clear
-                end
+        lastno = object.no
+      end
 
-                xrefs << XRef.new(get_object_offset(object.no, object.generation), object.generation, XRef::USED)
+      xrefsection << XRef::Subsection.new(brange, xrefs)
 
-                lastno = object.no
-            end
+      xrefsection
+    end
 
-            xrefsection << XRef::Subsection.new(brange, xrefs)
+    def get_object_offset(no, generation) # :nodoc:
+      objectoffset = @header.to_s.size
 
-            xrefsection
+      @revisions.each do |revision|
+        revision.objects.sort_by { |object| object.reference }
+          .each do |object|
+          if (object.no == no) && (object.generation == generation) then return objectoffset
+          else
+            objectoffset += object.to_s.size
+          end
         end
 
-        def get_object_offset(no, generation) #:nodoc:
-            objectoffset = @header.to_s.size
-
-            @revisions.each do |revision|
-                revision.objects.sort_by {|object| object.reference }
-                                .each do |object|
+        objectoffset += revision.xreftable.to_s.size
+        objectoffset += revision.trailer.to_s.size
+      end
 
-                    if object.no == no and object.generation == generation then return objectoffset
-                    else
-                        objectoffset += object.to_s.size
-                    end
-                end
-
-                objectoffset += revision.xreftable.to_s.size
-                objectoffset += revision.trailer.to_s.size
-            end
-
-            nil
-        end
+      nil
     end
-
+  end
 end