puppet-check 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e591abda5a49b0731073d14831000016b08d72b505ab3d22a287029fa1243f
-  data.tar.gz: 96bceb6ef51e82582984ab0c88f96591d30c26650e174a0215133af0723c9526
+  metadata.gz: 384ccc25e3b1a78f69e3d017131eaf9583dc24d73f1f9ef1c37c21ac706715b9
+  data.tar.gz: 5094bc3014d74b9a5707fade543d1535d4ef12684d5adaddbb4ceb26c5a4a37e
 SHA512:
-  metadata.gz: 805ef299109715901160e9f4c4894ff05f31140c8234ed867273434e85b525e4c91e0e5fd7e6f96fb23352a3b801afa006b31cb4a93515c76182725b510a57f8
-  data.tar.gz: 2fc8340befd7b6c5f9662038aeea6614858ed1a2bd92f0d76c797fe42b316fed9d080e38cd8f4203d16240c365086bc1165c89102f3ee4e496dae6f1cf75b9bd
+  metadata.gz: 1bfc1834fc8dc70defbfce8d330f724b834653e5ba48d4a546ff3d93b3bf94d5ac68850d84dcca6d0ac1bad1990d30c07f58c5bfbaaaf2b123fa352c408200f8
+  data.tar.gz: e65f3c64cbc715d2e49c15378165256c17c01e440c979557908bd8a64fa5b77fdf74f8dac5fadbafec6df9b106bf05adb23443b552334759812850e3d89a872f

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 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.

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,7 +282,7 @@ 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

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.2.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,23 +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
       parsed = YAML.load_file(file)
     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 && (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)
+      next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -28,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
 
@@ -54,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'
@@ -76,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 = []
 
@@ -89,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?
 
@@ -123,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
@@ -169,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
@@ -191,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,30 +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$}) ? true : false
+        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 for environment *root*: ', '')
+          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 = errors.map(&:to_s).join("\n").gsub(/file: #{File.absolute_path(file)}(, |\))/, '').gsub(/Could not parse.*: /, '')
+        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 has a new validator output format
-        warnings << "\n#{errors.map(&:to_s).join("\n").gsub("file: #{File.absolute_path(file)}, ", '')}"
+        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
@@ -61,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
 
@@ -79,9 +81,9 @@ class PuppetParser
       # 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}:", '')}")
+      PuppetCheck.files[:errors][file] = [err.to_s.gsub("file: #{file}, ", '')]
     else
-      PuppetCheck.settings[:clean_files].push(file.to_s)
+      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

@@ -10,26 +10,31 @@ class RubyParser
       # 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}")
+      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'
 
-        # check RuboCop and collect warnings
-        rubocop_warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'emacs', file]) }
-        warnings = rubocop_warnings == '' ? '' : rubocop_warnings.split("#{File.absolute_path(file)}:").join('')
+        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 collect warnings
+        # check Reek and parse warnings' JSON output
         require 'reek'
         require 'reek/cli/application'
-        reek_warnings = Utils.capture_stdout { Reek::CLI::Application.new([file]).execute }
-        warnings << reek_warnings.split("\n")[1..].map(&:strip).join("\n") unless reek_warnings == ''
+
+        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']}" }
+
+        # assign warnings from combined offenses
+        warnings = rubocop_offenses + reek_offenses
 
         # return warnings
-        next PuppetCheck.settings[:warning_files].push("#{file}:\n#{warnings.strip}") unless warnings == ''
+        next PuppetCheck.files[:warnings][file] = warnings unless warnings.empty?
       end
-      PuppetCheck.settings[:clean_files].push(file.to_s)
+      PuppetCheck.files[:clean].push(file.to_s)
     end
   end
 
@@ -43,16 +48,16 @@ class RubyParser
         # 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 = Utils.capture_stderr { ERB.new(File.read(file), trim_mode: '-').result }
-                   # ERB.new(File.read(file), trim_mode: '-').result(RubyParser.new.bind)
+        # 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
 
@@ -60,10 +65,8 @@ 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|
@@ -71,17 +74,21 @@ class RubyParser
       # 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}")
+      PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
     # check librarian puppet style
     else
       if style
         # check Rubocop
