origami-docspring 2.2.0 → 2.3.0

data/lib/origami/xreftable.rb

@@ -1,557 +1,557 @@
-=begin
+# 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/>.
+#
 
-    This file is part of Origami, PDF manipulation framework for Ruby
-    Copyright (C) 2016	Guillaume Delugré.
+module Origami
+  class PDF
+    #
+    # Tries to strip any xrefs information off the document.
+    #
+    def remove_xrefs
+      @revisions.reverse_each do |rev|
+        if rev.xrefstm?
+          delete_object(rev.xrefstm.reference)
+        end
+
+        if rev.trailer.XRefStm.is_a?(Integer)
+          xrefstm = get_object_by_offset(rev.trailer.XRefStm)
 
-    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.
+          delete_object(xrefstm.reference) if xrefstm.is_a?(XRefStream)
+        end
 
-    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.
+        rev.xrefstm = rev.xreftable = nil
+      end
+    end
+  end
 
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+  class InvalidXRefError < Error # :nodoc:
+  end
 
-=end
+  #
+  # Class representing a Cross-reference information.
+  #
+  class XRef
+    FREE = "f"
+    USED = "n"
+    FIRSTFREE = 65535
 
-module Origami
+    @@regexp = /(?<offset>\d{10}) (?<gen>\d{5}) (?<state>n|f)(\r\n| \r| \n)/
 
-    class PDF
-        #
-        # Tries to strip any xrefs information off the document.
-        #
-        def remove_xrefs
-            @revisions.reverse_each do |rev|
-                if rev.xrefstm?
-                    delete_object(rev.xrefstm.reference)
-                end
+    attr_accessor :offset, :generation, :state
 
-                if rev.trailer.XRefStm.is_a?(Integer)
-                    xrefstm = get_object_by_offset(rev.trailer.XRefStm)
+    #
+    # Creates a new XRef.
+    # _offset_:: The file _offset_ of the referenced Object.
+    # _generation_:: The generation number of the referenced Object.
+    # _state_:: The state of the referenced Object (FREE or USED).
+    #
+    def initialize(offset, generation, state)
+      @offset, @generation, @state = offset, generation, state
+    end
 
-                    delete_object(xrefstm.reference) if xrefstm.is_a?(XRefStream)
-                end
+    def self.parse(stream) # :nodoc:
+      scanner = Parser.init_scanner(stream)
 
-                rev.xrefstm = rev.xreftable = nil
-            end
-        end
+      if scanner.scan(@@regexp).nil?
+        raise InvalidXRefError, "Invalid XRef format"
+      end
+
+      offset = scanner['offset'].to_i
+      generation = scanner['gen'].to_i
+      state = scanner['state']
+
+      XRef.new(offset, generation, state)
     end
 
-    class InvalidXRefError < Error #:nodoc:
+    #
+    # Returns true if the associated object is used.
+    #
+    def used?
+      @state == USED
     end
 
     #
-    # Class representing a Cross-reference information.
+    # Returns true if the associated object is freed.
     #
-    class XRef
+    def free?
+      @state == FREE
+    end
 
-        FREE = "f"
-        USED = "n"
-        FIRSTFREE = 65535
+    #
+    # Marks an XRef as freed.
+    #
+    def free!
+      @state = FREE
+    end
 
-        @@regexp = /(?<offset>\d{10}) (?<gen>\d{5}) (?<state>n|f)(\r\n| \r| \n)/
+    #
+    # Outputs self into PDF code.
+    #
+    def to_s(eol: $/)
+      off = @offset.to_s.rjust(10, '0')
+      gen = @generation.to_s.rjust(5, '0')
 
-        attr_accessor :offset, :generation, :state
+      "#{off} #{gen} #{@state}" + eol.rjust(2, ' ')
+    end
 
-        #
-        # Creates a new XRef.
-        # _offset_:: The file _offset_ of the referenced Object.
-        # _generation_:: The generation number of the referenced Object.
-        # _state_:: The state of the referenced Object (FREE or USED).
-        #
-        def initialize(offset, generation, state)
-            @offset, @generation, @state = offset, generation, state
-        end
+    def to_xrefstm_data(type_w, field1_w, field2_w)
+      type_w <<= 3
+      field1_w <<= 3
+      field2_w <<= 3
 
