origamindee 3.0.0

data/lib/origami/linearization.rb

@@ -0,0 +1,330 @@
+=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
+
+module Origami
+
+    class PDF
+
+        class LinearizationError < Error #:nodoc:
+        end
+
+        #
+        # Returns whether the current document is linearized.
+        #
+        def linearized?
+            begin
+                first_obj = @revisions.first.objects.min_by{|obj| obj.file_offset}
+            rescue
+                return false
+            end
+
+            @revisions.size > 1 and first_obj.is_a?(Dictionary) and first_obj.has_key? :Linearized
+        end
+
+        #
+        # Tries to delinearize the document if it has been linearized.
+        # This operation is xrefs destructive, should be fixed in the future to merge tables.
+        #
+        def delinearize!
+            raise LinearizationError, 'Not a linearized document' unless self.linearized?
+
+            #
+            # Saves the first trailer.
+            #
+            prev_trailer = @revisions.first.trailer
+
+            linear_dict = @revisions.first.objects.min_by{|obj| obj.file_offset}
+
+            #
+            # Removes hint streams used by linearization.
+            #
+            delete_hint_streams(linear_dict)
+
+            #
+            # Update the trailer.
+            #
+            last_trailer = (@revisions.last.trailer ||= Trailer.new)
+            last_trailer.dictionary ||= Dictionary.new
+
+            if prev_trailer.dictionary?
+                last_trailer.dictionary =
+                    last_trailer.dictionary.merge(prev_trailer.dictionary)
+            else
+                xrefstm = @revisions.last.xrefstm
+                raise LinearizationError,
+                        'Cannot find trailer info while delinearizing document' unless xrefstm.is_a?(XRefStream)
+
+                last_trailer.dictionary[:Root] = xrefstm[:Root]
+                last_trailer.dictionary[:Encrypt] = xrefstm[:Encrypt]
+                last_trailer.dictionary[:Info] = xrefstm[:Info]
+                last_trailer.dictionary[:ID] = xrefstm[:ID]
+            end
+
+            #
+            # Remove all xrefs.
+            # Fix: Should be merged instead.
+            #
+            remove_xrefs
+
+            #
+            # Remove the linearization revision.
+            #
+            @revisions.first.body.delete(linear_dict.reference)
+            @revisions.last.body.merge! @revisions.first.body
+
+            remove_revision(0)
+
+            self
+        end
+
+        private
+
+        #
+        # Strip the document from Hint streams given a linearization dictionary.
+        #
+        def delete_hint_streams(linearization_dict)
+            hints = linearization_dict[:H]
+            return unless hints.is_a?(Array)
+
+            hints.each_slice(2) do |offset, _length|
+                next unless offset.is_a?(Integer)
+
+                stream = get_object_by_offset(offset)
+                delete_object(stream.reference) if stream.is_a?(Stream)
+            end
+        end
+    end
+
+    #
+    # Class representing a linearization dictionary.
+    #
+    class Linearization < Dictionary
+        include StandardObject
+
+        field   :Linearized,   :Type => Real, :Default => 1.0, :Required => true
+        field   :L,            :Type => Integer, :Required => true
+        field   :H,            :Type => Array.of(Integer), :Required => true
+        field   :O,            :Type => Integer, :Required => true
+        field   :E,            :Type => Integer, :Required => true
+        field   :N,            :Type => Integer, :Required => true
+        field   :T,            :Type => Integer, :Required => true
+        field   :P,            :Type => Integer, :Default => 0
+
+        def initialize(hash = {}, parser = nil)
+            super(hash, parser)
+
+            set_indirect(true)
+        end
+    end
+
+   class InvalidHintTableError < Error #:nodoc:
+   end
+
+    module HintTable
+        module ClassMethods
+            def header_item_size(number, size)
+                @header_items_size[number] = size
+            end
+
+            def get_header_item_size(number)
+                @header_items_size[number]
+            end
+
+            def entry_item_size(number, size)
+                @entry_items_size[number] = size
+            end
+
+            def get_entry_item_size(number)
+                @entry_items_size[number]
+            end
+
+            def nb_header_items
+                @header_items_size.size
+            end
+
+            def nb_entry_items
+                @entry_items_size.size
+            end
+        end
+
+        def self.included(receiver)
+            receiver.instance_variable_set(:@header_items_size, {})
+            receiver.instance_variable_set(:@entry_items_size, {})
+            receiver.extend(ClassMethods)
+        end
+
+        attr_accessor :header_items
+        attr_accessor :entries
+
+        def initialize
+            @header_items = {}
+            @entries = []
+        end
+
+        def to_s
+            data = ""
+
+            nitems = self.class.nb_header_items
+            for no in (1..nitems)
+                unless @header_items.include?(no)
+                    raise InvalidHintTableError, "Missing item #{no} in header section of #{self.class}"
+                end
+
+                value = @header_items[no]
+                item_size = self.class.get_header_item_size(no)
+
+                item_size = ((item_size + 7) >> 3) << 3
+                item_data = value.to_s(2)
+                item_data = "0" * (item_size - item_data.size) + item_data
+
+                data << [ item_data ].pack("B*")
+            end
+
+            nitems = self.class.nb_entry_items
+            @entries.each_with_index do |entry, i|
+                for no in (1..nitems)
+                    unless entry.include?(no)
+                        raise InvalidHintTableError, "Missing item #{no} in entry #{i} of #{self.class}"
+                    end
+
+                    value = entry[no]
+                    item_size = self.class.get_entry_item_size(no)
+
+                    item_size = ((item_size + 7) >> 3) << 3
+                    item_data = value.to_s(2)
+                    item_data = "0" * (item_size - item_data.size) + item_data
+
+                    data << [ item_data ].pack("B*")
+                end
+            end
+
+            data
+        end
+
+        class PageOffsetTable
+            include HintTable
+
+            header_item_size  1,  32
+            header_item_size  2,  32
+            header_item_size  3,  16
+            header_item_size  4,  32
+            header_item_size  5,  16
+            header_item_size  6,  32
+            header_item_size  7,  16
+            header_item_size  8,  32
+            header_item_size  9,  16
+            header_item_size  10,  16
+            header_item_size  11,  16
+            header_item_size  12,  16
+            header_item_size  13,  16
+
+            entry_item_size   1,  16
+            entry_item_size   2,  16
+            entry_item_size   3,  16
+            entry_item_size   4,  16
+            entry_item_size   5,  16
+            entry_item_size   6,  16
+            entry_item_size   7,  16
+        end
+
+        class SharedObjectTable
+            include HintTable
+
+            header_item_size  1,  32
+            header_item_size  2,  32
+            header_item_size  3,  32
+            header_item_size  4,  32
+            header_item_size  5,  16
+            header_item_size  6,  32
+            header_item_size  7,  16
+
+            entry_item_size   1,  16
+            entry_item_size   2,  1
+            entry_item_size   3,  128
+            entry_item_size   4,  16
+        end
+    end
+
+    class InvalidHintStreamObjectError < InvalidStreamObjectError #:nodoc:
+    end
+
+    class HintStream < Stream
+        attr_accessor :page_offset_table
+        attr_accessor :shared_objects_table
+        attr_accessor :thumbnails_table
+        attr_accessor :outlines_table
+        attr_accessor :threads_table
+        attr_accessor :named_destinations_table
+        attr_accessor :interactive_forms_table
+        attr_accessor :information_dictionary_table
+        attr_accessor :logical_structure_table
+        attr_accessor :page_labels_table
+        attr_accessor :renditions_table
+        attr_accessor :embedded_files_table
+
+        field   :S,             :Type => Integer, :Required => true # Shared objects
+        field   :T,             :Type => Integer  # Thumbnails
+        field   :O,             :Type => Integer  # Outlines
+        field   :A,             :Type => Integer  # Threads
+        field   :E,             :Type => Integer  # Named destinations
+        field   :V,             :Type => Integer  # Interactive forms
+        field   :I,             :Type => Integer  # Information dictionary
+        field   :C,             :Type => Integer  # Logical structure
+        field   :L,             :Type => Integer  # Page labels
+        field   :R,             :Type => Integer  # Renditions
+        field   :B,             :Type => Integer  # Embedded files
+
+        def pre_build
+            if @page_offset_table.nil?
+                raise InvalidHintStreamObjectError, "No page offset hint table"
+            end
+
+            if @shared_objects_table.nil?
+                raise InvalidHintStreamObjectError, "No shared objects hint table"
+            end
+
+            @data = ""
+            save_table(@page_offset_table)
+            save_table(@shared_objects_table,         :S)
+            save_table(@thumbnails_table,             :T)
+            save_table(@outlines_table,               :O)
+            save_table(@threads_table,                :A)
+            save_table(@named_destinations_table,     :E)
+            save_table(@interactive_forms_table,      :V)
+            save_table(@information_dictionary_table, :I)
+            save_table(@logical_structure_table,      :C)
+            save_table(@page_labels_table,            :L)
+            save_table(@renditions_table,             :R)
+            save_table(@embedded_files_table,         :B)
+
+            super
+        end
+
+        private
+
+        def save_table(table, name = nil)
+            unless table.nil?
+                self[name] = @data.size if name
+                @data << table.to_s
+            end
+        end
+    end
+
+end

