puppet-check 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b2722f210a74837313e3463c41abd5f07018fcf
-  data.tar.gz: 5f36ae7fb5b25c86f4da1c56391aeacb61e14363
+  metadata.gz: 2ce83eaa817c69d2ca4cd5219571bc0af2d0e125
+  data.tar.gz: 34afb49f0e47a20d75417dd11d5f2d277192394b
 SHA512:
-  metadata.gz: 93a0d80d2958ff85aa42f28936b0988f8cbab2701f2a49e9b44eeb4e44fa9a2bd006b606e82de10939451d0656c27f38521c0d72fa1546fb3f5ea01e83c5d6fd
-  data.tar.gz: 44d9243626055c3e2578e6c6c5ef6bb1b5a89978a543caa7a12588e319f1b52620d948fc20d6989ba3c535d02ecb43c407992bece46ecaf419c0c4bdad305dc5
+  metadata.gz: 1d5e0aae72d0fd85ac9332c2abbccb16d5000c458677ade54adac994a343037301f7abc123245a582ecbd1b151cd52f633264d43d1fe815895fa4f0af58ed602
+  data.tar.gz: 3ea14379bdcd682feedbdf10a82c2939f175832c2794ebc9fb81d0e673703d8f354c63664a4cbc6ce31380829a306424033e1190b0489e29ac58581e17796d46

data/CHANGELOG.md

@@ -1,13 +1,28 @@
-### 1.3.0 (Roadmap)
-- minimum ruby version bump to 2.0.0 (switch vagrant to centos7, remove 1.9.3 from travis.yml, add 2.3.x to travis.yml, update readme, remove psych::syntaxerror from dataparser.yaml, and remove 1.9.3 test from rubyparser.template style spec)
-- minimum puppet version bump to 3.4
+### 1.4.0 (Roadmap)
+- rudimentary catalog compilation testing? (only for Puppet4)
+- minimum Puppet version increased from 3.4 to 3.7.
 - rakefile interface with puppet-lint, rubocop, reek
-- json and yaml output formats support (error_files becomes hash with file keys and array of issues; refactor output_results)
-- rudimentary catalog compilation testing?
 - rspec puppet stubbing
 - infrataster and analogous docker task like thing ripienaar did?
+- some multithreading for speedup
+
+### 1.3.1 (Roadmap)
+- split syntax and style checks to separate methods for speedup
+- more args, fewer self accessors
+- improved json and yaml output formats support (file arrays become file hashes and output results further handles formatting)
+- metadata.json checks for dependency upper bounds, dependencies/operatingsystem_support as array of hashes, and operatingsystem and operatingsystem_release within operatingsystem_support
+- do another reek and rubocop check
 - add additional hiera checks
 
+### 1.3.0
+- Minimum Ruby version increased from 1.9.3 to 2.0.0.
+- Minimum Puppet version increased from 3.2 to 3.4.
+- Fixed issue where invalid arguments to PuppetLint were not displayed in error message.
+- Support for outputting the results in YAML or JSON formats.
+- Additional style check for `metadata.json`.
+- Slight code cleanup and optimization.
+- Block hieradata checks from excuting on `hiera.yaml`.
+
 ### 1.2.1
 - Code and output cleanup.
 - Add arguments support to external module download methods.

data/README.md

@@ -116,16 +116,17 @@ The following files have unrecognized formats and therefore were not processed:
 It is worth nothing that there is no current development objective for Puppet Check to achieve the same advanced level of robustness for spec testing that Puppetlabs Spec Helper enables. If you are performing standard spec testing on your Puppet code and data, then Puppet Check's spec testing is a fantastic lightweight and faster alternative to Puppetlabs Spec Helper. If you require advanced and intricate capabilities in your spec testing (e.g. direct interfacing to the `Puppet::Parser::Scope` API), then you will likely prefer Puppetlabs Spec Helper's spec testing in conjunction with Puppet Check's file validation.
 
 ## Usage
-Puppet Check requires `ruby >= 1.9.3`, `puppet >= 3.2`, and `puppet-lint >= 2.0.0`. All other dependencies should be fine with various versions. Puppet Check can be used either with a CLI or Rake tasks. Please note both interfaces will ignore any directories named `fixtures` or specified paths with that directory during file checks and spec tests.
+Puppet Check requires `ruby >= 2.0.0`, `puppet >= 3.4`, and `puppet-lint >= 2.0.0`. All other dependencies should be fine with various versions. Puppet Check can be used either with a CLI or Rake tasks. Please note both interfaces will ignore any directories named `fixtures` or specified paths with that directory during file checks and spec tests.
 
