puppet-check 2.2.0 → 2.2.2

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.clone, 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 parsed_files[:errors].empty? && (!settings[:fail_on_warning] || parsed_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

data/spec/puppet-check/cli_spec.rb

@@ -4,7 +4,7 @@ require_relative '../../lib/puppet-check/cli'
 describe PuppetCheck::CLI do
   context '.run' do
     it 'raises an error if no paths were specified' do
-      expect { PuppetCheck::CLI.run(%w[-s -f]) }.to raise_error(RuntimeError, 'puppet-check: no paths specified; try using --help')
+      expect { PuppetCheck::CLI.run(%w[-s -f]) }.to raise_error(RuntimeError, 'puppet-check: no file paths specified; try using --help')
     end
   end
 

data/spec/puppet-check/data_parser_spec.rb

@@ -3,37 +3,38 @@ require_relative '../../lib/puppet-check/data_parser'
 
 describe DataParser do
   before(:each) do
-    PuppetCheck.settings[:error_files] = []
-    PuppetCheck.settings[:warning_files] = []
-    PuppetCheck.settings[:clean_files] = []
+    PuppetCheck.files = {
+      errors: {},
+      warnings: {},
+      clean: [],
+      ignored: []
+    }
   end
 
   context '.yaml' do
-    it 'puts a bad syntax yaml file in the error files array' do
+    it 'puts a bad syntax yaml file in the error files hash' do
       DataParser.yaml(["#{fixtures_dir}hieradata/syntax.yaml"])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.yaml:\nblock sequence entries are not allowed})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.yaml"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(%r{^block sequence entries are not allowed})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good yaml file with potential hiera issues in the warning files array' do
       DataParser.yaml(["#{fixtures_dir}hieradata/style.yaml"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}hieradata/style.yaml:\nValue\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}hieradata/style.yaml"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}hieradata/style.yaml"].join("\n")).to match(%r{^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good yaml file in the clean files array' do
       DataParser.yaml(["#{fixtures_dir}hieradata/good.yaml"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.yaml"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.yaml"])
     end
   end
 
   context '.eyaml' do
-    before(:each) do
-      PuppetCheck.settings[:ignored_files] = []
-    end
-
     it 'returns a warning if a public key was not specified' do
       expect { DataParser.eyaml(['foo.eyaml'], nil, 'private.pem') }.to output("Public X509 and/or Private RSA PKCS7 certs were not specified. EYAML checks will not be executed.\n").to_stderr
     end
@@ -43,74 +44,80 @@ describe DataParser do
     it 'returns a warning if the public key or private key are not existing files' do
       expect { DataParser.eyaml(['foo.eyaml'], 'public.pem', 'private.pem') }.to output("Specified Public X509 and/or Private RSA PKCS7 certs do not exist. EYAML checks will not be executed.\n").to_stderr
     end
-    it 'puts a bad syntax eyaml file in the error files array' do
+    it 'puts a bad syntax eyaml file in the error files hash' do
       # DataParser.eyaml(["#{fixtures_dir}hieradata/syntax.eyaml'], fixtures_dir + 'keys/public_key.pkcs7.pem', fixtures_dir + 'keys/private_key.pkcs7.pem")
-      # expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.eyaml:\nblock sequence entries are not allowed})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      # expect(PuppetCheck.files[:errors][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.eyaml:\nblock sequence entries are not allowed})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good eyaml file with potential hiera issues in the warning files array' do
       # DataParser.eyaml(["#{fixtures_dir}hieradata/style.eyaml'], fixtures_dir + 'keys/public_key.pkcs7.pem', fixtures_dir + 'keys/private_key.pkcs7.pem")
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      # expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}hieradata/style.eyaml:\nValue\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera will fail to parse it correctly})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      # expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}hieradata/style.eyaml"])
+      # expect(PuppetCheck.files[:warnings]["#{fixtures_dir}hieradata/style.eyaml"]).to match(%r{^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera will fail to parse it correctly})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good eyaml file in the clean files array' do
       # DataParser.eyaml(["#{fixtures_dir}hieradata/good.eyaml'], fixtures_dir + 'keys/public_key.pkcs7.pem', fixtures_dir + 'keys/private_key.pkcs7.pem")
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      # expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.eyaml"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      # expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.eyaml"])
     end
   end
 
   context '.json' do
-    it 'puts a bad syntax json file in the error files array' do
+    it 'puts a bad syntax json file in the error files hash' do
       DataParser.json(["#{fixtures_dir}hieradata/syntax.json"])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.json:\n.*unexpected token})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.json"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.json"].join("\n")).to match(%r{^.*unexpected token})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