-        warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'emacs', file]) }
+        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?
+        next PuppetCheck.files[:warnings][file] = offenses unless offenses.empty?
       end
-      PuppetCheck.settings[:clean_files].push(file.to_s)
+      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.'

data/lib/puppet_check.rb

@@ -5,33 +5,35 @@ require_relative 'puppet-check/output_results'
 
 # interfaces from CLI/tasks and to individual parsers
 class PuppetCheck
-  # initialize settings hash
-  @settings = {}
-
-  # allow the parser methods read user options and append to the file arrays; allow CLI and tasks write to user options
+  # initialize files hash
+  @files = {
+    errors: {},
+    warnings: {},
+    clean: [],
+    ignored: []
+  }
+
+  # allow the parser methods write to the files
   class << self
-    attr_accessor :settings
+    attr_accessor :files
   end
 
   # main runner for PuppetCheck
-  def run(settings, paths)
-    # establish settings
-    self.class.settings = settings
-
+  def run(settings = {}, paths = [])
     # settings defaults
-    self.class.defaults(settings)
+    settings = self.class.defaults(settings)
 
     # grab all of the files to be processed
     files = self.class.parse_paths(paths)
 
     # parse the files
-    execute_parsers(files, settings)
+    parsed_files = execute_parsers(files, settings)
 
     # output the diagnostic results
-    settings[:output_format] == 'text' ? OutputResults.text : OutputResults.markup(settings[:output_format])
+    OutputResults.run(parsed_files, settings[:output_format])
 
     # progress to regression checks if no errors in file checks
-    if self.class.settings[:error_files].empty? && (!settings[:fail_on_warning] || self.class.settings[:warning_files].empty?)
+    if self.class.files[:errors].empty? && (!settings[:fail_on_warning] || self.class.files[:warnings].empty?)
       begin
         require_relative 'puppet-check/regression_check'
       # if octocatalog-diff is not installed then return immediately
@@ -68,7 +70,8 @@ class PuppetCheck
   end
 
   # establish default settings
-  def self.defaults(settings)
+  def self.defaults(settings = {})
+    private_class_method :method
     # initialize fail on warning,  style check, and regression check bools
     settings[:fail_on_warning] ||= false
     settings[:style] ||= false
@@ -82,12 +85,6 @@ class PuppetCheck
     # initialize output format option
     settings[:output_format] ||= 'text'
 
-    # initialize diagnostic output arrays
-    @settings[:error_files] = []
-    @settings[:warning_files] = []
-    @settings[:clean_files] = []
-    @settings[:ignored_files] = []
-
     # initialize octocatalog-diff options
     settings[:octoconfig] ||= '.octocatalog-diff.cfg.rb'
     settings[:octonodes] ||= %w[localhost.localdomain]
@@ -95,10 +92,14 @@ class PuppetCheck
     # initialize style arg arrays
     settings[:puppetlint_args] ||= []
     settings[:rubocop_args] ||= []
+
+    # return update settings
+    settings
   end
 
   # parse the paths and return the array of files
-  def self.parse_paths(paths)
+  def self.parse_paths(paths = [])
+    private_class_method :method
     files = []
 
     # traverse the unique paths and return all files
@@ -111,13 +112,15 @@ class PuppetCheck
     end
 
     # do not process fixtures, check that at least one file was found, and remove double slashes
-    files.reject! { |file| file =~ /fixtures/ }
+    files.reject! { |file| file.include?('fixtures') }
     raise "puppet-check: no files found in supplied paths '#{paths.join(', ')}'." if files.empty?
     files.map! { |file| file.gsub('//', '/') }
 
     files.uniq
   end
 
+  private
+
   # categorize and pass the files out to the parsers to determine their status
   def execute_parsers(files, settings)
     # check manifests
@@ -145,6 +148,8 @@ class PuppetCheck
     librarians, files = files.partition { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem)file$/ }
     RubyParser.librarian(librarians, settings[:style], settings[:rubocop_args]) unless librarians.empty?
     # ignore everything else
-    self.class.settings[:ignored_files].concat(files)
+    files.each { |file| self.class.files[:ignored].push(file.to_s) }
+    # return PuppetCheck.files to mitigate singleton write accessor side effects
+    PuppetCheck.files
   end
 end