bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/pops/lookup/lookup_key.rb

@@ -1,99 +0,0 @@
-require_relative 'sub_lookup'
-
-module Puppet::Pops
-module Lookup
-# @api private
-class LookupKey
-  include SubLookup
-
-  attr_reader :module_name, :root_key, :segments
-
-  def initialize(key)
-    segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new(_("%{problem} in key: '%{key}'") % { problem: problem, key: key }) }
-    root_key = segments.shift.freeze
-    qual_index = root_key.index(DOUBLE_COLON)
-
-    @key = key
-    @module_name = qual_index.nil? ? nil : root_key[0..qual_index-1].freeze
-    @root_key = root_key
-    @segments = segments.empty? ? nil : segments.freeze
-  end
-
-  def dig(lookup_invocation, value)
-    @segments.nil? ? value : sub_lookup(@key, lookup_invocation, @segments, value)
-  end
-
-  # Prunes a found root value with respect to subkeys in this key. The given _value_ is returned untouched
-  # if this key has no subkeys. Otherwise an attempt is made to create a Hash or Array that contains only the
-  # path to the appointed value and that value.
-  #
-  # If subkeys exists and no value is found, then this method will return `nil`, an empty `Array` or an empty `Hash`
-  # to enable further merges to be applied. The returned type depends on the given _value_.
-  #
-  # @param value [Object] the value to prune
-  # @return the possibly pruned value
-  def prune(value)
-    if @segments.nil?
-      value
-    else
-      pruned = @segments.reduce(value) do |memo, segment|
-        memo.is_a?(Hash) || memo.is_a?(Array) && segment.is_a?(Integer) ? memo[segment] : nil
-      end
-      if pruned.nil?
-        case value
-        when Hash
-          EMPTY_HASH
-        when Array
-          EMPTY_ARRAY
-        else
-          nil
-        end
-      else
-        undig(pruned)
-      end
-    end
-  end
-
-  # Create a structure that can be dug into using the subkeys of this key in order to find the
-  # given _value_. If this key has no subkeys, the _value_ is returned.
-  #
-  # @param value [Object] the value to wrap in a structure in case this value has subkeys
-  # @return [Object] the possibly wrapped value
-  def undig(value)
-    @segments.nil? ? value : segments.reverse.reduce(value) do |memo, segment|
-      if segment.is_a?(Integer)
-        x = []
-        x[segment] = memo
-      else
-        x = { segment => memo }
-      end
-      x
-    end
-  end
-
-  def to_a
-    unless instance_variable_defined?(:@all_segments)
-      a = [@root_key]
-      a += @segments unless @segments.nil?
-      @all_segments = a.freeze
-    end
-    @all_segments
-  end
-
-  def eql?(v)
-    v.is_a?(LookupKey) && @key == v.to_s
-  end
-  alias == eql?
-
-  def hash
-    @key.hash
-  end
-
-  def to_s
-    @key
-  end
-
-  LOOKUP_OPTIONS = LookupKey.new('lookup_options')
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/lookup/lookup_key_function_provider.rb

