pdk 1.15.0 → 2.0.0

data/lib/pdk/cli/update.rb

@@ -10,14 +10,12 @@ module PDK::CLI
     PDK::CLI.template_ref_option(self)
 
     run do |opts, _args, _cmd|
-      require 'pdk/cli/util'
-      require 'pdk/util'
-      require 'pdk/module/update'
+      # Write the context information to the debug log
+      PDK.context.to_debug_log
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('`pdk update` can only be run from inside a valid module directory.'),
-        log_level: :info,
-      )
+      unless PDK.context.is_a?(PDK::Context::Module)
+        raise PDK::CLI::ExitWithError, _('`pdk update` can only be run from inside a valid module directory.')
+      end
 
       raise PDK::CLI::ExitWithError, _('This module does not appear to be PDK compatible. To make the module compatible with PDK, run `pdk convert`.') unless PDK::Util.module_pdk_compatible?
 
@@ -46,7 +44,7 @@ module PDK::CLI
 
       PDK::CLI::Util.analytics_screen_view('update', opts)
 
-      updater = PDK::Module::Update.new(opts)
+      updater = PDK::Module::Update.new(PDK.context.root_path, opts)
 
       if updater.pinned_to_puppetlabs_template_tag?
         PDK.logger.info _(

data/lib/pdk/cli/util.rb

@@ -8,6 +8,7 @@ module PDK
       autoload :OptionValidator, 'pdk/cli/util/option_validator'
       autoload :Interview, 'pdk/cli/util/interview'
       autoload :Spinner, 'pdk/cli/util/spinner'
+      autoload :UpdateManagerPrinter, 'pdk/cli/util/update_manager_printer'
 
       # Ensures the calling code is being run from inside a module directory.
       #
@@ -129,13 +130,14 @@ module PDK
       end
       module_function :check_for_deprecated_puppet
 
-      # @param opts [Hash] - the pdk options ot use, defaults to empty hash
+      # @param opts [Hash] - the pdk options to use, defaults to empty hash
       # @option opts [String] :'puppet-dev' Use the puppet development version, default to PDK_PUPPET_DEV env
       # @option opts [String] :'puppet-version' Puppet version to use, default to PDK_PUPPET_VERSION env
       # @option opts [String] :'pe-version' PE Puppet version to use, default to PDK_PE_VERSION env
       # @param logging_disabled [Boolean] - disable logging of PDK info
+      # @param context [PDK::Context::AbstractContext] - The context the PDK is running in
       # @return [Hash] - return hash of { gemset: <>, ruby_version: 2.x.x }
-      def puppet_from_opts_or_env(opts, logging_disabled = false)
+      def puppet_from_opts_or_env(opts, logging_disabled = false, context = PDK.context)
         opts ||= {}
         use_puppet_dev = opts.fetch(:'puppet-dev', PDK::Util::Env['PDK_PUPPET_DEV'])
         desired_puppet_version = opts.fetch(:'puppet-version', PDK::Util::Env['PDK_PUPPET_VERSION'])
@@ -150,8 +152,10 @@ module PDK
               PDK::Util::PuppetVersion.find_gem_for(desired_puppet_version)
             elsif desired_pe_version
               PDK::Util::PuppetVersion.from_pe_version(desired_pe_version)
-            else
+            elsif context.is_a?(PDK::Context::Module)
               PDK::Util::PuppetVersion.from_module_metadata || PDK::Util::PuppetVersion.latest_available
+            else
+              PDK::Util::PuppetVersion.latest_available
             end
         rescue ArgumentError => e
           raise PDK::CLI::ExitWithError, e.message

data/lib/pdk/cli/util/option_validator.rb

@@ -8,6 +8,11 @@ module PDK
           (list =~ %r{^[\w\-]+(?:,[\w\-]+)+$}) ? true : false
         end
 
+        # @return [Boolean] true if the fact name is valid
+        def self.valid_fact_name?(name)
+          name.length > 1
+        end
+
         def self.enum(val, valid_entries, _options = {})
           vals = val.is_a?(Array) ? val : [val]
           invalid_entries = vals.reject { |e| valid_entries.include?(e) }
@@ -41,6 +46,7 @@ module PDK
 
           !(string =~ %r{\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z}).nil?
         end
+        singleton_class.send(:alias_method, :valid_function_name?, :valid_namespace?)
 
         singleton_class.send(:alias_method, :valid_class_name?, :valid_namespace?)
         singleton_class.send(:alias_method, :valid_defined_type_name?, :valid_namespace?)

data/lib/pdk/cli/util/update_manager_printer.rb

@@ -0,0 +1,82 @@
+require 'pdk'
+
+module PDK
+  module CLI
+    module Util
+      module UpdateManagerPrinter
+        # Prints the summary for a PDK::Module::UpdateManager Object
+        # @param update_manager [PDK::Module::UpdateManager] The object to print a summary of
+        # @param options [Hash{Object => Object}] A list of options when printing
+        # @option options [Boolean] :tense Whether to use future (:future) or past (:past) tense when printing the summary ("Files to be added" versus "Files added"). Default is :future
+        #
+        # @return [void]
+        def self.print_summary(update_manager, options = {})
+          require 'pdk/report'
+
+          options = {
+            tense: :future,
+          }.merge(options)
+
+          footer = false
+
+          summary(update_manager).each do |category, files|
+            next if files.empty?
+
+            PDK::Report.default_target.puts('')
+            PDK::Report.default_target.puts(generate_banner("Files #{(options[:tense] == :future) ? 'to be ' : ''}#{category}", 40))
+            PDK::Report.default_target.puts(files.map(&:to_s).join("\n"))
+            footer = true
+          end
+
+          if footer # rubocop:disable Style/GuardClause No.
+            PDK::Report.default_target.puts('')
+            PDK::Report.default_target.puts(generate_banner('', 40))
+          end
+        end
+
+        #:nocov: Tested as part of the public methods
+        # Returns a hash, summarizing the contents of the Update Manager object
+        # @param update_manager [PDK::Module::UpdateManager] The object to create a summary of
+        #
+        # @return [Hash{Symbol => Array[String]}] A hash of each category and the file paths in each category
+        def self.summary(update_manager)
+          summary = {}
+          update_manager.changes.each do |category, update_category|
+            if update_category.respond_to?(:keys)
+              updated_files = update_category.keys
+            else
+              begin
+                updated_files = update_category.map { |file| file[:path] }
+              rescue TypeError
+                updated_files = update_category.to_a
+              end
+            end
+
+            summary[category] = updated_files
+          end
+
+          summary
+        end
+        private_class_method :summary
+
+        # Creates a line of text, with `text` centered in the middle
+        # @param text [String] The text to put in the middle of the banner
+        # @param width [Integer] The width of the banner in characters. Default is 80
+        # @return [String] The generated banner
+        def self.generate_banner(text, width = 80)
+          padding = width - text.length
+          banner = ''
+          padding_char = '-'
+
+          (padding / 2.0).ceil.times { banner << padding_char }
+          banner << text
+          (padding / 2.0).floor.times { banner << padding_char }
+
+          banner
+        end
+        private_class_method :generate_banner
+        #:nocov:
+      end
+    end
+  end
+end

data/lib/pdk/cli/validate.rb

@@ -19,6 +19,9 @@ module PDK::CLI
     flag nil, :parallel, _('Run validations in parallel.')
 
     run do |opts, args, _cmd|
+      # Write the context information to the debug log
+      PDK.context.to_debug_log
+
       if args == ['help']
         PDK::CLI.run(['validate', '--help'])
         exit 0
@@ -26,42 +29,42 @@ module PDK::CLI
 
       require 'pdk/validate'
 
-      validator_names = PDK::Validate.validators.map { |v| v.name }
-      validators = PDK::Validate.validators
-      targets = []
-
       if opts[:list]
         PDK::CLI::Util.analytics_screen_view('validate', opts)
-        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: validator_names.join(', ') })
+        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: PDK::Validate.validator_names.join(', ') })
         exit 0
       end
 
       PDK::CLI::Util.validate_puppet_version_opts(opts)
