puppet-check 1.4.0 → 1.4.1

data/spec/puppet-check/output_results_spec.rb

@@ -4,80 +4,80 @@ require_relative '../../lib/puppet-check/output_results'
 describe OutputResults do
   context '.text' do
     before(:each) do
-      PuppetCheck.error_files = []
-      PuppetCheck.warning_files = []
-      PuppetCheck.clean_files = []
-      PuppetCheck.ignored_files = []
+      PuppetCheck.settings[:error_files] = []
+      PuppetCheck.settings[:warning_files] = []
+      PuppetCheck.settings[:clean_files] = []
+      PuppetCheck.settings[:ignored_files] = []
     end
 
     it 'outputs files with errors' do
-      PuppetCheck.error_files = ['foo: i had an error']
+      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
     end
     it 'outputs files with warnings' do
-      PuppetCheck.warning_files = ['foo: i had a warning']
+      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
     end
     it 'outputs files with no errors or warnings' do
-      PuppetCheck.clean_files = ['foo: i was totally good to go']
+      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
     end
     it 'outputs files that were not processed' do
-      PuppetCheck.ignored_files = ['foo: who knows what i am']
+      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
     end
   end
 
   context '.markup' do
     before(:each) do
-      PuppetCheck.error_files = []
-      PuppetCheck.warning_files = []
-      PuppetCheck.clean_files = []
-      PuppetCheck.ignored_files = []
+      PuppetCheck.settings[:error_files] = []
+      PuppetCheck.settings[:warning_files] = []
+      PuppetCheck.settings[:clean_files] = []
+      PuppetCheck.settings[:ignored_files] = []
     end
 
     it 'outputs files with errors as yaml' do
-      PuppetCheck.output_format = 'yaml'
-      PuppetCheck.error_files = ['foo: i had an error']
+      PuppetCheck.settings[:output_format] = 'yaml'
+      PuppetCheck.settings[:error_files] = ['foo: i had an error']
       expect { OutputResults.markup }.to output("---\nerrors:\n- 'foo: i had an error'\n").to_stdout
     end
     it 'outputs files with warnings as yaml' do
-      PuppetCheck.output_format = 'yaml'
-      PuppetCheck.warning_files = ['foo: i had a warning']
+      PuppetCheck.settings[:output_format] = 'yaml'
+      PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
       expect { OutputResults.markup }.to output("---\nwarnings:\n- 'foo: i had a warning'\n").to_stdout
     end
     it 'outputs files with no errors or warnings as yaml' do
-      PuppetCheck.output_format = 'yaml'
-      PuppetCheck.clean_files = ['foo: i was totally good to go']
+      PuppetCheck.settings[:output_format] = 'yaml'
+      PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
       expect { OutputResults.markup }.to output("---\nclean:\n- 'foo: i was totally good to go'\n").to_stdout
     end
     it 'outputs files that were not processed as yaml' do
-      PuppetCheck.output_format = 'yaml'
-      PuppetCheck.ignored_files = ['foo: who knows what i am']
+      PuppetCheck.settings[:output_format] = 'yaml'
+      PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
       expect { OutputResults.markup }.to output("---\nignored:\n- 'foo: who knows what i am'\n").to_stdout
     end
     it 'outputs files with errors as json' do
