pdk 1.17.0 → 2.1.1

data/lib/pdk/cli/set/config.rb

@@ -0,0 +1,119 @@
+module PDK::CLI
+  module Set
+    module Config
+      ALLOWED_TYPE_NAMES = %w[array boolean number string].freeze
+
+      # :nocov:
+      def self.pretty_allowed_names
+        ALLOWED_TYPE_NAMES.map { |name| "'#{name}'" }.join(', ')
+      end
+      # :nocov:
+
+      def self.transform_value(type_name, value)
+        normalized_name = type_name.downcase.strip
+        unless ALLOWED_TYPE_NAMES.include?(normalized_name)
+          raise PDK::CLI::ExitWithError, _('Unknown type %{type_name}. Expected one of %{allowed}') % { type_name: type_name, allowed: pretty_allowed_names }
+        end
+
+        # Short circuit string conversions as it's trivial
+        if normalized_name == 'string'
+          raise PDK::CLI::ExitWithError, _('An error occured converting \'%{value}\' into a %{type_name}') % { value: value.nil? ? 'nil' : value, type_name: type_name } unless value.is_a?(String)
+          return value
+        end
+
+        begin
+          case normalized_name
+          when 'array'
+            convert_to_array(value)
+          when 'boolean'
+            convert_to_boolean(value)
+          when 'number'
+            convert_to_number(value)
+          else
+            value
+          end
+        rescue ArgumentError, TypeError
+          raise PDK::CLI::ExitWithError, _('An error occured converting \'%{value}\' into a %{type_name}') % { value: value.nil? ? 'nil' : value, type_name: type_name }
+        end
+      end
+
+      def self.convert_to_array(value)
+        return [] if value.nil?
+        value.is_a?(Array) ? value : [value]
+      end
+      private_class_method :convert_to_array
+
+      def self.convert_to_boolean(value)
+        string_val = value.to_s.strip.downcase
+
+        return true  if %w[yes true -1 1].include?(string_val)
+        return false if %w[no false 0].include?(string_val)
+
+        raise ArgumentError
+      end
+      private_class_method :convert_to_boolean
+
+      def self.convert_to_number(value)
+        float_val = Float(value)
+        # Return an Integer if this is actually and Integer, otherwise return the float
+        (float_val.truncate == float_val) ? float_val.truncate : float_val
+      end
+      private_class_method :convert_to_number
+
+      def self.run(opts, args)
+        item_name = (args.count > 0) ? args[0] : nil
+        item_value = (args.count > 1) ? args[1] : nil
+
+        opts[:type] = opts[:as] if opts[:type].nil? && !opts[:as].nil?
+        force = opts[:force] || false
+
+        # Transform the value if we need to
+        item_value = PDK::CLI::Set::Config.transform_value(opts[:type], item_value) unless opts[:type].nil?
+
+        raise PDK::CLI::ExitWithError, _('Configuration name is required') if item_name.nil?
+        raise PDK::CLI::ExitWithError, _('Configuration value is required. If you wish to remove a value use \'pdk remove config\'') if item_value.nil?
+
+        current_value = PDK.config.get(item_name)
+        raise PDK::CLI::ExitWithError, _("The configuration item '%{name}' can not have a value set.") % { name: item_name } if current_value.is_a?(PDK::Config::Namespace)
+
+        # If we're forcing the value, don't do any munging
+        unless force
+          # Check if the setting already exists
+          if current_value.is_a?(Array) && current_value.include?(item_value)
+            PDK.logger.info(_("No changes made to '%{name}' as it already contains value '%{to}'") % { name: item_name, to: item_value })
+            return 0
+          end
+        end
+
+        new_value = PDK.config.set(item_name, item_value, force: opts[:force])
+        if current_value.nil? || force
+          PDK.logger.info(_("Set initial value of '%{name}' to '%{to}'") % { name: item_name, to: new_value })
+        elsif current_value.is_a?(Array)
+          # Arrays have a special output format
+          PDK.logger.info(_("Added new value '%{to}' to '%{name}'") % { name: item_name, to: item_value })
+        else
+          PDK.logger.info(_("Changed existing value of '%{name}' from '%{from}' to '%{to}'") % { name: item_name, from: current_value, to: new_value })
+        end
+
+        # Same output as `get config`
+        $stdout.puts _('%{name}=%{value}') % { name: item_name, value: PDK.config.get(item_name) }
+        0
+      end
+    end
+  end
+
+  @set_config_cmd = @set_cmd.define_command do
+    name 'config'
+    usage _('config [name] [value]')
+    summary _('Set or update the configuration for <name>')
+
+    option :f, :force, _('Force the configuration setting to be overwitten.'), argument: :forbidden
+
+    option :t, :type, _('The type of value to set. Acceptable values: %{values}') % { values: PDK::CLI::Set::Config.pretty_allowed_names }, argument: :required
+    option nil, :as, _('Alias of --type'), argument: :required
+
+    run do |opts, args, _cmd|
+      exit PDK::CLI::Set::Config.run(opts, args)
+    end
+  end
+end

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(PDK::Util.module_root, 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.
       #

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/config.rb

@@ -33,20 +33,12 @@ module PDK
       }.merge(options)
     end
 
