pdk 1.9.0 → 3.2.0

data/lib/pdk/cli/exec.rb

@@ -1,28 +1,39 @@
-require 'bundler'
-require 'childprocess'
-require 'tempfile'
-require 'tty-spinner'
-require 'tty-which'
-
-require 'pdk/util'
-require 'pdk/util/git'
-require 'pdk/util/ruby_version'
+require 'pdk'
 
 module PDK
   module CLI
     module Exec
+      autoload :Command, 'pdk/cli/exec/command'
+      autoload :InteractiveCommand, 'pdk/cli/exec/interactive_command'
+
       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)
-        message = _('Unable to find `%{name}`. Check that it is installed and try again.') % {
-          name: bin_name,
-        }
+        require 'tty-which'
+
+        message = format('Unable to find `%{name}`. Check that it is installed and try again.', name: bin_name)
 
         raise PDK::CLI::FatalError, message unless TTY::Which.exist?(bin_path)
       end
@@ -34,6 +45,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,206 +54,24 @@ 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,
-          })
+          PDK.logger.debug(format("PDK package installation not found. Trying '%{fallback}' from the system PATH instead.", fallback: fallback))
           return fallback
         end
 
         vendored_bin_full_path = File.join(PDK::Util.pdk_package_basedir, vendored_bin_path)
 
-        unless File.exist?(vendored_bin_full_path)
-          PDK.logger.debug(_("Could not find '%{vendored_bin}' in PDK package. Trying '%{fallback}' from the system PATH instead.") % {
-            fallback: fallback,
-            vendored_bin: vendored_bin_full_path,
-          })
+        require 'pdk/util/filesystem'
+        unless PDK::Util::Filesystem.exist?(vendored_bin_full_path)
+          PDK.logger.debug(format("Could not find '%{vendored_bin}' in PDK package. Trying '%{fallback}' from the system PATH instead.", fallback: fallback, vendored_bin: vendored_bin_full_path))
           return fallback
         end
 
-        PDK.logger.debug(_("Using '%{vendored_bin}' from PDK package.") % { vendored_bin: vendored_bin_full_path })
+        PDK.logger.debug format("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,
-              ENV['PATH'],
-              PDK::Util.package_install? ? PDK::Util::Git.git_paths : nil,
-            ].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_group.rb

@@ -1,66 +1,102 @@
-require 'tty-spinner'
-require 'tty-which'
-
-require 'pdk/util'
+require 'pdk'
 
 module PDK
   module CLI
     class ExecGroup
-      def initialize(message, opts = {})
-        @options = opts.merge(PDK::CLI::Util.spinner_opts_for_platform)
-
-        if PDK::CLI::Util.interactive?
-          @spinner = if parallel?
-                       TTY::Spinner::Multi.new("[:spinner] #{message}", @options)
-                     else
-                       TTY::Spinner.new("[:spinner] #{message}", @options)
-                     end
-          @spinner.auto_spin
+      # Execution Group (ExecGroup) factory.
+      #
+      # @param message [String] A name or message for this group. Provided for backwards compatibility during refactor
+      #
+      # @param create_options [Hash] A hash options used during creation of the ExecGroup.  This are not passed to the new object
+      # @option create_options :parallel [Boolean] Whether the group should be executed in Parallel (True) or Serial (False)
+      #
+      # @param group_opts [Hash] A hash of options used to configure the execution group.  Provided for backwards compatibility during refactor
+      #
+      # @return [ExecGroup]
+      def self.create(message, create_options = {}, group_opts = {})
+        if create_options[:parallel]
+          ParallelExecGroup.new(message, group_opts)
+        else
+          SerialExecGroup.new(message, group_opts)
         end
-
-        @threads_or_procs = []
-        @exit_codes = []
       end
 
-      def parallel?
-        @options[:parallel].nil? ? true : @options[:parallel]
+      # Base class for an Exection Group
+      #
+      # @param message [String] A name or message for this group. Provided for backwards compatibility during refactor
+      #
+      # @param opts [Hash] A hash of options used to configure the execution group. Provided for backwards compatibility during refactor
+      #
+      # @api private
+      def initialize(_message, opts = {})
+        @options = opts
       end
 
+      # Register something to execute as a group
+      #
+      # @param block [Block] A block of ruby to execute
+      #
+      # @api private
       def register(&block)
-        raise PDK::CLI::FatalError, 'No block registered' unless block_given?
+        raise PDK::CLI::FatalError, 'No block registered' unless block
+      end
+
+      # The return code of running all registered blocks
+      #
+      # @return [int] The highest exit code from the blocks
+      #
+      # @abstract
+      def exit_code; end
+    end
 
