pdk 1.9.0 → 3.2.0

data/lib/pdk/validate/metadata/metadata_json_lint.rb

@@ -1,86 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pdk/util/bundler'
-require 'pathname'
-
-module PDK
-  module Validate
-    class MetadataJSONLint < BaseValidator
-      # Validate each metadata file separately, as metadata-json-lint does not
-      # support multiple targets.
-      INVOKE_STYLE = :per_target
-
-      def self.name
-        'metadata-json-lint'
-      end
-
-      def self.cmd
-        'metadata-json-lint'
-      end
-
-      def self.spinner_text(targets = [])
-        _('Checking module metadata style (%{targets}).') % {
-          targets: PDK::Util.targets_relative_to_pwd(targets).join(' '),
-        }
-      end
-
-      def self.pattern
-        'metadata.json'
-      end
-
-      def self.parse_options(_options, targets)
-        cmd_options = ['--format', 'json']
-        cmd_options << '--strict-dependencies'
-
-        cmd_options.concat(targets)
-      end
-
-      def self.parse_output(report, result, targets)
-        raise ArgumentError, _('More than 1 target provided to PDK::Validate::MetadataJSONLint.') if targets.count > 1
-
-        if result[:stdout].strip.empty?
-          # metadata-json-lint will print nothing if there are no problems with
-          # the file being linted. This should be handled separately to
-          # metadata-json-lint generating output that can not be parsed as JSON
-          # (unhandled exception in metadata-json-lint).
-          json_data = {}
-        else
-          begin
-            json_data = JSON.parse(result[:stdout])
-          rescue JSON::ParserError
-            raise PDK::Validate::ParseOutputError, result[:stdout]
-          end
-        end
-
-        if json_data.empty?
-          report.add_event(
-            file:     targets.first,
-            source:   name,
-            state:    :passed,
-            severity: :ok,
-          )
-        else
-          json_data.delete('result')
-          json_data.keys.each do |type|
-            json_data[type].each do |offense|
-              # metadata-json-lint groups the offenses by type, so the type ends
-              # up being `warnings` or `errors`. We want to convert that to the
-              # singular noun for the event.
-              event_type = type[%r{\A(.+?)s?\Z}, 1]
-
-              report.add_event(
-                file:     targets.first,
-                source:   name,
-                message:  offense['msg'],
-                test:     offense['check'],
-                severity: event_type,
-                state:    :failure,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pdk/validate/metadata/metadata_syntax.rb

@@ -1,109 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pathname'
-
-module PDK
-  module Validate
-    class MetadataSyntax < BaseValidator
-      def self.name
-        'metadata-syntax'
-      end
-
-      def self.pattern
-        ['metadata.json', 'tasks/*.json']
-      end
-
-      def self.spinner_text(_targets = [])
-        _('Checking metadata syntax (%{targets}).') % {
-          targets: pattern.join(' '),
-        }
-      end
-
-      def self.create_spinner(targets = [], options = {})
-        return unless PDK::CLI::Util.interactive?
-        options = options.merge(PDK::CLI::Util.spinner_opts_for_platform)
-
-        exec_group = options[:exec_group]
-        @spinner = if exec_group
-                     exec_group.add_spinner(spinner_text(targets), options)
-                   else
-                     TTY::Spinner.new("[:spinner] #{spinner_text(targets)}", options)
-                   end
-        @spinner.auto_spin
-      end
-
-      def self.stop_spinner(exit_code)
-        if exit_code.zero? && @spinner
-          @spinner.success
-        elsif @spinner
-          @spinner.error
-        end
-      end
-
-      def self.invoke(report, options = {})
-        targets, skipped, invalid = parse_targets(options)
-
-        process_skipped(report, skipped)
-        process_invalid(report, invalid)
-
-        return 0 if targets.empty?
-
-        return_val = 0
-        create_spinner(targets, options)
-
-        # The pure ruby JSON parser gives much nicer parse error messages than
-        # the C extension at the cost of slightly slower parsing. We require it
-        # here and restore the C extension at the end of the method (if it was
-        # being used).
-        require 'json/pure'
-        JSON.parser = JSON::Pure::Parser
-
-        targets.each do |target|
-          unless File.readable?(target)
-            report.add_event(
-              file: target,
-              source: name,
-              state: :failure,
-              severity: 'error',
-              message: _('Could not be read.'),
-            )
-            return_val = 1
-            next
-          end
-
-          begin
-            JSON.parse(File.read(target))
-
-            report.add_event(
-              file:     target,
-              source:   name,
-              state:    :passed,
-              severity: 'ok',
-            )
-          rescue JSON::ParserError => e
-            # Because the message contains a raw segment of the file, we use
-            # String#dump here to unescape any escape characters like newlines.
-            # We then strip out the surrounding quotes and the exclaimation
-            # point that json_pure likes to put in exception messages.
-            sane_message = e.message.dump[%r{\A"(.+?)!?"\Z}, 1]
-
-            report.add_event(
-              file:     target,
-              source:   name,
-              state:    :failure,
-              severity: 'error',
-              message:  sane_message,
-            )
-            return_val = 1
-          end
-        end
-
-        stop_spinner(return_val)
-        return_val
-      ensure
-        JSON.parser = JSON::Ext::Parser if defined?(JSON::Ext::Parser)
-      end
-    end
-  end
-end

data/lib/pdk/validate/metadata_validator.rb

@@ -1,30 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pdk/validate/metadata/metadata_json_lint'
-require 'pdk/validate/metadata/metadata_syntax'
-
-module PDK
-  module Validate
-    class MetadataValidator < BaseValidator
-      def self.name
-        'metadata'
-      end
-
-      def self.metadata_validators
-        [MetadataSyntax, MetadataJSONLint]
-      end
-
-      def self.invoke(report, options = {})
-        exit_code = 0
-
-        metadata_validators.each do |validator|
-          exit_code = validator.invoke(report, options)
-          break if exit_code != 0
-        end
-
-        exit_code
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'pdk'
-require 'pdk/util'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-
-module PDK
-  module Validate
-    class PuppetLint < BaseValidator
-      def self.name
-        'puppet-lint'
-      end
-
-      def self.cmd
-        'puppet-lint'
-      end
-
-      def self.pattern
-        '**/*.pp'
-      end
-
-      def self.spinner_text(_targets = nil)
-        _('Checking Puppet manifest style (%{pattern}).') % { pattern: pattern }
-      end
-
-      def self.parse_options(options, targets)
-        cmd_options = ['--json', '--relative']
-
-        cmd_options << '--fix' if options[:auto_correct]
-
-        cmd_options.concat(targets)
-      end
-
-      def self.parse_output(report, result, targets)
-        begin
-          json_data = JSON.parse(result[:stdout]).flatten
-        rescue JSON::ParserError
-          raise PDK::Validate::ParseOutputError, result[:stdout]
-        end
-
-        # puppet-lint does not include files without problems in its JSON
-        # output, so we need to go through the list of targets and add passing
-        # events to the report for any target not listed in the JSON output.
-        targets.reject { |target| json_data.any? { |j| j['path'] == target } }.each do |target|
-          report.add_event(
-            file:     target,
-            source:   name,
-            severity: 'ok',
-            state:    :passed,
-          )
-        end
-
-        json_data.each do |offense|
-          report.add_event(
-            file:     offense['path'],
-            source:   name,
-            line:     offense['line'],
-            column:   offense['column'],
-            message:  offense['message'],
-            test:     offense['check'],
-            severity: (offense['kind'] == 'fixed') ? 'corrected' : offense['kind'],
-            state:    :failure,
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-
-module PDK
-  module Validate
-    class PuppetSyntax < BaseValidator
-      # In Puppet >= 5.3.4, the error context formatting was changed to facilitate localization
-      ERROR_CONTEXT = %r{(?:file:\s(?<file>.+?)|line:\s(?<line>.+?)|column:\s(?<column>.+?))}
-      # In Puppet < 5.3.3, the error context was formatted in these variations:
-      #   - "at file_path:line_num:col_num"
-      #   - "at file_path:line_num"
-      #   - "at line line_num"
-      #   - "in file_path"
-      ERROR_CONTEXT_LEGACY = %r{(?:at\sline\s(?<line>\d+)|at\s(?<file>.+?):(?<line>\d+):(?<column>\d+)|at\s(?<file>.+?):(?<line>\d+)|in\s(?<file>.+?))}
-
-      PUPPET_LOGGER_PREFIX = %r{^(debug|info|notice|warning|error|alert|critical):\s.+?$}i
-      PUPPET_SYNTAX_PATTERN = %r{^
-        (?<severity>.+?):\s
-        (?<message>.+?)
-        (?:
-          \s\(#{ERROR_CONTEXT}(,\s#{ERROR_CONTEXT})*\)| # attempt to match the new localisation friendly location
-          \s#{ERROR_CONTEXT_LEGACY}| # attempt to match the old " at file:line:column" location
-          $                                               # handle cases where the output has no location
-        )
-      $}x
-
-      def self.name
-        'puppet-syntax'
-      end
-
-      def self.cmd
-        'puppet'
-      end
-
-      def self.pattern
-        '**/**.pp'
-      end
-
-      def self.pattern_ignore
-        '/plans/**/*.pp'
-      end
-
-      def self.spinner_text(_targets = nil)
-        _('Checking Puppet manifest syntax (%{pattern}).') % { pattern: pattern }
-      end
-
-      def self.parse_options(_options, targets)
-        ['parser', 'validate', '--config', null_file].concat(targets)
-      end
-
-      def self.null_file
-        Gem.win_platform? ? 'NUL' : '/dev/null'
-      end
-
-      def self.parse_output(report, result, targets)
-        # Due to PUP-7504, we will have to programmatically construct the json
-        # object from the text output for now.
-        output = result[:stderr].split("\n").reject { |entry| entry.empty? }
-
-        results_data = []
-        output.each do |offense|
-          offense_data = parse_offense(offense)
-          results_data << offense_data
-        end
-
-        # puppet parser validate does not include files without problems in its
-        # output, so we need to go through the list of targets and add passing
-        # events to the report for any target not listed in the output.
-        targets.reject { |target| results_data.any? { |j| j[:file] =~ %r{#{target}} } }.each do |target|
-          report.add_event(
-            file:     target,
-            source:   name,
-            severity: :ok,
-            state:    :passed,
-          )
-        end
-
-        results_data.each do |offense|
-          report.add_event(offense)
-        end
-      end
-
-      def self.parse_offense(offense)
-        sanitize_console_output(offense)
-
-        offense_data = {
-          source:  name,
-          state:  :failure,
-        }
-
-        if offense.match(PUPPET_LOGGER_PREFIX)
-          attributes = offense.match(PUPPET_SYNTAX_PATTERN)
-
-          unless attributes.nil?
-            attributes.names.each do |name|
-              offense_data[name.to_sym] = attributes[name] unless attributes[name].nil?
-            end
-          end
-        else
-          offense_data[:message] = offense
-        end
-
-        offense_data
-      end
-
-      def self.sanitize_console_output(line)
-        line.gsub!(%r{\e\[([;\d]+)?m}, '')
-      end
-    end
-  end
-end

data/lib/pdk/validate/puppet_validator.rb

@@ -1,30 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pdk/validate/puppet/puppet_lint'
-require 'pdk/validate/puppet/puppet_syntax'
-
-module PDK
-  module Validate
-    class PuppetValidator < BaseValidator
-      def self.name
-        'puppet'
-      end
-
-      def self.puppet_validators
-        [PuppetSyntax, PuppetLint]
-      end
-
-      def self.invoke(report, options = {})
-        exit_code = 0
-
-        puppet_validators.each do |validator|
-          exit_code = validator.invoke(report, options)
-          break if exit_code != 0
-        end
-
-        exit_code
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/util'
-require 'pdk/util/bundler'
-require 'pdk/validate/base_validator'
-require 'pdk/validate/ruby_validator'
-
-module PDK
-  module Validate
-    class Rubocop < BaseValidator
-      ALLOW_EMPTY_TARGETS = true
-
-      def self.name
-        'rubocop'
-      end
-
-      def self.cmd
-        'rubocop'
-      end
-
-      def self.pattern
-        '**/**.rb'
-      end
-
-      def self.spinner_text(_targets = nil)
-        _('Checking Ruby code style (%{pattern}).') % { pattern: pattern }
-      end
-
-      def self.parse_options(options, targets)
-        cmd_options = ['--format', 'json']
-
-        if options[:auto_correct]
-          cmd_options << '--auto-correct'
-        end
-
-        cmd_options.concat(targets)
-      end
-
-      def self.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

data/lib/pdk/validate/ruby_validator.rb

@@ -1,29 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pdk/validate/ruby/rubocop'
-
-module PDK
-  module Validate
-    class RubyValidator < BaseValidator
-      def self.name
-        'ruby'
-      end
-
-      def self.ruby_validators
-        [Rubocop]
-      end
-
-      def self.invoke(report, options = {})
-        exit_code = 0
-
-        ruby_validators.each do |validator|
-          exit_code = validator.invoke(report, options)
-          break if exit_code != 0
-        end
-
-        exit_code
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/validate/base_validator'
-require 'pdk/util'
-require 'pathname'
-require 'json-schema'
-
-module PDK
-  module Validate
-    class Tasks
-      class MetadataLint < BaseValidator
-        FORGE_SCHEMA_URL = 'https://forgeapi.puppet.com/schemas/task.json'.freeze
-
-        def self.name
-          'task-metadata-lint'
-        end
-
-        def self.pattern
-          'tasks/*.json'
-        end
-
-        def self.spinner_text(_targets = [])
-          _('Checking task metadata style (%{targets}).') % {
-            targets: pattern,
-          }
-        end
-
-        def self.create_spinner(targets = [], options = {})
-          return unless PDK::CLI::Util.interactive?
-          options = options.merge(PDK::CLI::Util.spinner_opts_for_platform)
-
-          exec_group = options[:exec_group]
-          @spinner = if exec_group
-                       exec_group.add_spinner(spinner_text(targets), options)
-                     else
-                       TTY::Spinner.new("[:spinner] #{spinner_text(targets)}", options)
-                     end
-          @spinner.auto_spin
-        end
-
-        def self.stop_spinner(exit_code)
-          if exit_code.zero? && @spinner
-            @spinner.success
-          elsif @spinner
-            @spinner.error
-          end
-        end
-
-        def self.schema_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 self.invoke(report, options = {})
-          targets, skipped, invalid = parse_targets(options)
-
-          process_skipped(report, skipped)
-          process_invalid(report, invalid)
-
-          return 0 if targets.empty?
-
-          return_val = 0
-          create_spinner(targets, options)
-
-          targets.each do |target|
-            unless File.readable?(target)
-              report.add_event(
-                file:     target,
-                source:   name,
-                state:    :failure,
-                severity: 'error',
-                message:  _('Could not be read.'),
-              )
-              return_val = 1
-              next
-            end
-
-            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
-
-              begin
-                errors = JSON::Validator.fully_validate(schema_file, File.read(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',
-                )
-              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_val = 1
-              end
-            end
-          end
-
-          stop_spinner(return_val)
-          return_val
-        end
-      end
-    end
-  end
-end