-        def self.parse(stream) #:nodoc:
-            scanner = Parser.init_scanner(stream)
+      type = ((@state == FREE) ? "\000" : "\001").unpack1("B#{type_w}")
 
-            if scanner.scan(@@regexp).nil?
-                raise InvalidXRefError, "Invalid XRef format"
-            end
+      offset = @offset.to_s(2).rjust(field1_w, '0')
+      generation = @generation.to_s(2).rjust(field2_w, '0')
 
-            offset = scanner['offset'].to_i
-            generation = scanner['gen'].to_i
-            state = scanner['state']
+      [type, offset, generation].pack("B#{type_w}B#{field1_w}B#{field2_w}")
+    end
 
-            XRef.new(offset, generation, state)
-        end
+    class InvalidXRefSubsectionError < Error # :nodoc:
+    end
+
+    #
+    # Class representing a cross-reference subsection.
+    # A subsection contains a continute set of XRef.
+    #
+    class Subsection
+      include Enumerable
 
-        #
-        # Returns true if the associated object is used.
-        #
-        def used?
-            @state == USED
+      @@regexp = Regexp.new("(?<start>\\d+) (?<size>\\d+)" + WHITESPACES + "(\\r?\\n|\\r\\n?)")
+
+      attr_reader :range
+
+      #
+      # Creates a new XRef subsection.
+      # _start_:: The number of the first object referenced in the subsection.
+      # _entries_:: An array of XRef.
+      #
+      def initialize(start, entries = [])
+        @entries = entries.dup
+        @range = Range.new(start, start + entries.size - 1)
+      end
+
+      def self.parse(stream) # :nodoc:
+        scanner = Parser.init_scanner(stream)
+
+        if scanner.scan(@@regexp).nil?
+          raise InvalidXRefSubsectionError, "Bad subsection format"
         end
 
-        #
-        # Returns true if the associated object is freed.
-        #
-        def free?
-            @state == FREE
+        start = scanner['start'].to_i
+        size = scanner['size'].to_i
+
+        xrefs = []
+        size.times do
+          xrefs << XRef.parse(scanner)
         end
 
-        #
-        # Marks an XRef as freed.
-        #
-        def free!
-            @state = FREE
+        XRef::Subsection.new(start, xrefs)
+      end
+
+      #
+      # Returns whether this subsection contains information about a particular object.
+      # _no_:: The Object number.
+      #
+      def has_object?(no)
+        @range.include?(no)
+      end
+
+      #
+      # Returns XRef associated with a given object.
+      # _no_:: The Object number.
+      #
+      def [](no)
+        @entries[no - @range.begin]
+      end
+
+      #
+      # Processes each XRef in the subsection.
+      #
+      def each(&b)
+        @entries.each(&b)
+      end
+
+      #
+      # Processes each XRef in the subsection, passing the XRef and the object number to the block.
+      #
+      def each_with_number
+        return enum_for(__method__) { size } unless block_given?
+
+        counter = @range.to_enum
+        @entries.each do |entry|
+          yield(entry, counter.next)
+        end
+      end
+
+      #
+      # The number of entries in the subsection.
+      #
+      def size
+        @entries.size
+      end
+
+      #
+      # Outputs self into PDF code.
+      #
+      def to_s(eol: $/)
+        section = "#{@range.begin} #{@range.end - @range.begin + 1}" + eol
+        @entries.each do |xref|
+          section << xref.to_s(eol: eol)
         end
 
-        #
-        # Outputs self into PDF code.
-        #
-        def to_s(eol: $/)
-            off = @offset.to_s.rjust(10, '0')
-            gen = @generation.to_s.rjust(5, '0')
+        section
+      end
+    end
 
