puppet-check 2.1.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f43468b01f25dba9ea6e997c982c632fb884d6cb8ec8faa31a670ac523a8ee8
-  data.tar.gz: 5baeb571e293b32c6120448d45c036523b96ffc0a325ba02c6f47e70323c1f3f
+  metadata.gz: 384ccc25e3b1a78f69e3d017131eaf9583dc24d73f1f9ef1c37c21ac706715b9
+  data.tar.gz: 5094bc3014d74b9a5707fade543d1535d4ef12684d5adaddbb4ceb26c5a4a37e
 SHA512:
-  metadata.gz: f0ff327a57b78229800e56dae894b863ff0217d9ae8f368d7ff9db048160b29c0b1365144fb4db596c3951fafa4b5569d0c5ad741e7d0b3fa1a3491ed64fed50
-  data.tar.gz: 7b15f95dc0876eb1d8a6b9fa5295c45858fc7eef02ba6a2924c68ad29dadf6fa179c62ed32eae167923f39172eb9b1464910f48e7072dfaf8e9d98328dd6739e
+  metadata.gz: 1bfc1834fc8dc70defbfce8d330f724b834653e5ba48d4a546ff3d93b3bf94d5ac68850d84dcca6d0ac1bad1990d30c07f58c5bfbaaaf2b123fa352c408200f8
+  data.tar.gz: e65f3c64cbc715d2e49c15378165256c17c01e440c979557908bd8a64fa5b77fdf74f8dac5fadbafec6df9b106bf05adb23443b552334759812850e3d89a872f

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-### 2.1.0 (Roadmap)
+### 2.2.1
+- Improved output formatting for all formats.
+- Update and improve Rake task interfacing.
+
+### 2.2.0
+- Add Enable Pending Cops to base RuboCop configuration.
+- Support checking plans.
+- Fix Puppet >= 6.5 error message capture when line/col info.
+- Minimum Ruby version increased to 2.6.
+- Minimum Puppet version increased to 5.4.
+
+### 2.1.0
 - Minimum supported version of Puppet bumped to 5.0.
 - Minimum Ruby version bumped to 2.4.
 - Official support for Puppet 7, Rubocop 1, and Reek 6.

data/README.md

@@ -173,18 +173,24 @@ rake puppetcheck:kitchen:* # Execute Test Kitchen acceptance tests
 You can add style, smoke, and regression checks to the `rake puppetcheck:file`, or change the output format, by adding the following after the require:
 
 ```ruby
-# example of modifying Puppet Check behavior
-PuppetCheck.settings[:style] = true
-PuppetCheck.settings[:fail_on_warnings] = true
-PuppetCheck.settings[:smoke] = true
-PuppetCheck.settings[:regression] = true # in progress, do not use
-PuppetCheck.settings[:public] = 'public.pem'
-PuppetCheck.settings[:private] = 'private.pem'
-PuppetCheck.settings[:output_format] = 'yaml'
-PuppetCheck.settings[:octoconfig] = '.octocatalog-diff.cfg.rb'
-PuppetCheck.settings[:octonodes] = %w(localhost.localdomain)
-PuppetCheck.settings[:puppetlint_args] = ['--puppetlint-arg-one', '--puppetlint-arg-two']
-PuppetCheck.settings[:rubocop_args] = ['--except', 'rubocop-arg-one,rubocop-arg-two']
+# example of modifying Puppet Check behavior and creating a custom task
+settings = {}
+settings[:fail_on_warnings] = true # default false
+settings[:style] = true # default false
+settings[:smoke] = true # default false
+settings[:regression] = true # in progress, do not use; default false
+settings[:public] = 'public.pem' # default nil
+settings[:private] = 'private.pem' # default nil
+settings[:output_format] = 'yaml' # also 'json'; default 'text'
+settings[:octoconfig] = '$HOME/octocatalog-diff.cfg.rb' # default '.octocatalog-diff.cfg.rb'
+settings[:octonodes] = %w(server.example.com) # default: %w(localhost.localdomain)
+settings[:puppetlint_args] = ['--puppetlint-arg-one', '--puppetlint-arg-two'] # default []
+settings[:rubocop_args] = ['--except', 'rubocop-arg-one,rubocop-arg-two'] # default []
+
+desc 'Execute custom Puppet-Check file checks'
+task :file_custom do
+  Rake::Task[:'puppetcheck:file'].invoke(settings)
+end
 ```
 
 Please note that `rspec` does not support yaml output and therefore would still use the default 'progress' formatter even if `yaml` is specified as the format option to Puppet Check.
