puppet 4.0.0 → 4.9.1

data/lib/puppet/pops/lookup/module_data_provider.rb

@@ -0,0 +1,58 @@
+require_relative 'configured_data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class ModuleDataProvider < ConfiguredDataProvider
+
+  attr_reader :module_name
+
+  def initialize(module_name, config = nil)
+    super(config)
+    @module_name = module_name
+  end
+
+  def place
+    'Module'
+  end
+
+  # Asserts that all keys in the given _data_hash_ are prefixed with the configured _module_name_. Removes entries
+  # that does not follow the convention and logs a warning.
+  #
+  # @param data_hash [Hash] The data hash
+  # @return [Hash] The possibly pruned hash
+  def validate_data_hash(data_provider, data_hash)
+    super
+    module_prefix = "#{module_name}::"
+    data_hash.each_key.reduce(data_hash) do |memo, k|
+      next memo if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
+      msg = 'must use keys qualified with the name of the module'
+      memo = memo.clone if memo.equal?(data_hash)
+      memo.delete(k)
+      Puppet.warning("Module '#{module_name}': #{data_provider.name} #{msg}")
+      memo
+    end
+  end
+
+  protected
+
+  def assert_config_version(config)
+    raise Puppet::DataBinding::LookupError, "#{config.name} cannot be used in a module" unless config.version > 3
+    config
+  end
+
+  # Return the root of the module with the name equal to the configured module name
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to root of the module
+  # @raise [Puppet::DataBinding::LookupError] if the module can not be found
+  #
+  def provider_root(lookup_invocation)
+    env = lookup_invocation.scope.environment
+    mod = env.module(module_name)
+    raise Puppet::DataBinding::LookupError, "Environment '#{env.name}', cannot find module '#{module_name}'" unless mod
+    Pathname.new(mod.path)
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -0,0 +1,90 @@
+module Puppet::Pops
+module Lookup
+module SubLookup
+  SPECIAL = /['"\.]/
+
+  # Split key into segments. A segment may be a quoted string (both single and double quotes can
+  # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on
+  # both sides of each segment. Whitespace within quotes are not trimmed.
+  #
+  # If the key cannot be parsed, this method will yield a string describing the problem to a one
+  # parameter block. The block must return an exception instance.
+  #
+  # @param key [String] the string to split
+  # @return [Array<String>] the array of segments
+  # @yieldparam problem [String] the problem, i.e. 'Syntax error'
+  # @yieldreturn [Exception] the exception to raise
+  #
+  # @api public
+  def split_key(key)
+    return [key] if key.match(SPECIAL).nil?
+    segments = key.split(/(\s*"[^"]+"\s*|\s*'[^']+'\s*|[^'".]+)/)
+    if segments.empty?
+      # Only happens if the original key was an empty string
+      raise yield('Syntax error')
+    elsif segments.shift == ''
+      count = segments.size
+      raise yield('Syntax error') unless count > 0
+
+      segments.keep_if { |seg| seg != '.' }
+      raise yield('Syntax error') unless segments.size * 2 == count + 1
+      segments.map! do |segment|
+        segment.strip!
+        segment.start_with?('"') || segment.start_with?("'") ? segment[1..-2] : segment
+      end
+    else
+      raise yield('Syntax error')
+    end
+  end
+
+  # Perform a sub-lookup using the given _segments_ to access the given _value_. Each segment must be a string. A string
+  # consisting entirely of digits will be treated as an indexed lookup which means that the value that it is applied to
+  # must be an array. Other types of segments will expect that the given value is something other than a String that
+  # implements the '#[]' method.
+  #
+  # @param key [String] the original key (only used for error messages)
+  # @param context [Context] The current lookup context
+  # @param segments [Array<String>] the segments to use for lookup
+  # @param value [Object] the value to access using the segments
+  # @return [Object] the value obtained when accessing the value
+  #
+  # @api public
+  def sub_lookup(key, context, segments, value)
+    lookup_invocation = context.is_a?(Invocation) ? context : context.invocation
+    lookup_invocation.with(:sub_lookup, segments) do
+      segments.each do |segment|
+        lookup_invocation.with(:segment, segment) do
+          if value.nil?
+            lookup_invocation.report_not_found(segment)
+            throw :no_such_key
+          end
+          if segment.is_a?(Integer) || segment =~ /^[0-9]+$/
+            segment = segment.to_i
+            unless value.instance_of?(Array)
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless segment < value.size
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          else
+            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless value.include?(segment)
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          end
+          value = value[segment]
+          lookup_invocation.report_found(segment, value)
+        end
+      end
+      value
+    end
+  end
+end
+end
+end

