origamindee 3.0.0

data/lib/origami/compound.rb

@@ -0,0 +1,161 @@
+=begin
+
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2017	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 'set'
+
+module Origami
+
+    #
+    # Module for maintaining internal caches of objects for fast lookup.
+    #
+    module ObjectCache
+        attr_reader :strings_cache, :names_cache, :xref_cache
+
+        def initialize(*args)
+            super(*args)
+
+            init_caches
+        end
+
+        def rebuild_caches
+            self.each do |*items|
+                items.each do |object|
+                    object.rebuild_caches if object.is_a?(CompoundObject)
+                    cache_object(object)
+                end
+            end
+        end
+
+        private
+
+        def init_caches
+            @strings_cache = Set.new
+            @names_cache = Set.new
+            @xref_cache = {}
+        end
+
+        def cache_object(object)
+            case object
+            when String then cache_string(object)
+            when Name then cache_name(object)
+            when Reference then cache_reference(object)
+            when CompoundObject then cache_compound(object)
+            end
+
+            object
+        end
+
+        def cache_compound(object)
+            @strings_cache.merge(object.strings_cache)
+            @names_cache.merge(object.names_cache)
+            @xref_cache.update(object.xref_cache) do |_, cache1, cache2|
+                cache1.concat(cache2)
+            end
+
+            object.strings_cache.clear
+            object.names_cache.clear
+            object.xref_cache.clear
+        end
+
+        def cache_string(str)
+            @strings_cache.add(str)
+        end
+
+        def cache_name(name)
+            @names_cache.add(name)
+        end
+
+        def cache_reference(ref)
+            @xref_cache[ref] ||= []
+            @xref_cache[ref].push(self)
+        end
+    end
+
+    #
+    # Module for objects containing other objects.
+    #
+    module CompoundObject
+        include Origami::Object
+        include ObjectCache
+        using TypeConversion
+
+        #
+        # Returns true if the item is present in the compound object.
+        #
+        def include?(item)
+            super(item.to_o)
+        end
+
+        #
+        # Removes the item from the compound object if present.
+        #
+        def delete(item)
+            obj = super(item.to_o)
+            unlink_object(obj) unless obj.nil?
+        end
+
+        #
+        # Creates a deep copy of the compound object.
+        # This method can be quite expensive as nested objects are copied too.
+        #
+        def copy
+            obj = self.update_values(&:copy)
+
+            transfer_attributes(obj)
+        end
+
+        #
+        # Returns a new compound object with updated values based on the provided block.
+        #
+        def update_values(&b)
+            return enum_for(__method__) unless block_given?
+            return self.class.new self.transform_values(&b) if self.respond_to?(:transform_values)
+            return self.class.new self.map(&b) if self.respond_to?(:map)
+
+            raise NotImplementedError, "This object does not implement this method"
+        end
+
+        #
+        # Modifies the compound object's values based on the provided block.
+        #
+        def update_values!(&b)
+            return enum_for(__method__) unless block_given?
+            return self.transform_values!(&b) if self.respond_to?(:transform_values!)
+            return self.map!(&b) if self.respond_to?(:map!)
+
+            raise NotImplementedError, "This object does not implement this method"
+        end
+
+        private
+
+        def link_object(item)
+            obj = item.to_o
+            obj.parent = self unless obj.indirect?
+
+            cache_object(obj)
+        end
+
+        def unlink_object(obj)
+            obj.parent = nil 
+            obj
+        end
+    end
+
+end

data/lib/origami/destinations.rb