-            "#{off} #{gen} #{@state}" + eol.rjust(2, ' ')
-        end
+    class InvalidXRefSectionError < Error # :nodoc:
+    end
+
+    #
+    # Class representing a Cross-reference table.
+    # A section contains a set of XRef::Subsection.
+    #
+    class Section
+      include Enumerable
 
-        def to_xrefstm_data(type_w, field1_w, field2_w)
-            type_w <<= 3
-            field1_w <<= 3
-            field2_w <<= 3
+      TOKEN = "xref"
 
-            type = ((@state == FREE) ? "\000" : "\001").unpack("B#{type_w}")[0]
+      @@regexp_open = Regexp.new(WHITESPACES + TOKEN + WHITESPACES + "(\\r?\\n|\\r\\n?)")
+      @@regexp_sub = Regexp.new("(\\d+) (\\d+)" + WHITESPACES + "(\\r?\\n|\\r\\n?)")
 
-            offset = @offset.to_s(2).rjust(field1_w, '0')
-            generation = @generation.to_s(2).rjust(field2_w, '0')
+      #
+      # Creates a new XRef section.
+      # _subsections_:: An array of XRefSubsection.
+      #
+      def initialize(subsections = [])
+        @subsections = subsections
+      end
 
-            [ type , offset, generation ].pack("B#{type_w}B#{field1_w}B#{field2_w}")
+      def self.parse(stream) # :nodoc:
+        scanner = Parser.init_scanner(stream)
+
+        if scanner.skip(@@regexp_open).nil?
+          raise InvalidXRefSectionError, "No xref token found"
         end
 
-        class InvalidXRefSubsectionError < Error #:nodoc:
+        subsections = []
+        while scanner.match?(@@regexp_sub)
+          subsections << XRef::Subsection.parse(scanner)
         end
 
-        #
-        # Class representing a cross-reference subsection.
-        # A subsection contains a continute set of XRef.
-        #
-        class Subsection
-            include Enumerable
-
-            @@regexp = Regexp.new("(?<start>\\d+) (?<size>\\d+)" + WHITESPACES + "(\\r?\\n|\\r\\n?)")
-
-            attr_reader :range
-
-            #
-            # Creates a new XRef subsection.
-            # _start_:: The number of the first object referenced in the subsection.
-            # _entries_:: An array of XRef.
-            #
-            def initialize(start, entries = [])
-                @entries = entries.dup
-                @range = Range.new(start, start + entries.size - 1)
-            end
-
-            def self.parse(stream) #:nodoc:
-                scanner = Parser.init_scanner(stream)
-
-                if scanner.scan(@@regexp).nil?
-                    raise InvalidXRefSubsectionError, "Bad subsection format"
-                end
-
-                start = scanner['start'].to_i
-                size = scanner['size'].to_i
-
-                xrefs = []
-                size.times do
-                    xrefs << XRef.parse(scanner)
-                end
-
-                XRef::Subsection.new(start, xrefs)
-            end
-
-            #
-            # Returns whether this subsection contains information about a particular object.
-            # _no_:: The Object number.
-            #
-            def has_object?(no)
-                @range.include?(no)
-            end
-
-            #
-            # Returns XRef associated with a given object.
-            # _no_:: The Object number.
-            #
-            def [](no)
-                @entries[no - @range.begin]
-            end
-
-            #
-            # Processes each XRef in the subsection.
-            #
-            def each(&b)
-                @entries.each(&b)
-            end
-
-            #
-            # Processes each XRef in the subsection, passing the XRef and the object number to the block.
-            #
-            def each_with_number
-                return enum_for(__method__) { self.size } unless block_given?
-
-                counter = @range.to_enum
-                @entries.each do |entry|
-                    yield(entry, counter.next)
-                end
-            end
-
-            #
-            # The number of entries in the subsection.
-            #
-            def size
-                @entries.size
-            end
-
-            #
-            # Outputs self into PDF code.
-            #
-            def to_s(eol: $/)
-                section = "#{@range.begin} #{@range.end - @range.begin + 1}" + eol
-                @entries.each do |xref|
-                    section << xref.to_s(eol: eol)
-                end
-
-                section
-            end
+        XRef::Section.new(subsections)
+      end
+
+      #
+      # Appends a new subsection.
+      # _subsection_:: A XRefSubsection.
+      #
+      def <<(subsection)
+        @subsections << subsection
+      end
+
+      #
+      # Returns a XRef associated with a given object.
+      # _no_:: The Object number.
+      #
+      def [](no)
+        @subsections.each do |s|
+          return s[no] if s.has_object?(no)
         end
 
