hashie 4.1.0 → 5.2.0

data/lib/hashie/extensions/mash/required_keys.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Hashie
+  module Extensions
+    module Mash
+      # Extends a Mash with the ability to require specific keys to be
+      # set (non-nil) when constructed, while still allowing arbitrary,
+      # undeclared keys to be assigned - unlike Hashie::Dash, which
+      # restricts assignment to only pre-declared properties.
+      #
+      # @example
+      #
+      #   class PersonMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::RequiredKeys
+      #
+      #     required_keys :name, :email
+      #   end
+      #
+      #   expect { PersonMash.new(email: 'bob@example.com') }
+      #     .to raise_error(ArgumentError, 'the following keys are required: `name`')
+      #
+      #   person = PersonMash.new(name: 'Bob', email: 'bob@example.com')
+      #   person.age = 42 # arbitrary, undeclared keys are still allowed
+      #   person.age # => 42
+      module RequiredKeys
+        # @example Install required-key declarations
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::RequiredKeys
+        #   end
+        #   klass.required_keys # => []
+        def self.included(base)
+          base.instance_variable_set(:@required_keys, [])
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        # Class-level required-key declarations inherited by subclasses.
+        #
+        # @example
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::RequiredKeys
+        #     required_keys :name
+        #   end
+        #   klass.required_keys # => ['name']
+        module ClassMethods
+          # @example Copy required keys when subclassing
+          #   parent = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::RequiredKeys
+          #     required_keys :name
+          #   end
+          #   child = Class.new(parent)
+          #   child.required_keys :email
+          #   child.required_keys # => ['name', 'email']
+          #   parent.required_keys # => ['name']
+          def inherited(klass)
+            super
+            klass.instance_variable_set(:@required_keys, required_keys.dup)
+          end
+
+          # With no arguments, returns the keys currently declared as
+          # required. With one or more arguments, declares those keys
+          # as required. Keys are stored and compared as strings, so
+          # both symbol and string keys are accepted.
+          #
+          # @example
+          #   klass = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::RequiredKeys
+          #     required_keys :name, 'email', :name
+          #   end
+          #   klass.required_keys # => ['name', 'email']
+          def required_keys(*keys)
+            return @required_keys if keys.empty?
+
+            @required_keys |= keys.map(&:to_s)
+          end
+        end
+
+        # Checks required values when constructing a Mash.
+        #
+        # @example
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::RequiredKeys
+        #     required_keys :name
+        #   end
+        #   klass.new(name: 'Ada').name # => 'Ada'
+        module InstanceMethods
+          # @example Reject nil or missing required values
+          #   klass = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::RequiredKeys
+          #     required_keys :name
+          #   end
+          #   expect { klass.new(name: nil) }.to raise_error(ArgumentError, /name/)
+          #   klass.new(name: 'Ada', age: 37).age # => 37
+          def initialize(*args, &block)
+            super
+            assert_required_keys_set!
+          end
+
+          private
+
+          def assert_required_keys_set!
+            missing_keys = self.class.required_keys.select { |key| self[key].nil? }
+            return if missing_keys.empty?
+
+            raise ArgumentError, "the following keys are required: `#{missing_keys.join(', ')}`"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/mash/safe_assignment.rb

@@ -1,14 +1,32 @@
+# frozen_string_literal: true
+
 module Hashie
   module Extensions
     module Mash
+      # Rejects assignments that would shadow existing Mash methods.
+      #
+      # @example
+      #   klass = Class.new(Hashie::Mash) do
+      #     include Hashie::Extensions::Mash::SafeAssignment
+      #   end
+      #   mash = klass.new
+      #   expect { mash[:size] = 2 }.to raise_error(ArgumentError, /clashes/)
+      #   mash.empty? # => true
       module SafeAssignment
-        def custom_writer(key, *args) #:nodoc:
-          if !key?(key) && respond_to?(key, true)
-            raise ArgumentError, "The property #{key} clashes with an existing method."
-          end
+        def custom_writer(key, *args) # :nodoc:
+          raise ArgumentError, "the property `#{key}` clashes with an existing method" if !key?(key) && respond_to?(key, true)
+
           super
         end
 
+        # @example
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::SafeAssignment
+        #   end
+        #   mash = klass.new
+        #   mash[:name] = 'Ada'
+        #   mash.name # => 'Ada'
+        #   expect { mash[:size] = 2 }.to raise_error(ArgumentError, /clashes/)
         def []=(*args)
           custom_writer(*args)
         end

