origami-docspring 2.2.0 → 2.3.0

data/lib/origami/parsers/pdf/lazy.rb

@@ -1,176 +1,169 @@
-=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/parsers/pdf'
 
 module Origami
+  class PDF
+    #
+    # Create a new PDF lazy Parser.
+    #
+    class LazyParser < Parser
+      def parse(stream)
+        super
+
+        pdf = parse_initialize
+        revisions = []
+
+        # Locate the last xref offset at the end of the file.
+        xref_offset = locate_last_xref_offset
+
+        while xref_offset && (xref_offset != 0)
+
+          # Create a new revision based on the xref section offset.
+          revision = parse_revision(pdf, xref_offset)
+
+          # Locate the previous xref section.
+          xref_offset = if revision.xrefstm? && revision.xrefstm[:Prev].is_a?(Integer)
+            revision.xrefstm[:Prev].to_i
+          elsif revision.trailer[:Prev].is_a?(Integer)
+            revision.trailer[:Prev].to_i
+          end
+
+          # Prepend the revision.
+          revisions.unshift(revision)
+        end
 
-    class PDF
-
-        #
-        # Create a new PDF lazy Parser.
-        #
-        class LazyParser < Parser
-            def parse(stream)
-                super
-
-                pdf = parse_initialize
-                revisions = []
-
-                # Locate the last xref offset at the end of the file.
-                xref_offset = locate_last_xref_offset
-
-                while xref_offset and xref_offset != 0
-
-                    # Create a new revision based on the xref section offset.
-                    revision = parse_revision(pdf, xref_offset)
-
-                    # Locate the previous xref section.
-                    if revision.xrefstm? and revision.xrefstm[:Prev].is_a?(Integer)
-                        xref_offset = revision.xrefstm[:Prev].to_i
-                    elsif revision.trailer[:Prev].is_a?(Integer)
-                        xref_offset = revision.trailer[:Prev].to_i
-                    else
-                        xref_offset = nil
-                    end
-
-                    # Prepend the revision.
-                    revisions.unshift(revision)
-                end
-
-                pdf.revisions.clear
-                revisions.each do |rev|
-                    pdf.revisions.push(rev)
-                    pdf.insert(rev.xrefstm) if rev.xrefstm?
-                end
-
-                parse_finalize(pdf)
-
-                pdf
-            end
+        pdf.revisions.clear
+        revisions.each do |rev|
+          pdf.revisions.push(rev)
+          pdf.insert(rev.xrefstm) if rev.xrefstm?
+        end
 
-            private
+        parse_finalize(pdf)
 
-            #
-            # The document is scanned starting from the end, by locating the last startxref token.
-            #
-            def locate_last_xref_offset
-                # Set the scanner position at the end.
-                @data.terminate
+        pdf
+      end
 