-        class InvalidXRefSectionError < Error #:nodoc:
+        nil
+      end
+      alias_method :find, :[]
+
+      #
+      # Processes each XRef in each Subsection.
+      #
+      def each(&b)
+        return enum_for(__method__) { size } unless block_given?
+
+        @subsections.each do |subsection|
+          subsection.each(&b)
         end
+      end
 
-        #
-        # Class representing a Cross-reference table.
-        # A section contains a set of XRef::Subsection.
-        #
-        class Section
-            include Enumerable
-
-            TOKEN = "xref"
-
-            @@regexp_open = Regexp.new(WHITESPACES + TOKEN + WHITESPACES + "(\\r?\\n|\\r\\n?)")
-            @@regexp_sub = Regexp.new("(\\d+) (\\d+)" + WHITESPACES + "(\\r?\\n|\\r\\n?)")
-
-            #
-            # Creates a new XRef section.
-            # _subsections_:: An array of XRefSubsection.
-            #
-            def initialize(subsections = [])
-                @subsections = subsections
-            end
-
-            def self.parse(stream) #:nodoc:
-                scanner = Parser.init_scanner(stream)
-
-                if scanner.skip(@@regexp_open).nil?
-                    raise InvalidXRefSectionError, "No xref token found"
-                end
-
-                subsections = []
-                while scanner.match?(@@regexp_sub) do
-                    subsections << XRef::Subsection.parse(scanner)
-                end
-
-                XRef::Section.new(subsections)
-            end
-
-            #
-            # Appends a new subsection.
-            # _subsection_:: A XRefSubsection.
-            #
-            def <<(subsection)
-                @subsections << subsection
-            end
-
-            #
-            # Returns a XRef associated with a given object.
-            # _no_:: The Object number.
-            #
-            def [](no)
-                @subsections.each do |s|
-                    return s[no] if s.has_object?(no)
-                end
-
-                nil
-            end
-            alias find []
-
-            #
-            # Processes each XRef in each Subsection.
-            #
-            def each(&b)
-                return enum_for(__method__) { self.size } unless block_given?
-
-                @subsections.each do |subsection|
-                    subsection.each(&b)
-                end
-            end
-
-            #
-            # Processes each XRef in each Subsection, passing the XRef and the object number.
-            #
-            def each_with_number(&b)
-                return enum_for(__method__) { self.size } unless block_given?
-
-                @subsections.each do |subsection|
-                    subsection.each_with_number(&b)
-                end
-            end
-
-            #
-            # Processes each Subsection in this table.
-            #
-            def each_subsection(&b)
-                @subsections.each(&b)
-            end
-            
-            #
-            # Returns an Array of Subsection.
-            #
-            def subsections
-                @subsections
-            end
-
-            #
-            # Clear all the entries.
-            #
-            def clear
-                @subsections.clear
-            end
-
-            #
-            # The number of XRef entries in the Section.
-            #
-            def size
-                @subsections.reduce(0) { |total, subsection| total + subsection.size }
-            end
-
-            #
-            # Outputs self into PDF code.
-            #
-            def to_s(eol: $/)
-                "xref" << eol << @subsections.map{|sub| sub.to_s(eol: eol)}.join
-            end
+      #
+      # Processes each XRef in each Subsection, passing the XRef and the object number.
+      #
+      def each_with_number(&b)
+        return enum_for(__method__) { size } unless block_given?
+
+        @subsections.each do |subsection|
+          subsection.each_with_number(&b)
         end