+      unless PDK.feature_flag?('controlrepo') || PDK.context.is_a?(PDK::Context::Module)
+        raise PDK::CLI::ExitWithError.new(_('Code validation can only be run from inside a valid module directory'), log_level: :error)
+      end
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('Code validation can only be run from inside a valid module directory'),
-        log_level: :info,
-      )
+      PDK::CLI::Util.module_version_check if PDK.context.is_a?(PDK::Context::Module)
 
-      PDK::CLI::Util.module_version_check
+      # Set the ruby version we're going to use early. Must be set before the validators are created.
+      # Note that this is a bit of code-smell and should be fixed
+      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
 
+      targets = []
+      validators_to_run = nil
       if args[0]
         # This may be a single validator, a list of validators, or a target.
         if Util::OptionValidator.comma_separated_list?(args[0])
           # This is a comma separated list. Treat each item as a validator.
-
           vals = Util::OptionNormalizer.comma_separated_list_to_array(args[0])
-          validators = PDK::Validate.validators.select { |v| vals.include?(v.name) }
+          validators_to_run = PDK::Validate.validator_names.select { |name| vals.include?(name) }
 
-          invalid = vals.reject { |v| validator_names.include?(v) }
-          invalid.each do |v|
-            PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}.") % { v: v, validators: validator_names.join(', ') })
+          vals.reject { |v| PDK::Validate.validator_names.include?(v) }
+              .each do |v|
+            PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}.") % { v: v, validators: PDK::Validate.validator_names.join(', ') })
           end
         else
           # This is a single item. Check if it's a known validator, or otherwise treat it as a target.