-    # The user configuration settings.
-    # @deprecated This method is only provided as a courtesy until the `pdk set config` CLI and associated changes in this class, are completed.
-    #             Any read-only operations should be using `.get` or `.get_within_scopes`
-    # @return [PDK::Config::Namespace]
-    def user
-      user_config
-    end
-
     # The system level configuration settings.
     # @return [PDK::Config::Namespace]
     # @api private
     def system_config
       local_options = @config_options
-      @system ||= PDK::Config::JSON.new('system', file: local_options['system.path']) do
+      @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
@@ -56,7 +48,7 @@ module PDK
     # @api private
     def user_config
       local_options = @config_options
-      @user ||= PDK::Config::JSON.new('user', file: local_options['user.path']) do
+      @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
@@ -119,6 +111,8 @@ module PDK
     # - 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?
@@ -169,6 +163,26 @@ module PDK
       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
       file = PDK::Util::Filesystem.expand_path('~/.puppetlabs/bolt/analytics.yaml')
       PDK::Config::YAML.new(file: file)
@@ -247,9 +261,9 @@ 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)
@@ -260,7 +274,12 @@ module PDK
     #: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? || names.empty?
+      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]
@@ -296,6 +315,70 @@ module PDK
         '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

data/lib/pdk/context.rb

@@ -33,13 +33,15 @@ module PDK
     # Abstract class which all PDK Contexts will subclass from.
     # @abstract
     class AbstractContext
-      # The root of this context, for example the module root when inside a module. This is different from context_path
+      # The root of this context, for example the module root when inside a module. This can be different from context_path
       # For example a Module context_path could be /path/to/module/manifests/ but the root_path will be /path/to/module as
-      # that is the root of the Module context
-      # @return [String, Nil]
-      attr_reader :root_path
+      # that is the root of the Module context. Defaults to the context_path if not set.
+      # @return [String]
+      def root_path
+        @root_path || @context_path
+      end
 
-      # The path used to create this context, for example the current working directory. This is different from root_path
+      # The path used to create this context, for example the current working directory. This can be different from root_path
       # For example a Module context_path could be /path/to/module/manifests/ but the root_path will be /path/to/module as
       # that is the root of the Module context
       # @return [String]
@@ -48,6 +50,7 @@ module PDK
       # @param context_path [String] The path where this context was created from e.g. Dir.pwd
       def initialize(context_path)
         @context_path = context_path
+        @root_path = nil
       end
 
       # Whether the current context is compatible with the PDK e.g. in a Module context, whether it has the correct metadata.json content