+      end
+
+      #
+      # Processes each Subsection in this table.
+      #
+      def each_subsection(&b)
+        @subsections.each(&b)
+      end
+
+      #
+      # Returns an Array of Subsection.
+      #
+      attr_reader :subsections
+
+      #
+      # Clear all the entries.
+      #
+      def clear
+        @subsections.clear
+      end
+
+      #
+      # The number of XRef entries in the Section.
+      #
+      def size
+        @subsections.reduce(0) { |total, subsection| total + subsection.size }
+      end
+
+      #
+      # Outputs self into PDF code.
+      #
+      def to_s(eol: $/)
+        result = +"xref"
+        result << eol << @subsections.map { |sub| sub.to_s(eol: eol) }.join
+        result
+      end
     end
+  end
 
-    #
-    # An xref poiting to an Object embedded in an ObjectStream.
-    #
-    class XRefToCompressedObject
-        attr_accessor :objstmno, :index
+  #
+  # An xref poiting to an Object embedded in an ObjectStream.
+  #
+  class XRefToCompressedObject
+    attr_accessor :objstmno, :index
 
-        def initialize(objstmno, index)
-            @objstmno = objstmno
-            @index = index
-        end
+    def initialize(objstmno, index)
+      @objstmno = objstmno
+      @index = index
+    end
 
-        def to_xrefstm_data(type_w, field1_w, field2_w)
-            type_w <<= 3
-            field1_w <<= 3
-            field2_w <<= 3
+    def to_xrefstm_data(type_w, field1_w, field2_w)
+      type_w <<= 3
+      field1_w <<= 3
+      field2_w <<= 3
 
-            type = "\002".unpack("B#{type_w}")[0]
-            objstmno = @objstmno.to_s(2).rjust(field1_w, '0')
-            index = @index.to_s(2).rjust(field2_w, '0')
+      type = "\002".unpack1("B#{type_w}")
+      objstmno = @objstmno.to_s(2).rjust(field1_w, '0')
+      index = @index.to_s(2).rjust(field2_w, '0')
 
-            [ type , objstmno, index ].pack("B#{type_w}B#{field1_w}B#{field2_w}")
-        end
+      [type, objstmno, index].pack("B#{type_w}B#{field1_w}B#{field2_w}")
+    end
+
+    def used?
+      true
+    end
 
-        def used?; true end
-        def free?; false end
+    def free?
+      false
     end
+  end
 
-    class InvalidXRefStreamObjectError < InvalidStreamObjectError ; end
+  class InvalidXRefStreamObjectError < InvalidStreamObjectError; end
+
+  #
+  # Class representing a XRef Stream.
+  #
+  class XRefStream < Stream
+    include Enumerable
+    include StandardObject
+
+    XREF_FREE = 0
+    XREF_USED = 1
+    XREF_COMPRESSED = 2
 
     #
-    # Class representing a XRef Stream.
+    # Xref fields
     #
-    class XRefStream < Stream
-        include Enumerable
-        include StandardObject
+    field :Type, Type: Name, Default: :XRef, Required: true, Version: "1.5"
+    field :Size, Type: Integer, Required: true
+    field :Index, Type: Array.of(Integer, Integer)
+    field :Prev, Type: Integer
+    field :W, Type: Array.of(Integer, length: 3), Required: true
 
-        XREF_FREE = 0
-        XREF_USED = 1
-        XREF_COMPRESSED = 2
+    #
+    # Trailer fields
+    #
+    field :Root, Type: Catalog, Required: true
+    field :Encrypt, Type: Encryption::Standard::Dictionary
+    field :Info, Type: Metadata
+    field :ID, Type: Array.of(String, length: 2)
 
-        #
-        # Xref fields
-        #
-        field   :Type,          :Type => Name, :Default => :XRef, :Required => true, :Version => "1.5"
-        field   :Size,          :Type => Integer, :Required => true
-        field   :Index,         :Type => Array.of(Integer, Integer)
-        field   :Prev,          :Type => Integer
-        field   :W,             :Type => Array.of(Integer, length: 3), :Required => true
+    def initialize(data = "", dictionary = {})
+      super
 