-        @threads_or_procs << if parallel?
-                               Thread.new do
-                                 GettextSetup.initialize(File.absolute_path('../../../locales', File.dirname(__FILE__)))
-                                 GettextSetup.negotiate_locale!(GettextSetup.candidate_locales)
-                                 @exit_codes << yield
-                               end
-                             else
-                               block
-                             end
+    # Executes registered blocks in serial
+    #
+    # @see PDK::CLI::ExecGroup
+    class SerialExecGroup < ExecGroup
+      def initialize(message, opts = {})
+        super(message, opts)
+        @procs = []
       end
 
-      def add_spinner(message, opts = {})
-        return unless PDK::CLI::Util.interactive?
-        @spinner.register("[:spinner] #{message}", @options.merge(opts).merge(PDK::CLI::Util.spinner_opts_for_platform))
+      def register(&block)
+        super(&block)
+
+        @procs << block
       end
 
       def exit_code
-        if parallel?
-          @threads_or_procs.each(&:join)
-        else
-          @exit_codes = @threads_or_procs.map(&:call)
-        end
+        exit_codes = @procs.map(&:call)
+        exit_codes.nil? ? 0 : exit_codes.max
+      end
+    end
+
+    # Executes registered blocks in parallel using Ruby threads
+    #
+    # @see PDK::CLI::ExecGroup
+    class ParallelExecGroup < ExecGroup
+      def initialize(message, opts = {})
+        super(message, opts)
+        @threads = []
+        @exit_codes = []
+      end
 
-        exit_code = @exit_codes.max
+      def register(&block)
+        super(&block)
 
-        if exit_code.zero? && @spinner
-          @spinner.success
-        elsif @spinner
-          @spinner.error
+        # TODO: This executes the thread immediately, whereas the SerialExecGroup executes only when exit_code
+        # is called.  Need to change this so it uses a kind of ThreadPool to limit to number on concurrent jobs
+        # and only starts on the call to exit_code
+        # e.g. max_threads = No. of CPUs
+        @threads << Thread.new do
+          @exit_codes << yield
         end
+      end
+
+      def exit_code
+        @threads.each(&:join)
+        return 0 if @exit_codes.empty?
 
-        exit_code
+        @exit_codes.max
       end
     end
   end

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

@@ -0,0 +1,26 @@
+module PDK
+  module CLI
+    @get_config_cmd = @get_cmd.define_command do
+      name 'config'
+      usage 'config [name]'
+      summary 'Retrieve the configuration for <name>. If not specified, retrieve all configuration settings'
+
+      run do |_opts, args, _cmd|
+        item_name = args[0]
+        resolved_config = PDK.config.resolve(item_name)
+        # If the user wanted to know a setting but it doesn't exist, raise an error
+        if resolved_config.empty? && !item_name.nil?
+          PDK.logger.error(format("Configuration item '%{name}' does not exist", name: item_name))
+          exit 1
+        end
+        # If the user requested a setting and it's the only one resolved, then just output the value
+        if resolved_config.count == 1 && resolved_config.keys[0] == item_name
+          puts format('%{value}', value: resolved_config.values[0])
+          exit 0
+        end
+        # Otherwise just output everything
+        resolved_config.keys.sort.each { |key| puts format('%{name}=%{value}', name: key, value: resolved_config[key]) }
+      end
+    end
+  end
+end

data/lib/pdk/cli/get.rb

@@ -0,0 +1,22 @@
+module PDK
+  module CLI
+    @get_cmd = @base_cmd.define_command do
+      name 'get'
+      usage 'get [subcommand] [options]'
+      summary 'Retrieve information about the PDK or current project.'
+      default_subcommand 'help'
+
+      run do |_opts, args, _cmd|
+        if args == ['help']
+          PDK::CLI.run(['get', '--help'])
+          exit 0
+        end
+
+        PDK::CLI.run(['get', 'help']) if args.empty?
+      end
+    end
+    @get_cmd.add_command Cri::Command.new_basic_help
+  end
+end
+
+require 'pdk/cli/get/config'

data/lib/pdk/cli/new/class.rb

@@ -1,32 +1,30 @@
-module PDK::CLI
-  @new_class_cmd = @new_cmd.define_command do
-    name 'class'
-    usage _('class [options] <class_name>')
-    summary _('Create a new class named <class_name> using given options')
+module PDK
+  module CLI
+    @new_class_cmd = @new_cmd.define_command do
+      name 'class'
+      usage 'class [options] <class_name>'
+      summary 'Create a new class named <class_name> using given options'
 