data/lib/hashie/extensions/mash/strict_key_access.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hashie
+  module Extensions
+    module Mash
+      # Overrides Mash's default behavior of returning nil for keys that
+      # aren't set, raising a KeyError instead.
+      #
+      # Unlike Hashie::Extensions::StrictKeyAccess, this extension is aware
+      # of Mash's special suffixed methods (e.g. +?+, +!+, +_+ and +=+) so
+      # that they continue to work as expected instead of always raising.
+      #
+      # Because nested Hashes are converted into instances of +self.class+,
+      # this extension is automatically applied to any nested Mash as well.
+      #
+      # @example
+      #   class StrictMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::StrictKeyAccess
+      #   end
+      #
+      #   mash = StrictMash.new(name: 'Bob')
+      #   mash.name  #=> 'Bob'
+      #   expect { mash.age }.to raise_error(KeyError, 'key not found: `age`')
+      #
+      #   mash.name? #=> true
+      #   mash.age?  #=> false
+      #
+      #   mash.address!.city = 'Springfield'
+      #   mash.address.city  #=> 'Springfield'
+      #
+      # @api public
+      module StrictKeyAccess
+        # Hook for being included in a class
+        #
+        # @api private
+        # @return [void]
+        # @raise [ArgumentError] when the base class isn't a Mash
+        def self.included(descendant)
+          error_message = "#{descendant} is not a kind of Hashie::Mash"
+          raise ArgumentError, error_message unless descendant <= Hashie::Mash
+        end
+
+        # @api private
+        def method_missing(method_name, *args, &blk)
+          return super if key?(method_name)
+
+          name, suffix = method_name_and_suffix(method_name)
+          raise KeyError, "key not found: `#{name}`" if !key?(name) && !suffix
+
+          super
+        end
+
+        # @api private
+        def respond_to_missing?(method_name, *args)
+          return true if key?(method_name)
+
+          _, suffix = method_name_and_suffix(method_name)
+          return false unless suffix
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/mash/symbolize_keys.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hashie
   module Extensions
     module Mash
@@ -5,11 +7,11 @@ module Hashie
       #
       # @example
       #   class LazyResponse < Hashie::Mash
-      #     include Hashie::Extensions::Mash::SymbolizedKeys
+      #     include Hashie::Extensions::Mash::SymbolizeKeys
       #   end
       #
       #   response = LazyResponse.new("id" => 123, "name" => "Rey").to_h
-      #   #=> {id: 123, name: "Rey"}
+      #   response # => {id: 123, name: "Rey"}
       #
       # @api public
       module SymbolizeKeys
@@ -19,18 +21,20 @@ module Hashie
         # @return [void]
         # @raise [ArgumentError] when the base class isn't a Mash
         def self.included(base)
-          raise ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
+          return if base <= Hashie::Mash
+
+          raise ArgumentError, "`#{base}` must descend from Hashie::Mash"
         end
 
         private
 
-        # Converts a key to a symbol
+        # Converts a key to a symbol, if possible
         #
         # @api private
-        # @param [String, Symbol] key the key to convert to a symbol
-        # @return [void]
+        # @param [<K>] key the key to attempt convert to a symbol
+        # @return [Symbol, K]
         def convert_key(key)
-          key.to_sym
+          key.respond_to?(:to_sym) ? key.to_sym : key
         end
       end
     end

