pdk-akerl 1.9.1.1 → 1.14.0.1

data/lib/pdk/cli/convert.rb

@@ -1,5 +1,3 @@
-require 'pdk/cli/util'
-
 module PDK::CLI
   @convert_cmd = @base_cmd.define_command do
     name 'convert'
@@ -7,13 +5,16 @@ module PDK::CLI
     summary _('Convert an existing module to be compatible with the PDK.')
 
     PDK::CLI.template_url_option(self)
+    PDK::CLI.template_ref_option(self)
     PDK::CLI.skip_interview_option(self)
     PDK::CLI.full_interview_option(self)
     flag nil, :noop, _('Do not convert the module, just output what would be done.')
     flag nil, :force, _('Convert the module automatically, with no prompts.')
+    flag nil, :'add-tests', _('Add any missing tests while converting the module.')
 
     run do |opts, _args, _cmd|
       require 'pdk/module/convert'
+      require 'pdk/cli/util'
 
       PDK::CLI::Util.ensure_in_module!(
         check_module_layout: true,
@@ -21,10 +22,14 @@ module PDK::CLI
         log_level:           :info,
       )
 
+      PDK::CLI::Util.validate_template_opts(opts)
+
       if opts[:noop] && opts[:force]
         raise PDK::CLI::ExitWithError, _('You can not specify --noop and --force when converting a module')
       end
 
+      PDK::CLI::Util.analytics_screen_view('convert', opts)
+
       if opts[:'skip-interview'] && opts[:'full-interview']
         PDK.logger.info _('Ignoring --full-interview and continuing with --skip-interview.')
         opts[:'full-interview'] = false

data/lib/pdk/cli/exec.rb

@@ -1,25 +1,33 @@
-require 'bundler'
-require 'childprocess'
-require 'tempfile'
-require 'tty-spinner'
-require 'tty-which'
-
-require 'pdk/util'
-require 'pdk/util/git'
-require 'pdk/util/ruby_version'
-
 module PDK
   module CLI
     module Exec
       def self.execute(*cmd)
+        require 'pdk/cli/exec/command'
+
         Command.new(*cmd).execute!
       end
 
       def self.execute_with_env(env, *cmd)
+        require 'pdk/cli/exec/command'
+
         Command.new(*cmd).tap { |c| c.environment = env }.execute!
       end
 
+      def self.execute_interactive(*cmd)
+        require 'pdk/cli/exec/interactive_command'
+
+        InteractiveCommand.new(*cmd).execute!
+      end
+
+      def self.execute_interactive_with_env(env, *cmd)
+        require 'pdk/cli/exec/interactive_command'
+
+        InteractiveCommand.new(*cmd).tap { |c| c.environment = env }.execute!
+      end
+
       def self.ensure_bin_present!(bin_path, bin_name)
+        require 'tty-which'
+
         message = _('Unable to find `%{name}`. Check that it is installed and try again.') % {
           name: bin_name,
         }
@@ -34,6 +42,8 @@ module PDK
       end
 
       def self.bundle_bin
+        require 'pdk/util/ruby_version'
+
         bundle_bin = Gem.win_platform? ? 'bundle.bat' : 'bundle'
         vendored_bin_path = File.join('private', 'ruby', PDK::Util::RubyVersion.active_ruby_version, 'bin', bundle_bin)
 
@@ -41,6 +51,8 @@ module PDK
       end
 
       def self.try_vendored_bin(vendored_bin_path, fallback)