-    it 'puts a bad metadata json file in the error files array' do
+    it 'puts a bad metadata json file in the error files hash' do
       DataParser.json(["#{fixtures_dir}metadata_syntax/metadata.json"])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}metadata_syntax/metadata.json:\nRequired field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}metadata_syntax/metadata.json"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}metadata_syntax/metadata.json"].join("\n")).to match(%r{^Required field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style metadata json file in the warning files array' do
       DataParser.json(["#{fixtures_dir}metadata_style/metadata.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}metadata_style/metadata.json:\n'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}metadata_style/metadata.json"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}metadata_style/metadata.json"].join("\n")).to match(%r{^'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts another bad style metadata json file in the warning files array' do
       DataParser.json(["#{fixtures_dir}metadata_style_two/metadata.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}metadata_style_two/metadata.json:\n'puppetlabs/one' has non-semantic versioning.*\n'puppetlabs/two' is missing an upper bound\.\n.*operatingsystem.*\n.*operatingsystemrelease})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}metadata_style_two/metadata.json"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}metadata_style_two/metadata.json"].join("\n")).to match(%r{^'puppetlabs/one' has non-semantic versioning.*\n'puppetlabs/two' is missing an upper bound\.\n.*operatingsystem.*\n.*operatingsystemrelease})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad task metadata json file in the warning files array' do
       DataParser.json(["#{fixtures_dir}task_metadata/task_bad.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}task_metadata/task_bad.json:\ndescription value is not a String\ninput_method value is not one of environment, stdin, or powershell\nparameters value is not a Hash\npuppet_task_version value is not an Integer\nsupports_noop value is not a Boolean})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}task_metadata/task_bad.json"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}task_metadata/task_bad.json"].join("\n")).to match(%r{^description value is not a String\ninput_method value is not one of environment, stdin, or powershell\nparameters value is not a Hash\npuppet_task_version value is not an Integer\nsupports_noop value is not a Boolean})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good json file in the clean files array' do
       DataParser.json(["#{fixtures_dir}hieradata/good.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.json"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.json"])
     end
     it 'puts a good metadata json file in the clean files array' do
       DataParser.json(["#{fixtures_dir}metadata_good/metadata.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}metadata_good/metadata.json"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}metadata_good/metadata.json"])
     end
     it 'puts a good task metadata json file in the clean files array' do
       DataParser.json(["#{fixtures_dir}task_metadata/task_good.json"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}task_metadata/task_good.json"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}task_metadata/task_good.json"])
     end
   end
 end

data/spec/puppet-check/output_results_spec.rb

@@ -3,73 +3,62 @@ require_relative '../../lib/puppet-check/output_results'
 
 describe OutputResults do
   context '.text' do
-    before(:each) do
-      PuppetCheck.settings[:error_files] = []
-      PuppetCheck.settings[:warning_files] = []
-      PuppetCheck.settings[:clean_files] = []
-      PuppetCheck.settings[:ignored_files] = []
-    end
-
     it 'outputs files with errors' do
-      PuppetCheck.settings[:error_files] = ['foo: i had an error']
-      expect { OutputResults.text }.to output("\033[31mThe following files have errors:\033[0m\n-- foo: i had an error\n").to_stdout
+      files = { errors: { 'foo' => ['i had an error'] } }
+      expect { OutputResults.text(files) }.to output("\033[31mThe following files have errors:\033[0m\n-- foo:\ni had an error\n").to_stdout
     end
     it 'outputs files with warnings' do
-      PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
-      expect { OutputResults.text }.to output("\n\033[33mThe following files have warnings:\033[0m\n-- foo: i had a warning\n").to_stdout
+      files = { warnings: { 'foo' => ['i had a warning'] } }
+      expect { OutputResults.text(files) }.to output("\n\033[33mThe following files have warnings:\033[0m\n-- foo:\ni had a warning\n").to_stdout
     end
     it 'outputs files with no errors or warnings' do
-      PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
-      expect { OutputResults.text }.to output("\n\033[32mThe following files have no errors or warnings:\033[0m\n-- foo: i was totally good to go\n").to_stdout
+      files = { clean: ['foo'] }
+      expect { OutputResults.text(files) }.to output("\n\033[32mThe following files have no errors or warnings:\033[0m\n-- foo\n").to_stdout
     end
     it 'outputs files that were not processed' do
-      PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
-      expect { OutputResults.text }.to output("\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo: who knows what i am\n").to_stdout
+      files = { ignored: ['foo'] }
+      expect { OutputResults.text(files) }.to output("\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo\n").to_stdout
     end
   end
 
-  context '.markup' do
-    before(:each) do
-      PuppetCheck.settings[:error_files] = []
-      PuppetCheck.settings[:warning_files] = []
-      PuppetCheck.settings[:clean_files] = []
-      PuppetCheck.settings[:ignored_files] = []
+  context '.run' do
+    it 'redirects to text output formatting as expected' do
+      expect { OutputResults.run({}, 'text') }.to output('').to_stdout
     end
-
     it 'outputs files with errors as yaml' do
-      PuppetCheck.settings[:error_files] = ['foo: i had an error']
-      expect { OutputResults.markup('yaml') }.to output("---\nerrors:\n- 'foo: i had an error'\n").to_stdout
+      files = { errors: { 'foo' => ['i had an error'] } }
+      expect { OutputResults.run(files, 'yaml') }.to output("---\nerrors:\n  foo:\n  - i had an error\n").to_stdout
     end
     it 'outputs files with warnings as yaml' do
-      PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
-      expect { OutputResults.markup('yaml') }.to output("---\nwarnings:\n- 'foo: i had a warning'\n").to_stdout
+      files = { warnings: { 'foo' => ['i had a warning'] } }
+      expect { OutputResults.run(files, 'yaml') }.to output("---\nwarnings:\n  foo:\n  - i had a warning\n").to_stdout
     end
     it 'outputs files with no errors or warnings as yaml' do
-      PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
-      expect { OutputResults.markup('yaml') }.to output("---\nclean:\n- 'foo: i was totally good to go'\n").to_stdout
+      files = { clean: ['foo'] }
+      expect { OutputResults.run(files, 'yaml') }.to output("---\nclean:\n- foo\n").to_stdout
     end
     it 'outputs files that were not processed as yaml' do
-      PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
-      expect { OutputResults.markup('yaml') }.to output("---\nignored:\n- 'foo: who knows what i am'\n").to_stdout
+      files = { ignored: ['foo'] }
+      expect { OutputResults.run(files, 'yaml') }.to output("---\nignored:\n- foo\n").to_stdout
     end
     it 'outputs files with errors as json' do
-      PuppetCheck.settings[:error_files] = ['foo: i had an error']
-      expect { OutputResults.markup('json') }.to output("{\n  \"errors\": [\n    \"foo: i had an error\"\n  ]\n}\n").to_stdout
+      files = { errors: { 'foo' => ['i had an error'] } }
+      expect { OutputResults.run(files, 'json') }.to output("{\n  \"errors\": {\n    \"foo\": [\n      \"i had an error\"\n    ]\n  }\n}\n").to_stdout
     end
     it 'outputs files with warnings as json' do
-      PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
-      expect { OutputResults.markup('json') }.to output("{\n  \"warnings\": [\n    \"foo: i had a warning\"\n  ]\n}\n").to_stdout
+      files = { warnings: { 'foo' => ['i had a warning'] } }
+      expect { OutputResults.run(files, 'json') }.to output("{\n  \"warnings\": {\n    \"foo\": [\n      \"i had a warning\"\n    ]\n  }\n}\n").to_stdout
     end
     it 'outputs files with no errors or warnings as json' do
-      PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
-      expect { OutputResults.markup('json') }.to output("{\n  \"clean\": [\n    \"foo: i was totally good to go\"\n  ]\n}\n").to_stdout
+      files = { clean: ['foo'] }
+      expect { OutputResults.run(files, 'json') }.to output("{\n  \"clean\": [\n    \"foo\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files that were not processed as json' do
-      PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
-      expect { OutputResults.markup('json') }.to output("{\n  \"ignored\": [\n    \"foo: who knows what i am\"\n  ]\n}\n").to_stdout
+      files = { ignored: ['foo'] }
+      expect { OutputResults.run(files, 'json') }.to output("{\n  \"ignored\": [\n    \"foo\"\n  ]\n}\n").to_stdout
     end
     it 'raises an error for an unsupported output format' do
-      expect { OutputResults.markup('awesomesauce') }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
+      expect { OutputResults.run({}, 'awesomesauce') }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
     end
   end
 end

data/spec/puppet-check/puppet_parser_spec.rb

@@ -3,72 +3,81 @@ require_relative '../../lib/puppet-check/puppet_parser'
 
 describe PuppetParser do
   before(:each) do
-    PuppetCheck.settings[:error_files] = []
-    PuppetCheck.settings[:warning_files] = []
-    PuppetCheck.settings[:clean_files] = []
+    PuppetCheck.files = {
+      errors: {},
+      warnings: {},
+      clean: [],
+      ignored: []
+    }
   end
 
   context '.manifest' do
-    it 'puts a bad syntax Puppet manifest in the error files array' do
+    it 'puts a bad syntax Puppet manifest in the error files hash' do
       PuppetParser.manifest(["#{fixtures_dir}manifests/syntax.pp"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}manifests/syntax.pp"])
       if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('6.5.0')
-        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nLanguage validation logged 2 errors})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}manifests/syntax.pp"].join("\n")).to match(%r{^Language validation logged 2 errors})
       else
-        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(%r{^This Variable has no effect.*\nIllegal variable name})
       end
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     # puppet 5 api has output issues for this fixture
     unless Gem::Version.new(Puppet::PUPPETVERSION) < Gem::Version.new('6.0.0')
-      it 'puts a bad syntax at eof Puppet manifest in the error files array' do
+      it 'puts a bad syntax at eof Puppet manifest in the error files hash' do
         PuppetParser.manifest(["#{fixtures_dir}manifests/eof_syntax.pp"], false, [])
-        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/eof_syntax.pp:\nSyntax error at end of input})
-        expect(PuppetCheck.settings[:warning_files]).to eql([])
-        expect(PuppetCheck.settings[:clean_files]).to eql([])
+        expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}manifests/eof_syntax.pp"])
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}manifests/eof_syntax.pp"].join("\n")).to match(%r{^Syntax error at end of input})
+        expect(PuppetCheck.files[:warnings]).to eql({})
+        expect(PuppetCheck.files[:clean]).to eql([])
       end
     end
-    it 'puts a bad syntax Puppet plan in the error files array' do
+    it 'puts a bad syntax Puppet plan in the error files hash' do
       PuppetParser.manifest(["#{fixtures_dir}plans/syntax.pp"], false, [])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}plans/syntax.pp:\nSyntax error at '\)'})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}plans/syntax.pp"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}plans/syntax.pp"].join("\n")).to match(%r{^Syntax error at '\)'})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