data/lib/hashie/extensions/mash/transform_keys.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Hashie
+  module Extensions
+    module Mash
+      # Applies a class-configured normalization to string and symbol Mash keys.
+      #
+      # @example
+      #   klass = Class.new(Hashie::Mash) do
+      #     include Hashie::Extensions::Mash::TransformKeys
+      #     transform_keys_with(&:downcase)
+      #   end
+      #   klass.new('NAME' => 'Ada').name # => 'Ada'
+      module TransformKeys
+        # @example Install class-level transformation configuration
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::TransformKeys
+        #   end
+        #   klass.key_transformer # => nil
+        def self.included(base)
+          raise ArgumentError, "`#{base}` must descend from Hashie::Mash" unless base <= Hashie::Mash
+
+          base.extend(ClassMethods)
+        end
+
+        # Configures key normalization independently for each subclass.
+        #
+        # @example
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::TransformKeys
+        #     transform_keys_with(&:downcase)
+        #   end
+        #   klass.new('NAME' => 'Ada')['name'] # => 'Ada'
+        module ClassMethods
+          # @example Inherit a transformer without sharing later configuration
+          #   parent = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::TransformKeys
+          #     transform_keys_with(&:downcase)
+          #   end
+          #   child = Class.new(parent)
+          #   child.new('NAME' => 'Ada').name # => 'Ada'
+          #   child.transform_keys_with(&:upcase)
+          #   parent.new('NAME' => 'Ada').keys # => ['name']
+          def inherited(klass)
+            super
+            klass.instance_variable_set(:@key_transformer, key_transformer)
+          end
+
+          # @example Configure with a callable or a block
+          #   klass = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::TransformKeys
+          #     transform_keys_with(->(key) { key.downcase })
+          #   end
+          #   klass.new('NAME' => 'Ada').keys # => ['name']
+          #   klass.transform_keys_with { |key| key.upcase }
+          #   klass.new(name: 'Ada').keys # => ['NAME']
+          def transform_keys_with(callable = nil, &block)
+            raise ArgumentError, 'provide one callable or block' if (callable && block) || !(callable || block).respond_to?(:call)
+
+            @key_transformer = callable || block
+          end
+
+          # @example Read the configured callable
+          #   klass = Class.new(Hashie::Mash) do
+          #     include Hashie::Extensions::Mash::TransformKeys
+          #     transform_keys_with(&:downcase)
+          #   end
+          #   klass.key_transformer.call('NAME') # => 'name'
+          attr_reader :key_transformer
+        end
+
+        private
+
+        def convert_key(key)
+          transformer = self.class.key_transformer
+          return super unless transformer && (key.is_a?(String) || key.is_a?(Symbol))
+
+          transformed = transformer.call(key.to_s)
+          raise TypeError, 'key transformer must return a String' unless transformed.is_a?(String)
+
+          super(transformed)
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/mash/underscore_keys.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'hashie/extensions/mash/transform_keys'
+
+module Hashie
+  module Extensions
+    module Mash
+      # Normalizes camel-case and hyphenated Mash keys to lowercase underscores.
+      #
+      # @example
+      #   klass = Class.new(Hashie::Mash) do
+      #     include Hashie::Extensions::Mash::UnderscoreKeys
+      #   end
+      #   klass.new('firstName' => 'Ada', 'last-name' => 'Lovelace').to_h # => {'first_name' => 'Ada', 'last_name' => 'Lovelace'}
+      module UnderscoreKeys
+        # @example Configure underscore normalization on inclusion
+        #   klass = Class.new(Hashie::Mash) do
+        #     include Hashie::Extensions::Mash::UnderscoreKeys
+        #   end
+        #   klass.key_transformer.call('HTTPStatus') # => 'http_status'
+        def self.included(base)
+          base.include(TransformKeys) unless base < TransformKeys
+          base.transform_keys_with do |key|
+            key.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+               .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+               .tr('-', '_').downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/merge_initializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hashie
   module Extensions
     # The MergeInitializer is a super-simple mixin that allows
@@ -15,6 +17,13 @@ module Hashie
     #   h[:abc] # => 'def'
     #
     module MergeInitializer
+      # @example Initialize entries and a default value
+      #   class InitializedHash < Hash
+      #     include Hashie::Extensions::MergeInitializer
+      #   end
+      #   hash = InitializedHash.new({ name: 'Ada' }, 'unknown')
+      #   hash[:name] # => 'Ada'
+      #   hash[:missing] # => 'unknown'
       def initialize(hash = {}, default = nil, &block)
         default ? super(default) : super(&block)
         hash.each do |key, value|

data/lib/hashie/extensions/method_access.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hashie
   module Extensions
     # MethodReader allows you to access keys of the hash
@@ -25,13 +27,22 @@ module Hashie
     #   user[:birthday] = nil
     #   user.birthday # => nil
     #
-    #   user.not_declared # => NoMethodError
+    #   expect { user.not_declared }.to raise_error(NoMethodError)
     module MethodReader
+      # @example Advertise readers for existing keys
+      #   hash = { name: 'Ada' }.extend(Hashie::Extensions::MethodReader)
+      #   hash.respond_to?(:name) # => true
+      #   hash.respond_to?(:missing) # => false
       def respond_to_missing?(name, include_private = false)
         return true if key?(name.to_s) || key?(name.to_sym)
+
         super
       end
 
+      # @example Read both symbol and string keys
+      #   hash = { name: 'Ada', 'age' => 42 }.extend(Hashie::Extensions::MethodReader)
+      #   hash.name # => 'Ada'
+      #   hash.age # => 42
       def method_missing(name, *args)
         if key?(name)
           self[name]
@@ -67,19 +78,29 @@ module Hashie
     #   h['awesome'] # => 'sauce'
     #
     module MethodWriter
+      # @example Advertise arbitrary writers
+      #   hash = {}.extend(Hashie::Extensions::MethodWriter)
+      #   hash.respond_to?(:name=) # => true
+      #   hash.respond_to?(:name) # => false
       def respond_to_missing?(name, include_private = false)
         return true if name.to_s =~ /=$/
