pdk-akerl 1.8.0.1

data/lib/pdk/cli/util.rb

@@ -0,0 +1,193 @@
+module PDK
+  module CLI
+    module Util
+      # Ensures the calling code is being run from inside a module directory.
+      #
+      # @param opts [Hash] options to change the behavior of the check logic.
+      # @option opts [Boolean] :check_module_layout Set to true to check for
+      #   stardard module folder layout if the module does not contain
+      #   a metadata.json file.
+      #
+      # @raise [PDK::CLI::ExitWithError] if the current directory does not
+      #   contain a Puppet module.
+      def ensure_in_module!(opts = {})
+        return unless PDK::Util.module_root.nil?
+        return if opts[:check_module_layout] && PDK::Util.in_module_root?
+
+        message = opts.fetch(:message, _('This command must be run from inside a valid module (no metadata.json found).'))
+        raise PDK::CLI::ExitWithError.new(message, opts)
+      end
+      module_function :ensure_in_module!
+
+      def spinner_opts_for_platform
+        windows_opts = {
+          success_mark: '*',
+          error_mark: 'X',
+        }
+
+        return windows_opts if Gem.win_platform?
+        {}
+      end
+      module_function :spinner_opts_for_platform
+
+      def prompt_for_yes(question_text, opts = {})
+        prompt = opts[:prompt] || TTY::Prompt.new(help_color: :cyan)
+        validator = proc { |value| [true, false].include?(value) || value =~ %r{\A(?:yes|y|no|n)\Z}i }
+        response = nil
+
+        begin
+          response = prompt.yes?(question_text) do |q|
+            q.default opts[:default] unless opts[:default].nil?
+            q.validate(validator, _('Answer "Y" to continue or "n" to cancel.'))
+          end
+        rescue TTY::Prompt::Reader::InputInterrupt
+          PDK.logger.info opts[:cancel_message] if opts[:cancel_message]
+        end
+
+        response
+      end
+      module_function :prompt_for_yes
+
+      def interactive?
+        return false if PDK.logger.debug?
+        return !ENV['PDK_FRONTEND'].casecmp('noninteractive').zero? if ENV['PDK_FRONTEND']
+        return false unless $stderr.isatty
+
+        true
+      end
+      module_function :interactive?
+
+      def module_version_check
+        module_pdk_ver = PDK::Util.module_pdk_version
+
+        # This means the module does not have a pdk-version tag in the metadata.json
+        # and will require a pdk convert.
+        raise PDK::CLI::ExitWithError, _('This module is not PDK compatible. Run `pdk convert` to make it compatible with your version of PDK.') if module_pdk_ver.nil?
+
+        # This checks that the version of pdk in the module's metadata is older
+        # than 1.3.1, which means the module will need to run pdk convert to the
+        # new templates.
+        if Gem::Version.new(module_pdk_ver) < Gem::Version.new('1.3.1')
+          PDK.logger.warn _('This module template is out of date. Run `pdk convert` to make it compatible with your version of PDK.')
+        # This checks if the version of the installed PDK is older than the
+        # version in the module's metadata, and advises the user to upgrade to
+        # their install of PDK.
+        elsif Gem::Version.new(PDK::VERSION) < Gem::Version.new(module_pdk_ver)
+          PDK.logger.warn _('This module is compatible with a newer version of PDK. Upgrade your version of PDK to ensure compatibility.')
+        # This checks if the version listed in the module's metadata is older
+        # than the installed PDK, and advises the user to run pdk update.
+        elsif Gem::Version.new(PDK::VERSION) > Gem::Version.new(module_pdk_ver)
+          PDK.logger.warn _('This module is compatible with an older version of PDK. Run `pdk update` to update it to your version of PDK.')
+        end
+      end
+      module_function :module_version_check
+
+      def puppet_from_opts_or_env(opts)
+        use_puppet_dev = (opts || {})[:'puppet-dev'] || ENV['PDK_PUPPET_DEV']
+        desired_puppet_version = (opts || {})[:'puppet-version'] || ENV['PDK_PUPPET_VERSION']
+        desired_pe_version = (opts || {})[:'pe-version'] || ENV['PDK_PE_VERSION']
+
+        begin
+          puppet_env =
+            if use_puppet_dev
+              PDK::Util::PuppetVersion.puppet_dev_env
+            elsif desired_puppet_version
+              PDK::Util::PuppetVersion.find_gem_for(desired_puppet_version)
+            elsif desired_pe_version
+              PDK::Util::PuppetVersion.from_pe_version(desired_pe_version)
+            else
+              PDK::Util::PuppetVersion.from_module_metadata || PDK::Util::PuppetVersion.latest_available
+            end
+        rescue ArgumentError => e
+          raise PDK::CLI::ExitWithError, e.message
+        end
+
+        # Notify user of what Ruby version will be used.
+        PDK.logger.info(_('Using Ruby %{version}') % {
+          version: puppet_env[:ruby_version],
+        })
+
+        gemset = { puppet: puppet_env[:gem_version].to_s }
+
+        # Notify user of what gems are being activated.
+        gemset.each do |gem, version|
+          next if version.nil?
+
+          PDK.logger.info(_('Using %{gem} %{version}') % {
+            gem: gem.to_s.capitalize,
+            version: version,
+          })
+        end
+
+        {
+          gemset: gemset,
+          ruby_version: puppet_env[:ruby_version],
+        }
+      end
+      module_function :puppet_from_opts_or_env
+
+      def validate_puppet_version_opts(opts)
+        puppet_ver_specs = []
+        puppet_ver_specs << '--puppet-version option' if opts[:'puppet-version']
+        puppet_ver_specs << 'PDK_PUPPET_VERSION environment variable' if ENV['PDK_PUPPET_VERSION'] && !ENV['PDK_PUPPET_VERSION'].empty?
+
+        pe_ver_specs = []
+        pe_ver_specs << '--pe-version option' if opts[:'pe-version']
+        pe_ver_specs << 'PDK_PE_VERSION environment variable' if ENV['PDK_PE_VERSION'] && !ENV['PDK_PE_VERSION'].empty?
+
+        puppet_dev_specs = []
+        puppet_dev_specs << '--puppet-dev flag' if opts[:'puppet-dev']
+        puppet_dev_specs << 'PDK_PUPPET_DEV environment variable' if ENV['PDK_PUPPET_DEV'] && !ENV['PDK_PUPPET_DEV'].empty?
+
+        puppet_dev_specs.each do |pup_dev_spec|
+          [puppet_ver_specs, pe_ver_specs].each do |offending|
+            next if offending.empty?
+
+            raise PDK::CLI::ExitWithError, _('You cannot specify a %{first} and %{second} at the same time') % {
+              first: pup_dev_spec,
+              second: offending.first,
+            }
+          end
+        end
+
+        puppet_ver_specs.each do |pup_ver_spec|
+          next if pe_ver_specs.empty?
+
+          offending = [pup_ver_spec, pe_ver_specs[0]].sort
+
+          raise PDK::CLI::ExitWithError, _('You cannot specify a %{first} and %{second} at the same time.') % {
+            first: offending[0],
+            second: offending[1],
+          }
+        end
+
+        if puppet_dev_specs.size == 2
+          warning_str = 'Puppet dev flag from command line: "--puppet-dev" '
+          warning_str += 'overrides value from environment: "PDK_PUPPET_DEV=true". You should not specify both.'
+
+          PDK.logger.warn(_(warning_str) % {
+            pup_ver_opt: opts[:'puppet-dev'],
+            pup_ver_env: ENV['PDK_PUPPET_DEV'],
+          })
+        elsif puppet_ver_specs.size == 2
+          warning_str = 'Puppet version option from command line: "--puppet-version=%{pup_ver_opt}" '
+          warning_str += 'overrides value from environment: "PDK_PUPPET_VERSION=%{pup_ver_env}". You should not specify both.'
+
+          PDK.logger.warn(_(warning_str) % {
+            pup_ver_opt: opts[:'puppet-version'],
+            pup_ver_env: ENV['PDK_PUPPET_VERSION'],
+          })
+        elsif pe_ver_specs.size == 2
+          warning_str = 'Puppet Enterprise version option from command line: "--pe-version=%{pe_ver_opt}" '
+          warning_str += 'overrides value from environment: "PDK_PE_VERSION=%{pe_ver_env}". You should not specify both.'
+
+          PDK.logger.warn(_(warning_str) % {
+            pup_ver_opt: opts[:'pe-version'],
+            pup_ver_env: ENV['PDK_PE_VERSION'],
+          })
+        end
+      end
+      module_function :validate_puppet_version_opts
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'tty-prompt'
+
+module PDK
+  module CLI
+    module Util
+      class CommandRedirector < TTY::Prompt::AnswersCollector
+        attr_accessor :command
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def target_command(cmd)
+          @command = cmd
+        end
+
+        def run
+          @prompt.puts _('Did you mean \'%{command}\'?') % { command: pastel.bold(@command) }
+          @prompt.yes?('-->')
+        rescue TTY::Prompt::Reader::InputInterrupt
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'tty-prompt'
+
+module PDK
+  module CLI
+    module Util
+      class Interview < TTY::Prompt::AnswersCollector
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def add_questions(questions)
+          questions.each do |question|
+            add_question(question)
+          end
+        end
+
+        def add_question(options = {})
+          (@questions ||= {})[options[:name]] = options
+        end
+
+        def num_questions
+          (@questions ||= {}).count
+        end
+
+        def run
+          i = 1
+          num_questions = @questions.count
+          @questions.each do |question_name, question|
+            @name = question_name
+            @prompt.print pastel.bold(_('[Q %{current_number}/%{questions_total}]') % { current_number: i, questions_total: num_questions }) + ' '
+            @prompt.puts pastel.bold(question[:question])
+            @prompt.puts question[:help] if question.key?(:help)
+            if question.key?(:choices)
+              multi_select(_('-->'), per_page: question[:choices].count) do |q|
+                q.enum ')'
+                q.default(*question[:default]) if question.key?(:default)
+
+                question[:choices].each do |text, metadata|
+                  q.choice text, metadata
+                end
+              end
+            else
+              ask(_('-->')) do |q|
+                q.required(question.fetch(:required, false))
+
+                if question.key?(:validate_pattern)
+                  q.validate(question[:validate_pattern], question[:validate_message])
+                end
+
+                q.default(question[:default]) if question.key?(:default)
+              end
+            end
+            i += 1
+            @prompt.puts ''
+          end
+          @answers
+        rescue TTY::Prompt::Reader::InputInterrupt
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module PDK
+  module CLI
+    module Util
+      class OptionNormalizer
+        def self.comma_separated_list_to_array(list, _options = {})
+          raise _('Error: expected comma separated list') unless OptionValidator.comma_separated_list?(list)
+          list.split(',').compact
+        end
+
+        # Parse one or more format:target pairs into report format
+        # specifications.
+        #
+        # Each specification is a Hash with two values:
+        #   :method => The name of the method to call on the PDK::Report object
+        #              to render the report.
+        #   :target => The target to write the report to. This can be either an
+        #              IO object that implements #write, or a String filename
+        #              that will be opened for writing.
+        #
+        # If the target given is "stdout" or "stderr", this will convert those
+        # strings into the appropriate IO object.
+        #
+        # @return [Array<Hash{Symbol=>Object}>] An array of one or more report
+        #   format specifications
+        def self.report_formats(formats)
+          formats.map do |f|
+            format, target = f.split(':', 2)
+
+            begin
+              OptionValidator.enum(format, PDK::Report.formats)
+            rescue ArgumentError
+              raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid report format (%{valid})") % {
+                name:  format,
+                valid: PDK::Report.formats.join(', '),
+              }
+            end
+
+            case target
+            when 'stdout'
+              target = $stdout
+            when 'stderr'
+              target = $stderr
+            when nil
+              target = PDK::Report.default_target
+            end
+
+            { method: "write_#{format}".to_sym, target: target }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module PDK
+  module CLI
+    module Util
+      class OptionValidator
+        def self.comma_separated_list?(list, _options = {})
+          (list =~ %r{^[\w\-]+(?:,[\w\-]+)+$}) ? true : false
+        end
+
+        def self.enum(val, valid_entries, _options = {})
+          vals = val.is_a?(Array) ? val : [val]
+          invalid_entries = vals.reject { |e| valid_entries.include?(e) }
+
+          unless invalid_entries.empty?
+            raise ArgumentError, _('Error: the following values are invalid: %{invalid_entries}') % { invalid_entries: invalid_entries }
+          end
+
+          val
+        end
+
+        # Validate the module name against the regular expression in the
+        # documentation: https://docs.puppet.com/puppet/4.10/modules_fundamentals.html#allowed-module-names
+        def self.valid_module_name?(string)
+          !(string =~ %r{\A[a-z][a-z0-9_]*\Z}).nil?
+        end
+        singleton_class.send(:alias_method, :valid_task_name?, :valid_module_name?)
+
+        # https://puppet.com/docs/puppet/5.3/custom_types.html#creating-a-type only says the name has to be a ruby symbol.
+        # Let's assume that only strings similar to module names can actually be resolved by the puppet language.
+        singleton_class.send(:alias_method, :valid_provider_name?, :valid_module_name?)
+
+        # Validate a Puppet namespace against the regular expression in the
+        # documentation: https://docs.puppet.com/puppet/4.10/lang_reserved.html#classes-and-defined-resource-types
+        def self.valid_namespace?(string)
+          return false if (string || '').split('::').last == 'init'
+
+          !(string =~ %r{\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z}).nil?
+        end
+
+        singleton_class.send(:alias_method, :valid_class_name?, :valid_namespace?)
+        singleton_class.send(:alias_method, :valid_defined_type_name?, :valid_namespace?)
+
+        # Validate that a class/defined type parameter matches the regular
+        # expression in the documentation: https://docs.puppet.com/puppet/4.10/lang_reserved.html#parameters
+        # The parameter should also not be a reserved word or overload
+        # a metaparameter.
+        def self.valid_param_name?(string)
+          reserved_words = %w[trusted facts server_facts title name].freeze
+          metaparams = %w[alias audit before loglevel noop notify require schedule stage subscribe tag].freeze
+          return false if reserved_words.include?(string) || metaparams.include?(string)
+
+          !(string =~ %r{\A[a-z][a-zA-Z0-9_]*\Z}).nil?
+        end
+      end
+    end
+  end
+end

