origami 2.0.0 → 2.0.1

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

@@ -54,16 +54,7 @@ module Origami
                         trailer = parse_trailer
                         pdf.revisions.last.trailer = trailer
 
-                        if trailer.startxref != 0
-                            xrefstm = pdf.get_object_by_offset(trailer.startxref)
-                        elsif trailer[:XRefStm].is_a?(Integer)
-                            xrefstm = pdf.get_object_by_offset(trailer[:XRefStm])
-                        end
-
-                        if xrefstm.is_a?(XRefStream)
-                            warn "Found a XRefStream for this revision at #{xrefstm.reference}"
-                            pdf.revisions.last.xrefstm = xrefstm
-                        end
+                        locate_xref_stream(pdf, pdf.revisions.last)
 
                     rescue
                         error "Cannot read : " + (@data.peek(10) + "...").inspect
@@ -77,6 +68,24 @@ module Origami
 
                 parse_finalize(pdf)
             end
+
+            private
+
+            def locate_xref_stream(pdf, revision)
+                trailer = revision.trailer
+
+                # 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)
+                else
+                    xrefstm = pdf.get_object_by_offset(trailer[:XRefStm])
+                end
+
+                if xrefstm.is_a?(XRefStream)
+                    warn "Found a XRefStream for this revision at #{xrefstm.reference}"
+                    revision.xrefstm = xrefstm
+                end
+            end
         end
     end
 

data/lib/origami/parsers/ppklite.rb

@@ -44,7 +44,7 @@ module Origami
                     trailer = address_book.revisions.first.trailer
 
                     if trailer[:Root].is_a?(Reference)
-                        address_book.cast_object(trailer[:Root], PPKLite::Catalog, self)
+                        address_book.cast_object(trailer[:Root], PPKLite::Catalog)
                     end
 
                     propagate_types(address_book)

data/lib/origami/pdf.rb

@@ -45,8 +45,6 @@ require 'origami/actions'
 require 'origami/3d'
 require 'origami/signature'
 require 'origami/webcapture'
-require 'origami/export'
-require 'origami/webcapture'
 require 'origami/encryption'
 require 'origami/linearization'
 require 'origami/obfuscation'
@@ -147,15 +145,6 @@ module Origami
                 pdf.save(output, options)
             end
             alias write create
-
-            #
-            # Deserializes a PDF dump.
-            #
-            def deserialize(filename)
-                Zlib::GzipReader.open(filename) { |gz|
-                    return Marshal.load(gz.read)
-                }
-            end
         end
 
         #
@@ -166,16 +155,13 @@ module Origami
         def initialize(parser = nil)
             @header = PDF::Header.new
             @revisions = []
+            @parser = parser
+            @loaded = false
 
             add_new_revision
             @revisions.first.trailer = Trailer.new
 
-            if parser
-                @loaded = false
-                @parser = parser
-            else
-                init
-            end
+            init if parser.nil?
         end
 
         #
@@ -199,21 +185,6 @@ module Origami
             @parser.target_data if @parser
         end
 
-        #
-        # Serializes the current PDF.
-        #
-        def serialize(filename)
-            parser = @parser
-            @parser = nil # do not serialize the parser
-
-            Zlib::GzipWriter.open(filename) { |gz|
-                gz.write Marshal.dump(self)
-            }
-
-            @parser = parser
-            self
-        end
-
         #
         # Saves the current document.
         # _filename_:: The path where to save this PDF.
@@ -277,35 +248,9 @@ module Origami
 
             result = []
 
-            search_object = -> (object) do
-                case object
-                when Stream
-                    result.concat object.dictionary.strings_cache.select{|str| pattern === str}
-                    result.concat object.dictionary.names_cache.select{|name| pattern === name.value}
-
-                    begin
-                        result.push object if streams and object.data.match(pattern)
-                    rescue Filter::Error
-                        next # Skip object if a decoding error occured.
-                    end
-
-                    next if object.is_a?(ObjectStream) and not object_streams
-
-                    object.each do |subobject|
-                        search_object.call(subobject)
-                    end
-
-                when Name, String
-                    result.push object if object.value.match(pattern)
-
-                when Dictionary, Array then
-                    result.concat object.strings_cache.select{|str| pattern === str}
-                    result.concat object.names_cache.select{|name| pattern === name.value}
-                end
-            end
-
             self.indirect_objects.each do |object|
-                search_object.call(object)
+                result.concat search_object(object, pattern,
+                                            streams: streams, object_streams: object_streams)
             end
 
             result
@@ -329,42 +274,22 @@ module Origami
         # _compressed_: iterates over the objects inside object streams.
         # _recursive_: iterates recursively inside objects like arrays and dictionaries.
         #
-        def each_object(compressed: false, recursive: false)
+        def each_object(compressed: false, recursive: false, &block)
             return enum_for(__method__, compressed: compressed,
                                         recursive: recursive
                            ) unless block_given?
 