data/lib/puppet/pops/lookup.rb

@@ -1,96 +1,92 @@
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
-class Puppet::Pops::Lookup
+module Puppet::Pops
+module Lookup
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  GLOBAL = '__global__'.freeze
+
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
   # This is a backing function and all parameters are assumed to have been type checked.
   # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
   #
-  # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
   # @param name [String|Array<String>] The name or names to lookup
-  # @param type [Puppet::Pops::Types::PAnyType|nil] The expected type of the found value
+  # @param type [Types::PAnyType|nil] The expected type of the found value
   # @param default_value [Object] The value to use as default when no value is found
   # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
-  # @param override [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
-  # @param default_values_hash [Hash<String,Object>] A map to use as the last resort (but before default)
-  # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
+  # @param merge [MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Invocation] Invocation data containing scope, overrides, and defaults
   # @return [Object] The found value
   #
-  def self.lookup(scope, name, value_type, default_value, has_default, override, default_values_hash, merge)
-    value_type = Puppet::Pops::Types::PDataType.new if value_type.nil?
+  def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
     names = name.is_a?(Array) ? name : [name]
 
     # find first name that yields a non-nil result and wrap it in a two element array
     # with name and value.
-    not_found = Object.new
-    result_with_name = names.reduce([nil,not_found]) do |memo, key|
-      value = override.include?(key) ? assert_type('override', value_type, override[key]) : not_found
-      value = search_and_merge(key, scope, merge, not_found) if value.equal?(not_found)
-      break [key, assert_type('found', value_type, value)] unless value.equal?(not_found)
+    not_found = MergeStrategy::NOT_FOUND
+    override_values = lookup_invocation.override_values
+    result_with_name = names.reduce([nil, not_found]) do |memo, key|
+      value = override_values.include?(key) ? assert_type(["Value found for key '%s' in override hash", key], value_type, override_values[key]) : not_found
+      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge) } if value.equal?(not_found)
+      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
       memo
     end
 
-    # Use the 'default_values_hash' map as a last resort if nothing is found
-    if result_with_name[1].equal?(not_found) && !default_values_hash.empty?
-      result_with_name = names.reduce(result_with_name) do |memo, key|
-        value = default_values_hash.include?(key) ? assert_type('default_values_hash', value_type, default_values_hash[key]) : not_found
-        memo = [ key, value ]
-        break memo unless value.equal?(not_found)
-        memo
+    # Use the 'default_values' hash as a last resort if nothing is found
+    if result_with_name[1].equal?(not_found)
+      default_values = lookup_invocation.default_values
+      unless default_values.empty?
+        result_with_name = names.reduce(result_with_name) do |memo, key|
+          value = default_values.include?(key) ? assert_type(["Value found for key '%s' in default values hash", key], value_type, default_values[key]) : not_found
+          memo = [key, value]
+          break memo unless value.equal?(not_found)
+          memo
+        end
       end
     end
 
     answer = result_with_name[1]
     if answer.equal?(not_found)
       if block_given?
-        answer = assert_type('default_block', value_type, yield(name))
+        answer = assert_type('Value returned from default block', value_type, yield(name))
       elsif has_default
-        answer = assert_type('default_value', value_type, default_value)
+        answer = assert_type('Default value', value_type, default_value)
       else
+        lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
         fail_lookup(names)
       end
     end
+    lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
     answer
   end
 
-  def self.search_and_merge(name, scope, merge, not_found)
-    in_global = lambda { lookup_with_databinding(name, scope, merge) }
-    in_env = lambda { Puppet::DataProviders.lookup_in_environment(name, scope, merge) }
-    in_module = lambda { Puppet::DataProviders.lookup_in_module(name, scope, merge) }
-
-    [in_global, in_env, in_module].reduce(not_found) do |memo, f|
-      found = false # can't trust catch return value since nil is valid
-      value = catch (:no_such_key) do
-        answer = f.call
-        found = true
-        answer
-      end
-      next memo unless found
-      break value if merge.nil? # value found and no merge
-      strategy = Puppet::Pops::MergeStrategy.strategy(merge)
-      memo.equal?(not_found) ? strategy.convert_value(value) : strategy.merge(memo, value)
+  # @api private
+  def self.debug_preamble(names)
+    if names.size == 1
+      names = "'#{names[0]}'"
+    else
+      names = names.map { |n| "'#{n}'" }.join(', ')
     end
+    "Lookup of #{names}"
   end