@@ -0,0 +1,252 @@
+=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
+        #
+        # Lookup destination in the destination name directory.
+        #
+        def get_destination_by_name(name)
+            resolve_name Names::DESTINATIONS, name
+        end
+
+        #
+        # Calls block for each named destination.
+        #
+        def each_named_dest(&b)
+            each_name(Names::DESTINATIONS, &b)
+        end
+    end
+
+    #
+    # A destination represents a specified location into the document.
+    #
+    class Destination < Origami::Array
+        attr_reader :page, :top, :left, :right, :bottom, :zoom
+
+        #
+        # Class representing a Destination zooming on a part of a document.
+        #
+        class Zoom < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, @left, @top, @zoom = array
+            end
+
+            #
+            # Creates a new zoom Destination.
+            # _page_:: The destination Page.
+            # _left_, _top_:: Coords in the Page.
+            # _zoom_:: Zoom factor.
+            #
+            def self.[](page, left: 0, top: 0, zoom: 0)
+                self.new([page, :XYZ, left, top, zoom])
+            end
+        end
+
+        def self.Zoom(page, left: 0, top: 0, zoom: 0)
+            Zoom[page, left: left, top: top, zoom: zoom]
+        end
+
+
+        #
+        # Class representing a Destination showing a Page globally.
+        #
+        class GlobalFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _ = array
+            end
+
+            #
+            # Creates a new global fit Destination.
+            # _page_:: The destination Page.
+            #
+            def self.[](page)
+                self.new([page, :Fit])
+            end
+        end
+
+        def self.GlobalFit(page)
+            GlobalFit[page]
+        end
+
+        #
+        # Class representing a Destination fitting a Page horizontally.
+        #
+        class HorizontalFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, @top = array
+            end
+
+            #
+            # Creates a new horizontal fit destination.
+            # _page_:: The destination Page.
+            # _top_:: The vertical coord in the Page.
+            #
+            def self.[](page, top: 0)
+                self.new([page, :FitH, top])
+            end
+        end
+
+        def self.HorizontalFit(page, top: 0)
+            HorizontalFit[page, top: top]
+        end
+
+        #
+        # Class representing a Destination fitting a Page vertically.
+        # _page_:: The destination Page.
+        # _left_:: The horizontal coord in the Page.
+        #
+        class VerticalFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _,  @left = array
+            end
+
+            def self.[](page, left: 0)
+                self.new([page, :FitV, left])
+            end
+        end
+
+        def self.VerticalFit(page, left: 0)
+            VerticalFit[page, left: left]
+        end
+
+        #
+        # Class representing a Destination fitting the view on a rectangle in a Page.
+        #
+        class RectangleFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, @left, @bottom, @right, @top = array
+            end
+
+            #
+            # Creates a new rectangle fit Destination.
+            # _page_:: The destination Page.
+            # _left_, _bottom_, _right_, _top_:: The rectangle to fit in.
+            #
+            def self.[](page, left: 0, bottom: 0, right: 0, top: 0)
+                self.new([page, :FitR, left, bottom, right, top])
+            end
+        end
+
+        def self.RectangleFit(page, left: 0, bottom: 0, right: 0, top: 0)
+            RectangleFit[page, left: left, bottom: bottom, right: right, top: top]
+        end
+
+        #
+        # Class representing a Destination fitting the bounding box of a Page.
+        #
+        class GlobalBoundingBoxFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, = array
+            end
+
+            #
+            # Creates a new bounding box fit Destination.
+            # _page_:: The destination Page.
+            #
+            def self.[](page)
+                self.new([page, :FitB])
+            end
+        end
+
+        def self.GlobalBoundingBoxFit(page)
+            GlobalBoundingBoxFit[page]
+        end
+
+        #
+        # Class representing a Destination fitting horizontally the bouding box a Page.
+        #
+        class HorizontalBoudingBoxFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, @top = array
+            end
+
+            #
+            # Creates a new horizontal bounding box fit Destination.
+            # _page_:: The destination Page.
+            # _top_:: The vertical coord.
+            #
+            def self.[](page, top: 0)
+                self.new([page, :FitBH, top])
+            end
+        end
+
+        def self.HorizontalBoudingBoxFit(page, top: 0)
+            HorizontalBoudingBoxFit[page, top: top]
+        end
+
+        #
+        # Class representing a Destination fitting vertically the bounding box of a Page.
+        #
+        class VerticalBoundingBoxFit < Destination
+
+            def initialize(array)
+                super(array)
+
+                @page, _, @left = array
+            end
+
+            #
+            # Creates a new vertical bounding box fit Destination.
+            # _page_:: The destination Page.
+            # _left_:: The horizontal coord.
+            #
+            def self.[](page, left: 0)
+                self.new([page, :FitBV, left])
+            end
+        end
+
+        def self.VerticalBoundingBoxFit(page, left: 0)
+            VerticalBoundingBoxFit[page, left: left]
+        end
+    end
+
+    #
+    # This kind of Dictionary is used in named destinations.
+    #
+    class DestinationDictionary < Dictionary
+        include StandardObject
+
+        field   :D,         :Type => Destination, :Required => true
+    end
+
+end

data/lib/origami/dictionary.rb