-#### Important Note for Ruby 1.9.3
-If you are using Ruby 1.9.3, there is currently an issue where Hiera has an unspecified version dependency on JSonPure. Since JSonPure 2.0.2 requires `ruby >= 2.0.0`, this breaks Hiera installs on Ruby 1.9.3, which breaks Puppet installs, which breaks PuppetCheck installs. Therefore, you will need to restrict your installed version of JSonPure to something lower than 2.0.2 if you are using Ruby 1.9.3. A ticket with Puppet has been filed by me for this issue, so hopefully a resolution is forthcoming.
+#### Important Note for Ruby 1.9.3 and PuppetCheck <= 1.2.1
+If you are using Ruby 1.9.3, there is an issue where `Hiera <= 3.2.0` has an unspecified version dependency on JSonPure. Since JSonPure 2.0.2 requires `ruby >= 2.0.0`, this breaks Hiera installs on Ruby 1.9.3, which breaks Puppet installs, which breaks PuppetCheck installs. Therefore, you will need to either restrict your installed version of JSonPure to something lower than 2.0.2 if you are using Ruby 1.9.3, or use `Hiera >= 3.2.1`.
 
 ### CLI
 ```
 usage: puppet-check [options] paths
     -f, --future                     Enable future parser
     -s, --style                      Enable style checks
+    -o, --output format              Format for results output (default is text): text, json, or yaml
         --puppet-lint arg_one,arg_two
                                      Arguments for PuppetLint ignored checks
     -c, --config file                Load PuppetLint options from file.
@@ -150,13 +151,16 @@ rake puppetcheck:beaker    # Execute Beaker acceptance tests
 ```
 
 #### puppetcheck:file
-You can add style checks to and select the future parser for the `rake puppetcheck:file` by adding the following after the require:
+You can add style checks to and select the future parser for the `rake puppetcheck:file`, or change the output format, by adding the following after the require:
 
 ```ruby
 PuppetCheck.style_check = true
 PuppetCheck.future_parser = true
+PuppetCheck.output_format = yaml
 ```
 
+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.
+
 The style checks from within `rake puppetcheck:file` are directly interfaced to `puppet-lint`, `rubocop`, and `reek`. This means that all arguments and options should be specified from within your `.puppet-lint.rc`, `.rubocop.yml`, and `*.reek`. The capability to pass style arguments and options from within the `Rakefile` task block will be considered for future versions.
 
 #### puppetcheck:spec
@@ -222,19 +226,19 @@ RUN apt-get update && apt-get install ruby git -y
 RUN gem install --no-rdoc --no-ri puppet-check reek rspec-puppet rake
 # this is needed for the ruby json parser to not flip out on fresh os installs for some reason (change encoding value as necessary)
 ENV LANG en_US.UTF-8
-# create the directory for your module and change directory into it
-WORKDIR /module_name
-# copy the module contents into the module directory inside the container
+# create the directory for your module, directory environment, etc. and change directory into it
+WORKDIR /module_name_or_directory_environment_name
+# copy the module, directory environment, etc. contents into the module directory inside the container
 COPY / .