-      PuppetCheck.output_format = 'json'
-      PuppetCheck.error_files = ['foo: i had an error']
+      PuppetCheck.settings[:output_format] = 'json'
+      PuppetCheck.settings[:error_files] = ['foo: i had an error']
       expect { OutputResults.markup }.to output("{\n  \"errors\": [\n    \"foo: i had an error\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files with warnings as json' do
-      PuppetCheck.output_format = 'json'
-      PuppetCheck.warning_files = ['foo: i had a warning']
+      PuppetCheck.settings[:output_format] = 'json'
+      PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
       expect { OutputResults.markup }.to output("{\n  \"warnings\": [\n    \"foo: i had a warning\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files with no errors or warnings as json' do
-      PuppetCheck.output_format = 'json'
-      PuppetCheck.clean_files = ['foo: i was totally good to go']
+      PuppetCheck.settings[:output_format] = 'json'
+      PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
       expect { OutputResults.markup }.to output("{\n  \"clean\": [\n    \"foo: i was totally good to go\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files that were not processed as json' do
-      PuppetCheck.output_format = 'json'
-      PuppetCheck.ignored_files = ['foo: who knows what i am']
+      PuppetCheck.settings[:output_format] = 'json'
+      PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
       expect { OutputResults.markup }.to output("{\n  \"ignored\": [\n    \"foo: who knows what i am\"\n  ]\n}\n").to_stdout
     end
     it 'raises an error for an unsupported output format' do
-      PuppetCheck.output_format = 'awesomesauce'
+      PuppetCheck.settings[:output_format] = 'awesomesauce'
       expect { OutputResults.markup }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
     end
   end

data/spec/puppet-check/puppet_parser_spec.rb

@@ -3,9 +3,9 @@ require_relative '../../lib/puppet-check/puppet_parser'
 
 describe PuppetParser do
   before(:each) do
-    PuppetCheck.error_files = []
-    PuppetCheck.warning_files = []
-    PuppetCheck.clean_files = []
+    PuppetCheck.settings[:error_files] = []
+    PuppetCheck.settings[:warning_files] = []
+    PuppetCheck.settings[:clean_files] = []
   end
 
   context '.manifest' do
@@ -13,36 +13,36 @@ describe PuppetParser do
       PuppetParser.manifest([fixtures_dir + 'manifests/syntax.pp'], false, false, [])
       # stupid Puppet deprecation warning
       if RUBY_VERSION.to_f < 2.1
-        expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nSupport for ruby version.*\n.*\nThis Variable has no effect.*\nIllegal variable name})
+        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nSupport for ruby version.*\n.*\nThis Variable has no effect.*\nIllegal variable name})
       else
-        expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
+        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
       end
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad parser and lint style Puppet manifest in the warning files array' do
       PuppetParser.manifest([fixtures_dir + 'manifests/style_parser.pp'], false, true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.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.clean_files).to eql([])
+      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([])
     end
     it 'puts a bad lint style Puppet manifest in the warning files array' do
       PuppetParser.manifest([fixtures_dir + 'manifests/style_lint.pp'], false, true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}manifests/style_lint.pp:\n.*double quoted string containing.*\n.*indentation of})
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_lint.pp:\n.*double quoted string containing.*\n.*indentation of})
+      expect(PuppetCheck.settings[:clean_files]).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'], false, true, ['--no-double_quoted_strings-check', '--no-arrow_alignment-check'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
+      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"])
     end
     it 'puts a good Puppet manifest in the clean files array' do
       PuppetParser.manifest([fixtures_dir + 'manifests/good.pp'], false, true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}manifests/good.pp"])
+      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"])
     end
     it 'throws a well specified error for an invalid PuppetLint argument' do
       expect { PuppetParser.manifest([fixtures_dir + 'manifests/style_lint.pp'], false, true, ['--non-existent', '--does-not-exist']) }.to raise_error(RuntimeError, 'puppet-lint: invalid option supplied among --non-existent --does-not-exist')
