pdk 1.9.0 → 3.2.0

data/lib/pdk/cli.rb

@@ -1,113 +1,160 @@
 require 'cri'
 
+require 'pdk'
 require 'pdk/cli/errors'
-require 'pdk/cli/util'
-require 'pdk/cli/util/command_redirector'
-require 'pdk/cli/util/option_normalizer'
-require 'pdk/cli/util/option_validator'
-require 'pdk/cli/exec_group'
-require 'pdk/generate/module'
-require 'pdk/i18n'
-require 'pdk/logger'
-require 'pdk/report'
-require 'pdk/util/version'
-require 'pdk/util/puppet_version'
-
-module PDK::CLI
-  def self.run(args)
-    @base_cmd.run(args)
-  rescue PDK::CLI::ExitWithError => e
-    PDK.logger.send(e.log_level, e.message)
-
-    exit e.exit_code
-  rescue PDK::CLI::FatalError => e
-    PDK.logger.fatal(e.message) if e.message
-
-    # If FatalError was raised as the result of another exception, send the
-    # details of that exception to the debug log. If there was no cause
-    # (FatalError raised on its own outside a rescue block), send the details
-    # of the FatalError exception to the debug log.
-    cause = e.cause
-    if cause.nil?
-      e.backtrace.each { |line| PDK.logger.debug(line) }
-    else
-      PDK.logger.debug("#{cause.class}: #{cause.message}")
-      cause.backtrace.each { |line| PDK.logger.debug(line) }
-    end
-
-    exit e.exit_code
-  end
 
-  def self.template_url_option(dsl)
-    desc = _('Specifies the URL to the template to use when creating new modules or classes. (default: %{default_url})') % { default_url: PDK::Util.default_template_url }
+module TTY
+  autoload :Prompt, 'tty/prompt'
 
-    dsl.option nil, 'template-url', desc, argument: :required
+  class Prompt
+    autoload :Test, 'tty/prompt/test'
   end
+end
 
-  def self.skip_interview_option(dsl)
-    dsl.option nil, 'skip-interview', _('When specified, skips interactive querying of metadata.')
+module Cri
+  class Command
+    class CriExitException
+      def initialize(is_error:)
+        @is_error = is_error
+      end
+    end
   end
+end
 
-  def self.full_interview_option(dsl)
-    dsl.option nil, 'full-interview', _('When specified, interactive querying of metadata will include all optional questions.')
-  end
+module PDK
+  module CLI
+    autoload :Util, 'pdk/cli/util'
+
+    # Attempt to anonymise the raw ARGV array if the command parsing failed.
+    #
+    # If an item does not start with '-' but is preceeded by an item that does
+    # start with '-', assume that these items are an option/value pair and redact
+    # the value. Any additional values that do not start with '-' that follow an
+    # option/value pair are assumed to be arguments (rather than subcommand
+    # names) and are also redacted.
+    #
+    # @example
+    #   # Where PDK::CLI.args => ['new', 'plan', '--some', 'value', 'plan_name']
+    #
+    #   PDK::CLI.anonymised_args
+    #     => ['new', 'plan', '--some', 'redacted', 'redacted']
+    #
+    # @return Array[String] the command arguments with any identifying values
+    #   redacted.
+    def self.anonymised_args
+      in_args = false
+      @args.map do |arg|
+        if arg.start_with?('-')
+          in_args = true
+          arg
+        else
+          in_args ? 'redacted' : arg
+        end
+      end
+    end
 
-  def self.puppet_version_options(dsl)
-    dsl.option nil, 'puppet-version', _('Puppet version to run tests or validations against.'), argument: :required
-    dsl.option nil, 'pe-version', _('Puppet Enterprise version to run tests or validations against.'), argument: :required
-  end
+    def self.run(args)
+      @args = args
+      @base_cmd.run(args)
+    rescue PDK::CLI::ExitWithError => e
+      PDK.logger.send(e.log_level, e.message)
+
+      exit e.exit_code
+    rescue PDK::CLI::FatalError => e
+      PDK.logger.fatal(e.message) if e.message
+
+      # If FatalError was raised as the result of another exception, send the
+      # details of that exception to the debug log. If there was no cause
+      # (FatalError raised on its own outside a rescue block), send the details
+      # of the FatalError exception to the debug log.
+      cause = e.cause
+      if cause.nil?
+        e.backtrace.each { |line| PDK.logger.debug(line) }
+      else
+        PDK.logger.debug("#{cause.class}: #{cause.message}")
+        cause.backtrace.each { |line| PDK.logger.debug(line) }
+      end
+
+      exit e.exit_code
+    end
 