-    it 'puts a bad parser and lint style Puppet manifest in the warning files array' do
+    it 'puts a bad parser style and lint style Puppet manifest in the warning files array' do
       PuppetParser.manifest(["#{fixtures_dir}manifests/style_parser.pp"], true, [])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_parser.pp:\nUnrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}manifests/style_parser.pp"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}manifests/style_parser.pp"].join("\n")).to match(%r{^Unrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad lint style Puppet manifest in the warning files array' do
       PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, [])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_lint.pp:\n.*(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}manifests/style_lint.pp"].join("\n")).to match(%r{(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style Puppet manifest in the clean files array when puppetlint_args ignores its warnings' do
       PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, ['--no-double_quoted_strings-check', '--no-arrow_alignment-check'])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
     end
     it 'puts a bad style Puppet plan in the warning files array' do
       PuppetParser.manifest(["#{fixtures_dir}plans/style.pp"], true, [])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}plans/style.pp:\n.*variable not enclosed in {}})
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}plans/style.pp"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}plans/style.pp"].join("\n")).to match(%r{variable not enclosed in {}})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good Puppet manifest in the clean files array' do
       PuppetParser.manifest(["#{fixtures_dir}manifests/good.pp"], true, [])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}manifests/good.pp"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}manifests/good.pp"])
     end
     it 'puts a good Puppet plan in the clean files array' do
       PuppetParser.manifest(["#{fixtures_dir}plans/good.pp"], true, [])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}plans/good.pp"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}plans/good.pp"])
     end
     it 'throws a well specified error for an invalid PuppetLint argument' do
       expect { PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, ['--non-existent', '--does-not-exist']) }.to raise_error(RuntimeError, 'puppet-lint: invalid option supplied among --non-existent --does-not-exist')