data/lib/pdk/cli/validate.rb

@@ -0,0 +1,124 @@
+require 'pdk/util/bundler'
+
+module PDK::CLI
+  @validate_cmd = @base_cmd.define_command do
+    name 'validate'
+    usage _('validate [validators] [options] [targets]')
+    summary _('Run static analysis tests.')
+    description _(
+      "Run metadata, Puppet, Ruby, or Tasks validation.\n\n" \
+      '[validators] is an optional comma-separated list of validators to use. ' \
+      'If not specified, all validators are used. ' \
+      "Note that when using PowerShell, the list of validators must be enclosed in single quotes.\n\n" \
+      '[targets] is an optional space-separated list of files or directories to be validated. ' \
+      'If not specified, validators are run against all applicable files in the module.',
+    )
+
+    PDK::CLI.puppet_version_options(self)
+    PDK::CLI.puppet_dev_option(self)
+    flag nil, :list, _('List all available validators.')
+    flag :a, 'auto-correct', _('Automatically correct problems where possible.')
+    flag nil, :parallel, _('Run validations in parallel.')
+
+    run do |opts, args, _cmd|
+      if args == ['help']
+        PDK::CLI.run(['validate', '--help'])
+        exit 0
+      end
+
+      validator_names = PDK::Validate.validators.map { |v| v.name }
+      validators = PDK::Validate.validators
+      targets = []
+
+      if opts[:list]
+        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: validator_names.join(', ') })
+        exit 0
+      end
+
+      PDK::CLI::Util.validate_puppet_version_opts(opts)
+
+      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 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) }
+
+          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(', ') })
+          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 }
+          if val
+            validators = [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.
+            PDK.logger.info(_('Running all available validators...'))
+          end
+        end
+      else
+        PDK.logger.info(_('Running all available validators...'))
+      end
+
+      # Subsequent arguments are targets.
+      targets.concat(args[1..-1]) if args.length > 1
+
+      report = PDK::Report.new
+      report_formats = if opts[:format]
+                         PDK::CLI::Util::OptionNormalizer.report_formats(opts[:format])
+                       else
+                         [{
+                           method: PDK::Report.default_format,
+                           target: PDK::Report.default_target,
+                         }]
+                       end
+
+      options = targets.empty? ? {} : { targets: targets }
+      options[:auto_correct] = true if opts.key?(:'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::PuppetVersion.fetch_puppet_dev if opts.key?(:'puppet-dev')
+      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+
+      options.merge!(puppet_env[:gemset])
+
+      PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
+
+      exit_code = 0
+      if opts[:parallel]
+        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
+
+      report_formats.each do |format|
+        report.send(format[:method], format[:target])
+      end
+
+      exit exit_code
+    end
+  end
+end