origami-docspring 2.2.0 → 2.3.0

data/lib/origami/dictionary.rb

@@ -1,192 +1,193 @@
-=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é.
-
-    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 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)
 
-    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.
+    #
+    # 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()
 
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+      hash.each_pair do |k, v|
+        next if k.nil?
 
-=end
+        # Turns the values into Objects.
+        key, value = k.to_o, v.to_o
 
-module Origami
+        if Origami::OPTIONS[:enable_type_guessing]
+          hint_type = guess_value_type(key, value)
 
-    class InvalidDictionaryObjectError < InvalidObjectError #:nodoc:
-    end
+          if hint_type.is_a?(Class) && (hint_type < value.class)
+            value = value.cast_to(hint_type, parser)
+          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
+          if hint_type && parser && Origami::OPTIONS[:enable_type_propagation]
+            if value.is_a?(Reference)
+              parser.defer_type_cast(value, hint_type)
             end
+          end
         end
 
-        def self.parse(stream, parser = nil) #:nodoc:
-            scanner = Parser.init_scanner(stream)
-            offset = scanner.pos
+        self[key] = value
+      end
+    end
 
-            if scanner.skip(@@regexp_open).nil?
-                raise InvalidDictionaryObjectError, "No token '#{TOKENS.first}' found"
-            end
+    def self.parse(stream, parser = nil) # :nodoc:
+      scanner = Parser.init_scanner(stream)
+      offset = scanner.pos
 
-            hash = {}
-            while scanner.skip(@@regexp_close).nil? do
-                key = Name.parse(scanner, parser)
+      if scanner.skip(@@regexp_open).nil?
+        raise InvalidDictionaryObjectError, "No token '#{TOKENS.first}' found"
+      end
 
-                type = Object.typeof(scanner)
-                raise InvalidDictionaryObjectError, "Invalid object for field #{key}" if type.nil?
+      hash = {}
+      while scanner.skip(@@regexp_close).nil?
+        key = Name.parse(scanner, parser)
 
-                value = type.parse(scanner, parser)
-                hash[key] = value
-            end
+        type = Object.typeof(scanner)
+        raise InvalidDictionaryObjectError, "Invalid object for field #{key}" if type.nil?
 
-            if Origami::OPTIONS[:enable_type_guessing]
-                dict_type = self.guess_type(hash)
-            else
-                dict_type = self
-            end
+        value = type.parse(scanner, parser)
+        hash[key] = value
+      end
 
-            # Creates the Dictionary.
-            dict = dict_type.new(hash, parser)
+      dict_type = if Origami::OPTIONS[:enable_type_guessing]
+        guess_type(hash)
+      else
+        self
+      end
 
-            dict.file_offset = offset
-            dict
-        end
+      # Creates the Dictionary.
+      dict = dict_type.new(hash, parser)
 
-        def to_s(indent: 1, tab: "\t", eol: $/) #:nodoc:
-            nl = eol
-            tab, nl = '', '' if indent == 0
+      dict.file_offset = offset
+      dict
+    end
 
-            content = TOKENS.first + nl
-            self.each_pair do |key,value|
-                content << "#{tab * indent}#{key} "
+    def to_s(indent: 1, tab: "\t", eol: $/) # :nodoc:
+      nl = eol
+      tab, nl = '', '' if indent == 0
 
-                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 = TOKENS.first + nl
+      each_pair do |key, value|
+        content << "#{tab * indent}#{key} "
 
-                content << nl
-            end
+        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 << tab * (indent - 1) if indent > 0
-            content << TOKENS.last
+        content << nl
+      end
 
-            super(content, eol: eol)
-        end
+      content << tab * (indent - 1) if indent > 0
+      content << TOKENS.last
 
-        #
-        # 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
+      super(content, eol: eol)
+    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
+    #
+    # Returns a new Dictionary object with values modified by given block.
+    #
+    def transform_values(&b)
+      self.class.new map { |k, v|
+        [k.to_sym, b.call(v)]
+      }.to_h
+    end
 
-        #
-        # Merges the content of the Dictionary with another Dictionary.
-        #
-        def merge(dict)
-            self.class.new(super(dict))
-        end
+    #
+    # Modifies the values of the Dictionary, leaving keys unchanged.
+    #
+    def transform_values!(&b)
+      each_pair do |k, v|
+        self[k] = b.call(unlink_object(v))
+      end
+    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
+    #
+    # Merges the content of the Dictionary with another Dictionary.
+    #
+    def merge(dict)
+      self.class.new(super)
+    end
 
-            if val.nil?
-                self.delete(key)
-                return
-            end
+    def []=(key, val)
+      unless key.is_a?(Symbol) || key.is_a?(Name)
+        raise TypeError, "Expecting a Name for a Dictionary entry, found #{key.class} instead."
+      end
 
-            super(link_object(key), link_object(val))
-        end
+      if val.nil?
+        delete(key)
+        return
+      end
 
-        def [](key)
-            super(key.to_o)
-        end
+      super(link_object(key), link_object(val))
+    end
 
-        alias key? include?
-        alias has_key? key?
+    def [](key)
+      super(key.to_o)
+    end
 
-        def to_h
-            Hash[self.to_a.map!{|k, v| [ k.value, v.value ]}]
-        end
-        alias value to_h
+    alias_method :key?, :include?
+    alias_method :has_key?, :key?
+
+    def to_h
+      to_a.map! { |k, v| [k.value, v.value] }.to_h
+    end
+    alias_method :value, :to_h
 
-        def self.hint_type(_name); nil end #:nodoc:
+    # :nodoc:
+    def self.hint_type(_name)
+      nil
+    end
 
-        private
+    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
+    def guess_value_type(key, value)
+      hint_type = self.class.hint_type(key.value)
+      if hint_type.is_a?(::Array) && !value.is_a?(Reference) # Choose best match
+        hint_type = hint_type.find { |type| type < value.class }
+      end
 
-            hint_type
-        end
+      hint_type
     end
-
+  end
 end