-  def self.puppet_dev_option(dsl)
-    dsl.option nil,
-               'puppet-dev',
-               _('When specified, PDK will validate or test against the current Puppet source from github.com. To use this option, you must have network access to https://github.com.')
-  end
+    def self.template_url_option(dsl)
+      require 'pdk/util/template_uri'
 
-  @base_cmd = Cri::Command.define do
-    name 'pdk'
-    usage _('pdk command [options]')
-    summary _('Puppet Development Kit')
-    description _('The shortest path to better modules.')
-    default_subcommand 'help'
+      desc = format('Specifies the URL to the template to use when creating new modules or classes. (default: %{default_url})', default_url: PDK::Util::TemplateURI.default_template_uri)
 
-    flag nil, :version, _('Show version of pdk.') do |_, _|
-      puts PDK::Util::Version.version_string
-      exit 0
+      dsl.option nil, 'template-url', desc, argument: :required
     end
 
-    flag :h, :help, _('Show help for this command.') do |_, c|
-      puts c.help
-      exit 0
+    def self.template_ref_option(dsl)
+      dsl.option nil, 'template-ref', 'Specifies the template git branch or tag to use when creating new modules or classes.', argument: :required
     end
 
-    format_desc = _(
-      "Specify desired output format. Valid formats are '%{available_formats}'. " \
-      'You may also specify a file to which the formatted output is sent, ' \
-      "for example: '--format=junit:report.xml'. This option may be specified " \
-      'multiple times if each option specifies a distinct target file.',
-    ) % { available_formats: PDK::Report.formats.join("', '") }
+    def self.skip_interview_option(dsl)
+      dsl.option nil, 'skip-interview', 'When specified, skips interactive querying of metadata.'
+    end
 
-    option :f, :format, format_desc, argument: :required, multiple: true do |values|
-      PDK::CLI::Util::OptionNormalizer.report_formats(values.compact)
+    def self.full_interview_option(dsl)
+      dsl.option nil, 'full-interview', 'When specified, interactive querying of metadata will include all optional questions.'
     end
 
-    flag :d, :debug, _('Enable debug output.') do |_, _|
-      PDK.logger.enable_debug_output
+    def self.puppet_version_options(dsl)
+      dsl.option nil, 'puppet-version', 'Puppet version to run tests or validations against.', argument: :required
+      dsl.option nil, 'pe-version', '(Deprecated) Puppet Enterprise version to run tests or validations against.', argument: :required
     end
 
-    option nil, 'answer-file', _('Path to an answer file.'), argument: :required, hidden: true do |value|
-      PDK.answer_file = value
+    def self.puppet_dev_option(dsl)
+      dsl.option nil,
+                 'puppet-dev',
+                 'When specified, PDK will validate or test against the current Puppet source from github.com. To use this option, you must have network access to https://github.com.'
     end
-  end
 
-  require 'pdk/cli/bundle'
-  require 'pdk/cli/build'
-  require 'pdk/cli/convert'
-  require 'pdk/cli/new'
-  require 'pdk/cli/test'
-  require 'pdk/cli/update'
-  require 'pdk/cli/validate'
-  require 'pdk/cli/module'
+    @base_cmd = Cri::Command.define do
+      name 'pdk'
+      usage 'pdk command [options]'
+      summary 'Puppet Development Kit'
+      description 'The shortest path to better modules.'
+      default_subcommand 'help'
+
+      flag nil, :version, 'Show version of pdk.' do |_, _|
+        puts PDK::Util::Version.version_string
+        exit 0
+      end
+
+      flag :h, :help, 'Show help for this command.' do |_, c|
+        puts c.help
+        exit 0
+      end
+
+      format_desc =
+        "Specify desired output format. Valid formats are '#{PDK::Report.formats.join("', '")}'. " \
+        'You may also specify a file to which the formatted output is sent, ' \
+        "for example: '--format=junit:report.xml'. This option may be specified " \
+        'multiple times if each option specifies a distinct target file.'
+
+      option :f, :format, format_desc, argument: :required, multiple: true do |values|
+        PDK::CLI::Util::OptionNormalizer.report_formats(values.compact)
+      end
+
+      flag :d, :debug, 'Enable debug output.' do |_, _|
+        PDK.logger.enable_debug_output
+      end
+    end
 