@@ -1,92 +0,0 @@
-require_relative 'function_provider'
-
-module Puppet::Pops
-module Lookup
-# @api private
-class LookupKeyFunctionProvider < FunctionProvider
-  TAG = 'lookup_key'.freeze
-
-  # Performs a lookup with the assumption that a recursive check has been made.
-  #
-  # @param key [LookupKey] The key to lookup
-  # @param lookup_invocation [Invocation] The current lookup invocation
-  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
-  # @return [Object] the found object
-  # @throw :no_such_key when the object is not found
-  def unchecked_key_lookup(key, lookup_invocation, merge)
-    root_key = key.root_key
-    lookup_invocation.with(:data_provider, self) do
-      MergeStrategy.strategy(merge).lookup(locations, lookup_invocation) do |location|
-        invoke_with_location(lookup_invocation, location, root_key, merge)
-      end
-    end
-  end
-
-  def invoke_with_location(lookup_invocation, location, root_key, merge)
-    if location.nil?
-      value = lookup_key(root_key, lookup_invocation, nil, merge)
-      lookup_invocation.report_found(root_key, value)
-    else
-      lookup_invocation.with(:location, location) do
-        value = lookup_key(root_key, lookup_invocation, location, merge)
-        lookup_invocation.report_found(root_key, value)
-      end
-    end
-  end
-
-  def label
-    'Lookup Key'
-  end
-
-  private
-
-  def lookup_key(key, lookup_invocation, location, merge)
-    unless location.nil? || location.exist?
-      lookup_invocation.report_location_not_found
-      throw :no_such_key
-    end
-    ctx = function_context(lookup_invocation, location)
-    ctx.data_hash ||= {}
-    catch(:no_such_key) do
-      hash = ctx.data_hash
-      unless hash.include?(key)
-        hash[key] = validate_data_value(ctx.function.call(lookup_invocation.scope, key, options(location), Context.new(ctx, lookup_invocation))) do
-          msg = "Value for key '#{key}', returned from #{full_name}"
-          location.nil? ? msg : "#{msg}, when using location '#{location}',"
-        end
-      end
-      return hash[key]
-    end
-    lookup_invocation.report_not_found(key)
-    throw :no_such_key
-  end
-end
-
-# @api private
-class V3LookupKeyFunctionProvider < LookupKeyFunctionProvider
-  TAG = 'v3_lookup_key'.freeze
-
-  def initialize(name, parent_data_provider, function_name, options, locations)
-    @datadir = options.delete(HieraConfig::KEY_DATADIR)
-    super
-  end
-
-  def unchecked_key_lookup(key, lookup_invocation, merge)
-    extra_paths = lookup_invocation.hiera_v3_location_overrides
-    if extra_paths.nil? || extra_paths.empty?
-      super
-    else
-      # Extra paths provided. Must be resolved and placed in front of known paths
-      paths = parent_data_provider.config(lookup_invocation).resolve_paths(@datadir, extra_paths, lookup_invocation, false, ".#{@name}")
-      all_locations = paths + locations
-      root_key = key.root_key
-      lookup_invocation.with(:data_provider, self) do
-        MergeStrategy.strategy(merge).lookup(all_locations, lookup_invocation) do |location|
-          invoke_with_location(lookup_invocation, location, root_key, merge)
-        end
-      end
-    end
-  end
-end
-end
-end

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

@@ -1,89 +0,0 @@
-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
-
-  # Performs a lookup using a module default hierarchy with an endless recursion check.
-  #
-  # @param key [LookupKey] The key to lookup
-  # @param lookup_invocation [Invocation] The current lookup invocation
-  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
-  #
-  def key_lookup_in_default(key, lookup_invocation, merge)
-    dps = config(lookup_invocation).configured_data_providers(lookup_invocation, self, true)
-    if dps.empty?
-      lookup_invocation.report_not_found(key)
-      throw :no_such_key
-    end
-    merge_strategy = MergeStrategy.strategy(merge)
-    lookup_invocation.check(key.to_s) do
-      lookup_invocation.with(:data_provider, self) do
-        merge_strategy.lookup(dps, lookup_invocation) do |data_provider|
-          data_provider.unchecked_key_lookup(key, lookup_invocation, merge_strategy)
-        end
-      end
-    end
-  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_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 = "#{yield} 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}': #{msg}")
-      memo
-    end
-    data_hash
-  end
-
-  protected
-
-  def assert_config_version(config)
-    if config.version > 3
-      config
-    else
-      if Puppet[:strict] == :error
-        config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'module')
-      else
-        Puppet.warn_once(:hiera_v3_at_module_root, config.config_path, _('hiera.yaml version 3 found at module root was ignored'), config.config_path)
-      end
-      nil
-    end
-  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}', cannot find module '%{module_name}'") % { env: env.name, module_name: module_name } unless mod
-    Pathname.new(mod.path)
-  end
-end
-end
-end

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