+
         super
       end
 
+      # @example Write string keys with assignment syntax
+      #   hash = {}.extend(Hashie::Extensions::MethodWriter)
+      #   hash.name = 'Ada'
+      #   hash # => { 'name' => 'Ada' }
       def method_missing(name, *args)
-        if args.size == 1 && name.to_s =~ /(.*)=$/
-          return self[convert_key(Regexp.last_match[1])] = args.first
-        end
+        return self[convert_key(Regexp.last_match[1])] = args.first if args.size == 1 && name.to_s =~ /(.*)=$/
 
         super
       end
 
+      # @example Normalize a writer key
+      #   hash = {}.extend(Hashie::Extensions::MethodWriter)
+      #   hash.convert_key(:name) # => 'name'
       def convert_key(key)
         key.to_s
       end
@@ -104,8 +125,12 @@ module Hashie
     #   h.abc? # => true
     #   h['def'] = nil
     #   h.def? # => false
-    #   h.hji? # => NoMethodError
+    #   expect { h.hji? }.to raise_error(NoMethodError)
     module MethodQuery
+      # @example Advertise queries for present keys, including nil values
+      #   hash = { name: nil }.extend(Hashie::Extensions::MethodQuery)
+      #   hash.respond_to?(:name?) # => true
+      #   hash.respond_to?(:missing?) # => false
       def respond_to_missing?(name, include_private = false)
         if query_method?(name) && indifferent_key?(key_from_query_method(name))
           true
@@ -114,6 +139,10 @@ module Hashie
         end
       end
 
+      # @example Query the truthiness of values
+      #   hash = { active: true, disabled: nil }.extend(Hashie::Extensions::MethodQuery)
+      #   hash.active? # => true
+      #   hash.disabled? # => false
       def method_missing(name, *args)
         return super unless args.empty?
 
@@ -148,6 +177,12 @@ module Hashie
     # A macro module that will automatically include MethodReader,
     # MethodWriter, and MethodQuery, giving you the ability to read,
     # write, and query keys in a hash using method call shortcuts.
+    #
+    # @example Read, write, and query through methods
+    #   hash = {}.extend(Module.new { include Hashie::Extensions::MethodAccess })
+    #   hash.name = 'Ada'
+    #   hash.name # => 'Ada'
+    #   hash.name? # => true
     module MethodAccess
       def self.included(base)
         [MethodReader, MethodWriter, MethodQuery].each do |mod|
@@ -158,6 +193,16 @@ module Hashie
 
     # A module shared between MethodOverridingWriter and MethodOverridingInitializer
     # to contained shared logic. This module aids in redefining existing hash methods.
+    #
+    # @example Preserve an overridden method under a double-underscore alias
+    #   require 'hashie/extensions/method_access'
+    #   class OverridingHash < Hash
+    #     include Hashie::Extensions::MethodOverridingWriter
+    #   end
+    #   hash = OverridingHash.new
+    #   hash.size = 'large'
+    #   hash.size # => 'large'
+    #   hash.__size # => 1
     module RedefineMethod
       protected
 
@@ -185,6 +230,7 @@ module Hashie
     # appropriately as true.
     #
     # @example
+    #   require 'hashie/extensions/method_access'
     #   class MyHash < Hash
     #     include Hashie::Extensions::MethodOverridingWriter
     #   end
@@ -194,15 +240,25 @@ module Hashie
     #   h['awesome'] # => 'sauce'
     #   h.zip = 'a-dee-doo-dah'
     #   h.zip # => 'a-dee-doo-dah'
-    #   h.__zip # => [[['awesome', 'sauce'], ['zip', 'a-dee-doo-dah']]]
+    #   h.__zip # => [[['awesome', 'sauce']], [['zip', 'a-dee-doo-dah']]]
     #
     module MethodOverridingWriter
       include RedefineMethod
 
+      # @example Normalize keys before storage
+      #   require 'hashie/extensions/method_access'
+      #   hash = {}.extend(Hashie::Extensions::MethodOverridingWriter)
+      #   hash.convert_key(:size) # => 'size'
       def convert_key(key)
         key.to_s
       end
 
+      # @example Override a Hash method and keep access to the original
+      #   require 'hashie/extensions/method_access'
+      #   hash = {}.extend(Hashie::Extensions::MethodOverridingWriter)
+      #   hash.size = 'large'
+      #   hash.size # => 'large'
+      #   hash.__size # => 1
       def method_missing(name, *args)
         if args.size == 1 && name.to_s =~ /(.*)=$/
           key = Regexp.last_match[1]
@@ -213,8 +269,13 @@ module Hashie
         super
       end
 