-  @base_cmd.add_command Cri::Command.new_basic_help
+    require 'pdk/cli/bundle'
+    require 'pdk/cli/build'
+    require 'pdk/cli/convert'
+    require 'pdk/cli/env'
+    require 'pdk/cli/get'
+    require 'pdk/cli/new'
+    require 'pdk/cli/set'
+    require 'pdk/cli/test'
+    require 'pdk/cli/update'
+    require 'pdk/cli/validate'
+    # require 'pdk/cli/console' Temporarily disabled while we work on the puppet-debugger gem. It will be back soon! (CONT-1154)
+    require 'pdk/cli/release'
+    require 'pdk/cli/remove'
+
+    @base_cmd.add_command Cri::Command.new_basic_help
+  end
 end

data/lib/pdk/config/errors.rb

@@ -0,0 +1,5 @@
+module PDK
+  class Config
+    class LoadError < StandardError; end
+  end
+end

data/lib/pdk/config/ini_file.rb

@@ -0,0 +1,184 @@
+require 'pdk'
+
+module PDK
+  class Config
+    # Represents a configuration file using the INI file format
+    class IniFile < Namespace
+      # Ini Files have very strict valdiation rules which are set in the IniFileSetting class
+      # @see PDK::Config::Namespace.default_setting_class
+      def default_setting_class
+        PDK::Config::IniFileSetting
+      end
+
+      # Parses an IniFile document.
+      #
+      # @see PDK::Config::Namespace.parse_file
+      def parse_file(filename)
+        raise unless block_given?
+
+        data = load_data(filename)
+        return if data.nil? || data.empty?
+
+        ini_file = IniFileImpl.parse(data)
+        ini_file.to_hash.each do |name, value|
+          begin
+            new_setting = PDK::Config::IniFileSetting.new(name, self, value)
+          rescue StandardError
+            # We just ignore invalid initial settings
+            new_setting = PDK::Config::IniFileSetting.new(name, self, nil)
+          end
+
+          yield name, new_setting
+        end
+      end
+
+      # Serializes object data into an INI file string.
+      #
+      # @see PDK::Config::Namespace.serialize_data
+      def serialize_data(data)
+        default_lines = ''
+        lines = ''
+        data.each do |name, value|
+          next if value.nil?
+
+          if value.is_a?(Hash)
+            # Hashes are an INI section
+            lines += "\n[#{name}]\n"
+            value.each do |child_name, child_value|
+              next if child_value.nil?
+
+              lines += "#{child_name} = #{munge_serialized_value(child_value)}\n"
+            end
+          else
+            default_lines += "#{name} = #{munge_serialized_value(value)}\n"
+          end
+        end
+
+        default_lines + lines
+      end
+
+      private
+
+      def munge_serialized_value(value)
+        value = value.to_s unless value.is_a?(String)
+        # Add enclosing quotes if there's a space in the value
+        value = "\"#{value}\"" if value.include?(' ')
+        value
+      end
+
+      # Adapted from https://raw.githubusercontent.com/puppetlabs/puppet/6c257fc7827989c2af2901f974666f0f23611153/lib/puppet/settings/ini_file.rb
+      # rubocop:disable Style/PerlBackrefs
+      # rubocop:disable Style/RedundantSelf
+      # rubocop:disable Style/StringLiterals
+      class IniFileImpl
+        DEFAULT_SECTION_NAME = 'default_section_name'.freeze
+
+        def self.parse(config_fh)
+          config = new([DefaultSection.new])
+          config_fh.each_line do |line|
+            case line.chomp
+            when /^(\s*)\[([[:word:]]+)\](\s*)$/
+              config.append(SectionLine.new($1, $2, $3))
+            when /^(\s*)([[:word:]]+)(\s*=\s*)(.*?)(\s*)$/
+              config.append(SettingLine.new($1, $2, $3, $4, $5))
+            else
+              config.append(Line.new(line))
+            end
+          end
+
+          config
+        end
+
+        def initialize(lines = [])
+          @lines = lines
+        end
+
+        def to_hash
+          result = {}
+
+          current_section_name = nil
+          @lines.each do |line|
+            if line.instance_of?(SectionLine)
+              current_section_name = line.name
+              result[current_section_name] = {}
+            elsif line.instance_of?(SettingLine)
+              if current_section_name.nil?
+                result[line.name] = munge_value(line.value)
+              else
+                result[current_section_name][line.name] = munge_value(line.value)
+              end
+            end
+          end
+
+          result
+        end
+
+        def munge_value(value)
+          value = value.to_s unless value.is_a?(String)
+          # Strip enclosing quotes
+          value = value.slice(1...-1) if value.start_with?('"') && value.end_with?('"')
+          value
+        end
+
+        def append(line)
+          line.previous = @lines.last
+          @lines << line
+        end
+
+        module LineNumber
+          attr_accessor :previous
+
+          def line_number
+            line = 0
+            previous_line = previous
+            while previous_line
+              line += 1
+              previous_line = previous_line.previous
+            end
+            line
+          end
+        end
+
+        Line = Struct.new(:text) do
+          include LineNumber
+
+          def to_s
+            text
+          end
+        end
+
+        SettingLine = Struct.new(:prefix, :name, :infix, :value, :suffix) do
+          include LineNumber
+
+          def to_s
+            "#{prefix}#{name}#{infix}#{value}#{suffix}"
+          end
+
+          def ==(other)
+            super(other) && self.line_number == other.line_number
+          end
+        end
+
+        SectionLine = Struct.new(:prefix, :name, :suffix) do
+          include LineNumber
+
+          def to_s
+            "#{prefix}[#{name}]#{suffix}"
+          end
+        end
+
+        class DefaultSection < SectionLine
+          attr_accessor :write_sectionline
+
+          def initialize
+            @write_sectionline = false
+            super("", DEFAULT_SECTION_NAME, "")
+          end
+        end
+      end
+      # rubocop:enable Style/StringLiterals
+      # rubocop:enable Style/RedundantSelf
+      # rubocop:enable Style/PerlBackrefs
+    end
+  end
+end

