pdk 1.9.0 → 3.2.0

data/lib/pdk/validate/tasks/tasks_name_validator.rb

@@ -0,0 +1,45 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Tasks
+      class TasksNameValidator < InternalRubyValidator
+        INVALID_TASK_MSG = 'Invalid task name. Task names must start with a lowercase letter and can only contain lowercase letters, numbers, and underscores.'.freeze
+
+        def name
+          'task-name'
+        end
+
+        def pattern
+          contextual_pattern('tasks/**/*')
+        end
+
+        def spinner_text
+          format('Checking task names (%{pattern}).', pattern: pattern.join(' '))
+        end
+
+        def validate_target(report, target)
+          task_name = File.basename(target, File.extname(target))
+          if PDK::CLI::Util::OptionValidator.valid_task_name?(task_name)
+            report.add_event(
+              file: target,
+              source: name,
+              state: :passed,
+              severity: 'ok'
+            )
+            0
+          else
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              message: INVALID_TASK_MSG
+            )
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/tasks/tasks_validator_group.rb

@@ -0,0 +1,20 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Tasks
+      class TasksValidatorGroup < ValidatorGroup
+        def name
+          'tasks'
+        end
+
+        def validators
+          [
+            TasksNameValidator,
+            TasksMetadataLintValidator
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/validator.rb

@@ -0,0 +1,120 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    # The base Validator class which all other validators should inherit from.
+    # Acutal validator implementation should inherit from other child abstract classes e.g. ValidatorGroup or ExternalCommandValdiator
+    # @abstract
+    class Validator
+      # A hash of options set when the Validator was instantiated
+      # @return Hash[Object => Object]
+      attr_reader :options
+
+      # The PDK context which the validator will be within.
+      # @return [PDK::Context::AbstractContext] or a subclass PDK::Context::AbstractContext
+      attr_reader :context
+
+      # Whether the validator is prepared to be invoked.
+      # This should only be used for testing
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      attr_reader :prepared
+
+      # Creates a new Validator
+      #
+      # @param context [PDK::Context::AbstractContext] Optional context which specifies where the validation will take place.
+      #                Passing nil will use a None context (PDK::Context::None)
+      # @param options [Hash] Optional configuration for the Validator
+      # @option options :parent_validator [PDK::Validate::Validator] The parent validator for this validator.
+      #   Typically used by ValidatorGroup to create trees of Validators for invocation.
+      def initialize(context = nil, options = {})
+        if context.nil?
+          @context = PDK::Context::None.new(nil)
+        else
+          raise ArgumentError, format('Expected PDK::Context::AbstractContext but got \'%{klass}\' for context', klass: context.class) unless context.is_a?(PDK::Context::AbstractContext)
+
+          @context = context
+        end
+        @options = options.dup.freeze
+        @prepared = false
+      end
+
+      # Whether this Validator can be invoked in this context. By default any Validator can work in any Context
+      # @return [Boolean]
+      # @abstract
+      def valid_in_context?
+        true
+      end
+
+      # Returns the text used for the spinner to display to the user while invoking
+      #
+      # @return [String]
+      #
+      # @abstract
+      def spinner_text; end
+
+      # Whether Spinners should be enabled for this validator
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      # :nocov: .interactive? is tested elsewhere
+      def spinners_enabled?
+        PDK::CLI::Util.interactive?
+      end
+      # :nocov:
+
+      # The TTY Spinner for this Validator. Returns nil if spinners are disabled for this validator
+      #
+      # @return [TTY::Spinner, nil]
+      #
+      # @api private
+      # @abstract
+      def spinner; end
+
+      # Start the spinner if it exists
+      # @api private
+      def start_spinner
+        spinner&.auto_spin
+        nil
+      end
+
+      # Stop the spinner if it exists
+      # @api private
+      def stop_spinner(success)
+        return if spinner.nil?
+
+        success ? spinner.success : spinner.error
+        nil
+      end
+
+      # Name of the Validator
+      #
+      # @return [String]
+      #
+      # @abstract
+      def name; end
+
+      # Once off tasks to run prior to invoking
+      #
+      # @api private
+      #
+      # @abstract
+      def prepare_invoke!
+        @prepared = true
+      end
+
+      # Invokes the validator and returns the exit code
+      #
+      # @param report [PDK::Report] Accumulator of events during the invokation of this validator
+      #   and potential child validators
+      # @abstract
+      def invoke(_report)
+        prepare_invoke!
+        0
+      end
+    end
+  end
+end

data/lib/pdk/validate/validator_group.rb

@@ -0,0 +1,107 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    # The base class which should be used by meta-validators, that is, this group executes other validators
+    #
+    # At a minimum, the `name` and `validators` methods should be overridden in the child class
+    #
+    # An example concrete implementation could look like:
+    #
+    # module PDK
+    #   module Validate
+    #     module Tasks
+    #       class TasksValidatorGroup < ValidatorGroup
+    #         def name
+    #           'tasks'
+    #         end
+    #
+    #         def validators
+    #           [
+    #             TasksNameValidator,
+    #             TasksMetadataLintValidator,
+    #           ].freeze
+    #         end
+    #       end
+    #     end
+    #   end
+    # end
+    #
+    # @see PDK::Validate::Validator
+    # @abstract
+    class ValidatorGroup < Validator
+      # @see PDK::Validate::Validator.spinner_text
+      def spinner_text
+        format('Running %{name} validators ...', name: name)
+      end
+
+      # @see PDK::Validate::Validator.spinner
+      def spinner
+        return nil unless spinners_enabled?
+        return @spinner unless @spinner.nil?
+
+        require 'pdk/cli/util/spinner'
+
+        @spinner = TTY::Spinner::Multi.new("[:spinner] #{spinner_text}", PDK::CLI::Util.spinner_opts_for_platform)
+
+        # Register the child spinners
+        validator_instances.each do |instance|
+          next if instance.spinner.nil?
+
+          @spinner.register(instance.spinner)
+        end
+
+        @spinner
+      end
+
+      # Can be overridden by child classes to do their own preparation tasks.
+      # Typically this is not required by a meta-validator though.
+      #
+      # @see PDK::Validate::Validator.prepare_invoke!
+      def prepare_invoke!
+        return if @prepared
+
+        super
+
+        # Force the spinner to be registered etc.
+        spinner
+
+        # Prepare child validators
+        validator_instances.each(&:prepare_invoke!)
+        nil
+      end
+
+      # A list of Validator classes that this group will run
+      # @return Array[Class] An array of Validator classes (or objects that subclass to it) that this group will execute
+      # @abstract
+      def validators
+        []
+      end
+
+      # @see PDK::Validate::Validator.invoke
+      def invoke(report)
+        exit_code = 0
+
+        prepare_invoke!
+        start_spinner
+
+        validator_instances.each do |instance|
+          exit_code = instance.invoke(report)
+          break if exit_code != 0
+        end
+
+        stop_spinner(exit_code.zero?)
+
+        exit_code
+      end
+
+      # The instanitated PDK::Validator::Validator classes from the `validators` array
+      # @return Array[PDK::Validator::Validator]
+      # @api private
+      def validator_instances
+        @validator_instances ||= validators.map { |klass| klass.new(context, options.merge(parent_validator: self)) }
+                                           .select(&:valid_in_context?)
+      end
+    end
+  end
+end

data/lib/pdk/validate/yaml/yaml_syntax_validator.rb

@@ -0,0 +1,86 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module YAML
+      class YAMLSyntaxValidator < InternalRubyValidator
+        YAML_ALLOWLISTED_CLASSES = [Symbol].freeze
+
+        def ignore_dotfiles
+          false
+        end
+
+        def name
+          'yaml-syntax'
+        end
+
+        def pattern
+          [
+            '**/*.yaml',
+            '**/*.yml'
+          ].tap do |pat|
+            if context.is_a?(PDK::Context::ControlRepo)
+              pat.push(
+                '**/*.eyaml',
+                '**/*.eyml'
+              )
+            else
+              pat
+            end
+          end
+        end
+
+        def spinner_text
+          format('Checking YAML syntax (%{patterns}).', patterns: pattern.join(' '))
+        end
+
+        def validate_target(report, target)
+          return 0 unless PDK::Util::Filesystem.file?(target)
+
+          unless PDK::Util::Filesystem.readable?(target)
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              message: 'Could not be read.'
+            )
+            return 1
+          end
+
+          begin
+            ::YAML.safe_load(PDK::Util::Filesystem.read_file(target), permitted_classes: YAML_ALLOWLISTED_CLASSES, permitted_symbols: [], aliases: true)
+
+            report.add_event(
+              file: target,
+              source: name,
+              state: :passed,
+              severity: 'ok'
+            )
+            0
+          rescue Psych::SyntaxError => e
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              line: e.line,
+              column: e.column,
+              message: format('%{problem} %{context}', problem: e.problem, context: e.context)
+            )
+            1
+          rescue Psych::DisallowedClass => e
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              message: format('Unsupported class: %{message}', message: e.message)
+            )
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/yaml/yaml_validator_group.rb