data/lib/origami/metadata.rb

@@ -0,0 +1,172 @@
+=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 'rexml/document'
+
+module Origami
+
+    class PDF
+        #
+        # Returns true if the document has a document information dictionary.
+        #
+        def document_info?
+            trailer_key? :Info
+        end
+
+        #
+        # Returns the document information dictionary if present.
+        #
+        def document_info
+            trailer_key :Info
+        end
+
+        def title; get_document_info_field(:Title) end
+        def author; get_document_info_field(:Author) end
+        def subject; get_document_info_field(:Subject) end
+        def keywords; get_document_info_field(:Keywords) end
+        def creator; get_document_info_field(:Creator) end
+        def producer; get_document_info_field(:Producer) end
+        def creation_date; get_document_info_field(:CreationDate) end
+        def mod_date; get_document_info_field(:ModDate) end
+
+        #
+        # Returns true if the document has a catalog metadata stream.
+        #
+        def metadata?
+            self.Catalog.Metadata.is_a?(Stream)
+        end
+
+        #
+        # Returns a Hash of the information found in the metadata stream
+        #
+        def metadata
+            metadata_stm = self.Catalog.Metadata
+
+            if metadata_stm.is_a?(Stream)
+                doc = REXML::Document.new(metadata_stm.data)
+                info = {}
+
+                doc.elements.each('*/*/rdf:Description') do |description|
+
+                    description.attributes.each_attribute do |attr|
+                        case attr.prefix
+                        when 'pdf','xap'
+                            info[attr.name] = attr.value
+                        end
+                    end
+
+                    description.elements.each('*') do |element|
+                        value = (element.elements['.//rdf:li'] || element).text
+                        info[element.name] = value.to_s
+                    end
+                end
+
+                info
+            end
+        end
+
+        #
+        # Modifies or creates a metadata stream.
+        #
+        def create_metadata(info = {})
+            skeleton = <<-XMP
+            <?packet begin="\xef\xbb\xbf" id="W5M0MpCehiHzreSzNTczkc9d"?>
+              <x:xmpmeta xmlns:x="adobe:ns:meta/">
+                <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+                  <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
+                  </rdf:Description>
+                </rdf:RDF>
+              </x:xmpmeta>
+            <?xpacket end="w"?>
+            XMP
+
+            xml =
+                if self.Catalog.Metadata.is_a?(Stream)
+                    self.Catalog.Metadata.data
+                else
+                    skeleton
+                end
+
+            doc = REXML::Document.new(xml)
+            desc = doc.elements['*/*/rdf:Description']
+
+            info.each do |name, value|
+                elt = REXML::Element.new "pdf:#{name}"
+                elt.text = value
+
+                desc.elements << elt
+            end
+
+            xml = ""; doc.write(xml, 4)
+
+            if self.Catalog.Metadata.is_a?(Stream)
+                self.Catalog.Metadata.data = xml
+            else
+               self.Catalog.Metadata = Stream.new(xml)
+            end
+
+            self.Catalog.Metadata
+        end
+
+        private
+
+        def get_document_info_field(field) #:nodoc:
+            if self.document_info?
+                doc_info = self.document_info
+
+                if doc_info.key?(field)
+                    case obj = doc_info[field].solve
+                    when String then obj.value
+                    when Stream then obj.data
+                    end
+                end
+            end
+        end
+    end
+
+    #
+    # Class representing an information Dictionary, containing title, author, date of creation and the like.
+    #
+    class Metadata < Dictionary
+        include StandardObject
+
+        field   :Title,                   :Type => String, :Version => "1.1"
+        field   :Author,                  :Type => String
+        field   :Subject,                 :Type => String, :Version => "1.1"
+        field   :Keywords,                :Type => String, :Version => "1.1"
+        field   :Creator,                 :Type => String
+        field   :Producer,                :Type => String
+        field   :CreationDate,            :Type => String
+        field   :ModDate,                 :Type => String, :Version => "1.1"
+        field   :Trapped,                 :Type => Name, :Default => :Unknown, :Version => "1.3"
+    end
+
+    #
+    # Class representing a metadata Stream.
+    # This stream can contain the same information as the Metadata dictionary, but is storing in XML data.
+    #
+    class MetadataStream < Stream
+        include StandardObject
+
+        field   :Type,                    :Type => Name, :Default => :Metadata, :Required => true
+        field   :Subtype,                 :Type => Name, :Default =>:XML, :Required => true
+    end
+
+end