-    PDK::CLI.template_url_option(self)
+      run do |opts, args, _cmd|
+        require 'pdk/generate/puppet_class'
 
-    run do |opts, args, _cmd|
-      require 'pdk/generate/puppet_class'
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Classes can only be created from inside a valid module directory.',
+          log_level: :info
+        )
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('Classes can only be created from inside a valid module directory.'),
-        log_level: :info,
-      )
+        class_name = args[0]
 
-      class_name = args[0]
-      module_dir = Dir.pwd
+        if class_name.nil? || class_name.empty?
+          puts command.help
+          exit 1
+        end
 
-      if class_name.nil? || class_name.empty?
-        puts command.help
-        exit 1
-      end
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid class name", name: class_name) unless Util::OptionValidator.valid_class_name?(class_name)
 
-      unless Util::OptionValidator.valid_class_name?(class_name)
-        raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid class name") % { name: class_name }
+        updates = PDK::Generate::PuppetClass.new(PDK.context, class_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
       end
-
-      PDK::Generate::PuppetClass.new(module_dir, class_name, opts).run
     end
   end
 end

data/lib/pdk/cli/new/defined_type.rb

@@ -1,30 +1,30 @@
-module PDK::CLI
-  @new_define_cmd = @new_cmd.define_command do
-    name 'defined_type'
-    usage _('defined_type [options] <name>')
-    summary _('Create a new defined type named <name> using given options')
+module PDK
+  module CLI
+    @new_define_cmd = @new_cmd.define_command do
+      name 'defined_type'
+      usage 'defined_type [options] <name>'
+      summary 'Create a new defined type named <name> using given options'
 
-    PDK::CLI.template_url_option(self)
+      run do |opts, args, _cmd|
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Defined types can only be created from inside a valid module directory.',
+          log_level: :info
+        )
 
-    run do |opts, args, _cmd|
-      PDK::CLI::Util.ensure_in_module!(
-        message: _('Defined types can only be created from inside a valid module directory.'),
-        log_level: :info,
-      )
+        defined_type_name = args[0]
 
-      defined_type_name = args[0]
-      module_dir = Dir.pwd
+        if defined_type_name.nil? || defined_type_name.empty?
+          puts command.help
+          exit 1
+        end
 
-      if defined_type_name.nil? || defined_type_name.empty?
-        puts command.help
-        exit 1
-      end
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid defined type name", name: defined_type_name) unless Util::OptionValidator.valid_defined_type_name?(defined_type_name)
 
-      unless Util::OptionValidator.valid_defined_type_name?(defined_type_name)
-        raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid defined type name") % { name: defined_type_name }
-      end
+        require 'pdk/generate/defined_type'
 
-      PDK::Generate::DefinedType.new(module_dir, defined_type_name, opts).run
+        updates = PDK::Generate::DefinedType.new(PDK.context, defined_type_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
     end
   end
 end

data/lib/pdk/cli/new/fact.rb

@@ -0,0 +1,27 @@
+module PDK
+  module CLI
+    @new_fact_cmd = @new_cmd.define_command do
+      name 'fact'
+      usage 'fact [options] <name>'
+      summary 'Create a new custom fact named <name> using given options'
+
+      run do |opts, args, _cmd|
+        PDK::CLI::Util.ensure_in_module!
+
+        fact_name = args[0]
+
+        if fact_name.nil? || fact_name.empty?
+          puts command.help
+          exit 1
+        end
+
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid fact name", name: fact_name) unless Util::OptionValidator.valid_fact_name?(fact_name)
+
+        require 'pdk/generate/fact'
+
+        updates = PDK::Generate::Fact.new(PDK.context, fact_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
+    end
+  end
+end

data/lib/pdk/cli/new/function.rb

@@ -0,0 +1,27 @@
+module PDK
+  module CLI
+    @new_function_cmd = @new_cmd.define_command do
+      name 'function'
+      usage 'function [options] <name>'
+      summary 'Create a new function named <name> using given options'
+      option :t, :type, 'The function type, (native or v4)', argument: :required, default: 'native'
+
+      run do |opts, args, _cmd|
+        PDK::CLI::Util.ensure_in_module!
+
+        function_name = args[0]
+
+        if function_name.nil? || function_name.empty?
+          puts command.help
+          exit 1
+        end
+
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid function name", name: function_name) unless Util::OptionValidator.valid_function_name?(function_name)
+
+        require 'pdk/generate/function'
+        updates = PDK::Generate::Function.new(PDK.context, function_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
+    end
+  end
+end