@@ -0,0 +1,19 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module YAML
+      class YAMLValidatorGroup < ValidatorGroup
+        def name
+          'yaml'
+        end
+
+        def validators
+          [
+            YAMLSyntaxValidator
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate.rb

@@ -1,19 +1,93 @@
-require 'pdk/validate/metadata_validator'
-require 'pdk/validate/puppet_validator'
-require 'pdk/validate/ruby_validator'
-require 'pdk/validate/tasks_validator'
-require 'pdk/validate/yaml_validator'
+require 'pdk'
 
 module PDK
   module Validate
+    autoload :ExternalCommandValidator, 'pdk/validate/external_command_validator'
+    autoload :InternalRubyValidator, 'pdk/validate/internal_ruby_validator'
+    autoload :InvokableValidator, 'pdk/validate/invokable_validator'
+    autoload :Validator, 'pdk/validate/validator'
+    autoload :ValidatorGroup, 'pdk/validate/validator_group'
+
+    module ControlRepo
+      autoload :ControlRepoValidatorGroup, 'pdk/validate/control_repo/control_repo_validator_group'
+      autoload :EnvironmentConfValidator, 'pdk/validate/control_repo/environment_conf_validator'
+    end
+
+    module Metadata
+      autoload :MetadataJSONLintValidator, 'pdk/validate/metadata/metadata_json_lint_validator'
+      autoload :MetadataSyntaxValidator, 'pdk/validate/metadata/metadata_syntax_validator'
+      autoload :MetadataValidatorGroup, 'pdk/validate/metadata/metadata_validator_group'
+    end
+
+    module Puppet
+      autoload :PuppetEPPValidator, 'pdk/validate/puppet/puppet_epp_validator'
+      autoload :PuppetLintValidator, 'pdk/validate/puppet/puppet_lint_validator'
+      autoload :PuppetSyntaxValidator, 'pdk/validate/puppet/puppet_syntax_validator'
+      autoload :PuppetPlanSyntaxValidator, 'pdk/validate/puppet/puppet_plan_syntax_validator'
+      autoload :PuppetValidatorGroup, 'pdk/validate/puppet/puppet_validator_group'
+    end
+
+    module Ruby
+      autoload :RubyRubocopValidator, 'pdk/validate/ruby/ruby_rubocop_validator'
+      autoload :RubyValidatorGroup, 'pdk/validate/ruby/ruby_validator_group'
+    end
+
+    module Tasks
+      autoload :TasksMetadataLintValidator, 'pdk/validate/tasks/tasks_metadata_lint_validator'
+      autoload :TasksNameValidator, 'pdk/validate/tasks/tasks_name_validator'
+      autoload :TasksValidatorGroup, 'pdk/validate/tasks/tasks_validator_group'
+    end
+
+    module YAML
+      autoload :YAMLSyntaxValidator, 'pdk/validate/yaml/yaml_syntax_validator'
+      autoload :YAMLValidatorGroup, 'pdk/validate/yaml/yaml_validator_group'
+    end
+
     def self.validators
-      @validators ||= [
-        MetadataValidator,
-        YAMLValidator,
-        PuppetValidator,
-        RubyValidator,
-        TasksValidator,
-      ].freeze
+      validator_hash.values
+    end
+
+    def self.validator_names
+      validator_hash.keys
+    end
+
+    # @api private
+    def self.validator_hash
+      # TODO: This isn't the most performant... But with only 6 items, it's fine
+      @validator_hash ||= [
+        ControlRepo::ControlRepoValidatorGroup,
+        Metadata::MetadataValidatorGroup,
+        Puppet::PuppetValidatorGroup,
+        Ruby::RubyValidatorGroup,
+        Tasks::TasksValidatorGroup,
+        YAML::YAMLValidatorGroup
+      ].to_h { |klass| [klass.new.name, klass] }.freeze
+    end
+
+    def self.invoke_validators_by_name(context, names, parallel = false, options = {})
+      instances = names.select { |name| validator_names.include?(name) }
+                       .map { |name| validator_hash[name].new(context, options) }
+                       .select(&:valid_in_context?)
+                       .each(&:prepare_invoke!)
+      report = PDK::Report.new
+
+      # Nothing to validate then nothing to do.
+      return [0, report] if instances.empty?
+
+      require 'pdk/cli/exec_group'
+      exec_group = PDK::CLI::ExecGroup.create(
+        format('Validating module using %{num_of_threads} threads', num_of_threads: instances.count),
+        { parallel: parallel },
+        options
+      )
+
+      instances.each do |validator|
+        exec_group.register do
+          validator.invoke(report)
+        end
+      end
+
+      [exec_group.exit_code, report]
     end
 
     class ParseOutputError < StandardError; end

data/lib/pdk/version.rb

@@ -1,4 +1,4 @@
 module PDK
-  VERSION = '1.9.0'.freeze
-  TEMPLATE_REF = VERSION
+  VERSION = '3.2.0'.freeze
+  TEMPLATE_REF = '3.2.0'.freeze
 end

data/lib/pdk.rb

@@ -1,10 +1,60 @@
-require 'pdk/answer_file'
-require 'pdk/generate'
-require 'pdk/i18n'
-require 'pdk/logger'
-require 'pdk/report'
-require 'pdk/template_file'
-require 'pdk/validate'
-require 'pdk/version'
-
-module PDK; end
+module PDK
+  autoload :AnswerFile, 'pdk/answer_file'
+  autoload :Bolt, 'pdk/bolt'
+  autoload :Config, 'pdk/config'
+  autoload :Context, 'pdk/context'
+  autoload :ControlRepo, 'pdk/control_repo'
+  autoload :Generate, 'pdk/generate'
+  autoload :Logger, 'pdk/logger'
+  autoload :Module, 'pdk/module'
+  autoload :Report, 'pdk/report'
+  autoload :Template, 'pdk/template'
+  autoload :TEMPLATE_REF, 'pdk/version'
+  autoload :Util, 'pdk/util'
+  autoload :Validate, 'pdk/validate'
+  autoload :VERSION, 'pdk/version'
+
+  # TODO: Refactor backend code to not raise CLI errors or use CLI util
+  #       methods.
+  module CLI
+    autoload :ExitWithError, 'pdk/cli/errors'
+    autoload :FatalError, 'pdk/cli/errors'
+    autoload :Util, 'pdk/cli/util'
+    autoload :Exec, 'pdk/cli/exec'
+    autoload :ExecGroup, 'pdk/cli/exec_group'
+  end
+
+  module Test
+    autoload :Unit, 'pdk/tests/unit'
+  end
+
+  def self.logger
+    @logger ||= PDK::Logger.new
+  end
+
+  def self.config
+    return @config unless @config.nil?
+
+    options = {}
+    options['user.module_defaults.path'] = PDK::Util::Env['PDK_ANSWER_FILE'] unless PDK::Util::Env['PDK_ANSWER_FILE'].nil?
+    @config = PDK::Config.new(options)
+  end
+
+  def self.context
+    @context ||= PDK::Context.create(Dir.pwd)
+  end
+
+  def self.available_feature_flags
+    @available_feature_flags ||= ['controlrepo'].freeze
+  end
+
+  def self.requested_feature_flags
+    @requested_feature_flags ||= (PDK::Util::Env['PDK_FEATURE_FLAGS'] || '').split(',').map(&:strip)
+  end
+
+  def self.feature_flag?(flagname)
+    return false unless available_feature_flags.include?(flagname)
+
+    requested_feature_flags.include?(flagname)
+  end
+end