@@ -1,92 +0,0 @@
-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!
-        if segment.start_with?('"') || segment.start_with?("'")
-          segment[1..-2]
-        elsif segment =~ /^(:?[+-]?[0-9]+)$/
-          segment.to_i
-        else
-          segment
-        end
-      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) && value.instance_of?(Array)
-            unless segment >= 0 && segment < value.size
-              lookup_invocation.report_not_found(segment)
-              throw :no_such_key
-            end
-          else
-            unless value.respond_to?(:'[]') && !(value.is_a?(Array) || value.instance_of?(String))
-              raise Puppet::DataBinding::LookupError,
-                _("Data Provider type mismatch: Got %{klass} when a hash-like object was expected to access value using '%{segment}' from key '%{key}'") %
-                  { klass: value.class.name, segment: segment, 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/vendored/puppet/lib/puppet/pops/merge_strategy.rb

@@ -1,437 +0,0 @@
-require 'deep_merge/core'
-
-module Puppet::Pops
-  # Merges to objects into one based on an implemented strategy.
-  #
-  class MergeStrategy
-    NOT_FOUND = Object.new.freeze
-
-    def self.strategies
-      @@strategies ||= {}
-    end
-    private_class_method :strategies
-
-    # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
-    #
-    # @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)
-      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?
-          #TRANSLATORS 'merge' is a variable name and 'strategy' is a key and should not be translated
-          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.size == 1 ? EMPTY_HASH : merge
-      else
-        merge_strategy = merge
-        merge_options = EMPTY_HASH
-      end
-      merge_strategy = merge_strategy.to_sym if merge_strategy.is_a?(String)
-      strategy_class = strategies[merge_strategy]
-      raise ArgumentError, _("Unknown merge strategy: '%{strategy}'") % { 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
-    #
-    # @return [Array<Symbol>] List of strategy keys
-    #
-    def self.strategy_keys
-      strategies.keys - [:default, :unconstrained_deep, :reverse_deep]
-    end
-
-    # Adds a new merge strategy to the map of strategies known to this class
-    #
-    # @param strategy_class [Class<MergeStrategy>] The class of the added strategy
-    #
-    def self.add_strategy(strategy_class)
-      unless MergeStrategy > strategy_class
-        #TRANSLATORS 'MergeStrategies.add_strategy' is a method, 'stratgey_class' is a variable and 'MergeStrategy' is a class name and should not be translated
-        raise ArgumentError, _("MergeStrategies.add_strategy 'strategy_class' must be a 'MergeStrategy' class. Got %{strategy_class}") %
-            { strategy_class: strategy_class }
-      end
-      strategies[strategy_class.key] = strategy_class
-      nil
-    end
-
-    # Finds a merge strategy that corresponds to the given _merge_ argument and delegates the task of merging the elements of _e1_ and _e2_ to it.
-    #
-    # @param e1 [Object] The first element
-    # @param e2 [Object] The second element
-    # @return [Object] The result of the merge
-    #
-    def self.merge(e1, e2, merge)
-      strategy(merge).merge(e1, e2)
-    end
-
-    def self.key
-      raise NotImplementedError, "Subclass must implement 'key'"
-    end
-
-    # 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('The merge options', self.class.options_t, options) unless options.empty?
-      @options = options
-    end
-
-    # 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
-    # @param e2 [Object] The second element
-    # @return [Object] The result of the merge
-    #
-    def merge(e1, e2)
-      checked_merge(
-        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
-        merge_single(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 expected when merging two elements
-    # @param value [Object] the value to convert
-    # @return [Object] the converted value
-    def convert_value(value)
-      value
-    end
-
-    # Applies the merge strategy on a single element. Only applicable for `unique`
-    # @param value [Object] the value to merge with nothing
-    # @return [Object] the merged value
-    def merge_single(value)
-      value
-    end
-
-    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 [Types::PStructType] the puppet type
-    #
-    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 [Types::PAnyType] the puppet type
-    #
-    def value_t
-      raise NotImplementedError, "Subclass must implement 'value_t'"
-    end
-
-    def checked_merge(e1, e2)
-      raise NotImplementedError, "Subclass must implement 'checked_merge(e1,e2)'"
-    end
-
-    def assert_type(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
-
-    # @param e1 [Hash<String,Object>] The hash that will act as the source of the merge
-    # @param e2 [Hash<String,Object>] The hash that will act as the receiver for the merge
-    # @return [Hash<String,Object]] The merged hash
-    # @see Hash#merge
-    def checked_merge(e1, e2)
-      e2.merge(e1)
-    end
-
-    protected
-
-    def value_t
-      @value_t ||= Types::TypeParser.singleton.parse('Hash[String,Data]')
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-
-  # Merges two values that must be either scalar or arrays into a unique set of values.
-  #
-  # Scalar values will be converted into a one element arrays and array values will be flattened
-  # prior to forming the unique set. The order of the elements is preserved with e1 being the
-  # first contributor of elements and e2 the second.
-  #
-  class UniqueMergeStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
-
-    def self.key
-      :unique
-    end
-
-    # @param e1 [Array<Object>] The first array
-    # @param e2 [Array<Object>] The second array
-    # @return [Array<Object>] The unique set of elements
-    #
-    def checked_merge(e1, e2)
-      convert_value(e1) | convert_value(e2)
-    end
-
-    def convert_value(e)
-      e.is_a?(Array) ? e.flatten : [e]
-    end
-
-    # If _value_ is an array, then return the result of calling `uniq` on that array. Otherwise,
-    # the argument is returned.
-    # @param value [Object] the value to merge with nothing
-    # @return [Object] the merged value
-    def merge_single(value)
-      value.is_a?(Array) ? value.uniq : value
-    end
-
-    protected
-
-    def value_t
-      @value_t ||= Types::TypeParser.singleton.parse('Variant[Scalar,Array[Data]]')
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-
-  # Documentation copied from https://github.com/danielsdeleo/deep_merge/blob/master/lib/deep_merge/core.rb
-  # altered with respect to _preserve_unmergeables_ since this implementation always disables that option.
-  #
-  # The destination is dup'ed before the deep_merge is called to allow frozen objects as values.
-  #
-  # deep_merge method permits merging of arbitrary child elements. The two top level
-  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
-  # of child elements. These child elements to not have to be of the same types.
-  # Where child elements are of the same type, deep_merge will attempt to merge them together.
-  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
-  # the destination element with the contents of the source element at that level.
-  # So if you have two hashes like this:
-  #   source = {:x => [1,2,3], :y => 2}
-  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-  #   dest.deep_merge!(source)
-  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
-  #
-  # "deep_merge" will unconditionally overwrite any unmergeables and merge everything else.
-  #
-  # Options:
-  #   Options are specified in the last parameter passed, which should be in hash format:
-  #   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_
-  #   - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
-  #
-  # Selected Options Details:
-  # :knockout_prefix => The purpose of this is to provide a way to remove elements
-  #   from existing Hash by specifying them in a special way in incoming hash
-  #    source = {:x => ['--1', '2']}
-  #    dest   = {:x => ['1', '3']}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ['2','3']}
-  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-  #   the entire element to be removed:
-  #    source = {:x => '--'}
-  #    dest   = {:x => [1,2,3]}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ""}
-  #
-  # :merge_hash_arrays => merge hashes within arrays
-  #   source = {:x => [{:y => 1}]}
-  #   dest   = {:x => [{:z => 2}]}
-  #   dest.deep_merge!(source, {:merge_hash_arrays => true})
-  #   Results: {:x => [{:y => 1, :z => 2}]}
-  #
-  class DeepMergeStrategy < MergeStrategy
-    INSTANCE = self.new(EMPTY_HASH)
-
-    def self.key
-      :deep
-    end
-
-    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 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
-
-    # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
-    # the setting of that option to false
-    #
-    # @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_merged_arrays=>Optional[Boolean],'\
-          '}]')
-    end
-
-    def value_t
-      @value_t ||= Types::PAnyType::DEFAULT
-    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)
-  end
-end