@@ -276,33 +282,12 @@ PuppetCheck.new.run(settings, [dirs, files])
 require 'puppet-check/rspec_puppet_support'
 
 RSpecPuppetSupport.run
-task.pattern = Dir.glob('**/{classes,defines,facter,functions,hosts,puppet,unit,types}/**/*_spec.rb').reject { |dir| dir =~ /fixtures/ }
+task.pattern = Dir.glob('**/{classes,defines,facter,functions,hosts,puppet,unit,types}/**/*_spec.rb').grep_v(/fixtures/)
 ```
 
 ### Docker
 
-You can also use Puppet Check inside of Docker for quick, portable, and disposable testing. Below is an example `Dockerfile` for this purpose:
-
-```dockerfile
-# a reliable and small container; today should maybe use ruby:slim instead
-FROM ubuntu:20.04
-# you need ruby and any other extra dependencies that come from packages; in this example we install git to use it for downloading external module dependencies
-RUN apt-get update && apt-get install ruby git -y
-# you need puppet-check and any other extra dependencies that come from gems; in this example we install rspec-puppet and rake for extra testing
-RUN gem install --no-document puppet-check rspec-puppet rake
-# this is needed for the ruby json parser to not flip out on fresh os installs for some reason (change encoding value as necessary)
-ENV LANG en_US.UTF-8
-# create the directory for your module, directory environment, etc. and change directory into it
-WORKDIR /module_name_or_directory_environment_name
-# copy the module, directory environment, etc. contents into the corresponding directory inside the container; alternative, bind a volume mount for your module(s) into the container at runtime
-COPY / .
-# execute your tests; in this example we are executing the full suite of tests
-ENTRYPOINT ["rake", "puppetcheck"]
-```
-
-You can also build your own general container image for testing various Puppet situations by removing the last three lines. You can then test each module, directory environment, etc. on top of that container by merely adding and modifying the final three lines to a `Dockerfile` that uses the container you built from the first four lines. This is recommended usage due to being very efficient and stable.
-
-As an alternative to copying Puppet code and data into the image for testing, it is also recommended to bind volume mount the container to the directory with your Puppet code and data.
+A supported [Docker image](https://hub.docker.com/r/matthewschuchard/puppet-check) of Puppet-Check is now available from the public Docker Hub registry. Please consult the repository documentation for further usage information.
 
 ### Vagrant
 

data/lib/puppet-check/cli.rb

@@ -1,4 +1,3 @@
-require 'optparse'
 require_relative '../puppet_check'
 
 # the command line interface for PuppetCheck
@@ -7,7 +6,7 @@ class PuppetCheck::CLI
   def self.run(args)
     # gather the user arguments
     settings = parse(args)
-    raise 'puppet-check: no paths specified; try using --help' if args.empty?
+    raise 'puppet-check: no file paths specified; try using --help' if args.empty?
 
     # run PuppetCheck with specified paths
     PuppetCheck.new.run(settings, args)
@@ -15,6 +14,9 @@ class PuppetCheck::CLI
 
   # parse the user arguments
   def self.parse(args)
+    private_class_method :method
+    require 'optparse'
+
     # show help message if no args specified
     args = %w[-h] if args.empty?
 
@@ -27,7 +29,7 @@ class PuppetCheck::CLI
 
       # base options
       opts.on('--version', 'Display the current version.') do
-        puts 'puppet-check 2.1.0'
+        puts 'puppet-check 2.2.1'
         exit 0
       end
 
@@ -58,7 +60,7 @@ class PuppetCheck::CLI
       opts.on('--rubocop arg_one,arg_two', String, 'Arguments for Rubocop disabled cops') { |arg| settings[:rubocop_args] = ['--except', arg] }
     end
 
-    # remove atched args and return settings
+    # remove matched args and return settings
     opt_parser.parse!(args)
     settings
   end

data/lib/puppet-check/data_parser.rb

@@ -2,25 +2,23 @@ require_relative '../puppet_check'
 
 # executes diagnostics on data files
 class DataParser
+  require 'yaml'
+
   # checks yaml (.yaml/.yml)
   def self.yaml(files)
-    require 'yaml'
-
     files.each do |file|
       # check yaml syntax
-      begin
-        parsed = YAML.load_file(file)
-      rescue StandardError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err.to_s.gsub("(#{file}): ", '')}")
-      else
-        warnings = []
+      parsed = YAML.load_file(file)
+    rescue StandardError => err
+      PuppetCheck.files[:errors][file] = err.to_s.gsub("(#{file}): ", '').split("\n")
+    else
+      warnings = []
 
-        # perform some rudimentary hiera checks if data exists and is hieradata
-        warnings = hiera(parsed, file) if parsed && (File.basename(file) != 'hiera.yaml')
+      # perform some rudimentary hiera checks if data exists and is hieradata
+      warnings = hiera(parsed, file) if parsed && (File.basename(file) != 'hiera.yaml')
 
-        next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.join("\n")}") unless warnings.empty?
-        PuppetCheck.settings[:clean_files].push(file.to_s)
-      end
+      next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -30,13 +28,13 @@ class DataParser
 
     # keys specified?
     if public.nil? || private.nil?
-      PuppetCheck.settings[:ignored_files].concat(files)
+      PuppetCheck.files[:ignored].concat(files)
       return warn 'Public X509 and/or Private RSA PKCS7 certs were not specified. EYAML checks will not be executed.'
     end
 
     # keys exist?
     unless File.file?(public) && File.file?(private)
-      PuppetCheck.settings[:ignored_files].concat(files)
+      PuppetCheck.files[:ignored].concat(files)
       return warn 'Specified Public X509 and/or Private RSA PKCS7 certs do not exist. EYAML checks will not be executed.'
     end
 
@@ -56,19 +54,25 @@ class DataParser
       begin
         parsed = YAML.load_file(decrypted)
       rescue StandardError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err.to_s.gsub("(#{file}): ", '')}")
+        PuppetCheck.files[:errors][file] = err.to_s.gsub("(#{file}): ", '').split("\n")
       else
         warnings = []
 
         # perform some rudimentary hiera checks if data exists and is hieradata
         warnings = hiera(parsed, file) if parsed
 
-        next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.join("\n")}") unless warnings.empty?
-        PuppetCheck.settings[:clean_files].push(file.to_s)
+        next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
+        PuppetCheck.files[:clean].push(file.to_s)
       end
     end
   end
 
+  # metadata consts
+  REQUIRED_KEYS = %w[name version author license summary source dependencies].freeze
+  REQ_DEP_KEYS = %w[requirements dependencies].freeze
+  DEPRECATED_KEYS = %w[types checksum].freeze
+  TASK_INPUTS = %w[environment stdin powershell].freeze
+
   # checks json (.json)
   def self.json(files)
     require 'json'
@@ -78,7 +82,7 @@ class DataParser
       begin
         parsed = JSON.parse(File.read(file))
       rescue JSON::ParserError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err.to_s.lines.first.strip}")
+        PuppetCheck.files[:errors][file] = err.to_s.lines.first.strip.split("\n")
       else
         warnings = []
 
@@ -91,12 +95,12 @@ class DataParser
           errors = []
 
           # check for required keys
-          %w[name version author license summary source dependencies].each do |key|
+          REQUIRED_KEYS.each do |key|
             errors.push("Required field '#{key}' not found.") unless parsed.key?(key)
           end
 
           # check requirements and dependencies keys
-          %w[requirements dependencies].each do |key|
+          REQ_DEP_KEYS.each do |key|
             # skip if key is missing or value is an empty string, array, or hash
             next if !parsed.key?(key) || parsed[key].empty?
 
@@ -125,14 +129,14 @@ class DataParser
           end
 
           # check for deprecated fields
-          %w[types checksum].each do |key|
+          DEPRECATED_KEYS.each do |key|
             errors.push("Deprecated field '#{key}' found.") if parsed.key?(key)
           end
 
           # check for summary under 144 character
           errors.push('Summary exceeds 144 characters.') if parsed.key?('summary') && parsed['summary'].size > 144
 
-          next PuppetCheck.settings[:error_files].push("#{file}:\n#{errors.join("\n")}") unless errors.empty?
+          next PuppetCheck.files[:errors][file] = errors unless errors.empty?
 
           # check for warnings
           # check for operatingsystem_support hash array
@@ -171,7 +175,7 @@ class DataParser
           # check that input_method is one of three possible values
           if parsed.key?('input_method')
             if parsed['input_method'].is_a?(String)
-              warnings.push('input_method value is not one of environment, stdin, or powershell') unless %w[environment stdin powershell].include?(parsed['input_method'])
+              warnings.push('input_method value is not one of environment, stdin, or powershell') unless TASK_INPUTS.include?(parsed['input_method'])
             else
               warnings.push('input_method value is not a String')
             end
@@ -193,8 +197,8 @@ class DataParser
           # perform some rudimentary hiera checks if data exists
           warnings = hiera(parsed, file)
         end
-        next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.join("\n")}") unless warnings.empty?
-        PuppetCheck.settings[:clean_files].push(file.to_s)
+        next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
+        PuppetCheck.files[:clean].push(file.to_s)
       end
     end
   end

data/lib/puppet-check/output_results.rb

@@ -2,44 +2,50 @@ require_relative '../puppet_check'
 
 # class to handle outputting diagnostic results in desired format
 class OutputResults
-  # output the results as text
-  def self.text
-    unless PuppetCheck.settings[:error_files].empty?
-      print "\033[31mThe following files have errors:\033[0m\n-- "
-      puts PuppetCheck.settings[:error_files].join("\n\n-- ")
-    end
-    unless PuppetCheck.settings[:warning_files].empty?
-      print "\n\033[33mThe following files have warnings:\033[0m\n-- "
-      puts PuppetCheck.settings[:warning_files].join("\n\n-- ")
-    end
-    unless PuppetCheck.settings[:clean_files].empty?
-      print "\n\033[32mThe following files have no errors or warnings:\033[0m\n-- "
-      puts PuppetCheck.settings[:clean_files].join("\n-- ")
-    end
-    return if PuppetCheck.settings[:ignored_files].empty?
-    print "\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- "
-    puts PuppetCheck.settings[:ignored_files].join("\n-- ")
-  end
+  # output the results in various formats
+  def self.run(files, format)
+    # remove empty entries
+    files.delete_if { |_, sorted_files| sorted_files.empty? }
 
-  # output the results as yaml or json
-  def self.markup(format)
-    # generate output hash
-    hash = {}
-    hash['errors'] = PuppetCheck.settings[:error_files] unless PuppetCheck.settings[:error_files].empty?
-    hash['warnings'] = PuppetCheck.settings[:warning_files] unless PuppetCheck.settings[:warning_files].empty?
-    hash['clean'] = PuppetCheck.settings[:clean_files] unless PuppetCheck.settings[:clean_files].empty?
-    hash['ignored'] = PuppetCheck.settings[:ignored_files] unless PuppetCheck.settings[:ignored_files].empty?
-
-    # convert hash to markup language
+    # output hash according to specified format
     case format
+    when 'text'
+      text(files)
     when 'yaml'
       require 'yaml'
-      puts Psych.dump(hash, indentation: 2)
+      # maintain filename format consistency among output formats
+      files.transform_keys!(&:to_s)
+      puts Psych.dump(files, indentation: 2)
     when 'json'
       require 'json'
-      puts JSON.pretty_generate(hash)
+      puts JSON.pretty_generate(files)
     else
       raise "puppet-check: Unsupported output format '#{format}' was specified."
     end
   end
+
+  # output the results as text
+  def self.text(files)
+    private_class_method :method
+
+    # errors
+    if files.key?(:errors)
+      puts "\033[31mThe following files have errors:\033[0m"
+      files[:errors].each { |file, errors| puts "-- #{file}:\n#{errors.join("\n")}" }
+    end
+    # warnings
+    if files.key?(:warnings)
+      puts "\n\033[33mThe following files have warnings:\033[0m"
+      files[:warnings].each { |file, warnings| puts "-- #{file}:\n#{warnings.join("\n")}" }
+    end
+    # cleans
+    if files.key?(:clean)
+      print "\n\033[32mThe following files have no errors or warnings:\033[0m\n-- "
+      puts files[:clean].join("\n-- ")
+    end
+    # ignores
+    return unless files.key?(:ignored)
+    print "\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- "
+    puts files[:ignored].join("\n-- ")
+  end
 end

data/lib/puppet-check/puppet_parser.rb

@@ -18,41 +18,33 @@ class PuppetParser
       # check puppet syntax
       begin
         # initialize message
-        message = ''
+        messages = []
+        # specify tasks attribute for parser validation if this looks like a plan or not
+        Puppet[:tasks] = file.match?(%r{plans/\w+\.pp$})
         # in puppet >= 6.5 the return of this method is a hash with the error
         new_error = Puppet::Face[:parser, :current].validate(file)
         # puppet 6.5 output format is now a hash from the face api
         if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('6.5.0') && new_error != {}
-          message = new_error.values.map(&:to_s).join("\n").gsub(/ \(file: #{File.absolute_path(file)}(, |\))/, '').gsub(/Could not parse.*: /, '')
+          messages.concat(new_error.values.map(&:to_s).map { |error| error.gsub(/ \(file: #{File.absolute_path(file)}(, |\))/, '') }.map { |error| error.gsub('Could not parse for environment *root*: ', '') })
         end
       # this is the actual error that we need to rescue Puppet::Face from
       rescue SystemExit
         # puppet 5.4-6.4 has a new validator output format and eof errors have fake dir env info
-        message = if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('5.4') && Gem::Version.new(Puppet::PUPPETVERSION) < Gem::Version.new('6.5')
-                    errors.map(&:to_s).join("\n").gsub(/file: #{File.absolute_path(file)}(, |\))/, '').gsub(/Could not parse.*: /, '')
-                  # puppet 5.0-5.2 can only do one error per line and outputs fake dir env info
-                  elsif Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('5.0') && Gem::Version.new(Puppet::PUPPETVERSION) < Gem::Version.new('5.3')
-                    errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '').gsub(/Could not parse.*: /, '')
-                  # puppet < 5 and 5.3 parser output style
-                  else
-                    errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')
-                  end
+        messages.concat(errors.map(&:to_s).join("\n").map { |error| error.gsub(/file: #{File.absolute_path(file)}(, |\))/, '') }.map { |error| error.gsub(/Could not parse.*: /, '') })
       end
-      # output message
-      next PuppetCheck.settings[:error_files].push("#{file}:\n#{message}") unless message.empty?
+
+      Puppet::Util::Log.close_all
+
+      # store info and continue validating files
+      next PuppetCheck.files[:errors][file] = messages unless messages.empty?
 
       # initialize warnings with output from the parser if it exists, since the output is warnings if Puppet::Face did not trigger a SystemExit
-      warnings = "#{file}:"
+      warnings = []
+      # weirdly puppet >= 6.5 still does not return warnings and logs them instead unlike errors
       unless errors.empty?
-        # puppet 5.4-5.x has a new validator output format
-        warnings << if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('5.4')
-                      "\n#{errors.map(&:to_s).join("\n").gsub("file: #{File.absolute_path(file)}, ", '')}"
-                    # puppet <= 5.3 validator output format
-                    else
-                      "\n#{errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')}"
-                    end
+        # puppet >= 5.4 has a new validator output format
+        warnings.concat(errors.map(&:to_s).join("\n").gsub("file: #{File.absolute_path(file)}, ", '').split("\n"))
       end
-      Puppet::Util::Log.close_all
 
       # check puppet style
       if style
@@ -72,12 +64,11 @@ class PuppetParser
         puppet_lint.run
 
         # collect the warnings
-        if puppet_lint.warnings?
-          puppet_lint.problems.each { |values| warnings << "\n#{values[:line]}:#{values[:column]}: #{values[:message]}" }
-        end
+        offenses = puppet_lint.problems.map { |problem| "#{problem[:line]}:#{problem[:column]} #{problem[:message]}" }
+        warnings.concat(offenses)
       end
-      next PuppetCheck.settings[:warning_files].push(warnings) unless warnings == "#{file}:"
-      PuppetCheck.settings[:clean_files].push(file.to_s)
+      next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -87,14 +78,12 @@ class PuppetParser
 
     files.each do |file|
       # check puppet template syntax
-      begin
-        # credits to gds-operations/puppet-syntax for the parser function call
-        Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new.parse_file(file)
-      rescue StandardError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err.to_s.gsub("#{file}:", '')}")
-      else
-        PuppetCheck.settings[:clean_files].push(file.to_s)
-      end
+      # credits to gds-operations/puppet-syntax for the parser function call
+      Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new.parse_file(file)
+    rescue StandardError => err
+      PuppetCheck.files[:errors][file] = [err.to_s.gsub("file: #{file}, ", '')]
+    else
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 end

data/lib/puppet-check/rspec_puppet_support.rb

@@ -9,7 +9,7 @@ class RSpecPuppetSupport
   # prepare the spec fixtures directory for rspec-puppet testing
   def self.run
     # ensure this method does not do anything inside module dependencies
-    specdirs = Dir.glob('**/spec').reject { |dir| dir =~ /fixtures/ }
+    specdirs = Dir.glob('**/spec').reject { |dir| dir.include?('fixtures') }
     return if specdirs.empty?
 
     # setup fixtures for rspec-puppet testing

data/lib/puppet-check/ruby_parser.rb

@@ -7,31 +7,34 @@ class RubyParser
   def self.ruby(files, style, rc_args)
     files.each do |file|
       # check ruby syntax
-      begin
-        # prevents ruby code from actually executing
-        catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
-      rescue ScriptError, StandardError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err}")
-      else
-        # check ruby style
-        if style
-          require 'rubocop'
+      # prevents ruby code from actually executing
+      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
+    rescue ScriptError, StandardError => err
+      PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
+    else
+      # check ruby style
+      if style
+        # check RuboCop and parse warnings' JSON output
+        require 'json'
+        require 'rubocop'
+
+        rubocop_warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'json', file]) }
+        rubocop_offenses = JSON.parse(rubocop_warnings)['files'][0]['offenses'].map { |warning| "#{warning['location']['line']}:#{warning['location']['column']} #{warning['message']}" }
+
+        # check Reek and parse warnings' JSON output
+        require 'reek'
+        require 'reek/cli/application'
 
-          # check RuboCop and collect warnings
-          rubocop_warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--require', 'rubocop-performance', '--format', 'emacs', file]) }
-          warnings = rubocop_warnings == '' ? '' : rubocop_warnings.split("#{File.absolute_path(file)}:").join('')
+        reek_warnings = Utils.capture_stdout { Reek::CLI::Application.new(['-f', 'json', file]).execute }
+        reek_offenses = JSON.parse(reek_warnings).map { |warning| "#{warning['lines'].join(',')}: #{warning['context']} #{warning['message']}" }
 
-          # check Reek and collect warnings
-          require 'reek'
-          require 'reek/cli/application'
-          reek_warnings = Utils.capture_stdout { Reek::CLI::Application.new([file]).execute }
-          warnings << reek_warnings.split("\n")[1..-1].map(&:strip).join("\n") unless reek_warnings == ''
+        # assign warnings from combined offenses
+        warnings = rubocop_offenses + reek_offenses
 
-          # return warnings
-          next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.strip}") unless warnings == ''
-        end
-        PuppetCheck.settings[:clean_files].push(file.to_s)
+        # return warnings
+        next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
       end
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -44,22 +47,17 @@ class RubyParser
       begin
         # need to eventually have this associated with a different binding during each iteration
         # older usage throws extra warning and mixes with valid warnings confusingly
-        warnings = if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-                     Utils.capture_stderr { ERB.new(File.read(file), trim_mode: '-').result }
-                     # ERB.new(File.read(file), trim_mode: '-').result(RubyParser.new.bind)
-                   # and for extra fun it is incompatible with non-new ruby
-                   else
-                     Utils.capture_stderr { ERB.new(File.read(file), nil, '-').result }
-                   end
+        warnings = Utils.capture_stderr { ERB.new(File.read(file), trim_mode: '-').result }
+        # warnings = ERB.new(File.read(file), trim_mode: '-').result(RubyParser.new.bind)
       rescue NameError, TypeError
         # empty out warnings since it would contain an error if this pass triggers
         warnings = ''
       rescue ScriptError => err
-        next PuppetCheck.settings[:error_files].push("#{file}:\n#{err}")
+        next PuppetCheck.files[:errors][file] = err.to_s.gsub('(erb):', '').split("\n")
       end
       # return warnings from the check if there were any
-      next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.gsub('warning: ', '').split('(erb):').join('').strip}") unless warnings == ''
-      PuppetCheck.settings[:clean_files].push(file.to_s)
+      next PuppetCheck.files[:warnings][file] = warnings.to_s.gsub('warning: ', '').delete("\n").split('(erb):').compact unless warnings == ''
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -67,30 +65,30 @@ class RubyParser
   def self.librarian(files, style, rc_args)
     # efficient var assignment prior to iterator
     if style
-      require 'rubocop'
-
       # RuboCop is grumpy about non-snake_case filenames so disable the FileName check
-      rc_args.include?('--except') ? rc_args[rc_args.index('--except') + 1] = "#{rc_args[rc_args.index('--except') + 1]},Naming/FileName" : rc_args.concat(['--except', 'Naming/FileName'])
+      rc_args.include?('--except') ? rc_args[rc_args.index('--except') + 1] = "#{rc_args[rc_args.index('--except') + 1]},Naming/FileName" : rc_args.push('--except', 'Naming/FileName')
     end
 
     files.each do |file|
       # check librarian puppet syntax
-      begin
-        # prevents ruby code from actually executing
-        catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
-      rescue SyntaxError, LoadError, ArgumentError => err
-        PuppetCheck.settings[:error_files].push("#{file}:\n#{err}")
-      # check librarian puppet style
-      else
-        if style
-          # check Rubocop
-          warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--require', 'rubocop-performance', '--format', 'emacs', file]) }
+      # prevents ruby code from actually executing
+      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
+    rescue SyntaxError, LoadError, ArgumentError => err
+      PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
+    # check librarian puppet style
+    else
+      if style
+        # check Rubocop
+        require 'json'
+        require 'rubocop'
+
+        warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'json', file]) }
+        offenses = JSON.parse(warnings)['files'][0]['offenses'].map { |warning| "#{warning['location']['line']}:#{warning['location']['column']} #{warning['message']}" }
 
-          # collect style warnings
-          next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.split("#{File.absolute_path(file)}:").join('')}") unless warnings.empty?
-        end
-        PuppetCheck.settings[:clean_files].push(file.to_s)
+        # collect style warnings
+        next PuppetCheck.files[:warnings][file] = offenses unless offenses.empty?
       end
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 

data/lib/puppet-check/tasks.rb

@@ -6,15 +6,17 @@ end
 require_relative '../puppet_check'
 
 # the rake interface for PuppetCheck
-class PuppetCheck::Tasks < ::Rake::TaskLib
+class PuppetCheck::Tasks < Rake::TaskLib
   def initialize
+    super
+
     desc 'Execute all Puppet-Check checks'
     task puppetcheck: %w[puppetcheck:file puppetcheck:spec puppetcheck:beaker puppetcheck:kitchen]
 
     namespace :puppetcheck do
       desc 'Execute Puppet-Check file checks'
-      task :file do
-        PuppetCheck.new.run(PuppetCheck.settings, Dir.glob('*'))
+      task :file, [:settings] do |_, wrapped_settings|
+        PuppetCheck.new.run(wrapped_settings[:settings], Dir.glob('*'))
       end
 
       # rspec and rspec-puppet tasks
@@ -26,9 +28,8 @@ class PuppetCheck::Tasks < ::Rake::TaskLib
         RSpec::Core::RakeTask.new(:spec) do |task|
           RSpecPuppetSupport.run
           # generate tasks for all recognized directories and ensure spec tests inside module dependencies are ignored
-          spec_dirs = Dir.glob('**/{classes,defines,facter,functions,hosts,puppet,unit,types}/**/*_spec.rb').reject { |dir| dir =~ /fixtures/ }
+          spec_dirs = Dir.glob('**/{classes,defines,facter,functions,hosts,puppet,unit,types}/**/*_spec.rb').grep_v(/fixtures/)
           task.pattern = spec_dirs.empty? ? 'skip_rspec' : spec_dirs
-          task.rspec_opts = '-f json' if PuppetCheck.settings[:output_format] == 'json'
         end
       rescue LoadError
         desc 'RSpec is not installed.'