-        #
-        # Trailer fields
-        #
-        field   :Root,          :Type => Catalog, :Required => true
-        field   :Encrypt,       :Type => Encryption::Standard::Dictionary
-        field   :Info,          :Type => Metadata
-        field   :ID,            :Type => Array.of(String, length: 2)
+      @xrefs = nil
+    end
 
-        def initialize(data = "", dictionary = {})
-            super(data, dictionary)
+    def entries
+      load! if @xrefs.nil?
 
-            @xrefs = nil
-        end
+      @xrefs
+    end
 
-        def entries
-            load! if @xrefs.nil?
+    #
+    # Returns XRef entries present in this stream.
+    #
+    def pre_build # :nodoc:
+      load! if @xrefs.nil?
 
-            @xrefs
-        end
+      self.W = [1, 2, 2] unless key?(:W)
+      self.Size = @xrefs.length + 1
 
-        #
-        # Returns XRef entries present in this stream.
-        #
-        def pre_build #:nodoc:
-            load! if @xrefs.nil?
+      save!
 
-            self.W = [ 1, 2, 2 ] unless self.key?(:W)
-            self.Size = @xrefs.length + 1
+      super
+    end
 
-            save!
+    #
+    # Adds an XRef to this Stream.
+    #
+    def <<(xref)
+      load! if @xrefs.nil?
 
-            super
-        end
+      @xrefs << xref
+    end
 
-        #
-        # Adds an XRef to this Stream.
-        #
-        def <<(xref)
-            load! if @xrefs.nil?
+    #
+    # Iterates over each XRef present in the stream.
+    #
+    def each(&b)
+      load! if @xrefs.nil?
 
-            @xrefs << xref
-        end
+      @xrefs.each(&b)
+    end
+
+    #
+    # Iterates over each XRef present in the stream, passing the XRef and its object number.
+    #
+    def each_with_number
+      return enum_for(__method__) unless block_given?
 
-        #
-        # Iterates over each XRef present in the stream.
-        #
-        def each(&b)
-            load! if @xrefs.nil?
+      load! if @xrefs.nil?
 
-            @xrefs.each(&b)
-        end
+      ranges = object_ranges
+      xrefs = @xrefs.to_enum
 
-        #
-        # Iterates over each XRef present in the stream, passing the XRef and its object number.
-        #
-        def each_with_number
-            return enum_for(__method__) unless block_given?
-
-            load! if @xrefs.nil?
-
-            ranges = object_ranges
-            xrefs = @xrefs.to_enum
-
-            ranges.each do |range|
-                range.each do |no|
-                    begin
-                        yield(xrefs.next, no)
-                    rescue StopIteration
-                        raise InvalidXRefStreamObjectError, "Range is bigger than number of entries"
-                    end
-                end
-            end
+      ranges.each do |range|
+        range.each do |no|
+          yield(xrefs.next, no)
+        rescue StopIteration
+          raise InvalidXRefStreamObjectError, "Range is bigger than number of entries"
         end
+      end
+    end
 
-        #
-        # Returns an XRef matching this object number.
-        #
-        def find(no)
-            load! if @xrefs.nil?
-
-            ranges = object_ranges
+    #
+    # Returns an XRef matching this object number.
+    #
+    def find(no)
+      load! if @xrefs.nil?
 
-            index = 0
-            ranges.each do |range|
-                return @xrefs[index + no - range.begin] if range.cover?(no)
+      ranges = object_ranges
 
-                index += range.size
-            end
+      index = 0
+      ranges.each do |range|
+        return @xrefs[index + no - range.begin] if range.cover?(no)
 
-            nil
-        end
+        index += range.size
+      end
 
-        def clear
-            self.data = ''
-            @xrefs = []
-            self.Index = []
-        end
+      nil
+    end
 
-        private
+    def clear
+      self.data = ''
+      @xrefs = []
+      self.Index = []
+    end
 
-        def object_ranges
-            load! if @xrefs.nil?
+    private
 