-# execute your tests; in this example we are executing the full suite of tests for this module
-RUN rake puppetcheck
+# execute your tests; in this example we are executing the full suite of tests
+ENTRYPOINT ["rake", "puppetcheck"]
 ```
 
 You can also build your own general container for testing various Puppet situations by removing the last three lines. You can then test each module, directory environment, etc. on top of that container by merely adding and modifying the final three lines to a Dockerfile that uses the container you built from the first four lines. This is recommended usage due to being very efficient and stable.
 
 ### Exit Codes
 - 0: PuppetCheck exited with no internal exceptions or errors in your Puppet code and data.
-- 1: PuppetCheck exited with an internal exception (takes preference over other non-zero exit codes).
+- 1: PuppetCheck exited with an internal exception (takes preference over other non-zero exit codes) or failed spec test.
 - 2: PuppetCheck exited with one or more errors in your Puppet code and data.
 
 ### Optional dependencies

data/lib/puppet-check.rb

@@ -1,6 +1,7 @@
 require_relative 'puppet-check/puppet_parser'
 require_relative 'puppet-check/ruby_parser'
 require_relative 'puppet-check/data_parser'
+require_relative 'puppet-check/output_results'
 
 # interfaces from CLI/tasks and to individual parsers
 class PuppetCheck
@@ -8,6 +9,9 @@ class PuppetCheck
   @future_parser = false
   @style_check = false
 
+  # initialize output format option
+  @output_format = 'text'
+
   # initialize diagnostic output arrays
   @error_files = []
   @warning_files = []
@@ -20,7 +24,7 @@ class PuppetCheck
 
   # allow the parser methods read user options and append to the file arrays; allow CLI and tasks write to user options
   class << self
-    attr_accessor :future_parser, :style_check, :error_files, :warning_files, :clean_files, :ignored_files, :puppetlint_args, :rubocop_args
+    attr_accessor :future_parser, :style_check, :output_format, :error_files, :warning_files, :clean_files, :ignored_files, :puppetlint_args, :rubocop_args
   end
 
   # main runner for PuppetCheck
@@ -32,7 +36,7 @@ class PuppetCheck
     execute_parsers(files)
 
     # output the diagnostic results
-    self.class.output_results
+    PuppetCheck.output_format == 'text' ? OutputResults.text : OutputResults.markup
 
     # exit code
     self.class.error_files.empty? ? 0 : 2
@@ -75,14 +79,6 @@ class PuppetCheck
     files.reject! { |file| File.extname(file) == '.json' }
     RubyParser.librarian(files.select { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem)file$/ })
     files.reject! { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem)file$/ }
-    files.each { |file| self.class.ignored_files.push("-- #{file}") }
-  end
-
-  # output the results for the files that were requested to be checked
-  def self.output_results
-    puts "\033[31mThe following files have errors:\033[0m", error_files.join("\n\n") unless error_files.empty?
-    puts "\n\033[33mThe following files have warnings:\033[0m", warning_files.join("\n\n") unless warning_files.empty?
-    puts "\n\033[32mThe following files have no errors or warnings:\033[0m", clean_files unless clean_files.empty?
-    puts "\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m", ignored_files unless ignored_files.empty?
+    files.each { |file| self.class.ignored_files.push(file.to_s) }
   end
 end

data/lib/puppet-check/cli.rb

@@ -21,7 +21,7 @@ class PuppetCheck::CLI
 
       # base options
       opts.on('--version', 'Display the current version.') do
-        puts 'puppet-check 1.2.1'
+        puts 'puppet-check 1.3.0'
         exit 0
       end
 
@@ -29,6 +29,9 @@ class PuppetCheck::CLI
       opts.on('-f', '--future', 'Enable future parser') { PuppetCheck.future_parser = true }
       opts.on('-s', '--style', 'Enable style checks') { PuppetCheck.style_check = true }
 
+      # formatting options
+      opts.on('-o', '--output format', String, 'Format for results output (default is text): text, json, or yaml') { |arg| PuppetCheck.output_format = arg }
+
       # arguments to style checkers
       opts.on('--puppet-lint arg_one,arg_two', Array, 'Arguments for PuppetLint ignored checks') do |puppetlint_args|
         PuppetCheck.puppetlint_args += puppetlint_args.map { |arg| "--#{arg}" }

data/lib/puppet-check/data_parser.rb

@@ -10,13 +10,16 @@ class DataParser
       # check yaml syntax
       begin
         parsed = YAML.load_file(file)
-      rescue Psych::SyntaxError, StandardError => err
-        PuppetCheck.error_files.push("-- #{file}:\n#{err.to_s.gsub("(#{file}): ", '')}")
+      rescue StandardError => err
+        PuppetCheck.error_files.push("#{file}:\n#{err.to_s.gsub("(#{file}): ", '')}")
       else
-        # perform some rudimentary hiera checks if data exists
-        warnings = parsed.class.to_s == 'NilClass' ? [] : hiera(parsed)
-        next PuppetCheck.warning_files.push("-- #{file}:\n#{warnings.join("\n")}") unless warnings.empty?
-        PuppetCheck.clean_files.push("-- #{file}")
+        warnings = []
+
+        # perform some rudimentary hiera checks if data exists and is hieradata
+        warnings = hiera(parsed) unless (parsed.class.to_s == 'NilClass') || (file == 'hiera.yaml')
+
+        next PuppetCheck.warning_files.push("#{file}:\n#{warnings.join("\n")}") unless warnings.empty?
+        PuppetCheck.clean_files.push(file.to_s)
       end
     end
   end
@@ -30,7 +33,7 @@ class DataParser
       begin
         parsed = JSON.parse(File.read(file))
       rescue JSON::ParserError => err
-        PuppetCheck.error_files.push("-- #{file}:\n#{err.to_s.lines.first.strip}")
+        PuppetCheck.error_files.push("#{file}:\n#{err.to_s.lines.first.strip}")
       else
         warnings = []
 
@@ -66,9 +69,12 @@ class DataParser
           # check for summary under 144 character
           errors.push('Summary exceeds 144 characters.') if parsed.key?('summary') && parsed['summary'].size > 144
 
-          next PuppetCheck.error_files.push("-- #{file}:\n#{errors.join("\n")}") unless errors.empty?
+          next PuppetCheck.error_files.push("#{file}:\n#{errors.join("\n")}") unless errors.empty?
 
           # check for warnings
+          # check for operatingsystem_support
+          warnings.push('Recommended field \'operatingsystem_support\' not found.') unless parsed.key?('operatingsystem_support')
+
           # check for spdx license (rubygems/util/licenses for rubygems >= 2.5 in the far future)
           if parsed.key?('license') && !SpdxLicenses.exist?(parsed['license']) && parsed['license'] !~ /[pP]roprietary/
             warnings.push("License identifier '#{parsed['license']}' is not in the SPDX list: http://spdx.org/licenses/")
@@ -78,8 +84,8 @@ class DataParser
           # perform some rudimentary hiera checks if data exists
           warnings = hiera(parsed) unless parsed.class.to_s == 'NilClass'
         end
-        next PuppetCheck.warning_files.push("-- #{file}:\n#{warnings.join("\n")}") unless warnings.empty?
-        PuppetCheck.clean_files.push("-- #{file}")
+        next PuppetCheck.warning_files.push("#{file}:\n#{warnings.join("\n")}") unless warnings.empty?
+        PuppetCheck.clean_files.push(file.to_s)
       end
     end
   end

data/lib/puppet-check/output_results.rb

@@ -0,0 +1,46 @@
+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.error_files.empty?
+      print "\033[31mThe following files have errors:\033[0m\n-- "
+      puts PuppetCheck.error_files.join("\n\n-- ")
+    end
+    unless PuppetCheck.warning_files.empty?
+      print "\n\033[33mThe following files have warnings:\033[0m\n-- "
+      puts PuppetCheck.warning_files.join("\n\n-- ")
+    end
+    unless PuppetCheck.clean_files.empty?
+      print "\n\033[32mThe following files have no errors or warnings:\033[0m\n-- "
+      puts PuppetCheck.clean_files.join("\n-- ")
+    end
+    unless PuppetCheck.ignored_files.empty?
+      print "\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- "
+      puts PuppetCheck.ignored_files.join("\n-- ")
+    end
+  end
+
+  # output the results as yaml or json
+  def self.markup
+    require 'yaml'
+    require 'json'
+
+    # generate output hash
+    hash = {}
+    hash['errors'] = PuppetCheck.error_files unless PuppetCheck.error_files.empty?
+    hash['warnings'] = PuppetCheck.warning_files unless PuppetCheck.warning_files.empty?
+    hash['clean'] = PuppetCheck.clean_files unless PuppetCheck.clean_files.empty?
+    hash['ignored'] = PuppetCheck.ignored_files unless PuppetCheck.ignored_files.empty?
+
+    # convert hash to markup language
+    if PuppetCheck.output_format == 'yaml'
+      puts Psych.dump(hash, indentation: 2)
+    elsif PuppetCheck.output_format == 'json'
+      puts JSON.pretty_generate(hash)
+    else
+      raise "puppet-check: Unsupported output format '#{PuppetCheck.output_format}' was specified."
+    end
+  end
+end

data/lib/puppet-check/puppet_parser.rb

@@ -21,11 +21,11 @@ class PuppetParser
         Puppet::Face[:parser, :current].validate(file)
       # this is the actual error that we need to rescue Puppet::Face from
       rescue SystemExit
-        next PuppetCheck.error_files.push("-- #{file}:\n#{errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')}")
+        next PuppetCheck.error_files.push("#{file}:\n#{errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')}")
       end
 
       # initialize warnings with output from the parser if it exists, since the output is warnings if Puppet::Face did not trigger a SystemExit
-      warnings = errors.empty? ? "-- #{file}:" : "-- #{file}:\n#{errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')}"
+      warnings = errors.empty? ? "#{file}:" : "#{file}:\n#{errors.map(&:to_s).join("\n").gsub("#{File.absolute_path(file)}:", '')}"
       Puppet::Util::Log.close_all
 
       # check puppet style
@@ -35,9 +35,9 @@ class PuppetParser
 
         # check for invalid arguments to PuppetLint
         begin
-          PuppetLint::OptParser.build.parse!(PuppetCheck.puppetlint_args)
+          PuppetLint::OptParser.build.parse!(PuppetCheck.puppetlint_args.clone)
         rescue OptionParser::InvalidOption
-          raise "puppet-lint: invalid option supplied among #{PuppetCheck.puppetlint_args}"
+          raise "puppet-lint: invalid option supplied among #{PuppetCheck.puppetlint_args.join(' ')}"
         end
 
         # prepare the PuppetLint object for style checks
@@ -50,8 +50,8 @@ class PuppetParser
           puppet_lint.problems.each { |values| warnings += "\n#{values[:line]}:#{values[:column]}: #{values[:message]}" }
         end
       end
-      next PuppetCheck.warning_files.push(warnings) unless warnings == "-- #{file}:"
-      PuppetCheck.clean_files.push("-- #{file}")
+      next PuppetCheck.warning_files.push(warnings) unless warnings == "#{file}:"
+      PuppetCheck.clean_files.push(file.to_s)
     end
   end
 
@@ -61,16 +61,16 @@ class PuppetParser
 
     files.each do |file|
       # puppet before version 4 cannot check template syntax
-      next PuppetCheck.ignored_files.push("-- #{file}: ignored due to Puppet < 4.0.0") if Puppet::PUPPETVERSION.to_i < 4
+      next PuppetCheck.ignored_files.push("#{file}: ignored due to Puppet < 4.0.0") if Puppet::PUPPETVERSION.to_i < 4
 
       # check puppet template syntax
       begin
         # credits to gds-operations/puppet-syntax for the parser function call
         Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new.parse_file(file)
       rescue StandardError => err
-        PuppetCheck.error_files.push("-- #{file}:\n#{err.to_s.gsub("#{file}:", '')}")
+        PuppetCheck.error_files.push("#{file}:\n#{err.to_s.gsub("#{file}:", '')}")
       else
-        PuppetCheck.clean_files.push("-- #{file}")
+        PuppetCheck.clean_files.push(file.to_s)
       end
     end
   end

data/lib/puppet-check/rspec_puppet_support.rb

@@ -16,7 +16,7 @@ class RSpecPuppetSupport
       # skip to next specdir if it does not seem like a puppet module
       next unless File.directory?(specdir + '/../manifests')
 
-      # move up to module directory
+      # change to module directory
       Dir.chdir(specdir + '/..')
 
       # grab the module name from the directory name of the module to pass to file_setup
@@ -29,19 +29,17 @@ class RSpecPuppetSupport
 
   # setup the files, directories, and symlinks for rspec-puppet testing
   def self.file_setup(module_name)
-    require 'fileutils'
-
     # create all the necessary fixture dirs that are missing
     ['spec/fixtures', 'spec/fixtures/manifests', 'spec/fixtures/modules', "spec/fixtures/modules/#{module_name}"].each do |dir|
-      FileUtils.mkdir(dir) unless File.directory?(dir)
+      Dir.mkdir(dir) unless File.directory?(dir)
     end
 
     # create empty site.pp if missing
-    FileUtils.touch('spec/fixtures/manifests/site.pp') unless File.file?('spec/fixtures/manifests/site.pp')
+    File.write('spec/fixtures/manifests/site.pp', '') unless File.file?('spec/fixtures/manifests/site.pp')
 
     # symlink over everything the module needs for compilation
     %w(hiera.yaml data hieradata functions manifests lib files templates).each do |file|
-      FileUtils.ln_s("../../../../#{file}", "spec/fixtures/modules/#{module_name}/#{file}") if File.exist?(file) && !File.exist?("spec/fixtures/modules/#{module_name}/#{file}")
+      File.symlink("../../../../#{file}", "spec/fixtures/modules/#{module_name}/#{file}") if File.exist?(file) && !File.exist?("spec/fixtures/modules/#{module_name}/#{file}")
     end
 
     # create spec_helper if missing

data/lib/puppet-check/ruby_parser.rb

@@ -11,7 +11,7 @@ class RubyParser
         # prevents ruby code from actually executing
         catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}") }
       rescue ScriptError, StandardError => err
-        PuppetCheck.error_files.push("-- #{file}:\n#{err}")
+        PuppetCheck.error_files.push("#{file}:\n#{err}")
       else
         # check ruby style
         if PuppetCheck.style_check
@@ -30,9 +30,9 @@ class RubyParser
           end
 
           # return warnings
-          next PuppetCheck.warning_files.push("-- #{file}:\n#{warnings.strip}") unless warnings == ''
+          next PuppetCheck.warning_files.push("#{file}:\n#{warnings.strip}") unless warnings == ''
         end
-        PuppetCheck.clean_files.push("-- #{file}")
+        PuppetCheck.clean_files.push(file.to_s)
       end
     end
   end
@@ -52,11 +52,11 @@ class RubyParser
         # empty out warnings since it would contain an error if this pass triggers
         warnings = ''
       rescue ScriptError => err
-        next PuppetCheck.error_files.push("-- #{file}:\n#{err}")
+        next PuppetCheck.error_files.push("#{file}:\n#{err}")
       end
       # return warnings from the check if there were any
-      next PuppetCheck.warning_files.push("-- #{file}:\n#{warnings.gsub('warning: ', '').split('(erb):').join('').strip}") unless warnings == ''
-      PuppetCheck.clean_files.push("-- #{file}")
+      next PuppetCheck.warning_files.push("#{file}:\n#{warnings.gsub('warning: ', '').split('(erb):').join('').strip}") unless warnings == ''
+      PuppetCheck.clean_files.push(file.to_s)
     end
   end
 
@@ -68,7 +68,7 @@ class RubyParser
         # prevents ruby code from actually executing
         catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}") }
       rescue SyntaxError, LoadError, ArgumentError => err
-        PuppetCheck.error_files.push("-- #{file}:\n#{err}")
+        PuppetCheck.error_files.push("#{file}:\n#{err}")
       # check librarian puppet style
       else
         if PuppetCheck.style_check
@@ -81,9 +81,9 @@ class RubyParser
           warnings = Utils.capture_stdout { RuboCop::CLI.new.run(rubocop_args + ['--format', 'emacs', file]) }
 
           # collect style warnings
-          next PuppetCheck.warning_files.push("-- #{file}:\n#{warnings.split("#{File.absolute_path(file)}:").join('')}") unless warnings.empty?
+          next PuppetCheck.warning_files.push("#{file}:\n#{warnings.split("#{File.absolute_path(file)}:").join('')}") unless warnings.empty?
         end
-        PuppetCheck.clean_files.push("-- #{file}")
+        PuppetCheck.clean_files.push(file.to_s)
       end
     end
   end

data/lib/puppet-check/tasks.rb

@@ -12,9 +12,7 @@ class PuppetCheck::Tasks < ::Rake::TaskLib
     namespace :puppetcheck do
       desc 'Execute Puppet-Check file checks'
       task :file do
-        exit_code = PuppetCheck.new.run(Dir.glob('*'))
-        # changes nothing if this task is run separately; aborts 'puppetcheck' task if there are errors here
-        exit exit_code if exit_code != 0
+        PuppetCheck.new.run(Dir.glob('*'))
       end
 
       desc 'Execute RSpec and RSpec-Puppet tests'
@@ -23,6 +21,7 @@ class PuppetCheck::Tasks < ::Rake::TaskLib
         # 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/ }
         task.pattern = spec_dirs.empty? ? 'skip_rspec' : spec_dirs
+        task.rspec_opts = '-f json' if PuppetCheck.output_format == 'json'
       end
 
       desc 'Execute Beaker acceptance tests'
@@ -30,6 +29,7 @@ class PuppetCheck::Tasks < ::Rake::TaskLib
         # generate tasks for all recognized directories and ensure acceptance tests inside module dependencies are ignored
         acceptance_dirs = Dir.glob('**/acceptance').reject { |dir| dir =~ /fixtures/ }
         task.pattern = acceptance_dirs.empty? ? 'skip_beaker' : acceptance_dirs
+        task.rspec_opts = '-f json' if PuppetCheck.output_format == 'json'
       end
     end
   end

data/spec/fixtures/metadata_style/metadata.json

@@ -7,17 +7,6 @@
   "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
   "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
   "issues_url": "https://tickets.puppetlabs.com/browse/MODULES",
-  "operatingsystem_support": [
-    {
-      "operatingsystem": "RedHat",
-      "operatingsystemrelease": [
-        "4",
-        "5",
-        "6",
-        "7"
-      ]
-    }
-  ],
   "requirements": [
     {
       "name": "pe",

data/spec/puppet-check/cli_spec.rb

@@ -21,6 +21,12 @@ describe PuppetCheck::CLI do
       expect(PuppetCheck.style_check).to eql(true)
     end
 
+    it 'correctly parses a formatting option' do
+      PuppetCheck.output_format = ''
+      PuppetCheck::CLI.parse(%w(-o text))
+      expect(PuppetCheck.output_format).to eql('text')
+    end
+
     it 'correctly parses PuppetLint arguments' do
       PuppetCheck.puppetlint_args = []
       PuppetCheck::CLI.parse(%w(--puppet-lint puppetlint-arg-one,puppetlint-arg-two foo))

data/spec/puppet-check/data_parser_spec.rb

@@ -11,54 +11,54 @@ describe DataParser do
   context '.yaml' do
     it 'puts a bad syntax yaml file in the error files array' do
       DataParser.yaml([fixtures_dir + 'hieradata/syntax.yaml'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}hieradata/syntax.yaml:\nblock sequence entries are not allowed})
+      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}hieradata/syntax.yaml:\nblock sequence entries are not allowed})
       expect(PuppetCheck.warning_files).to eql([])
       expect(PuppetCheck.clean_files).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.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^\-\- #{fixtures_dir}hieradata/style.yaml:\nValue\(s\) missing in key.*\nValue\(s\) missing in key})
+      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}hieradata/style.yaml:\nValue\(s\) missing in key.*\nValue\(s\) missing in key})
       expect(PuppetCheck.clean_files).to eql([])
     end
     it 'puts a good yaml file in the clean files array' do
       DataParser.yaml([fixtures_dir + 'hieradata/good.yaml'])
       expect(PuppetCheck.error_files).to eql([])
       expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["-- #{fixtures_dir}hieradata/good.yaml"])
+      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}hieradata/good.yaml"])
     end
   end
 
   context '.json' do
     it 'puts a bad syntax json file in the error files array' do
       DataParser.json([fixtures_dir + 'hieradata/syntax.json'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}hieradata/syntax.json:\n.*unexpected token})
+      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}hieradata/syntax.json:\n.*unexpected token})
       expect(PuppetCheck.warning_files).to eql([])
       expect(PuppetCheck.clean_files).to eql([])
     end
     it 'puts a bad metadata json file in the error files array' do
       DataParser.json([fixtures_dir + 'metadata_syntax/metadata.json'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}metadata_syntax/metadata.json:\nRequired field.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
+      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}metadata_syntax/metadata.json:\nRequired field.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
       expect(PuppetCheck.warning_files).to eql([])
       expect(PuppetCheck.clean_files).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.error_files).to eql([])
-      expect(PuppetCheck.warning_files[0]).to match(%r{^\-\- #{fixtures_dir}metadata_style/metadata.json:\nLicense identifier})
+      expect(PuppetCheck.warning_files[0]).to match(%r{^#{fixtures_dir}metadata_style/metadata.json:\n.*operatingsystem_support.*\nLicense identifier})
       expect(PuppetCheck.clean_files).to eql([])
     end
     it 'puts a good json file in the clean files array' do
       DataParser.json([fixtures_dir + 'hieradata/good.json'])
       expect(PuppetCheck.error_files).to eql([])
       expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["-- #{fixtures_dir}hieradata/good.json"])
+      expect(PuppetCheck.clean_files).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.error_files).to eql([])
       expect(PuppetCheck.warning_files).to eql([])
-      expect(PuppetCheck.clean_files).to eql(["-- #{fixtures_dir}metadata_good/metadata.json"])
+      expect(PuppetCheck.clean_files).to eql(["#{fixtures_dir}metadata_good/metadata.json"])
     end
   end
 end

data/spec/puppet-check/output_results_spec.rb

@@ -0,0 +1,84 @@
+require_relative '../spec_helper'
+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 = []
+    end
+
+    it 'outputs files with errors' do
+      PuppetCheck.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']
+      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']
+      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']
+      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 = []
+    end
+
+    it 'outputs files with errors as yaml' do
+      PuppetCheck.output_format = 'yaml'
+      PuppetCheck.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']
+      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']
+      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']
+      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']
+      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']
+      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']
+      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']
+      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'
+      expect { OutputResults.markup }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
+    end
+  end
+end

data/spec/puppet-check/puppet_parser_spec.rb

@@ -14,8 +14,8 @@ describe PuppetParser do
   context '.manifest' do
     it 'puts a bad syntax Puppet manifest in the error files array' do
       PuppetParser.manifest([fixtures_dir + 'manifests/syntax.pp'])
-      # expect(subject.instance_variable_get(:@error_files)[0]).to match(%r{^\-\- #{fixtures_dir}manifests/syntax.pp:.*syntax error})
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
+      # expect(subject.instance_variable_get(:@error_files)[0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:.*syntax error})
+      expect(PuppetCheck.error_files[0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
       expect(PuppetCheck.warning_files).to eql([])
       expect(PuppetCheck.clean_files).to eql([])
     end
@@ -23,14 +23,14 @@ describe PuppetParser do
       PuppetCheck.style_check = true
       PuppetParser.manifest([fixtures_dir + 'manifests/style_parser.pp'])
       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.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([])
     end
     it 'puts a bad lint style Puppet manifest in the warning files array' do
       PuppetCheck.style_check = true
       PuppetParser.manifest([fixtures_dir + 'manifests/style_lint.pp'])
       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.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([])
     end
     it 'puts a bad style Puppet manifest in the clean files array when puppetlint_args ignores its warnings' do
@@ -39,21 +39,26 @@ describe PuppetParser do
       PuppetParser.manifest([fixtures_dir + 'manifests/style_lint.pp'])
       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.clean_files).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
     end
     it 'puts a good Puppet manifest in the clean files array' do
       PuppetCheck.style_check = true
       PuppetParser.manifest([fixtures_dir + 'manifests/good.pp'])
       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.clean_files).to eql(["#{fixtures_dir}manifests/good.pp"])
+    end
+    it 'throws a well specified error for an invalid PuppetLint argument' do
+      PuppetCheck.style_check = true
+      PuppetCheck.puppetlint_args = ['--non-existent', '--does-not-exist']
+      expect { PuppetParser.manifest([fixtures_dir + 'manifests/style_lint.pp']) }.to raise_error(RuntimeError, 'puppet-lint: invalid option supplied among --non-existent --does-not-exist')
     end
   end
 
   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.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([])
     end
@@ -61,7 +66,7 @@ describe PuppetParser 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.clean_files).to eql(["#{fixtures_dir}templates/good.epp"])
     end
   end
 end

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -1,5 +1,6 @@
 require_relative '../spec_helper.rb'
 require_relative '../../lib/puppet-check/rspec_puppet_support'
+require 'fileutils'
 
 describe RSpecPuppetSupport do
   context '.run' do

data/spec/puppet-check/ruby_parser_spec.rb

@@ -13,7 +13,7 @@ describe RubyParser do
   context '.ruby' do
     it 'puts a bad syntax ruby file in the error files array' do
       RubyParser.ruby([fixtures_dir + 'lib/syntax.rb'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}lib/syntax.rb:\n.*syntax error})
+      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([])
     end
@@ -22,7 +22,7 @@ describe RubyParser do
         PuppetCheck.style_check = true
         RubyParser.ruby([fixtures_dir + 'lib/style.rb'])
         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.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([])
       end
     else
@@ -30,7 +30,7 @@ describe RubyParser do
         PuppetCheck.style_check = true
         RubyParser.ruby([fixtures_dir + 'lib/style.rb'])
         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})
+        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})
         expect(PuppetCheck.clean_files).to eql([])
       end
     end
@@ -40,57 +40,48 @@ describe RubyParser do
       RubyParser.ruby([fixtures_dir + 'lib/rubocop_style.rb'])
       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.clean_files).to eql(["#{fixtures_dir}lib/rubocop_style.rb"])
     end
     it 'puts a good ruby file in the clean files array' do
       PuppetCheck.style_check = true
       RubyParser.ruby([fixtures_dir + 'lib/good.rb'])
       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.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.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([])
     end
-    if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0.0')
-      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([])
-      end
-    else
-      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:})
-        expect(PuppetCheck.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([])
     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.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.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'])
-      expect(PuppetCheck.error_files[0]).to match(%r{^\-\- #{fixtures_dir}librarian_syntax/Puppetfile:\n.*syntax error})
+      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([])
     end
@@ -98,7 +89,7 @@ describe RubyParser do
       PuppetCheck.style_check = true
       RubyParser.librarian([fixtures_dir + 'librarian_style/Puppetfile'])
       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.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([])
     end
     it 'puts a bad style librarian Puppet file in the clean files array when rubocop_args ignores its warnings' do
@@ -107,14 +98,14 @@ describe RubyParser do
       RubyParser.librarian([fixtures_dir + 'librarian_style/Puppetfile'])
       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.clean_files).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
     end
     it 'puts a good librarian Puppet file in the clean files array' do
       PuppetCheck.style_check = true
       RubyParser.librarian([fixtures_dir + 'librarian_good/Puppetfile'])
       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.clean_files).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])
     end
   end
 end

data/spec/puppet-check_spec.rb

@@ -54,29 +54,7 @@ describe PuppetCheck do
     end
   end
 
-  context '.output_results' do
-    before(:each) do
-      PuppetCheck.error_files = []
-      PuppetCheck.warning_files = []
-      PuppetCheck.clean_files = []
-      PuppetCheck.ignored_files = []
-    end
-
-    it 'outputs files with errors' do
-      PuppetCheck.error_files = ['-- foo: i had an error']
-      expect { PuppetCheck.output_results }.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']
-      expect { PuppetCheck.output_results }.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']
-      expect { PuppetCheck.output_results }.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']
-      expect { PuppetCheck.output_results }.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
+  context '.execute_parsers' do
+    #
   end
 end

data/spec/system/system_spec.rb

@@ -3,19 +3,21 @@ require_relative '../spec_helper.rb'
 require_relative '../../lib/puppet-check/cli'
 require_relative '../../lib/puppet-check/tasks'
 
-describe 'PuppetCheck' do
+describe PuppetCheck do
   context 'executed as a system from the CLI with arguments and various files to be processed' do
     let(:cli) { PuppetCheck::CLI.run(%w(-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Metrics/LineLength,Style/Encoding .)) }
 
     it 'outputs diagnostic results correctly after processing all of the files' do
       Dir.chdir(fixtures_dir)
 
-      expect(cli).to eql(2)
       expect { cli }.not_to raise_exception
+
       expect(PuppetCheck.error_files.length).to eql(8)
       expect(PuppetCheck.warning_files.length).to eql(8)
       expect(PuppetCheck.clean_files.length).to eql(11)
       expect(PuppetCheck.ignored_files.length).to eql(1)
+
+      expect(cli).to eql(2)
     end
   end
 
@@ -25,14 +27,16 @@ describe 'PuppetCheck' do
     it 'outputs diagnostic results correctly after processing all of the files' do
       # ensure rake only checks the files inside fixtures
       Dir.chdir(fixtures_dir)
+
+      # clear out arrays from previous system test
       PuppetCheck.error_files = []
       PuppetCheck.warning_files = []
       PuppetCheck.clean_files = []
       PuppetCheck.ignored_files = []
       PuppetCheck.style_check = true
 
-      expect(tasks).to eql(2)
       expect { tasks }.not_to raise_exception
+
       expect(PuppetCheck.error_files.length).to eql(8)
       expect(PuppetCheck.warning_files.length).to eql(8)
       expect(PuppetCheck.clean_files.length).to eql(11)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-check
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Matt Schuchard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -122,6 +122,7 @@ files:
 - lib/puppet-check.rb
 - lib/puppet-check/cli.rb
 - lib/puppet-check/data_parser.rb
+- lib/puppet-check/output_results.rb
 - lib/puppet-check/puppet_parser.rb
 - lib/puppet-check/rspec_puppet_support.rb
 - lib/puppet-check/ruby_parser.rb
@@ -158,6 +159,7 @@ files:
 - spec/fixtures/templates/syntax.erb
 - spec/puppet-check/cli_spec.rb
 - spec/puppet-check/data_parser_spec.rb
+- spec/puppet-check/output_results_spec.rb
 - spec/puppet-check/puppet_parser_spec.rb
 - spec/puppet-check/rspec_puppet_support_spec.rb
 - spec/puppet-check/ruby_parser_spec.rb
@@ -178,7 +180,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -186,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A streamlined comprehensive set of checks for your entire Puppet code and
@@ -223,6 +225,7 @@ test_files:
 - spec/fixtures/templates/syntax.erb
 - spec/puppet-check/cli_spec.rb
 - spec/puppet-check/data_parser_spec.rb
+- spec/puppet-check/output_results_spec.rb
 - spec/puppet-check/puppet_parser_spec.rb
 - spec/puppet-check/rspec_puppet_support_spec.rb
 - spec/puppet-check/ruby_parser_spec.rb