-            walk_object = -> (object) do
-                case object
-                when Dictionary
-                    object.each_value do |value|
-                        yield(value)
-                        walk_object.call(value)
-                    end
-
-                when Array
-                    object.each do |child|
-                        yield(child)
-                        walk_object.call(child)
-                    end
-
-                when Stream
-                    yield(object.dictionary)
-                    walk_object.call(object.dictionary)
-                end
-            end
-
             @revisions.each do |revision|
                 revision.each_object do |object|
-                    yield(object)
+                    block.call(object)
 
-                    walk_object.call(object) if recursive
+                    walk_object(object, &block) if recursive
 
                     if object.is_a?(ObjectStream) and compressed
                         object.each do |child_obj|
-                            yield(child_obj)
+                            block.call(child_obj)
 
-                            walk_object.call(child_obj) if recursive
+                            walk_object(child_obj) if recursive
                         end
                     end
                 end
@@ -539,7 +464,7 @@ module Origami
                 #
                 # We found a matching XRef.
                 #
-                if xref.is_a?(XRefToCompressedObj)
+                if xref.is_a?(XRefToCompressedObject)
                     objstm = get_object(xref.objstmno, 0, use_xrefstm: use_xrefstm)
 
                     object = objstm.extract_by_index(xref.index)
@@ -570,35 +495,35 @@ module Origami
         # Casts a PDF object into another object type.
         # The target type must be a subtype of the original type.
         #
-        def cast_object(reference, type, parser = nil) #:nodoc:
+        def cast_object(reference, type) #:nodoc:
             @revisions.each do |rev|
-                if rev.body.include?(reference) and type < rev.body[reference].class
-                    rev.body[reference] = rev.body[reference].cast_to(type, parser)
+                if rev.body.include?(reference)
+                    object = rev.body[reference]
+                    return object if object.is_a?(type)
 
-                    rev.body[reference]
-                else
-                    nil
+                    if type < rev.body[reference].class
+                        rev.body[reference] = object.cast_to(type, @parser)
+
+                        return rev.body[reference]
+                    end
                 end
             end
+
+            nil
         end
 
         #
         # Returns a new number/generation for future object.
         #
         def allocate_new_object_number
-            no = 1
 
-            # Deprecated number allocation policy (first available)
-            #no = no + 1 while get_object(no)
-
-            objset = self.indirect_objects
-            self.indirect_objects.find_all{|obj| obj.is_a?(ObjectStream)}.each do |objstm|
-                objstm.each{|obj| objset << obj}
+            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
 
-            allocated = objset.collect{|obj| obj.no}.compact
-            no = allocated.max + 1 unless allocated.empty?
-
             [ no, 0 ]
         end
 
@@ -614,6 +539,70 @@ module Origami
         private
         ##########################
 
+        #
+        # Iterates over the children of an object, avoiding cycles.
+        #
+        def walk_object(object, excludes: [])
+            return enum_for(__method__, object, excludes: excludes) unless block_given?
+
+            return if excludes.include?(object)
+            excludes.push(object)
+
+            case object
+            when Dictionary
+                object.each_value do |value|
+                    yield(value)
+                    walk_object(value, excludes: excludes)
+                end
+
+            when Array
+                object.each do |child|
+                    yield(child)
+                    walk_object(child, excludes: excludes)
+                end
+
+            when Stream
+                yield(object.dictionary)
+                walk_object(object.dictionary, excludes: excludes)
+            end
+        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| pattern === str}
+                result.concat object.dictionary.names_cache.select{|name| pattern === name.value}
+
+                begin
+                    result.push object if streams and object.data.match(pattern)
+                rescue Filter::Error
+                    return result # Skip object if a decoding error occured.
+                end
+
+                return result unless object.is_a?(ObjectStream) and object_streams
+
+                object.each do |child|
+                    result.concat search_object(child, pattern,
+                                                streams: streams, object_streams: object_streams)
+                end
+
+            when Name, String
+                result.push object if object.value.match(pattern)
+
+            when Dictionary, Array
+                result.concat object.strings_cache.select{|str| pattern === str}
+                result.concat object.names_cache.select{|name| pattern === name.value}
+            end
+
+            result
+        end
+
         #
         # Load an object from its given file offset.
         # The document must have an associated Parser.
@@ -627,19 +616,7 @@ module Origami
                 return nil if object.nil?
 
                 if self.is_a?(Encryption::EncryptedDocument)
-                    case object
-                    when String
-                        object.extend(Encryption::EncryptedString)
-                        object.decrypted = false
-                    when Stream
-                        object.extend(Encryption::EncryptedStream)
-                        object.decrypted = false
-                    when Dictionary, Array
-                        object.strings_cache.each do |string|
-                            string.extend(Encryption::EncryptedString)
-                            string.decrypted = false
-                        end
-                    end
+                    make_encrypted_object(object)
                 end
 
                 add_to_revision(object, revision)
@@ -650,6 +627,22 @@ module Origami
             object
         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 Dictionary, Array
+                object.strings_cache.each do |string|
+                    string.extend(Encryption::EncryptedString)
+                end
+            end
+        end
+
         #
         # Force the loading of all objects in the document.
         #