@@ -76,17 +85,18 @@ describe PuppetParser do
   end
 
   context '.template' do
-    it 'puts a bad syntax Puppet template in the error files array' do
+    it 'puts a bad syntax Puppet template in the error files hash' do
       PuppetParser.template(["#{fixtures_dir}templates/syntax.epp"])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.epp:\nThis Name has no effect})
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}templates/syntax.epp"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.epp"].join("\n")).to match(%r{^This Name has no effect})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good Puppet template in the clean files array' do
       PuppetParser.template(["#{fixtures_dir}templates/good.epp"])
-      expect(PuppetCheck.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}templates/good.epp"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}templates/good.epp"])
     end
   end
 end

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -15,10 +15,10 @@ describe RSpecPuppetSupport do
 
     it 'creates missing directories, missing site.pp, missing symlinks, and a missing spec_helper' do
       # travis ci
-      if ENV['TRAVIS'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      if ENV['TRAVIS'] == 'true'
         expect { rspec_puppet_setup }.to output("puppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
-      # circle ci
-      elsif ENV['CIRCLECI'] == 'true'
+      # circle ci and gh actions
+      elsif ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
         expect { rspec_puppet_setup }.to output("git is not installed and cannot be used to retrieve dependency modules\nsubversion is not installed and cannot be used to retrieve dependency modules\npuppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
       else
         expect { rspec_puppet_setup }.to output("subversion is not installed and cannot be used to retrieve dependency modules\npuppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
@@ -32,7 +32,7 @@ describe RSpecPuppetSupport do
       expect(File.file?('spec/spec_helper.rb')).to be true
 
       # .dependency_setup
-      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless ENV['CIRCLECI'] == 'true'
+      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
       expect(File.directory?('spec/fixtures/modules/stdlib')).to be true
     end
   end