origamindee 3.0.0

data/lib/origami/parser.rb

@@ -0,0 +1,269 @@
+=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
+
+require 'rainbow'
+require 'strscan'
+
+module Origami
+
+    class Parser #:nodoc:
+
+        class ParsingError < Error #:nodoc:
+        end
+
+        #
+        # Do not output debug information.
+        #
+        VERBOSE_QUIET = 0
+
+        #
+        # Output some useful information.
+        #
+        VERBOSE_INFO = 1
+
+        #
+        # Output debug information.
+        #
+        VERBOSE_DEBUG = 2
+
+        #
+        # Output every objects read
+        #
+        VERBOSE_TRACE = 3
+
+        attr_accessor :options
+
+        def initialize(options = {}) #:nodoc:
+            # Type information for indirect objects.
+            @deferred_casts = {}
+
+            #Default options values
+            @options =
+            {
+                verbosity: VERBOSE_INFO, # Verbose level.
+                ignore_errors: true,     # Try to keep on parsing when errors occur.
+                callback: Proc.new {},   # Callback procedure whenever a structure is read.
+                logger: STDERR,          # Where to output parser messages.
+                colorize_log: true       # Colorize parser output?
+            }
+
+            @options.update(options)
+            @logger = @options[:logger]
+            @data = nil
+        end
+
+        def pos
+            raise RuntimeError, "Cannot get position, parser has no loaded data." if @data.nil?
+
+            @data.pos
+        end
+
+        def pos=(offset)
+            raise RuntimeError, "Cannot set position, parser has no loaded data." if @data.nil?
+
+            @data.pos = offset
+        end
+
+        def parse(stream)
+            data =
+            if stream.respond_to? :read
+                StringScanner.new(stream.read.force_encoding('binary'))
+            elsif stream.is_a? ::String
+                @filename = stream
+                StringScanner.new(File.binread(@filename))
+            elsif stream.is_a? StringScanner
+                stream
+            else
+                raise TypeError
+            end
+
+            @data = data
+            @data.pos = 0
+        end
+
+        def parse_object(pos = @data.pos) #:nodoc:
+            @data.pos = pos
+
+            begin
+                obj = Object.parse(@data, self)
+                return if obj.nil?
+
+                obj = try_object_promotion(obj)
+                trace "Read #{obj.type} object, #{obj.reference}"
+
+                @options[:callback].call(obj)
+                obj
+
+            rescue UnterminatedObjectError
+                error $!.message
+                obj = $!.obj
+
+                Object.skip_until_next_obj(@data)
+                @options[:callback].call(obj)
+                obj
+
+            rescue
+                error "Breaking on: #{(@data.peek(10) + "...").inspect} at offset 0x#{@data.pos.to_s(16)}"
+                error "Last exception: [#{$!.class}] #{$!.message}"
+                if not @options[:ignore_errors]
+                    error "Manually fix the file or set :ignore_errors parameter."
+                    raise
+                end
+
+                debug 'Skipping this indirect object.'
+                raise if not Object.skip_until_next_obj(@data)
+
+                retry
+            end
+        end
+
+        def parse_xreftable(pos = @data.pos) #:nodoc:
+            @data.pos = pos
+
+            begin
+                info "...Parsing xref table..."
+                xreftable = XRef::Section.parse(@data)
+                @options[:callback].call(xreftable)
+
+                xreftable
+
+            rescue
+                debug "Exception caught while parsing xref table : " + $!.message
+                warn "Unable to parse xref table! Xrefs might be stored into an XRef stream."
+
+                @data.pos -= 'trailer'.length unless @data.skip_until(/trailer/).nil?
+
+                nil
+            end
+        end
+
+        def parse_trailer(pos = @data.pos) #:nodoc:
+            @data.pos = pos
+
+            begin
+                info "...Parsing trailer..."
+                trailer = Trailer.parse(@data, self)
+
+                @options[:callback].call(trailer)
+                trailer
+
+            rescue
+                debug "Exception caught while parsing trailer : " + $!.message
+                warn "Unable to parse trailer!"
+
+                raise
+            end
+        end
+
+        def defer_type_cast(reference, type) #:nodoc:
+            @deferred_casts[reference] = type
+        end
+
+        def target_filename
+            @filename
+        end
+
+        def target_filesize
+            @data.string.size if @data
+        end
+
+        def target_data
+            @data.string.dup if @data
+        end
+
+        def error(msg = "") #:nodoc:
+            log(VERBOSE_QUIET, 'error', :red, msg)
+        end
+
+        def warn(msg = "") #:nodoc:
+            log(VERBOSE_INFO, 'warn ', :yellow, msg)
+        end
+
+        def info(msg = "") #:nodoc:
+            log(VERBOSE_INFO, 'info ', :green, msg)
+        end
+
+        def debug(msg = "") #:nodoc:
+            log(VERBOSE_DEBUG, 'debug', :magenta, msg)
+        end
+
+        def trace(msg = "") #:nodoc:
+            log(VERBOSE_TRACE, 'trace', :cyan, msg)
+        end
+
+        def self.init_scanner(stream)
+            if stream.is_a?(StringScanner)
+                stream
+            elsif stream.respond_to?(:to_str)
+                StringScanner.new(stream.to_str)
+            else
+                raise TypeError, "Cannot initialize scanner from #{stream.class}"
+            end
+        end
+
+        private
+
+        #
+        # Attempt to promote an object using the deferred casts.
+        #
+        def try_object_promotion(obj)
+            return obj unless Origami::OPTIONS[:enable_type_propagation] and @deferred_casts.key?(obj.reference)
+
+            types = @deferred_casts[obj.reference]
+            types = [ types ] unless types.is_a?(::Array)
+
+            # Promote object if a compatible type is found.
+            cast_type = types.find {|type| type < obj.class }
+            if cast_type
+                obj = obj.cast_to(cast_type, self)
+            else
+                obj
+            end
+        end
+
+        def log(level, prefix, color, message) #:nodoc:
+            return unless @options[:verbosity] >= level
+
+            if @options[:colorize_log]
+                @logger.print Rainbow("[#{prefix}]").color(color)
+                @logger.puts " #{message}"
+            else
+                @logger.puts "[#{prefix}] #{message}"
+            end
+        end
+
+        def propagate_types(document)
+            info "...Propagating types..."
+
+            current_state = nil
+            until current_state == @deferred_casts
+                current_state = @deferred_casts.clone
+
+                current_state.each_pair do |ref, type|
+                    type = [ type ] unless type.is_a?(::Array)
+                    type.each do |hint|
+                        break if document.cast_object(ref, hint)
+                    end
+                end
+            end
+        end
+    end
+
+end

