pdk 1.16.0 → 2.1.0

data/lib/pdk/validate/puppet/puppet_validator_group.rb

@@ -0,0 +1,21 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Puppet
+      class PuppetValidatorGroup < ValidatorGroup
+        def name
+          'puppet'
+        end
+
+        def validators
+          [
+            PuppetSyntaxValidator,
+            PuppetLintValidator,
+            PuppetEPPValidator,
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/ruby/ruby_rubocop_validator.rb

@@ -0,0 +1,80 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Ruby
+      class RubyRubocopValidator < ExternalCommandValidator
+        def allow_empty_targets?
+          true
+        end
+
+        def name
+          'rubocop'
+        end
+
+        def cmd
+          'rubocop'
+        end
+
+        def pattern
+          if context.is_a?(PDK::Context::ControlRepo)
+            ['Puppetfile', '**/**.rb']
+          else
+            '**/**.rb'
+          end
+        end
+
+        def spinner_text_for_targets(_targets)
+          _('Checking Ruby code style (%{pattern}).') % { pattern: pattern }
+        end
+
+        def parse_options(targets)
+          cmd_options = ['--format', 'json']
+
+          if options[:auto_correct]
+            cmd_options << '--auto-correct'
+          end
+
+          cmd_options.concat(targets)
+        end
+
+        def parse_output(report, result, _targets)
+          return if result[:stdout].empty?
+
+          begin
+            json_data = JSON.parse(result[:stdout])
+          rescue JSON::ParserError
+            raise PDK::Validate::ParseOutputError, result[:stdout]
+          end
+
+          return unless json_data.key?('files')
+
+          json_data['files'].each do |file_info|
+            next unless file_info.key?('offenses')
+            result = {
+              file: file_info['path'],
+              source: 'rubocop',
+            }
+
+            if file_info['offenses'].empty?
+              report.add_event(result.merge(state: :passed, severity: :ok))
+            else
+              file_info['offenses'].each do |offense|
+                report.add_event(
+                  result.merge(
+                    line:     offense['location']['line'],
+                    column:   offense['location']['column'],
+                    message:  offense['message'],
+                    severity: offense['corrected'] ? 'corrected' : offense['severity'],
+                    test:     offense['cop_name'],
+                    state:    :failure,
+                  ),
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/ruby/ruby_validator_group.rb

@@ -0,0 +1,19 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Ruby
+      class RubyValidatorGroup < ValidatorGroup
+        def name
+          'ruby'
+        end
+
+        def validators
+          [
+            RubyRubocopValidator,
+          ].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module Tasks
+      class TasksMetadataLintValidator < InternalRubyValidator
+        FORGE_SCHEMA_URL = 'https://forgeapi.puppet.com/schemas/task.json'.freeze
+
+        def name
+          'task-metadata-lint'
+        end
+
+        def pattern
+          contextual_pattern('tasks/*.json')
+        end
+
+        def spinner_text
+          _('Checking task metadata style (%{pattern}).') % {
+            pattern: pattern.join(' '),
+          }
+        end
+
+        def schema_file
+          require 'pdk/util/vendored_file'
+
+          schema = PDK::Util::VendoredFile.new('task.json', FORGE_SCHEMA_URL).read
+
+          JSON.parse(schema)
+        rescue PDK::Util::VendoredFile::DownloadError => e
+          raise PDK::CLI::FatalError, e.message
+        rescue JSON::ParserError
+          raise PDK::CLI::FatalError, _('Failed to parse Task Metadata Schema file.')
+        end
+
+        def validate_target(report, 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
+
+          require 'json-schema'
+          begin
+            # Need to set the JSON Parser and State Generator to the Native one to be
+            # compatible with the multi_json adapter.
+            JSON.parser = JSON::Ext::Parser if defined?(JSON::Ext::Parser)
+            JSON.generator = JSON::Ext::Generator if defined?(JSON::Ext::Generator)
+
+            begin
+              errors = JSON::Validator.fully_validate(schema_file, PDK::Util::Filesystem.read_file(target)) || []
+            rescue JSON::Schema::SchemaError => e
+              raise PDK::CLI::FatalError, _('Unable to validate Task Metadata. %{error}.') % { error: e.message }
+            end
+
+            if errors.empty?
+              report.add_event(
+                file:     target,
+                source:   name,
+                state:    :passed,
+                severity: 'ok',
+              )
+              return 0
+            else
+              errors.each do |error|
+                # strip off the trailing parts that aren't relevant
+                error = error.split('in schema').first if error.include? 'in schema'
+
+                report.add_event(
+                  file:     target,
+                  source:   name,
+                  state:    :failure,
+                  severity: 'error',
+                  message:  error,
+                )
+              end
+              return 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+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.',
+        )
+
+        def name
+          'task-name'
+        end
+
+        def pattern
+          contextual_pattern('tasks/**/*')
+        end
+
+        def spinner_text
+          _('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',
+            )
+            return 0
+          else
+            report.add_event(
+              file:     target,
+              source:   name,
+              state:    :failure,
+              severity: 'error',
+              message:  INVALID_TASK_MSG,
+            )
+            return 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,118 @@
+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, _('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 unless spinner.nil?
+        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,104 @@
+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
+        _('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 { |instance| instance.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 { |instance| instance.valid_in_context? }
+      end
+    end
+  end
+end