-  private_class_method :search_and_merge
 
-  def self.lookup_with_databinding(key, scope, merge)
-    begin
-      Puppet::DataBinding.indirection.find(key, { :environment => scope.environment.to_s, :variables => scope, :merge => merge })
-    rescue Puppet::DataBinding::LookupError => e
-      raise Puppet::Error, "Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e
-    end
+  # @api private
+  def self.search_and_merge(name, lookup_invocation, merge)
+    lookup_invocation.lookup_adapter.lookup(name, lookup_invocation, merge)
   end
-  private_class_method :lookup_with_databinding
 
   def self.assert_type(subject, type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(subject, type, value)
+    type ? Types::TypeAsserter.assert_instance_of(subject, type, value) : value
   end
   private_class_method :assert_type
 
   def self.fail_lookup(names)
-    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map {|n| "'#{n}'"} .join(', ') + ']'
-    raise Puppet::Error, "Function lookup() did not find a value for #{name_part}"
+    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map { |n| "'#{n}'" }.join(', ') + ']'
+    raise Puppet::DataBinding::LookupError, "Function lookup() did not find a value for #{name_part}"
   end
   private_class_method :fail_lookup
 end
+end
+
+require_relative 'lookup/lookup_adapter'

data/lib/puppet/pops/merge_strategy.rb

@@ -4,14 +4,7 @@ module Puppet::Pops
   # Merges to objects into one based on an implemented strategy.
   #
   class MergeStrategy
-    TypeAsserter = Puppet::Pops::Types::TypeAsserter
-    TypeParser = Puppet::Pops::Types::TypeParser
-
-    # The type used for validation of the _merge_ argument
-    def self.merge_t
-      @@merge_t ||=  TypeParser.new.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
-    end
-    private_class_method :merge_t
+    NOT_FOUND = Object.new.freeze
 
     def self.strategies
       @@strategies ||= {}
@@ -20,25 +13,28 @@ module Puppet::Pops
 
     # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
     #
-    # @param merge [String|Symbol|Hash<String,Object>] The merge strategy. Can be a string or symbol denoting the key
+    # @param merge [MergeStrategy,String,Hash<String,Object>,nil] The merge strategy. Can be a string or symbol denoting the key
     #   identifier or a hash with options where the key 'strategy' denotes the key
     # @return [MergeStrategy] The matching merge strategy
     #
     def self.strategy(merge)
-      TypeAsserter.assert_instance_of("MergeStrategies.merge 'merge' parameter", merge_t, merge)
+      return DefaultMergeStrategy::INSTANCE unless merge
+      return merge if merge.is_a?(MergeStrategy)
+
       if merge.is_a?(Hash)
         merge_strategy = merge['strategy']
         if merge_strategy.nil?
           raise ArgumentError, "The hash given as 'merge' must contain the name of a strategy in string form for the key 'strategy'"
         end
-        merge_options  = merge
+        merge_options  = merge.size == 1 ? EMPTY_HASH : merge
       else
         merge_strategy = merge
-        merge_options  = {}
+        merge_options = EMPTY_HASH
       end
-      strategy = strategies[merge_strategy.to_sym]
-      raise ArgumentError, "Unknown merge strategy: '#{merge_strategy}'" if strategy.nil?
-      strategy.new(merge_options)
+      merge_strategy = merge_strategy.to_sym if merge_strategy.is_a?(String)
+      strategy_class = strategies[merge_strategy]
+      raise ArgumentError, "Unknown merge strategy: '#{merge_strategy}'" if strategy_class.nil?
+      merge_options == EMPTY_HASH ? strategy_class::INSTANCE : strategy_class.new(merge_options)
     end
 
     # Returns the list of merge strategy keys known to this class
@@ -46,7 +42,7 @@ module Puppet::Pops
     # @return [Array<Symbol>] List of strategy keys
     #
     def self.strategy_keys
-      strategies.keys
+      strategies.keys - [:default, :unconstrained_deep, :reverse_deep]
     end
 
     # Adds a new merge strategy to the map of strategies known to this class
@@ -78,11 +74,11 @@ module Puppet::Pops
     # Create a new instance of this strategy configured with the given _options_
     # @param merge_options [Hash<String,Object>] Merge options
     def initialize(options)
-      assert_type('merge_options', options_t, options)
+      assert_type('The merge options', self.class.options_t, options) unless options.empty?
       @options = options
     end
 
-    # Merges the elements of _e1_ and _e2_ accoring to the implemented strategy and options given when this
+    # Merges the elements of _e1_ and _e2_ according to the rules of this strategy and options given when this
     # instance was created
     #
     # @param e1 [Object] The first element
@@ -91,34 +87,93 @@ module Puppet::Pops
     #
     def merge(e1, e2)
       checked_merge(
-        assert_type('e1', value_t, e1),
-        assert_type('e2', value_t, e2))
+        assert_type('The first element of the merge', value_t, e1),
+        assert_type('The second element of the merge', value_t, e2))
+    end
+
+    # TODO: API 5.0 Remove this method
+    # @deprecated
+    def merge_lookup(lookup_variants)
+      lookup(lookup_variants, Lookup::Invocation.current)
+    end
+
+    # Merges the result of yielding the given _lookup_variants_ to a given block.
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value.
+    # @yield [} ]
+    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
+    # @yieldreturn [Object] the value to merge with other values
+    # @throws :no_such_key if the lookup was unsuccessful
+    #
+    # Merges the result of yielding the given _lookup_variants_ to a given block.
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value.
+    # @yield [} ]
+    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
+    # @yieldreturn [Object] the value to merge with other values
+    # @throws :no_such_key if the lookup was unsuccessful
+    #
+    def lookup(lookup_variants, lookup_invocation)
+      case lookup_variants.size
+      when 0
+        throw :no_such_key
+      when 1
+        yield(lookup_variants[0])
+      else
+        lookup_invocation.with(:merge, self) do
+          result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
+            not_found = true
+            value = catch(:no_such_key) do
+              v = yield(lookup_variant)
+              not_found = false
+              v
+            end
+            if not_found
+              memo
+            else
+              memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
+            end
+          end
+          throw :no_such_key if result == NOT_FOUND
+          lookup_invocation.report_result(result)
+        end
+      end
     end
 