-          val = PDK::Validate.validators.find { |v| args[0] == v.name }
+          val = PDK::Validate.validator_names.find { |name| args[0] == name }
           if val
-            validators = [val]
+            validators_to_run = [val]
           else
             targets = [args[0]]
             # We now know that no validators were passed, so let the user know we're using all of them by default.
@@ -71,11 +74,12 @@ module PDK::CLI
       else
         PDK.logger.info(_('Running all available validators...'))
       end
+      validators_to_run = PDK::Validate.validator_names if validators_to_run.nil?
 
-      if validators == PDK::Validate.validators
+      if validators_to_run.sort == PDK::Validate.validator_names.sort
         PDK::CLI::Util.analytics_screen_view('validate', opts)
       else
-        PDK::CLI::Util.analytics_screen_view(['validate', validators.map(&:name).sort].flatten.join('_'), opts)
+        PDK::CLI::Util.analytics_screen_view(['validate', validators_to_run.sort].flatten.join('_'), opts)
       end
 
       # Subsequent arguments are targets.
@@ -93,36 +97,14 @@ module PDK::CLI
 
       options = targets.empty? ? {} : { targets: targets }
       options[:auto_correct] = true if opts[:'auto-correct']
-
-      # Ensure that the bundled gems are up to date and correct Ruby is activated before running any validations.
-      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
-      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
-
       options.merge!(puppet_env[:gemset])
 
+      # Ensure that the bundled gems are up to date and correct Ruby is activated before running any validations.
+      # Note that if no Gemfile exists, then ensure_bundle! will log a debug message and exit gracefully
       require 'pdk/util/bundler'
-
       PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
-      exit_code = 0
-      if opts[:parallel]
-        require 'pdk/cli/exec_group'
-
-        exec_group = PDK::CLI::ExecGroup.new(_('Validating module using %{num_of_threads} threads' % { num_of_threads: validators.count }), opts)
-
-        validators.each do |validator|
-          exec_group.register do
-            validator.invoke(report, options.merge(exec_group: exec_group))
-          end
-        end
-
-        exit_code = exec_group.exit_code
-      else
-        validators.each do |validator|
-          validator_exit_code = validator.invoke(report, options.dup)
-          exit_code = validator_exit_code if validator_exit_code != 0
-        end
-      end
+      exit_code, report = PDK::Validate.invoke_validators_by_name(PDK.context, validators_to_run, opts.fetch(:parallel, false), options)
 
       report_formats.each do |format|
         report.send(format[:method], format[:target])

data/lib/pdk/config.rb

@@ -2,6 +2,8 @@ require 'pdk'
 
 module PDK
   class Config
+    autoload :IniFile, 'pdk/config/ini_file'
+    autoload :IniFileSetting, 'pdk/config/ini_file_setting'
     autoload :JSON, 'pdk/config/json'
     autoload :JSONSchemaNamespace, 'pdk/config/json_schema_namespace'
     autoload :JSONSchemaSetting, 'pdk/config/json_schema_setting'
@@ -11,16 +13,50 @@ module PDK
     autoload :Validator, 'pdk/config/validator'
     autoload :YAML, 'pdk/config/yaml'
 