+        require 'pdk/util'
+
         unless PDK::Util.package_install?
           PDK.logger.debug(_("PDK package installation not found. Trying '%{fallback}' from the system PATH instead.") % {
             fallback: fallback,
@@ -61,186 +73,6 @@ module PDK
         PDK.logger.debug(_("Using '%{vendored_bin}' from PDK package.") % { vendored_bin: vendored_bin_full_path })
         vendored_bin_full_path
       end
-
-      # TODO: decide how/when to connect stdin to child process for things like pry
-      # TODO: need a way to set callbacks on new stdout/stderr data
-      class Command
-        attr_reader :argv
-        attr_reader :context
-        attr_accessor :timeout
-        attr_accessor :environment
-        attr_writer :exec_group
-
-        def initialize(*argv)
-          @argv = argv
-
-          @process = ChildProcess.build(*@argv)
-          @process.leader = true
-
-          @stdout = Tempfile.new('stdout').tap { |io| io.sync = true }
-          @stderr = Tempfile.new('stderr').tap { |io| io.sync = true }
-
-          @process.io.stdout = @stdout
-          @process.io.stderr = @stderr
-
-          # Default to running things in the system context.
-          @context = :system
-
-          # Extra environment vars to add to base set.
-          @environment = {}
-
-          # Register the ExecGroup when running in parallel
-          @exec_group = nil
-        end
-
-        def context=(new_context)
-          unless [:system, :module, :pwd].include?(new_context)
-            raise ArgumentError, _("Expected execution context to be :system or :module but got '%{context}'.") % { context: new_context }
-          end
-
-          @context = new_context
-        end
-
-        def register_spinner(spinner, opts = {})
-          return unless PDK::CLI::Util.interactive?
-          @success_message = opts.delete(:success)
-          @failure_message = opts.delete(:failure)
-
-          @spinner = spinner
-        end
-
-        def add_spinner(message, opts = {})
-          return unless PDK::CLI::Util.interactive?
-          @success_message = opts.delete(:success)
-          @failure_message = opts.delete(:failure)
-
-          @spinner = TTY::Spinner.new("[:spinner] #{message}", opts.merge(PDK::CLI::Util.spinner_opts_for_platform))
-        end
-
-        def update_environment(additional_env)
-          @environment.merge!(additional_env)
-        end
-
-        def execute!
-          # Start spinning if configured.
-          @spinner.auto_spin if @spinner
-
-          # Add custom env vars.
-          @environment.each do |k, v|
-            @process.environment[k] = v
-          end
-
-          @process.environment['BUNDLE_IGNORE_CONFIG'] = '1'
-
-          if [:module, :pwd].include?(context)
-            @process.environment['GEM_HOME'] = PDK::Util::RubyVersion.gem_home
-            @process.environment['GEM_PATH'] = PDK::Util::RubyVersion.gem_path
-
-            # Make sure invocation of Ruby prefers our private installation.
-            package_binpath = PDK::Util.package_install? ? File.join(PDK::Util.pdk_package_basedir, 'bin') : nil
-            @process.environment['PATH'] = [
-              PDK::Util::RubyVersion.bin_path,
-              File.join(@process.environment['GEM_HOME'], 'bin'),
-              PDK::Util::RubyVersion.gem_paths_raw.map { |gem_path| File.join(gem_path, 'bin') },
-              package_binpath,
-              PDK::Util.package_install? ? PDK::Util::Git.git_paths : nil,
-              ENV['PATH'],
-            ].compact.flatten.join(File::PATH_SEPARATOR)
-
-            mod_root = PDK::Util.module_root
-
-            unless mod_root
-              @spinner.error if @spinner
-
-              raise PDK::CLI::FatalError, _('Current working directory is not part of a module. (No metadata.json was found.)')
-            end
-
-            if Dir.pwd == mod_root || context == :pwd
-              run_process_in_clean_env!
-            else
-              Dir.chdir(mod_root) do
-                run_process_in_clean_env!
-              end
-            end
-          else
-            run_process!
-          end
-
-          # Stop spinning when done (if configured).
-          stop_spinner
-
-          @stdout.rewind
-          @stderr.rewind
-
-          process_data = {
-            stdout: @stdout.read,
-            stderr: @stderr.read,
-            exit_code: @process.exit_code,
-            duration: @duration,
-          }
-
-          return process_data
-        ensure
-          @stdout.close
-          @stderr.close
-        end
-
-        protected
-
-        def stop_spinner
-          return unless @spinner
-
-          # If it is a single spinner, we need to send it a success/error message
-          if @process.exit_code.zero?
-            @spinner.success(@success_message || '')
-          else
-            @spinner.error(@failure_message || '')
-          end
-        end
-
-        def run_process_in_clean_env!
-          ::Bundler.with_clean_env do
-            run_process!
-          end
-        end
-
-        def run_process!
-          command_string = argv.join(' ')
-
-          PDK.logger.debug(_("Executing '%{command}'") % { command: command_string })
-
-          if context == :module
-            PDK.logger.debug(_('Command environment:'))
-            @process.environment.each do |var, val|
-              PDK.logger.debug("  #{var}: #{val}")
-            end
-          end
-
-          start_time = Time.now
-
-          begin
-            @process.start
-          rescue ChildProcess::LaunchError => e
-            raise PDK::CLI::FatalError, _("Failed to execute '%{command}': %{message}") % { command: command_string, message: e.message }
-          end
-
-          if timeout
-            begin
-              @process.poll_for_exit(timeout)
-            rescue ChildProcess::TimeoutError
-              @process.stop # tries increasingly harsher methods to kill the process.
-            end
-          else
-            # Wait indfinitely if no timeout set.
-            @process.wait
-          end
-
-          @duration = Time.now - start_time
-
-          PDK.logger.debug(_("Execution of '%{command}' complete (duration: %{duration_in_seconds}s; exit code: %{exit_code})") %
-            { command: command_string, duration_in_seconds: @duration, exit_code: @process.exit_code })
-        end
-      end
     end
   end
 end

data/lib/pdk/cli/exec/command.rb

@@ -0,0 +1,238 @@
+module PDK
+  module CLI
+    module Exec
+      class Command
+        attr_reader :argv
+        attr_reader :context
+        attr_accessor :timeout
+        attr_accessor :environment
+        attr_writer :exec_group
+
+        def initialize(*argv)
+          require 'childprocess'
+          require 'tempfile'
+
+          @argv = argv
+
+          @process = ChildProcess.build(*@argv)
+          @process.leader = true
+
+          @stdout = Tempfile.new('stdout').tap { |io| io.sync = true }
+          @stderr = Tempfile.new('stderr').tap { |io| io.sync = true }
+
+          @process.io.stdout = @stdout
+          @process.io.stderr = @stderr
+
+          # Default to running things in the system context.
+          @context = :system
+
+          # Extra environment vars to add to base set.
+          @environment = {}
+
+          # Register the ExecGroup when running in parallel
+          @exec_group = nil
+        end
+
+        def context=(new_context)
+          unless [:system, :module, :pwd].include?(new_context)
+            raise ArgumentError, _("Expected execution context to be :system or :module but got '%{context}'.") % { context: new_context }
+          end
+
+          @context = new_context
+        end
+
+        def register_spinner(spinner, opts = {})
+          require 'pdk/cli/util'
+
+          return unless PDK::CLI::Util.interactive?
+          @success_message = opts.delete(:success)
+          @failure_message = opts.delete(:failure)
+
+          @spinner = spinner
+        end
+
+        def add_spinner(message, opts = {})
+          require 'pdk/cli/util'
+
+          return unless PDK::CLI::Util.interactive?
+          @success_message = opts.delete(:success)
+          @failure_message = opts.delete(:failure)
+
+          require 'pdk/cli/util/spinner'
+
+          @spinner = TTY::Spinner.new("[:spinner] #{message}", opts.merge(PDK::CLI::Util.spinner_opts_for_platform))
+        end
+
+        def update_environment(additional_env)
+          @environment.merge!(additional_env)
+        end
+
+        def execute!
+          # Start spinning if configured.
+          @spinner.auto_spin if @spinner
+
+          # Set env for child process
+          resolved_env_for_command.each { |k, v| @process.environment[k] = v }
+
+          if [:module, :pwd].include?(context)
+            require 'pdk/util'
+            mod_root = PDK::Util.module_root
+
+            unless mod_root
+              @spinner.error if @spinner
+
+              raise PDK::CLI::FatalError, _('Current working directory is not part of a module. (No metadata.json was found.)')
+            end
+
+            if Dir.pwd == mod_root || context == :pwd
+              run_process_in_clean_env!
+            else
+              Dir.chdir(mod_root) do
+                run_process_in_clean_env!
+              end
+            end
+          else
+            run_process!
+          end
+
+          # Stop spinning when done (if configured).
+          stop_spinner
+
+          @stdout.rewind
+          @stderr.rewind
+
+          process_data = {
+            stdout: @stdout.read,
+            stderr: @stderr.read,
+            exit_code: @process.exit_code,
+            duration: @duration,
+          }
+
+          PDK.logger.debug _('STDOUT: %{output}') % {
+            output: process_data[:stdout].empty? ? 'N/A' : "\n#{process_data[:stdout]}",
+          }
+          PDK.logger.debug _('STDERR: %{output}') % {
+            output: process_data[:stderr].empty? ? 'N/A' : "\n#{process_data[:stderr]}",
+          }
+
+          process_data
+        ensure
+          @stdout.close
+          @stderr.close
+        end
+
+        protected
+
+        def warn_on_legacy_env_vars!
+          if ENV['PUPPET_GEM_VERSION']
+            PDK.logger.warn_once _(
+              'PUPPET_GEM_VERSION is not supported by PDK. ' \
+              'Use the --puppet-version option on your PDK command ' \
+              'or set the PDK_PUPPET_VERSION environment variable instead',
+            )
+          end
+
+          %w[FACTER HIERA].each do |gem|
+            if ENV["#{gem}_GEM_VERSION"]
+              PDK.logger.warn_once _('%{varname} is not supported by PDK.') % { varname: "#{gem}_GEM_VERSION" }
+            end
+          end
+        end
+
+        def resolved_env_for_command
+          warn_on_legacy_env_vars!
+
+          resolved_env = {}
+
+          resolved_env['TERM'] = ENV['TERM']
+          resolved_env['PUPPET_GEM_VERSION'] = nil
+          resolved_env['FACTER_GEM_VERSION'] = nil
+          resolved_env['HIERA_GEM_VERSION'] = nil
+
+          resolved_env.merge!(@environment.dup)
+
+          resolved_env['BUNDLE_IGNORE_CONFIG'] = '1'
+
+          if [:module, :pwd].include?(context)
+            require 'pdk/util'
+            require 'pdk/util/git'
+            require 'pdk/util/ruby_version'
+
+            resolved_env['GEM_HOME'] = PDK::Util::RubyVersion.gem_home
+            resolved_env['GEM_PATH'] = PDK::Util::RubyVersion.gem_path
+
+            # Make sure invocation of Ruby prefers our private installation.
+            package_binpath = PDK::Util.package_install? ? File.join(PDK::Util.pdk_package_basedir, 'bin') : nil
+
+            resolved_env['PATH'] = [
+              PDK::Util::RubyVersion.bin_path,
+              File.join(resolved_env['GEM_HOME'], 'bin'),
+              PDK::Util::RubyVersion.gem_paths_raw.map { |gem_path| File.join(gem_path, 'bin') },
+              package_binpath,
+              PDK::Util.package_install? ? PDK::Util::Git.git_paths : nil,
+              ENV['PATH'],
+            ].compact.flatten.join(File::PATH_SEPARATOR)
+          end
+
+          resolved_env
+        end
+
+        def stop_spinner
+          return unless @spinner
+
+          # If it is a single spinner, we need to send it a success/error message
+          if @process.exit_code.zero?
+            @spinner.success(@success_message || '')
+          else
+            @spinner.error(@failure_message || '')
+          end
+        end
+
+        def run_process_in_clean_env!
+          require 'bundler'
+
+          ::Bundler.with_clean_env do
+            run_process!
+          end
+        end
+
+        def run_process!
+          command_string = argv.join(' ')
+
+          PDK.logger.debug(_("Executing '%{command}'") % { command: command_string })
+
+          if context == :module
+            PDK.logger.debug(_('Command environment:'))
+            @process.environment.each do |var, val|
+              PDK.logger.debug("  #{var}: #{val}")
+            end
+          end
+
+          start_time = Time.now
+
+          begin
+            @process.start
+          rescue ChildProcess::LaunchError => e
+            raise PDK::CLI::FatalError, _("Failed to execute '%{command}': %{message}") % { command: command_string, message: e.message }
+          end
+
+          if timeout
+            begin
+              @process.poll_for_exit(timeout)
+            rescue ChildProcess::TimeoutError
+              @process.stop # tries increasingly harsher methods to kill the process.
+            end
+          else
+            # Wait indfinitely if no timeout set.
+            @process.wait
+          end
+
+          @duration = Time.now - start_time
+
+          PDK.logger.debug(_("Execution of '%{command}' complete (duration: %{duration_in_seconds}s; exit code: %{exit_code})") %
+            { command: command_string, duration_in_seconds: @duration, exit_code: @process.exit_code })
+        end
+      end
+    end
+  end
+end