@@ -0,0 +1,192 @@
+=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 InvalidDictionaryObjectError < InvalidObjectError #:nodoc:
+    end
+
+    #
+    # Class representing a Dictionary Object.
+    # Dictionaries are containers associating a Name to an embedded Object.
+    #
+    class Dictionary < Hash
+        include CompoundObject
+        include FieldAccessor
+        using TypeConversion
+        extend TypeGuessing
+
+        TOKENS = %w{ << >> } #:nodoc:
+        @@regexp_open = Regexp.new(WHITESPACES + TOKENS.first + WHITESPACES)
+        @@regexp_close = Regexp.new(WHITESPACES + TOKENS.last + WHITESPACES)
+
+        #
+        # Creates a new Dictionary.
+        # _hash_:: The hash representing the new Dictionary.
+        #
+        def initialize(hash = {}, parser = nil)
+            raise TypeError, "Expected type Hash, received #{hash.class}." unless hash.is_a?(Hash)
+            super()
+
+            hash.each_pair do |k,v|
+                next if k.nil?
+
+                # Turns the values into Objects.
+                key, value = k.to_o, v.to_o
+
+                if Origami::OPTIONS[:enable_type_guessing]
+                    hint_type = guess_value_type(key, value)
+
+                    if hint_type.is_a?(Class) and hint_type < value.class
+                        value = value.cast_to(hint_type, parser)
+                    end
+
+                    if hint_type and parser and Origami::OPTIONS[:enable_type_propagation]
+                        if value.is_a?(Reference)
+                            parser.defer_type_cast(value, hint_type)
+                        end
+                    end
+                end
+
+                self[key] = value
+            end
+        end
+
+        def self.parse(stream, parser = nil) #:nodoc:
+            scanner = Parser.init_scanner(stream)
+            offset = scanner.pos
+
+            if scanner.skip(@@regexp_open).nil?
+                raise InvalidDictionaryObjectError, "No token '#{TOKENS.first}' found"
+            end
+
+            hash = {}
+            while scanner.skip(@@regexp_close).nil? do
+                key = Name.parse(scanner, parser)
+
+                type = Object.typeof(scanner)
+                raise InvalidDictionaryObjectError, "Invalid object for field #{key}" if type.nil?
+
+                value = type.parse(scanner, parser)
+                hash[key] = value
+            end
+
+            if Origami::OPTIONS[:enable_type_guessing]
+                dict_type = self.guess_type(hash)
+            else
+                dict_type = self
+            end
+
+            # Creates the Dictionary.
+            dict = dict_type.new(hash, parser)
+
+            dict.file_offset = offset
+            dict
+        end
+
+        def to_s(indent: 1, tab: "\t", eol: $/) #:nodoc:
+            nl = eol
+            tab, nl = '', '' if indent == 0
+
+            content = TOKENS.first + nl
+            self.each_pair do |key,value|
+                content << "#{tab * indent}#{key} "
+
+                content <<
+                if value.is_a?(Dictionary)
+                    value.to_s(eol: eol, indent: (indent == 0) ? 0 : indent + 1)
+                else
+                    value.to_s(eol: eol)
+                end
+
+                content << nl
+            end
+
+            content << tab * (indent - 1) if indent > 0
+            content << TOKENS.last
+
+            super(content, eol: eol)
+        end
+
+        #
+        # Returns a new Dictionary object with values modified by given block.
+        #
+        def transform_values(&b)
+            self.class.new self.map { |k, v|
+                [ k.to_sym, b.call(v) ]
+            }.to_h
+        end
+
+        #
+        # Modifies the values of the Dictionary, leaving keys unchanged.
+        #
+        def transform_values!(&b)
+            self.each_pair do |k, v|
+                self[k] = b.call(unlink_object(v))
+            end
+        end
+
+        #
+        # Merges the content of the Dictionary with another Dictionary.
+        #
+        def merge(dict)
+            self.class.new(super(dict))
+        end
+
+        def []=(key,val)
+            unless key.is_a?(Symbol) or key.is_a?(Name)
+                raise TypeError, "Expecting a Name for a Dictionary entry, found #{key.class} instead."
+            end
+
+            if val.nil?
+                self.delete(key)
+                return
+            end
+
+            super(link_object(key), link_object(val))
+        end
+
+        def [](key)
+            super(key.to_o)
+        end
+
+        alias key? include?
+        alias has_key? key?
+
+        def to_h
+            Hash[self.to_a.map!{|k, v| [ k.value, v.value ]}]
+        end
+        alias value to_h
+
+        def self.hint_type(_name); nil end #:nodoc:
+
+        private
+
+        def guess_value_type(key, value)
+            hint_type = self.class.hint_type(key.value)
+            if hint_type.is_a?(::Array) and not value.is_a?(Reference) # Choose best match
+                hint_type = hint_type.find {|type| type < value.class }
+            end
+
+            hint_type
+        end
+    end
+
+end