-    def user
-      @user ||= PDK::Config::JSON.new('user', file: PDK::Config.user_config_path) do
-        mount :module_defaults, PDK::Config::JSON.new(file: PDK.answers.answer_file_path)
+    # Create a new instance of the PDK Configuration
+    # @param options [Hash[String => Object]] Optional hash to override configuration options
+    # @option options [String]                        'system.path'                 Path to the system PDK configuration file
+    # @option options [String]                        'system.module_defaults.path' Path to the system module answers PDK configuration file
+    # @option options [String]                        'user.path'                   Path to the user PDK configuration file
+    # @option options [String]                        'user.module_defaults.path'   Path to the user module answers PDK configuration file
+    # @option options [String]                        'user.analytics.path'         Path to the user analytics PDK configuration file
+    # @option options [PDK::Context::AbstractContext] 'context'                     The context that the configuration should be created in
+    def initialize(options = nil)
+      options = {} if options.nil?
+      @config_options = {
+        'system.path'                 => PDK::Config.system_config_path,
+        'system.module_defaults.path' => PDK::Config.system_answers_path,
+        'user.path'                   => PDK::Config.user_config_path,
+        'user.module_defaults.path'   => PDK::AnswerFile.default_answer_file_path,
+        'user.analytics.path'         => PDK::Config.analytics_config_path,
+        'context'                     => PDK.context,
+      }.merge(options)
+    end
+
+    # The system level configuration settings.
+    # @return [PDK::Config::Namespace]
+    # @api private
+    def system_config
+      local_options = @config_options
+      @system_config ||= PDK::Config::JSON.new('system', file: local_options['system.path']) do
+        mount :module_defaults, PDK::Config::JSON.new(file: local_options['system.module_defaults.path'])
+      end
+    end
+
+    # The user level configuration settings.
+    # @return [PDK::Config::Namespace]
+    # @api private
+    def user_config
+      local_options = @config_options
+      @user_config ||= PDK::Config::JSON.new('user', file: local_options['user.path']) do
+        mount :module_defaults, PDK::Config::JSON.new(file: local_options['user.module_defaults.path'])
 
         # Due to the json-schema gem having issues with Windows based paths, and only supporting Draft 05 (or less) do
         # not use JSON validation yet.  Once PDK drops support for EOL rubies, we will be able to use the json_schemer gem
         # Which has much more modern support
         # Reference - https://github.com/puppetlabs/pdk/pull/777
         # Reference - https://tickets.puppetlabs.com/browse/PDK-1526
-        mount :analytics, PDK::Config::YAML.new(file: PDK::Config.analytics_config_path, persistent_defaults: true) do
+        mount :analytics, PDK::Config::YAML.new(file: local_options['user.analytics.path'], persistent_defaults: true) do
           setting :disabled do
             validate PDK::Config::Validator.boolean
             default_to { PDK::Config.bolt_analytics_config.fetch('disabled', true) }
@@ -35,6 +71,29 @@ module PDK
             end
           end
         end
+
+        # Display the feature flags
+        mount :pdk_feature_flags, PDK::Config::Namespace.new('pdk_feature_flags') do
+          setting 'available' do
+            default_to { PDK.available_feature_flags }
+          end
+
+          setting 'requested' do
+            default_to { PDK.requested_feature_flags }
+          end
+        end
+      end
+    end
+
+    # The project level configuration settings.
+    # @return [PDK::Config::Namespace]
+    # @api private
+    def project_config
+      context = @config_options['context']
+      @project ||= PDK::Config::Namespace.new('project') do
+        if context.is_a?(PDK::Context::ControlRepo)
+          mount :environment, PDK::ControlRepo.environment_conf_as_config(File.join(context.root_path, 'environment.conf'))
+        end
       end
     end
 
@@ -43,7 +102,85 @@ module PDK
     # @param filter [String] Only resolve setting names which match the filter. See PDK::Config::Namespace.be_resolved? for matching rules
     # @return [Hash{String => Object}] All resolved settings for example {'user.module_defaults.author' => 'johndoe'}
     def resolve(filter = nil)