@@ -52,15 +52,15 @@ describe PuppetParser do
   context '.template' do
     it 'puts a bad syntax Puppet template in the error files array' do
       PuppetParser.template([fixtures_dir + 'templates/syntax.epp'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}templates/syntax.epp:\nThis Name has no effect})
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql([])
+      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([])
     end
     it 'puts a good Puppet template in the clean files array' do
       PuppetParser.template([fixtures_dir + 'templates/good.epp'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{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"])
     end
   end
 end

data/spec/puppet-check/regression_check_spec.rb

@@ -4,8 +4,11 @@ require_relative '../../lib/puppet-check/regression_check'
 # once a good config is loaded, bad configs would have no effect so failures are tested first; config is also tested before compilation so that the good config can be loaded at the end and used for compilation and regression tests
 describe RegressionCheck do
   context '.config' do
-    it 'raise an appropriate error if the file is malformed' do
-      expect { RegressionCheck.config(fixtures_dir + 'metadata.json') }.to raise_error(OctocatalogDiff::Errors::ConfigurationFileContentError, 'Configuration must define OctocatalogDiff::Config!')
+    # json gem got messed up for the EOL Ruby versions
+    if RUBY_VERSION.to_f >= 2.2
+      it 'raise an appropriate error if the file is malformed' do
+        expect { RegressionCheck.config(fixtures_dir + 'metadata.json') }.to raise_error(OctocatalogDiff::Errors::ConfigurationFileContentError, 'Configuration must define OctocatalogDiff::Config!')
+      end
     end
     it 'loads in a good octocatalog-diff config file' do
       expect { RegressionCheck.config(octocatalog_diff_dir + 'octocatalog-diff.cfg.rb') }.not_to raise_exception
@@ -16,14 +19,14 @@ describe RegressionCheck do
   end
 
   context '.smoke' do
-    # API requires :puppet_binary, which needs an absolute path, which is absurdly difficult to pull off for a matrix of travis ci rvm tests
+    # octocatalog-diff is returning a blank error for these tests
     unless File.directory?('/home/travis')
       it 'returns a pass for a successful catalog compilation' do
         expect { RegressionCheck.smoke(['good.example.com'], "#{octocatalog_diff_dir}octocatalog-diff.cfg.rb") }.not_to raise_exception
       end
-    end
-    it 'returns a failure for a catalog with an error' do
-      expect { RegressionCheck.smoke(['does_not_exist.example.com'], "#{octocatalog_diff_dir}octocatalog-diff.cfg.rb") }.to raise_error(OctocatalogDiff::Errors::CatalogError)
+      it 'returns a failure for a catalog with an error' do
+        expect { RegressionCheck.smoke(['does_not_exist.example.com'], "#{octocatalog_diff_dir}octocatalog-diff.cfg.rb") }.to raise_error(OctocatalogDiff::Errors::CatalogError)
+      end
     end
     it 'returns a failure for a good and bad catalog' do
       # RegressionCheck.smoke(['good.example.com', 'syntax_error.example.com'], "#{fixtures_dir}octocatalog-diff.cfg.rb")

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -25,8 +25,8 @@ describe RSpecPuppetSupport do
       expect(File.directory?('spec/fixtures/modules/stdlib')).to be true
 
       # cleanup rspec_puppet_setup
-      %w(spec/spec_helper.rb).each { |file| File.delete(file) }
-      %w(manifests modules).each { |dir| FileUtils.rm_r('spec/fixtures/' + dir) }
+      %w[spec/spec_helper.rb].each { |file| File.delete(file) }
+      %w[manifests modules].each { |dir| FileUtils.rm_r('spec/fixtures/' + dir) }
     end
   end
 end

data/spec/puppet-check/ruby_parser_spec.rb

@@ -3,89 +3,89 @@ require_relative '../../lib/puppet-check/ruby_parser'
 
 describe RubyParser do
   before(:each) do
-    PuppetCheck.error_files = []
-    PuppetCheck.warning_files = []
-    PuppetCheck.clean_files = []
+    PuppetCheck.settings[:error_files] = []
+    PuppetCheck.settings[:warning_files] = []
+    PuppetCheck.settings[:clean_files] = []
   end
 
   context '.ruby' do
     it 'puts a bad syntax ruby file in the error files array' do
       RubyParser.ruby([fixtures_dir + 'lib/syntax.rb'], false, [])
-      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}lib/syntax.rb:\n.*syntax error})
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}lib/syntax.rb:\n.*syntax error})
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style ruby file in the warning files array' do
       RubyParser.ruby([fixtures_dir + 'lib/style.rb'], true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}lib/style.rb:\n.*Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment})
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}lib/style.rb:\n.*Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment})
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style ruby file in the clean files array when rubocop_args ignores its warnings' do
       RubyParser.ruby([fixtures_dir + 'lib/rubocop_style.rb'], true, ['--except', 'Lint/UselessAssignment,Style/HashSyntax,Style/GlobalVars,Style/StringLiterals'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}lib/rubocop_style.rb"])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}lib/rubocop_style.rb"])
     end
     it 'puts a good ruby file in the clean files array' do
       RubyParser.ruby([fixtures_dir + 'lib/good.rb'], true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}lib/good.rb"])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}lib/good.rb"])
     end
   end
 
   context '.template' do
     it 'puts a bad syntax ruby template file in the error files array' do
       RubyParser.template([fixtures_dir + 'templates/syntax.erb'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}templates/syntax.erb:\n.*syntax error, unexpected tIDENTIFIER})
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.erb:\n.*syntax error, unexpected tIDENTIFIER})
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style ruby template file in the warning files array' do
       RubyParser.template([fixtures_dir + 'templates/style.erb'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}templates/style.erb:\n.*already initialized constant.*\n.*previous definition of})
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}templates/style.erb:\n.*already initialized constant.*\n.*previous definition of})
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a ruby template file with ignored errors in the clean files array' do
       RubyParser.template([fixtures_dir + 'templates/no_method_error.erb'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}templates/no_method_error.erb"])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}templates/no_method_error.erb"])
     end
     it 'puts a good ruby template file in the clean files array' do
       RubyParser.template([fixtures_dir + 'templates/good.erb'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}templates/good.erb"])
+      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.erb"])
     end
   end
 
   context '.librarian' do
     it 'puts a bad syntax librarian Puppet file in the error files array' do
       RubyParser.librarian([fixtures_dir + 'librarian_syntax/Puppetfile'], false, [])
-      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}librarian_syntax/Puppetfile:\n.*syntax error})
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}librarian_syntax/Puppetfile:\n.*syntax error})
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style librarian Puppet file in the warning files array' do
       RubyParser.librarian([fixtures_dir + 'librarian_style/Puppetfile'], true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}librarian_style/Puppetfile:\n.*Align the parameters.*\n.*Use the new})
