pdk-akerl 1.8.0.1

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,77 @@
+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