-      user.resolve(filter)
+      all_scopes.values.reverse.reduce({}) do |result, method_name|
+        result.merge(send(method_name).resolve(filter))
+      end
+    end
+
+    # Returns a configuration setting by name. This name can either be a String, Array or parameters e.g. These are equivalent
+    # - PDK.config.get('user.a.b.c')
+    # - PDK.config.get(['user', 'a', 'b', 'c'])
+    # - PDK.config.get('user', 'a', 'b', 'c')
+    # @param root [Array[String], String] The root setting name or the entire setting name as a single string
+    # @param keys [String] The child names of the setting
+    # @return [PDK::Config::Namespace, Object, nil] The value of the configuration setting. Returns nil if it does no exist
+    def get(root, *keys)
+      return nil if root.nil? || root.empty?
+
+      if keys.empty?
+        if root.is_a?(Array)
+          name = root
+        elsif root.is_a?(String)
+          name = split_key_string(root)
+        else
+          return nil
+        end
+      else
+        name = [root].concat(keys)
+      end
+
+      get_within_scopes(name[1..-1], [name[0]])
+    end
+
+    # Returns a configuration setting by name, using scope precedence rules. If no scopes are passed, then all scopes are queried using the default precedence rules
+    # @setting_name [String, Array[String]] The setting name to retrieve without the leading scope name e.g. Use 'setting' instead of 'system.setting'
+    # @scopes [Nil, Array[String]] The list of scopes, in order, to query in turn for the setting_name. Invalid or missing scopes are ignored.
+    # @return [PDK::Config::Namespace, Object, nil] The value of the configuration setting. Returns nil if it does no exist
+    def get_within_scopes(setting_name, scopes = nil)
+      raise ArgumentError, _('Expected an Array but got \'%{klass}\' for scopes') % { klass: scopes.class } unless scopes.nil? || scopes.is_a?(Array)
+      raise ArgumentError, _('Expected an Array or String but got \'%{klass}\' for setting_name') % { klass: setting_name.class } unless setting_name.is_a?(Array) || setting_name.is_a?(String)
+
+      setting_arr = setting_name.is_a?(String) ? split_key_string(setting_name) : setting_name
+      all_scope_names = all_scopes.keys
+
+      # Use only valid scope names
+      scopes = scopes.nil? ? all_scope_names : scopes & all_scope_names
+
+      scopes.each do |scope_name|
+        value = traverse_object(send(all_scopes[scope_name]), *setting_arr)
+        return value unless value.nil?
+      end
+      nil
+    end
+
+    # Yields a configuration setting value by name, using scope precedence rules. If no scopes are passed, then all scopes are queried using the default precedence rules
+    # @setting_name [String, Array[String]] The setting name to retrieve without the leading scope name e.g. Use 'setting' instead of 'system.setting'
+    # @scopes [Nil, Array[String]] The list of scopes, in order, to query in turn for the setting_name. Invalid or missing scopes are ignored.
+    # @yield [PDK::Config::Namespace, Object] The value of the configuration setting. Does not yield if the setting does not exist or is nil
+    def with_scoped_value(setting_name, scopes = nil)
+      raise ArgumentError, _('must be passed a block') unless block_given?
+      value = get_within_scopes(setting_name, scopes)
+      yield value unless value.nil?
+    end
+
+    # Sets a configuration setting by name. This name can either be a String or an Array
+    # - PDK.config.set('user.a.b.c', ...)
+    # - PDK.config.set(['user', 'a', 'b', 'c'], ...)
+    # @param key [String, Array[String]] The name of the configuration key to change
+    # @param value [Object] The value to set the configuration setting to
+    # @param options [Hash] Changes the behaviour of the setting process
+    # @option options [Boolean] :force Disables any munging or array processing, and sets the value as it is. Default is false
+    # @return [Object] The new value of the configuration setting
+    def set(key, value, options = {})
+      options = {
+        force: false,
+      }.merge(options)
+
+      names = key.is_a?(String) ? split_key_string(key) : key
+      raise ArgumentError, _('Invalid configuration names') if names.nil? || !names.is_a?(Array) || names.empty?
+      scope_name = names[0]
+      raise ArgumentError, _("Unknown configuration root '%{name}'") % { name: scope_name } if all_scopes[scope_name].nil?
+      deep_set_object(value, options[:force], send(all_scopes[scope_name]), *names[1..-1])
     end
 
     def self.bolt_analytics_config
@@ -65,6 +202,14 @@ module PDK
       File.join(PDK::Util.configdir, 'user_config.json')
     end
 
+    def self.system_config_path
+      File.join(PDK::Util.system_configdir, 'system_config.json')
+    end
+
+    def self.system_answers_path
+      File.join(PDK::Util.system_configdir, 'answers.json')
+    end
+
     def self.json_schemas_path
       File.join(__dir__, 'config')
     end
@@ -116,12 +261,124 @@ module PDK
 
       if answers.nil?
         PDK.logger.info _('No answer given, opting out of analytics collection.')
-        PDK.config.user['analytics']['disabled'] = true
+        PDK.config.set(%w[user analytics disabled], true)
       else
-        PDK.config.user['analytics']['disabled'] = !answers['enabled']
+        PDK.config.set(%w[user analytics disabled], !answers['enabled'])
       end
 
       PDK.logger.info(text: post_message, wrap: true)
     end