data/lib/pdk/config/ini_file_setting.rb

@@ -0,0 +1,35 @@
+require 'pdk'
+
+module PDK
+  class Config
+    class IniFileSetting < PDK::Config::Setting
+      # Initialises the PDK::Config::JSONSchemaSetting object.
+      #
+      # @see PDK::Config::Setting.initialize
+      def initialize(_name, namespace, initial_value = nil)
+        raise 'The IniFileSetting object can only be created within the IniFile Namespace' unless namespace.is_a?(PDK::Config::IniFile)
+
+        super
+        validate!(initial_value) unless initial_value.nil?
+      end
+
+      # Verifies that the new setting value is valid in an Ini File
+      #
+      # @see PDK::Config::Setting.validate!
+      def validate!(value)
+        # We're very restrictive here. Realistically Ini files only have string types
+        return if value.nil? || value.is_a?(String) || value.is_a?(Integer)
+
+        # The only other valid-ish type is a Hash
+        raise ArgumentError, format('The setting %{key} may only be a String or Integer, not %{class}', key: qualified_name, class: value.class) unless value.is_a?(Hash)
+
+        # Any hashes can only have a single String/Integer value
+        value.each do |child_name, child_value|
+          next if child_value.nil? || child_value.is_a?(String) || child_value.is_a?(Integer)
+
+          raise ArgumentError, format('The setting %{key} may only be a String or Integer, not %{class}', key: "#{qualified_name}.#{child_name}", class: child_value.class)
+        end
+      end
+    end
+  end
+end

data/lib/pdk/config/json.rb

@@ -0,0 +1,35 @@
+require 'pdk'
+
+module PDK
+  class Config
+    class JSON < Namespace
+      # Parses a JSON document.
+      #
+      # @see PDK::Config::Namespace.parse_file
+      def parse_file(filename)
+        raise unless block_given?
+
+        data = load_data(filename)
+        return if data.nil? || data.empty?
+
+        require 'json'
+
+        data = ::JSON.parse(data)
+        return if data.nil? || data.empty?
+
+        data.each { |k, v| yield k, PDK::Config::Setting.new(k, self, v) }
+      rescue ::JSON::ParserError => e
+        raise PDK::Config::LoadError, e.message
+      end
+
+      # Serializes object data into a JSON string.
+      #
+      # @see PDK::Config::Namespace.serialize_data
+      def serialize_data(data)
+        require 'json'
+
+        ::JSON.pretty_generate(data)
+      end
+    end
+  end
+end

data/lib/pdk/config/json_schema_namespace.rb