-    # Converts a single value to the type expeced when peforming a merge of two elements
+    # Converts a single value to the type expected when merging two elements
     # @param value [Object] the value to convert
     # @return [Object] the converted value
     def convert_value(value)
       value
     end
 
-    protected
-
     def options
       @options
     end
 
+    def configuration
+      if @options.nil? || @options.empty?
+        self.class.key.to_s
+      else
+        @options.include?('strategy') ? @options : { 'strategy' => self.class.key.to_s }.merge(@options)
+      end
+    end
+
+    protected
+
     # Returns the type used to validate the options hash
     #
-    # @return [Puppet::Pops::Types::PStructType] the puppet type
+    # @return [Types::PStructType] the puppet type
     #
-    def options_t
-      @options_t ||=TypeParser.new.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
+    def self.options_t
+      @options_t ||=Types::TypeParser.singleton.parse("Struct[{strategy=>Optional[Pattern[/#{key}/]]}]")
     end
 
     # Returns the type used to validate the options hash
     #
-    # @return [Puppet::Pops::Types::PAnyType] the puppet type
+    # @return [Types::PAnyType] the puppet type
     #
     def value_t
       raise NotImplementedError, "Subclass must implement 'value_t'"
@@ -129,14 +184,58 @@ module Puppet::Pops
     end
 
     def assert_type(param, type, value)
-      TypeAsserter.assert_instance_of(param, type, value)
+      Types::TypeAsserter.assert_instance_of(param, type, value)
     end
   end
 
+  # Simple strategy that returns the first value found. It never merges any values.
+  #
+  class FirstFoundStrategy < MergeStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
+    def self.key
+      :first
+    end
+
+    # Returns the first value found
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value
+    # @throws :no_such_key unless the lookup was successful
+    #
+    def lookup(lookup_variants, _)
+      # First found does not continue when a root key was found and a subkey wasn't since that would
+      # simulate a hash merge
+      lookup_variants.each { |lookup_variant| catch(:no_such_key) { return yield(lookup_variant) } }
+      throw :no_such_key
+    end
+
+    protected
+
+    def value_t
+      @value_t ||= Types::PAnyType::DEFAULT
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
+  # Same as {FirstFoundStrategy} but used when no strategy has been explicitly given
+  class DefaultMergeStrategy < FirstFoundStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
+    def self.key
+      :default
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
   # Produces a new hash by merging hash e1 with hash e2 in such a way that the values of duplicate keys
   # will be those of e1
   #
   class HashMergeStrategy < MergeStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
     def self.key
       :hash
     end