data/lib/origami/name.rb

@@ -0,0 +1,135 @@
+=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
+
+module Origami
+
+    REGULARCHARS = "([^ \\t\\r\\n\\0\\[\\]<>()%\\/]|#[a-fA-F0-9][a-fA-F0-9])*" #:nodoc:
+
+    class InvalidNameObjectError < InvalidObjectError #:nodoc:
+    end
+
+    #
+    # Class representing a Name Object.
+    # Name objects are strings which identify some PDF file inner structures.
+    #
+    class Name
+        include Origami::Object
+        include Comparable
+
+        TOKENS = %w{ / } #:nodoc:
+
+        @@regexp = Regexp.new(WHITESPACES + TOKENS.first + "(?<name>#{REGULARCHARS})" + WHITESPACES) #:nodoc
+
+        #
+        # Creates a new Name.
+        # _name_:: A symbol representing the new Name value.
+        #
+        def initialize(name = "")
+            unless name.is_a?(Symbol) or name.is_a?(::String)
+                raise TypeError, "Expected type Symbol or String, received #{name.class}."
+            end
+
+            @value = name.to_s
+
+            super()
+        end
+
+        def value
+            @value.to_sym
+        end
+        alias to_sym value
+
+        def <=>(name)
+            return unless name.is_a?(Name)
+
+            self.value <=> name.value
+        end
+
+        def ==(object) #:nodoc:
+            self.eql?(object) or @value.to_sym == object
+        end
+
+        def eql?(object) #:nodoc:
+            object.is_a?(Name) and self.value.eql?(object.value)
+        end
+
+        def hash #:nodoc:
+            @value.hash
+        end
+
+        def to_s(eol: $/) #:nodoc:
+            super(TOKENS.first + Name.expand(@value), eol: eol)
+        end
+
+        def self.parse(stream, _parser = nil) #:nodoc:
+            scanner = Parser.init_scanner(stream)
+            offset = scanner.pos
+
+            name =
+                if scanner.scan(@@regexp).nil?
+                    raise InvalidNameObjectError, "Bad name format"
+                else
+                    value = scanner['name']
+
+                    Name.new(value.include?('#') ? contract(value) : value)
+                end
+
+            name.file_offset = offset
+
+            name
+        end
+
+        def self.contract(name) #:nodoc:
+            i = 0
+            name = name.dup
+
+            while i < name.length
+                if name[i] == "#"
+                    digits = name[i+1, 2]
+
+                    unless digits =~ /^[A-Za-z0-9]{2}$/
+                        raise InvalidNameObjectError, "Irregular use of # token"
+                    end
+
+                    char = digits.hex.chr
+
+                    if char == "\0"
+                        raise InvalidNameObjectError, "Null byte forbidden inside name definition"
+                    end
+
+                    name[i, 3] = char
+                end
+
+                i = i + 1
+            end
+
+            name
+        end
+
+        def self.expand(name) #:nodoc:
+            forbiddenchars = /[ #\t\r\n\0\[\]<>()%\/]/
+
+            name.gsub(forbiddenchars) do |c|
+                "#" + c.ord.to_s(16).rjust(2,"0")
+            end
+        end
+    end
+
+end

data/lib/origami/null.rb

@@ -0,0 +1,65 @@
+=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
+
+module Origami
+
+    class InvalidNullObjectError < InvalidObjectError #:nodoc:
+    end
+
+    #
+    # Class representing  Null Object.
+    #
+    class Null
+        include Origami::Object
+
+        TOKENS = %w{ null } #:nodoc:
+        @@regexp = Regexp.new(WHITESPACES + TOKENS.first)
+
+        def initialize
+            super
+        end
+
+        def self.parse(stream, _parser = nil) #:nodoc:
+            scanner = Parser.init_scanner(stream)
+            offset = scanner.pos
+
+            if scanner.skip(@@regexp).nil?
+                raise InvalidNullObjectError
+            end
+
+            null = Null.new
+            null.file_offset = offset
+
+            null
+        end
+
+        #
+        # Returns *nil*.
+        #
+        def value
+            nil
+        end
+
+        def to_s(eol: $/) #:nodoc:
+            super(TOKENS.first, eol: eol)
+        end
+    end
+
+end