data/lib/origami/parsers/fdf.rb

@@ -0,0 +1,56 @@
+=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
+
+require 'origami/parser'
+
+module Origami
+
+    class FDF
+        class Parser < Origami::Parser
+            def parse(stream) #:nodoc:
+                super(stream)
+
+                fdf = FDF.new(self)
+                fdf.header = FDF::Header.parse(@data)
+                @options[:callback].call(fdf.header)
+
+                loop do
+                    break if (object = parse_object).nil?
+                    fdf.insert(object)
+                end
+
+                fdf.revisions.first.xreftable = parse_xreftable
+                fdf.revisions.first.trailer = parse_trailer
+
+                if Origami::OPTIONS[:enable_type_propagation]
+                    trailer = fdf.revisions.first.trailer
+
+                    if trailer[:Root].is_a?(Reference)
+                        fdf.cast_object(trailer[:Root], FDF::Catalog)
+                    end
+
+                    propagate_types(fdf)
+                end
+
+                fdf
+            end
+        end
+    end
+end

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

@@ -0,0 +1,176 @@
+=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
+
+
+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 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
+
+            private
+
+            #
+            # 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
+
+                # Locate the startxref token.
+                until @data.match?(/#{Trailer::XREF_TOKEN}/)
+                    raise ParsingError, "No xref token found" if @data.pos == 0
+                    @data.pos -= 1
+                end
+
+                # Extract the offset of the last xref section.
+                trailer = Trailer.parse(@data, self)
+                raise ParsingError, "Cannot locate xref section" if trailer.startxref.zero?
+
+                trailer.startxref
+            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)
+
+                @data.pos = offset
+
+                # Create a new revision.
+                revision = PDF::Revision.new(pdf)
+
+                # Regular xref section.
+                if @data.match?(/#{XRef::Section::TOKEN}/)
+                    parse_revision_from_xreftable(revision)
+
+                # The xrefs are stored in a stream.
+                else
+                    parse_revision_from_xrefstm(revision)
+                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

@@ -0,0 +1,122 @@
+=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
+
+
+require 'origami/parsers/pdf'
+
+module Origami
+
+    class PDF
+
+        #
+        # 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
+        end
+    end
+
+end