+
+    private
+
+    #:nocov: This is a private method and is tested elsewhere
+    def traverse_object(object, *names)
+      return nil if object.nil? || !object.respond_to?(:[])
+      return nil if names.nil?
+      # It's possible to pass in empty names at the root traversal layer
+      # but this should _only_ happen at the root namespace level
+      if names.empty?
+        return (object.is_a?(PDK::Config::Namespace) ? object : nil)
+      end
+
+      name = names.shift
+      value = object[name]
+      if names.empty?
+        return value if value.is_a?(PDK::Config::Namespace)
+        # Duplicate arrays and hashes so that they are isolated from changes being made
+        (value.is_a?(Hash) || value.is_a?(Array)) ? value.dup : value
+      else
+        traverse_object(value, *names)
+      end
+    end
+    #:nocov:
+
+    #:nocov: This is a private method and is tested elsewhere
+    # Takes a string representation of a setting and splits into its constituent setting parts e.g.
+    # 'user.a.b.c' becomes ['user', 'a', 'b', 'c']
+    # @return [Array[String]] The string split into each setting name as an array
+    def split_key_string(key)
+      raise ArgumentError, _('Expected a String but got \'%{klass}\'') % { klass: key.class } unless key.is_a?(String)
+      key.split('.')
+    end
+    #:nocov:
+
+    #:nocov:
+    # Returns all known scope names and their associated method name to call, to query the scope
+    # Note - Order is important. This dictates the resolution precedence order (topmost is processed first)
+    # @return [Hash[String, Symbol]] A hash of the scope name then method name to call to query the scope (as a Symbol)
+    def all_scopes
+      # Note - Order is important. This dictates the resolution precedence order (topmost is processed first)
+      {
+        'project' => :project_config,
+        'user'    => :user_config,
+        'system'  => :system_config,
+      }.freeze
+    end
+
+    #:nocov: This is a private method and is tested elsewhere
+    # Deeply traverses an object tree via `[]` and sets the last
+    # element to the value specified.
+    #
+    # Creating any missing parent hashes during the traversal
+    def deep_set_object(value, force, namespace, *names)
+      raise ArgumentError, _('Missing or invalid namespace') unless namespace.is_a?(PDK::Config::Namespace)
+      raise ArgumentError, _('Missing a name to set') if names.nil? || names.empty?
+
+      name = names.shift
+      current_value = namespace[name]
+
+      # If the next thing in the traversal chain is another namespace, set the value using that child namespace.
+      if current_value.is_a?(PDK::Config::Namespace)
+        return deep_set_object(value, force, current_value, *names)
+      end
+
+      # We're at the end of the name traversal
+      if names.empty?
+        if force || !current_value.is_a?(Array)
+          namespace[name] = value
+          return value
+        end
+
+        # Arrays are a special case if we're not forcing the value
+        namespace[name] = current_value << value unless current_value.include?(value)
+        return value
+      end
+
+      # Need to generate a deep hash using the current remaining names
+      # So given an origin *names of ['a', 'b', 'c', 'd'] and a value 'foo',
+      # we eventually want a hash of `{"b"=>{"c"=>{"d"=>"foo"}}}`
+      #
+      # The code above has already shifted the first element so we currently have
+      # name : 'a'
+      # names: ['b', 'c', 'd']
+      #
+      #
+      # First we need to pop off the last element ('d') in this case as we need to set that in the `reduce` call below
+      # So now we have:
+      # name : 'a'
+      # names: ['b', 'c']
+      # last_name : 'd'
+      last_name = names.pop
+      # Using reduce and an accumulator, we create the nested hash from the deepest value first. In this case the deepest value
+      # is the last_name, so the starting condition is {"d"=>"foo"}
+      # After the first iteration ('c'), the accumulator has {"c"=>{"d"=>"foo"}}}
+      # After the last iteration ('b'), the accumulator has {"b"=>{"c"=>{"d"=>"foo"}}}
+      hash_value = names.reverse.reduce(last_name => value) { |accumulator, item| { item => accumulator } }
+
+      # If the current value is nil, then it can't be a namespace or an existing value
+      # or
+      # If the current value is not a Hash and are forcing the change.
+      if current_value.nil? || (force && !current_value.is_a?(Hash))
+        namespace[name] = hash_value
+        return value
+      end
+
+      raise ArgumentError, _("Unable to set '%{key}' to '%{value}' as it is not a Hash") % { key: namespace.name + '.' + name, value: hash_value } unless current_value.is_a?(Hash)
+
+      namespace[name] = current_value.merge(hash_value)
+      value
+    end
+    #:nocov:
   end
 end