@@ -665,8 +658,8 @@ module Origami
                     next
                 end
 
-                xrefs.each_with_number do |_, no|
-                    self.get_object(no)
+                xrefs.each_with_number do |xref, no|
+                    self.get_object(no) unless xref.free?
                 end
             end
 
@@ -716,11 +709,7 @@ module Origami
             # Allocates object numbers and creates references.
             # Invokes object finalization methods.
             #
-            if self.is_a?(Encryption::EncryptedDocument)
-                physicalize(options)
-            else
-                physicalize
-            end
+            physicalize(options)
 
             #
             # Sets the PDF version header.
@@ -735,100 +724,58 @@ module Origami
         end
 
         #
-        # Cleans the document from its references.
-        # Indirects objects are made direct whenever possible.
-        # TODO: Circuit-checking to avoid infinite induction
+        # Converts a logical PDF view into a physical view ready for writing.
         #
-        def logicalize #:nodoc:
-            raise NotImplementedError
+        def physicalize(options = {})
 
-            processed = []
-
-            convert = -> (root) do
-                replaced = []
-                if root.is_a?(Dictionary) or root.is_a?(Array)
-                    root.each do |obj|
-                        convert[obj]
-                    end
-
-                    root.map! do |obj|
-                        if obj.is_a?(Reference)
-                            target = obj.solve
-                            # Streams can't be direct objects
-                            if target.is_a?(Stream)
-                                obj
-                            else
-                                replaced << obj
-                                target
-                            end
-                        else
-                            obj
-                        end
-                    end
-                end
-
-                replaced
+            indirect_objects_by_rev.each do |obj, revision|
+                build_object(obj, revision, options)
             end
 
-            @revisions.each do |revision|
-                revision.objects.each do |obj|
-                    processed.concat(convert[obj])
-                end
-            end
+            self
         end
 
-        #
-        # Converts a logical PDF view into a physical view ready for writing.
-        #
-        def physicalize
-
-            #
-            # Indirect objects are added to the revision and assigned numbers.
-            #
-            build = -> (obj, revision) do
-                #
-                # Finalize any subobjects before building the stream.
-                #
-                if obj.is_a?(ObjectStream)
-                    obj.each do |subobj|
-                        build.call(subobj, revision)
-                    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
 
-                obj.pre_build
+            object.pre_build
 
-                if obj.is_a?(Dictionary) or obj.is_a?(Array)
+            case object
+            when Stream
+                build_object(object.dictionary, revision, options)
+            when Dictionary, Array
+                build_compound_object(object, revision, options)
+            end
 
-                    obj.map! do |subobj|
-                        if subobj.indirect?
-                            if get_object(subobj.reference)
-                                subobj.reference
-                            else
-                                ref = add_to_revision(subobj, revision)
-                                build.call(subobj, revision)
-                                ref
-                            end
-                        else
-                            subobj
-                        end
-                    end
+            object.post_build
+        end
 
-                    obj.each do |subobj|
-                        build.call(subobj, revision)
-                    end
+        def build_compound_object(object, revision, options)
+            return unless object.is_a?(Dictionary) or object.is_a?(Array)
 
-                elsif obj.is_a?(Stream)
-                    build.call(obj.dictionary, revision)
-                end
+            # Flatten the object by adding indirect objects to the revision and
+            # replacing them with their reference.
+            object.map! do |child|
+                next(child) unless child.indirect?
 
-                obj.post_build
+                if get_object(child.reference)
+                    child.reference
+                else
+                    reference = add_to_revision(child, revision)
+                    build_object(child, revision, options)
+                    reference
+                end
             end
 
-          indirect_objects_by_rev.each do |obj, revision|
-              build.call(obj, revision)
-          end
-
-          self
+            # Finalize all the children objects.
+            object.each do |child|
+                build_object(child, revision, options)
+            end
         end
 
         #
@@ -858,9 +805,7 @@ module Origami
             end
 
             # Get trailer dictionary
-            trailer_info = get_trailer_info
-            raise InvalidPDFError, "No trailer information found" if trailer_info.nil?
-            trailer_dict = trailer_info.dictionary
+            trailer_dict = self.trailer.dictionary
 
             prev_xref_offset = nil
             xrefstm_offset = nil
@@ -939,7 +884,7 @@ module Origami
                         if options[:use_xrefstm] and obj.parent != obj and obj.parent.is_a?(ObjectStream)
                             index = obj.parent.index(obj.no)
 
-                            xrefs_stm << XRefToCompressedObj.new(obj.parent.no, index)
+                            xrefs_stm << XRefToCompressedObject.new(obj.parent.no, index)
 
                             lastno_stm = obj.no
                         else
@@ -1022,7 +967,6 @@ module Origami
         #
         def init
             catalog = (self.Catalog = (trailer_key(:Root) || Catalog.new))
-            catalog.Pages = PageTreeNode.new.set_indirect(true)
             @revisions.last.trailer.Root = catalog.reference
 
             @loaded = true