-            if self.key?(:Index)
-                ranges = self.Index
-                unless ranges.is_a?(Array) and ranges.length.even? and ranges.all?{|i| i.is_a?(Integer)}
-                    raise InvalidXRefStreamObjectError, "Index must be an even Array of integers"
-                end
+    def object_ranges
+      load! if @xrefs.nil?
 
-                ranges.each_slice(2).map { |start, length| Range.new(start.to_i, start.to_i + length.to_i - 1) }
-            else
-                [ 0...@xrefs.size ]
-            end
+      if key?(:Index)
+        ranges = self.Index
+        unless ranges.is_a?(Array) && ranges.length.even? && ranges.all? { |i| i.is_a?(Integer) }
+          raise InvalidXRefStreamObjectError, "Index must be an even Array of integers"
         end
 
-        def load! #:nodoc:
-            if @xrefs.nil? and self.key?(:W)
-                decode!
-
-                type_w, field1_w, field2_w = field_widths
-
-                entrymask = "B#{type_w << 3}B#{field1_w << 3}B#{field2_w << 3}"
-                size = @data.size / (type_w + field1_w + field2_w)
-
-                xentries = @data.unpack(entrymask * size).map!{|field| field.to_i(2) }
-
-                @xrefs = []
-                xentries.each_slice(3) do |type, field1, field2|
-                    case type
-                    when XREF_FREE
-                        @xrefs << XRef.new(field1, field2, XRef::FREE)
-                    when XREF_USED
-                        @xrefs << XRef.new(field1, field2, XRef::USED)
-                    when XREF_COMPRESSED
-                        @xrefs << XRefToCompressedObject.new(field1, field2)
-                    end
-                end
-            else
-                @xrefs = []
-            end
-        end
+        ranges.each_slice(2).map { |start, length| Range.new(start.to_i, start.to_i + length.to_i - 1) }
+      else
+        [0...@xrefs.size]
+      end
+    end
 
-        def save! #:nodoc:
-            self.data = ""
+    def load! # :nodoc:
+      if @xrefs.nil? && key?(:W)
+        decode!
 
-            type_w, field1_w, field2_w = self.W
-            @xrefs.each do |xref| @data << xref.to_xrefstm_data(type_w, field1_w, field2_w) end
+        type_w, field1_w, field2_w = field_widths
 
-            encode!
+        entrymask = "B#{type_w << 3}B#{field1_w << 3}B#{field2_w << 3}"
+        size = @data.size / (type_w + field1_w + field2_w)
+
+        xentries = @data.unpack(entrymask * size).map! { |field| field.to_i(2) }
+
+        @xrefs = []
+        xentries.each_slice(3) do |type, field1, field2|
+          case type
+          when XREF_FREE
+            @xrefs << XRef.new(field1, field2, XRef::FREE)
+          when XREF_USED
+            @xrefs << XRef.new(field1, field2, XRef::USED)
+          when XREF_COMPRESSED
+            @xrefs << XRefToCompressedObject.new(field1, field2)
+          end
         end
+      else
+        @xrefs = []
+      end
+    end
 
-        #
-        # Check and return the internal field widths.
-        #
-        def field_widths
-            widths = self.W
+    def save! # :nodoc:
+      self.data = +""
 
-            unless widths.is_a?(Array) and widths.length == 3 and widths.all? {|w| w.is_a?(Integer) and w >= 0 }
-                raise InvalidXRefStreamObjectError, "Invalid W field: #{widths}"
-            end
+      type_w, field1_w, field2_w = self.W
+      @xrefs.each do |xref| @data << xref.to_xrefstm_data(type_w, field1_w, field2_w) end
 
-            widths
-        end
+      encode!
     end
 
+    #
+    # Check and return the internal field widths.
+    #
+    def field_widths
+      widths = self.W
+
+      unless widths.is_a?(Array) && (widths.length == 3) && widths.all? { |w| w.is_a?(Integer) && (w >= 0) }
+        raise InvalidXRefStreamObjectError, "Invalid W field: #{widths}"
+      end
+
+      widths
+    end
+  end
 end