-                # Locate the startxref token.
-                until @data.match?(/#{Trailer::XREF_TOKEN}/)
-                    raise ParsingError, "No xref token found" if @data.pos == 0
-                    @data.pos -= 1
-                end
+      private
 
-                # Extract the offset of the last xref section.
-                trailer = Trailer.parse(@data, self)
-                raise ParsingError, "Cannot locate xref section" if trailer.startxref.zero?
+      #
+      # The document is scanned starting from the end, by locating the last startxref token.
+      #
+      def locate_last_xref_offset
+        # Set the scanner position at the end.
+        @data.terminate
 
-                trailer.startxref
-            end
+        # Locate the startxref token.
+        until @data.match?(/#{Trailer::XREF_TOKEN}/)
+          raise ParsingError, "No xref token found" if @data.pos == 0
+          @data.pos -= 1
+        end
 
-            # 
-            # In the LazyParser, the revisions are parsed by jumping through the cross-references (table or streams).
-            #
-            def parse_revision(pdf, offset)
-                raise ParsingError, "Invalid xref offset" unless offset.between?(0, @data.string.size - 1)
+        # Extract the offset of the last xref section.
+        trailer = Trailer.parse(@data, self)
+        raise ParsingError, "Cannot locate xref section" if trailer.startxref.zero?
 
-                @data.pos = offset
+        trailer.startxref
+      end
 
-                # Create a new revision.
-                revision = PDF::Revision.new(pdf)
+      #
+      # In the LazyParser, the revisions are parsed by jumping through the cross-references (table or streams).
+      #
+      def parse_revision(pdf, offset)
+        raise ParsingError, "Invalid xref offset" unless offset.between?(0, @data.string.size - 1)
 
-                # Regular xref section.
-                if @data.match?(/#{XRef::Section::TOKEN}/)
-                    parse_revision_from_xreftable(revision)
+        @data.pos = offset
 
-                # The xrefs are stored in a stream.
-                else
-                    parse_revision_from_xrefstm(revision)
-                end
+        # Create a new revision.
+        revision = PDF::Revision.new(pdf)
 
-                revision
-            end
+        # Regular xref section.
+        if @data.match?(/#{XRef::Section::TOKEN}/)
+          parse_revision_from_xreftable(revision)
 
-            #
-            # Assume the current pointer is at the xreftable of the revision.
-            # We are expecting:
-            #   - a regular xref table, starting with xref
-            #   - a revision trailer
-            #
-            # The trailer may hold a XRefStm entry in case of hybrid references.
-            #
-            def parse_revision_from_xreftable(revision)
-                xreftable = parse_xreftable
-                raise ParsingError, "Cannot parse xref section" if xreftable.nil?
-
-                revision.xreftable = xreftable
-                revision.trailer = parse_trailer
-
-                # Handle hybrid cross-references.
-                if revision.trailer[:XRefStm].is_a?(Integer)
-                    begin
-                        offset = revision.trailer[:XRefStm].to_i
-                        xrefstm = parse_object(offset)
-
-                        if xrefstm.is_a?(XRefStream)
-                            revision.xrefstm = xrefstm
-                        else
-                            warn "Invalid xref stream at offset #{offset}"
-                        end
-
-                    rescue
-                        warn "Cannot parse xref stream at offset #{offset}"
-                    end
-                end
-            end
+        # The xrefs are stored in a stream.
+        else
+          parse_revision_from_xrefstm(revision)
+        end
 
-            #
-            # Assume the current pointer is at the xref stream of the revision.
-            #
-            # The XRefStream should normally be at the end of the revision.
-            # We scan after the object for a trailer token.
-            # 
-            # The revision is allowed not to have a trailer, and the stream
-            # dictionary will be used as the trailer dictionary in that case.
-            #
-            def parse_revision_from_xrefstm(revision)
-                xrefstm = parse_object
-                raise ParsingError, "Invalid xref stream" unless xrefstm.is_a?(XRefStream)
-
-                revision.xrefstm = xrefstm
-
-                # Search for the trailer.
-                if @data.skip_until Regexp.union(Trailer::XREF_TOKEN, *Trailer::TOKENS)
-                    @data.pos -= @data.matched_size
-
-                    revision.trailer = parse_trailer
-                else
-                    warn "No trailer found."
-                    revision.trailer = Trailer.new
-                end
+        revision
+      end
+
+      #
+      # Assume the current pointer is at the xreftable of the revision.
+      # We are expecting:
+      #   - a regular xref table, starting with xref
+      #   - a revision trailer
+      #
+      # The trailer may hold a XRefStm entry in case of hybrid references.
+      #
+      def parse_revision_from_xreftable(revision)
+        xreftable = parse_xreftable
+        raise ParsingError, "Cannot parse xref section" if xreftable.nil?
+
+        revision.xreftable = xreftable
+        revision.trailer = parse_trailer
+
+        # Handle hybrid cross-references.
+        if revision.trailer[:XRefStm].is_a?(Integer)
+          begin
+            offset = revision.trailer[:XRefStm].to_i
+            xrefstm = parse_object(offset)
+
+            if xrefstm.is_a?(XRefStream)
+              revision.xrefstm = xrefstm
+            else
+              warn "Invalid xref stream at offset #{offset}"
             end
+          rescue
+            warn "Cannot parse xref stream at offset #{offset}"
+          end
+        end
+      end
+
+      #
+      # Assume the current pointer is at the xref stream of the revision.
+      #
+      # The XRefStream should normally be at the end of the revision.
+      # We scan after the object for a trailer token.
+      #
+      # The revision is allowed not to have a trailer, and the stream
+      # dictionary will be used as the trailer dictionary in that case.
+      #
+      def parse_revision_from_xrefstm(revision)
+        xrefstm = parse_object
+        raise ParsingError, "Invalid xref stream" unless xrefstm.is_a?(XRefStream)
+
+        revision.xrefstm = xrefstm
+
+        # Search for the trailer.
+        if @data.skip_until Regexp.union(Trailer::XREF_TOKEN, *Trailer::TOKENS)
+          @data.pos -= @data.matched_size
+
+          revision.trailer = parse_trailer
+        else
+          warn "No trailer found."
+          revision.trailer = Trailer.new
         end
+      end
     end
-
+  end
 end

data/lib/origami/parsers/pdf/linear.rb

@@ -1,122 +1,117 @@
-=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é.
+require 'origami/parsers/pdf'
 
-    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.
+module Origami
+  class PDF
+    #
+    # Create a new PDF linear Parser.
+    #
+    class LinearParser < Parser
+      def parse(stream)
+        super
 
-    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.
+        pdf = parse_initialize
 
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+        #
+        # Parse each revision
+        #
+        revision = 0
+        until @data.eos?
+          begin
+            pdf.add_new_revision unless revision.zero?
+
+            parse_revision(pdf, revision)
+            revision += 1
+          rescue
+            error "Cannot read : " + (@data.peek(10) + "...").inspect
+            error "Stopped on exception : " + $!.message
+            warn $!.backtrace.join($/)
+
+            break
+          end
+        end
 
-=end
+        pdf.loaded!
 
+        parse_finalize(pdf)
+      end
 
-require 'origami/parsers/pdf'
+      private
 
-module Origami
+      def parse_revision(pdf, revision_no)
+        revision = pdf.revisions[revision_no]
 
-    class PDF
+        info "...Parsing revision #{revision_no + 1}..."
+        loop do
+          break if (object = parse_object).nil?
+          pdf.insert(object)
+        end
 
-        #
-        # Create a new PDF linear Parser.
-        #
-        class LinearParser < Parser
-            def parse(stream)
-                super
-            
-                pdf = parse_initialize
-
-                #
-                # Parse each revision
-                #
-                revision = 0
-                until @data.eos? do
-                    begin
-                        pdf.add_new_revision unless revision.zero?
-
-                        parse_revision(pdf, revision)
-                        revision = revision + 1
-
-                    rescue
-                        error "Cannot read : " + (@data.peek(10) + "...").inspect
-                        error "Stopped on exception : " + $!.message
-                        STDERR.puts $!.backtrace.join($/)
-
-                        break
-                    end
-                end
-
-                pdf.loaded!
-
-                parse_finalize(pdf)
-            end
-
-            private
-
-            def parse_revision(pdf, revision_no)
-                revision = pdf.revisions[revision_no]
-
-                info "...Parsing revision #{revision_no + 1}..."
-                loop do
-                    break if (object = parse_object).nil?
-                    pdf.insert(object)
-                end
-
-                revision.xreftable = parse_xreftable
-                revision.trailer = parse_trailer
-
-                locate_xref_streams(pdf, revision_no)
-
-                revision
-            end
-
-            def locate_xref_streams(pdf, revision_no)
-                revision = pdf.revisions[revision_no]
-                trailer = revision.trailer
-                xrefstm = nil
-
-                # Try to match the location of the last startxref / XRefStm with an XRefStream.
-                if trailer.startxref != 0
-                    xrefstm = pdf.get_object_by_offset(trailer.startxref)
-                elsif trailer.key?(:XRefStm)
-                    xrefstm = pdf.get_object_by_offset(trailer[:XRefStm])
-                end
-
-                if xrefstm.is_a?(XRefStream)
-                    warn "Found a XRefStream for revision #{revision_no + 1} at #{xrefstm.reference}"
-                    revision.xrefstm = xrefstm
-
-                    if xrefstm.key?(:Prev)
-                        locate_prev_xref_streams(pdf, revision_no, xrefstm)
-                    end
-                end
-            end
-
-            def locate_prev_xref_streams(pdf, revision_no, xrefstm)
-                return unless revision_no > 0 and xrefstm.Prev.is_a?(Integer)
-
-                prev_revision = pdf.revisions[revision_no - 1]
-                prev_offset = xrefstm.Prev.to_i
-                prev_xrefstm = pdf.get_object_by_offset(prev_offset)
-
-                if prev_xrefstm.is_a?(XRefStream)
-                    warn "Found a previous XRefStream for revision #{revision_no} at #{prev_xrefstm.reference}"
-                    prev_revision.xrefstm = prev_xrefstm
-
-                    if prev_xrefstm.key?(:Prev)
-                        locate_prev_xref_streams(pdf, revision_no - 1, prev_xrefstm)
-                    end
-                end
-            end
+        revision.xreftable = parse_xreftable
+        revision.trailer = parse_trailer
+
+        locate_xref_streams(pdf, revision_no)
+
+        revision
+      end
+
+      def locate_xref_streams(pdf, revision_no)
+        revision = pdf.revisions[revision_no]
+        trailer = revision.trailer
+        xrefstm = nil
+
+        # Try to match the location of the last startxref / XRefStm with an XRefStream.
+        if trailer.startxref != 0
+          xrefstm = pdf.get_object_by_offset(trailer.startxref)
+        elsif trailer.key?(:XRefStm)
+          xrefstm = pdf.get_object_by_offset(trailer[:XRefStm])
         end
-    end
 
+        if xrefstm.is_a?(XRefStream)
+          warn "Found a XRefStream for revision #{revision_no + 1} at #{xrefstm.reference}"
+          revision.xrefstm = xrefstm
+
+          if xrefstm.key?(:Prev)
+            locate_prev_xref_streams(pdf, revision_no, xrefstm)
+          end
+        end
+      end
+
+      def locate_prev_xref_streams(pdf, revision_no, xrefstm)
+        return unless (revision_no > 0) && xrefstm.Prev.is_a?(Integer)
+
+        prev_revision = pdf.revisions[revision_no - 1]
+        prev_offset = xrefstm.Prev.to_i
+        prev_xrefstm = pdf.get_object_by_offset(prev_offset)
+
+        if prev_xrefstm.is_a?(XRefStream)
+          warn "Found a previous XRefStream for revision #{revision_no} at #{prev_xrefstm.reference}"
+          prev_revision.xrefstm = prev_xrefstm
+
+          if prev_xrefstm.key?(:Prev)
+            locate_prev_xref_streams(pdf, revision_no - 1, prev_xrefstm)
+          end
+        end
+      end
+    end
+  end
 end