-      expect(PuppetCheck.clean_files).to eql([])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}librarian_style/Puppetfile:\n.*Align the parameters.*\n.*Use the new})
+      expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style librarian Puppet file in the clean files array when rubocop_args ignores its warnings' do
       RubyParser.librarian([fixtures_dir + 'librarian_style/Puppetfile'], true, ['--except', 'Style/AlignParameters,Style/HashSyntax'])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
     end
     it 'puts a good librarian Puppet file in the clean files array' do
       RubyParser.librarian([fixtures_dir + 'librarian_good/Puppetfile'], true, [])
-      expect(PuppetCheck.error_files).to eql([])
-      expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])
     end
   end
 end

data/spec/puppet-check/tasks_spec.rb

@@ -15,8 +15,8 @@ describe PuppetCheck::Tasks do
       expect { spec_tasks }.not_to raise_exception
 
       # cleanup rspec_puppet_setup
-      %w(spec/spec_helper.rb).each { |file| File.delete(file) }
-      %w(manifests modules).each { |dir| FileUtils.rm_r('spec/fixtures/' + dir) }
+      %w[spec/spec_helper.rb].each { |file| File.delete(file) }
+      %w[manifests modules].each { |dir| FileUtils.rm_r('spec/fixtures/' + dir) }
     end
   end
 

data/spec/puppet-check_spec.rb

@@ -4,34 +4,36 @@ require_relative '../lib/puppet-check'
 describe PuppetCheck do
   context 'self' do
     it 'settings can be altered' do