+      # @example Advertise method-overriding writers
+      #   require 'hashie/extensions/method_access'
+      #   hash = {}.extend(Hashie::Extensions::MethodOverridingWriter)
+      #   hash.respond_to?(:size=) # => true
       def respond_to_missing?(name, include_private = false)
         return true if name.to_s.end_with?('=')
+
         super
       end
 
@@ -231,6 +292,16 @@ module Hashie
     # shortcuts that can override object methods. Any overridden
     # object method is automatically aliased with two leading
     # underscores.
+    #
+    # @example Initialize, read, write, and query a conflicting key
+    #   class OverridingHash < Hash
+    #     include Hashie::Extensions::MethodAccessWithOverride
+    #   end
+    #   hash = OverridingHash.new(size: 'large')
+    #   hash.size # => 'large'
+    #   hash.size = 'small'
+    #   hash.size? # => true
+    #   hash.__size # => 1
     module MethodAccessWithOverride
       def self.included(base)
         [MethodReader, MethodOverridingWriter,
@@ -241,10 +312,11 @@ module Hashie
     end
 
     # MethodOverridingInitializer allows you to override default hash
-    # methods when passing in values from an existing hash. The overriden
+    # methods when passing in values from an existing hash. The overridden
     # methods are aliased with two leading underscores.
     #
     # @example
+    #   require 'hashie/extensions/method_access'
     #   class MyHash < Hash
     #     include Hashie::Extensions::MethodOverridingInitializer
     #   end
@@ -255,7 +327,21 @@ module Hashie
     module MethodOverridingInitializer
       include RedefineMethod
 
-      def initialize(hash = {})
+      # @example Initialize conflicting keys and preserve a default
+      #   require 'hashie/extensions/method_access'
+      #   class OverridingHash < Hash
+      #     include Hashie::Extensions::MethodOverridingInitializer
+      #   end
+      #   hash = OverridingHash.new({ size: 'large' }, false)
+      #   hash.size # => 'large'
+      #   hash.__size # => 1
+      #   hash[:missing] # => false
+      def initialize(hash = {}, default = nil, &block)
+        raise ArgumentError, 'cannot specify both a default value and a default block' if default && block
+
+        self.default = default unless default.nil?
+        self.default_proc = block if block
+
         hash.each do |key, value|
           skey = key.to_s
           redefine_method(skey) if method?(skey)

data/lib/hashie/extensions/parsers/yaml_erb_parser.rb

@@ -1,46 +1,39 @@
-require 'yaml'
+# frozen_string_literal: true
+
 require 'erb'
-require 'pathname'
+require 'hashie/extensions/parsers/yaml_parser'
 
 module Hashie
   module Extensions
     module Parsers
-      class YamlErbParser
-        def initialize(file_path, options = {})
-          @content = File.read(file_path)
-          @file_path = file_path.is_a?(Pathname) ? file_path.to_s : file_path
-          @options = options
-        end
-
+      # Parses YAML after evaluating ERB templates.
+      #
+      # @example
+      #   require 'tempfile'
+      #   file = Tempfile.new(['hashie-example', '.yml'], '.')
+      #   begin
+      #     file.write("count: <%= 1 + 2 %>\n")
+      #     file.close
+      #     Hashie::Extensions::Parsers::YamlErbParser.perform(file.path) # => {'count' => 3}
+      #   ensure
+      #     file.close!
+      #   end
+      class YamlErbParser < YamlParser
+        # @example Evaluate ERB before safely loading YAML
+        #   require 'tempfile'
+        #   file = Tempfile.new(['hashie-example', '.yml'], '.')
+        #   begin
+        #     file.write("count: <%= 2 * 3 %>\n")
+        #     file.close
+        #     parser = Hashie::Extensions::Parsers::YamlErbParser.new(file.path)
+        #     parser.perform # => {'count' => 6}
+        #   ensure
+        #     file.close!
+        #   end
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          permitted_classes = @options.fetch(:permitted_classes) { [] }
-          permitted_symbols = @options.fetch(:permitted_symbols) { [] }
-          aliases = @options.fetch(:aliases) { true }
-
-          yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
-        end
-
-        def self.perform(file_path, options = {})
-          new(file_path, options).perform
-        end
-
-        private
-
-        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
-          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
-            YAML.safe_load(
-              template.result,
-              permitted_classes: permitted_classes,
-              permitted_symbols: permitted_symbols,
-              aliases: aliases
-            )
-          end
-        else
-          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
-            YAML.safe_load(template.result, permitted_classes, permitted_symbols, aliases)
-          end
+          yaml_safe_load(template.result)
         end
       end
     end