@@ -152,7 +251,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Hash[String,Data]')
+      @value_t ||= Types::TypeParser.singleton.parse('Hash[String,Data]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -165,6 +264,8 @@ module Puppet::Pops
   # first contributor of elements and e2 the second.
   #
   class UniqueMergeStrategy < MergeStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
     def self.key
       :unique
     end
@@ -184,7 +285,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Variant[Scalar,Array[Data]]')
+      @value_t ||= Types::TypeParser.singleton.parse('Variant[Scalar,Array[Data]]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -214,7 +315,6 @@ module Puppet::Pops
   #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
   #   - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
   #   - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
-  #   - 'unpack_arrays' Set to string value used as a deliminator to join all array values and then split them again. Default is _undef_
   #   - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
   #
   # Selected Options Details:
@@ -230,14 +330,6 @@ module Puppet::Pops
   #    dest   = {:x => [1,2,3]}
   #    dest.ko_deep_merge!(source)
   #    Results: {:x => ""}
-  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
-  #   in as strings and to be converted into discrete array elements
-  #   irsource = {:x => ['1,2,3', '4']}
-  #   dest   = {:x => ['5','6','7,8']}
-  #   dest.deep_merge!(source, {:unpack_arrays => ','})
-  #   Results: {:x => ['1','2','3','4','5','6','7','8']}
-  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
-  #    to pass multiple values from within a single HTML element
   #
   # :merge_hash_arrays => merge hashes within arrays
   #   source = {:x => [{:y => 1}]}
@@ -246,6 +338,8 @@ module Puppet::Pops
   #   Results: {:x => [{:y => 1, :z => 2}]}
   #
   class DeepMergeStrategy < MergeStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
     def self.key
       :deep
     end
@@ -253,8 +347,20 @@ module Puppet::Pops
     def checked_merge(e1, e2)
       dm_options = { :preserve_unmergeables => false }
       options.each_pair { |k,v| dm_options[k.to_sym] = v unless k == 'strategy' }
-      # e2 (the destination) is dup'ed to avoid that the passed in object mutates
-      DeepMerge.deep_merge!(e1, e2.dup, dm_options)
+      # e2 (the destination) is deep cloned to avoid that the passed in object mutates
+      DeepMerge.deep_merge!(e1, deep_clone(e2), dm_options)
+    end
+
+    def deep_clone(value)
+      if value.is_a?(Hash)
+        result = value.clone
+        value.each{ |k, v| result[k] = deep_clone(v) }
+        result
+      elsif value.is_a?(Array)
+        value.map{ |v| deep_clone(v) }
+      else
+        value
+      end
     end
 
     protected
@@ -262,20 +368,50 @@ module Puppet::Pops
     # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
     # the setting of that option to false
     #
-    # @return [Puppet::Pops::Types::PAnyType] the puppet type used when validating the options hash
-    def options_t
-      @options_t ||= Puppet::Pops::Types::TypeParser.new.parse('Struct[{'\
-          "strategy=>Optional[Pattern[#{self.class.key}]],"\
+    # @return [Types::PAnyType] the puppet type used when validating the options hash
+    def self.options_t
+      @options_t ||= Types::TypeParser.singleton.parse('Struct[{'\
+          "strategy=>Optional[Pattern[#{key}]],"\
           'knockout_prefix=>Optional[String],'\
           'merge_debug=>Optional[Boolean],'\
           'merge_hash_arrays=>Optional[Boolean],'\
           'sort_merge_arrays=>Optional[Boolean],'\
-          'unpack_arrays=>Optional[String]'\
           '}]')
     end
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Variant[Array[Data],Hash[String,Data]]')
+      @value_t ||= Types::TypeParser.singleton.parse('Variant[Array[Data],Hash[String,Data]]')
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
+  # Same as {DeepMergeStrategy} but without constraint on valid merge options
+  # (needed for backward compatibility with Hiera v3)
+  class UnconstrainedDeepMergeStrategy < DeepMergeStrategy
+    def self.key
+      :unconstrained_deep
+    end
+
+    # @return [Types::PAnyType] the puppet type used when validating the options hash
+    def self.options_t
+      @options_t ||= Types::TypeParser.singleton.parse('Hash[String[1],Any]')
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
+  # Same as {UnconstrainedDeepMergeStrategy} but with reverse priority of merged elements.
+  # (needed for backward compatibility with Hiera v3)
+  class ReverseDeepMergeStrategy < UnconstrainedDeepMergeStrategy
+    INSTANCE = self.new(EMPTY_HASH)
+
+    def self.key
+      :reverse_deep
+    end
+
+    def checked_merge(e1, e2)
+      super(e2, e1)
     end
 
     MergeStrategy.add_strategy(self)