-      PuppetCheck.future_parser = true
-      expect(PuppetCheck.future_parser).to eql(true)
-      PuppetCheck.style_check = true
-      expect(PuppetCheck.style_check).to eql(true)
-      PuppetCheck.smoke_check = true
-      expect(PuppetCheck.smoke_check).to eql(true)
-      PuppetCheck.regression_check = true
-      expect(PuppetCheck.regression_check).to eql(true)
-      PuppetCheck.output_format = 'text'
-      expect(PuppetCheck.output_format).to eql('text')
-      PuppetCheck.octoconfig = '.octocatalog-diff.cfg.rb'
-      expect(PuppetCheck.octoconfig).to eql('.octocatalog-diff.cfg.rb')
-      PuppetCheck.octonodes = %w(localhost.localdomain)
-      expect(PuppetCheck.octonodes).to eql(%w(localhost.localdomain))
-      PuppetCheck.puppetlint_args = ['--puppetlint-arg-one', '--puppetlint-arg-two']
-      expect(PuppetCheck.puppetlint_args).to eql(['--puppetlint-arg-one', '--puppetlint-arg-two'])
-      PuppetCheck.rubocop_args = ['--rubocop-arg-one', '--rubocop-arg-two']
-      expect(PuppetCheck.rubocop_args).to eql(['--rubocop-arg-one', '--rubocop-arg-two'])
+      PuppetCheck.settings[:future_parser] = true
+      expect(PuppetCheck.settings[:future_parser]).to eql(true)
+      PuppetCheck.settings[:fail_on_warnings] = true
+      expect(PuppetCheck.settings[:fail_on_warnings]).to eql(true)
+      PuppetCheck.settings[:style_check] = true
+      expect(PuppetCheck.settings[:style_check]).to eql(true)
+      PuppetCheck.settings[:smoke_check] = true
+      expect(PuppetCheck.settings[:smoke_check]).to eql(true)
+      PuppetCheck.settings[:regression_check] = true
+      expect(PuppetCheck.settings[:regression_check]).to eql(true)
+      PuppetCheck.settings[:output_format] = 'text'
+      expect(PuppetCheck.settings[:output_format]).to eql('text')
+      PuppetCheck.settings[:octoconfig] = '.octocatalog-diff.cfg.rb'
+      expect(PuppetCheck.settings[:octoconfig]).to eql('.octocatalog-diff.cfg.rb')
+      PuppetCheck.settings[:octonodes] = %w[localhost.localdomain]
+      expect(PuppetCheck.settings[:octonodes]).to eql(%w[localhost.localdomain])
+      PuppetCheck.settings[:puppetlint_args] = ['--puppetlint-arg-one', '--puppetlint-arg-two']
+      expect(PuppetCheck.settings[:puppetlint_args]).to eql(['--puppetlint-arg-one', '--puppetlint-arg-two'])
+      PuppetCheck.settings[:rubocop_args] = ['--rubocop-arg-one', '--rubocop-arg-two']
+      expect(PuppetCheck.settings[:rubocop_args]).to eql(['--rubocop-arg-one', '--rubocop-arg-two'])
     end
   end
 
   context '.parse_paths' do
     before(:each) { Dir.chdir(fixtures_dir) }
 
-    let(:no_files) { PuppetCheck.parse_paths(%w(foo bar baz)) }
+    let(:no_files) { PuppetCheck.parse_paths(%w[foo bar baz]) }
     let(:file) { PuppetCheck.parse_paths(['lib/good.rb']) }
     let(:dir) { PuppetCheck.parse_paths(['.']) }
-    let(:multi_dir) { PuppetCheck.parse_paths(%w(hieradata lib manifests)) }
+    let(:multi_dir) { PuppetCheck.parse_paths(%w[hieradata lib manifests]) }
     let(:repeats) { PuppetCheck.parse_paths(['hieradata', 'hieradata', 'lib', 'hieradata/good.json', 'manifests/good.pp', 'manifests/good.pp']) }
 
     it 'raises an error if no files were found' do
@@ -59,6 +61,16 @@ describe PuppetCheck do
   end
 
   context '.execute_parsers' do
-    #
+    it 'correctly organizes a set of files and invokes the correct parsers' do
+      # parser_output = instance_double('execute_parsers', files: %w[puppet.pp puppet_template.epp ruby.rb ruby_template.erb yaml.yaml yaml.yml json.json Puppetfile Modulefile foobarbaz], future: false, style: false, pl_args: [], rc_args: [])
+      # expect(parser_output).to receive(:manifest).with(%w[puppet.pp])
+      # expect(parser_output).to receive(:template).with(%w[puppet_template.epp])
+      # expect(parser_output).to receive(:ruby).with(%w[ruby.rb])
+      # expect(parser_output).to receive(:template).with(%w[ruby_template.erb])
+      # expect(parser_output).to receive(:yaml).with(%w[yaml.yaml yaml.yml])
+      # expect(parser_output).to receive(:json).with(%w[json.json])
+      # expect(parser_output).to receive(:librarian).with(%w[Puppetfile Modulefile])
+      # expect(PuppetCheck.settings[:ignored_files]).to eql(%w[foobarbaz])
+    end
   end
 end