@@ -0,0 +1,137 @@
+require 'pdk'
+
+# Due to https://github.com/ruby-json-schema/json-schema/issues/439
+# Windows file paths "appear" as uri's with no host and a schema of drive letter
+# Also it is not possible to craft a URI with a Windows path due to the URI object
+# always prepending the path with forward slash (`/`) so Windows paths end up looking
+# like '/C:\schema.json', which can not be read.
+# Instead we need to monkey patch the Schema Reader reader to remove the errant forward slash
+require 'json-schema/schema/reader'
+module JSON
+  class Schema
+    class Reader
+      alias original_read_file read_file
+
+      def read_file(pathname)
+        new_pathname = JSON::Util::URI.unescaped_path(pathname.to_s)
+        # Munge the path if it looks like a Windows path e.g. /C:/Windows ...
+        # Note that UNC style paths do not have the same issue (\\host\path)
+        new_pathname.slice!(0) if new_pathname.start_with?('/') && new_pathname[2] == ':'
+        original_read_file(Pathname.new(new_pathname))
+      end
+    end
+  end
+end
+
+require 'json-schema'
+
+module PDK
+  class Config
+    class JSONSchemaNamespace < Namespace
+      # Initialises the PDK::Config::JSONSchemaNamespace object.
+      #
+      # @see PDK::Config::Namespace.initialize
+      #
+      # @option params [String] :schema_file Path to the JSON Schema document
+      def initialize(name = nil, file: nil, parent: nil, persistent_defaults: false, schema_file: nil, &block)
+        super(name, file: file, parent: parent, persistent_defaults: persistent_defaults, &block)
+        @schema_file = schema_file
+        @unmanaged_settings = {}
+      end
+
+      # The JSON Schema for the namespace
+      #
+      # @return [Hash]
+      def schema
+        document_schema.schema
+      end
+
+      # Whether the schema is valid but empty.
+      #
+      # @return [Boolean]
+      def empty_schema?
+        document_schema.schema.empty?
+      end
+
+      # Name of all the top level properties for the schema
+      #
+      # @return [String[]]
+      def schema_property_names
+        return [] if schema['properties'].nil?
+
+        schema['properties'].keys
+      end
+
+      # Extends the to_h namespace method to include unmanaged settings
+      #
+      # @see PDK::Config::Namespace.to_h
+      def to_h
+        # This may seem counter-intuitive but we need to call super first as the settings
+        # may not have been loaded yet, which means @unmanaged_settings will be empty.
+        # We call super first to force any file loading and then merge the unmanaged settings
+        settings_hash = super
+        @unmanaged_settings = {} if @unmanaged_settings.nil?
+        @unmanaged_settings.merge(settings_hash)
+      end
+
+      # Validates a document (Hash table) against the schema
+      #
+      # @return [Boolean]
+      def validate_document!(document)
+        ::JSON::Validator.validate!(schema, document)
+      end
+
+      protected
+
+      # @!attribute [w] unmanaged_settings
+      #   Sets the list of unmanaged settings. For subclass use only
+      #
+      #   @param unmanaged_settings [Hash<String, Object]] A hashtable of all unmanaged settings which will be persisted, but not visible
+      #   @protected
+      attr_writer :unmanaged_settings
+
+      private
+
+      # Override the create_setting method to always fail. This is called
+      # to dyanmically add settings. However as we're using a schema, no
+      # new settings can be created
+      #
+      # @see PDK::Config::Namespace.create_missing_setting
+      #
+      # @private
+      def create_missing_setting(key, _initial_value = nil)
+        raise ArgumentError, "Setting '#{key}' does not exist'"
+      end
+
+      # Create a valid, but empty schema
+      #
+      # @return [JSON::Schema]
+      def create_empty_schema
+        ::JSON::Schema.new({}, 'http://json-schema.org/draft-06/schema#')
+      end
+
+      # Lazily retrieve the JSON schema from disk for this namespace
+      #
+      # @return [JSON::Schema]
+      def document_schema
+        return @document_schema unless @document_schema.nil?
+
+        # Create an empty schema by default.
+        @document_schema = create_empty_schema
+
+        return @document_schema if @schema_file.nil?
+
+        raise PDK::Config::LoadError, format('Unable to open %{file} for reading. File does not exist', file: @schema_file) unless PDK::Util::Filesystem.file?(@schema_file)
+
+        # The schema should not query external URI references, except for the meta-schema. Local files are allowed
+        schema_reader = ::JSON::Schema::Reader.new(
+          accept_file: true,
+          accept_uri: proc { |uri| uri.host.nil? || ['json-schema.org'].include?(uri.host) }
+        )
+        @document_schema = schema_reader.read(Addressable::URI.convert_path(@schema_file))
+      rescue ::JSON::Schema::JsonParseError => e
+        raise PDK::Config::LoadError, format('Unable to open %{file} for reading. JSON Error: %{msg}', file: @schema_file, msg: e.message)
+      end
+    end
+  end
+end