puppet-check 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caea7da11b0b884512bc9e078c71caece3bfb2045f5798c55b41201b948e5d3f
-  data.tar.gz: 6e4eae239a2cbbeda1709741c523161720dd8b28399d9e1e5cae6add54cef59b
+  metadata.gz: c5c74c1af6aee54ad5dcfd3eeefa459ed9fd5eaaafdc847f346a8e3674ffb362
+  data.tar.gz: c11db9238470434a489608d62360d12fe1ff10dda29627a05cdded940785b992
 SHA512:
-  metadata.gz: 18d8d802b337a1b47de63aa25a4f0c2b7e6f6f6678047b2f941a28766ee7d1a18f07244b287faf37747170d170230dfb58073f67a63dce95513421acd125ca5a
-  data.tar.gz: '09031de8c432747e7967241ff0abd4290d34d38892eb4df0443e3f7e88acd5d30c177fbabf811a6958874533fe951ea795965acea0617d21e0f2f28832987e17'
+  metadata.gz: 12416f0a0d2d2615c467645cb238e0b14be8f42c9172e5adf7acf3bfbdddbdae1d5b08ccd2a967dcb7b6af41a8149f2e30e22ed5d0db97c5f05e586e384c4a61
+  data.tar.gz: 053f4f90842f2d71ccbc82a3b05cd5ef1347af5399686fc3ed4a7cbf824baeee63ad412c1d6261f3640929bdcba789db7e2fe46d7f3e529cf3cd6b1c8b9690d8

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+### 2.4.0
+- Minimum Ruby version increased to 3.0.
+- Fix `rubocop-performance` inclusion warning.
+- Improve recognition of Ruby support files during filesystem parsing.
+- Fix `file` task for no settings override usage.
+- Add `rubocop-rspec` plugin to Ruby checks.
+- Fix `--fail-on-warnings` functionality.
+- Improve safety of Ruby syntax checks.
+- Safely load Puppet data files.
+
+### 2.3.1
+- No input target paths now defaults to current working directory instead of error.
+- Additionally check `Vagrantfile` and `gemspec` files.
+- Fix and improve behavior for when optional dependency `octocatalog-diff` is absent.
+
 ### 2.3.0
 - Minimum Ruby version increased to 2.7.
 - Support Puppet 8.

data/lib/puppet-check/cli.rb

@@ -6,15 +6,16 @@ class PuppetCheck::CLI
   def self.run(args)
     # gather the user arguments
     settings = parse(args)
-    raise 'puppet-check: no file paths specified; try using --help' if args.empty?
+
+    # target cwd if no paths input as variadic
+    args = [Dir.pwd] if args.empty?
 
     # run PuppetCheck with specified paths
     PuppetCheck.new.run(settings, args)
   end
 
   # parse the user arguments
-  def self.parse(args)
-    private_class_method :method
+  private_class_method def self.parse(args)
     require 'optparse'
 
     # show help message if no args specified

data/lib/puppet-check/data_parser.rb

@@ -8,7 +8,7 @@ class DataParser
   def self.yaml(files)
     files.each do |file|
       # check yaml syntax
-      parsed = YAML.load_file(file)
+      parsed = YAML.safe_load_file(file, permitted_classes: [Symbol], permitted_symbols: [], aliases: true)
     rescue StandardError => err
       PuppetCheck.files[:errors][file] = err.to_s.gsub("(#{file}): ", '').split("\n")
     else
@@ -44,7 +44,7 @@ class DataParser
 
     files.each do |file|
       # check encoded yaml syntax
-      parsed = YAML.load_file(file)
+      parsed = YAML.safe_load_file(file, permitted_classes: [Symbol], permitted_symbols: [], aliases: true)
 
       # extract encoded values
       # ENC[PKCS7]
@@ -205,8 +205,7 @@ class DataParser
   end
 
   # checks hieradata
-  def self.hiera(data, file)
-    private_class_method :method
+  private_class_method def self.hiera(data, file)
     warnings = []
 
     # disregard nil/undef value data check if default values (common)

data/lib/puppet-check/output_results.rb

@@ -2,6 +2,13 @@ require_relative '../puppet_check'
 
 # class to handle outputting diagnostic results in desired format
 class OutputResults
+  HEADER = {
+    errors: "\033[31mThe following files have errors:\033[0m\n",
+    warnings: "\033[33mThe following files have warnings:\033[0m\n",
+    clean: "\033[32mThe following files have no errors or warnings:\033[0m\n-- ",
+    ignored: "\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- "
+  }.freeze
+
   # output the results in various formats
   def self.run(files, format)
     # remove empty entries
@@ -25,34 +32,27 @@ class OutputResults
   end
 
   # output the results as text
-  def self.text(files)
-    private_class_method :method
-
-    # errors
-    category_info("\033[31mThe following files have errors:\033[0m\n", files[:errors]) if files.key?(:errors)
-    # warnings
-    category_info("\033[33mThe following files have warnings:\033[0m\n", files[:warnings]) if files.key?(:warnings)
-    # cleans
-    category_info("\033[32mThe following files have no errors or warnings:\033[0m\n-- ", files[:clean]) if files.key?(:clean)
-    # ignores
-    return unless files.key?(:ignored)
-    category_info("\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- ", files[:ignored])
-  end
+  private_class_method def self.text(files)
+    # output text for each of four file categories
+    %i[errors warnings clean ignored].each do |category|
+      # immediately return if category is empty
+      next unless files.key?(category)
 
-  # display heading, files, and file messages per category for text formatting
-  def self.category_info(heading, files)
-    private_class_method :method
-    # display category heading
-    print heading
-
-    # display files and optionally messages
-    case files
-    when Hash then files.each { |file, messages| puts "-- #{file}:\n#{messages.join("\n")}" }
-    when Array then puts files.join("\n-- ")
-    else raise "puppet-check: The category files were of unexpected type #{files.class}. Please file an issue with this log message, category heading, and information about the parsed files."
-    end
+      # display heading, files, and file messages per category for text formatting
+      category_files = files[category]
 
-    # newline between categories for easier visual parsing
-    puts ''
+      # display category heading
+      print HEADER[category]
+
+      # display files and optionally messages
+      case category_files
+      when Hash then category_files.each { |file, messages| puts "-- #{file}:\n#{messages.join("\n")}" }
+      when Array then puts category_files.join("\n-- ")
+      else raise "puppet-check: The files category was of unexpected type #{category_files.class}. Please file an issue with this log message, category heading, and information about the parsed files."
+      end
+
+      # newline between categories for easier visual parsing
+      puts ''
+    end
   end
 end

data/lib/puppet-check/regression_check.rb

@@ -1,29 +1,33 @@
-# temporarily supress warning messages for octocatalog-diff redefining puppet constants and then reactivate
-$VERBOSE = nil
-require 'octocatalog-diff'
-$VERBOSE = false
+begin
+  # temporarily supress warning messages for octocatalog-diff redefining puppet constants and then reactivate
+  $VERBOSE = nil
+  require 'octocatalog-diff'
+  $VERBOSE = false
 
-# executes smoke and regression tests on catalogs
-class RegressionCheck
-  # smoke testing
-  def self.smoke(interface_nodes, octoconfig)
-    options = config(octoconfig)
-    nodes = options.key?(:node) ? [options[:node]] : interface_nodes
-    nodes.each do |node|
-      options[:node] = node
-      OctocatalogDiff::API::V1.catalog(options)
+  # executes smoke and regression tests on catalogs
+  class RegressionCheck
+    # smoke testing
+    def self.smoke(interface_nodes, octoconfig)
+      options = config(octoconfig)
+      nodes = options.key?(:node) ? [options[:node]] : interface_nodes
+      nodes.each do |node|
+        options[:node] = node
+        OctocatalogDiff::API::V1.catalog(options)
+      end
     end
-  end
 
-  # regression testing
-  # def self.regression(nodes, octoconfig)
-  #   options = RegressionCheck.config(octoconfig)
-  #   nodes.each { |node| stuff }
-  # end
+    # regression testing
+    # def self.regression(nodes, octoconfig)
+    #   options = RegressionCheck.config(octoconfig)
+    #   nodes.each { |node| stuff }
+    # end
 
-  # config file loading
-  def self.config(octoconfig)
-    private_class_method :method
-    OctocatalogDiff::API::V1.config(filename: octoconfig)
+    # config file loading
+    private_class_method def self.config(octoconfig)
+      OctocatalogDiff::API::V1.config(filename: octoconfig)
+    end
   end
+rescue LoadError
+  warn 'puppet-check: octocatalog-diff is not installed, and therefore the regression checks will be skipped'
+  $VERBOSE = false
 end

data/lib/puppet-check/rspec_puppet_support.rb

@@ -29,8 +29,7 @@ class RSpecPuppetSupport
   end
 
   # setup the files, directories, and symlinks for rspec-puppet testing
-  def self.file_setup(module_name)
-    private_class_method :method
+  private_class_method def self.file_setup(module_name)
     # create all the necessary fixture dirs that are missing
     ['spec/fixtures', 'spec/fixtures/manifests', 'spec/fixtures/modules'].each do |dir|
       Dir.mkdir(dir) unless File.directory?(dir)
@@ -58,8 +57,7 @@ class RSpecPuppetSupport
   end
 
   # setup the module dependencies for rspec-puppet testing
-  def self.dependency_setup
-    private_class_method :method
+  private_class_method def self.dependency_setup
     require 'json'
 
     # parse the metadata.json (assumes DataParser.json has already given it a pass)
@@ -85,8 +83,7 @@ class RSpecPuppetSupport
   end
 
   # download external module dependency with git
-  def self.git(git_url, args = '')
-    private_class_method :method
+  private_class_method def self.git(git_url, args = '')
     # establish path to clone module to
     path = "spec/fixtures/modules/#{File.basename(git_url, '.git')}"
     # is the module present and already cloned with git? do a pull; otherwise, do a clone
@@ -98,16 +95,14 @@ class RSpecPuppetSupport
   end
 
   # download external module dependency with forge
-  def self.forge(forge_name, args = '')
-    private_class_method :method
+  private_class_method def self.forge(forge_name, args = '')
     # is the module present? do an upgrade; otherwise, do an install
     subcommand = File.directory?("spec/fixtures/modules/#{forge_name}") ? 'upgrade' : 'install'
     spawn("puppet module #{subcommand} --modulepath spec/fixtures/modules/ #{args} #{forge_name}")
   end
 
   # download external module dependency with svn
-  def self.svn(svn_url, args = '')
-    private_class_method :method
+  private_class_method def self.svn(svn_url, args = '')
     # establish path to checkout module to
     path = "spec/fixtures/modules/#{File.basename(svn_url)}"
     # is the module present and already checked out with svn? do an update; otherwise, do a checkout
@@ -119,8 +114,7 @@ class RSpecPuppetSupport
   end
 
   # download external module dependency with hg
-  def self.hg(hg_url, args = '')
-    private_class_method :method
+  private_class_method def self.hg(hg_url, args = '')
     # establish path to clone module to
     path = "spec/fixtures/modules/#{File.basename(hg_url)}"
     # is the module present and already cloned with hg? do a pull and update; otherwise do a clone

data/lib/puppet-check/ruby_parser.rb

@@ -17,15 +17,14 @@ class RubyParser
 
     files.each do |file|
       # check ruby syntax
-      # prevents ruby code from actually executing
-      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
+      RubyVM::InstructionSequence.compile_file(file)
     rescue ScriptError, StandardError => err
       PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
     else
       # check ruby style
       if style
         # check RuboCop and parse warnings' JSON output
-        rubocop_warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'json', file]) }
+        rubocop_warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--plugin', 'rubocop-performance', '--plugin', 'rubocop-rspec', '--format', 'json', file]) }
         rubocop_offenses = JSON.parse(rubocop_warnings)['files'][0]['offenses'].map { |warning| "#{warning['location']['line']}:#{warning['location']['column']} #{warning['message']}" }
 
         # check Reek and parse warnings' JSON output
@@ -80,14 +79,14 @@ class RubyParser
 
     files.each do |file|
       # check librarian puppet syntax
-      # prevents ruby code from actually executing
-      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)}", file) }
+      # prevents ruby code from actually executing the input ruby file
+      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)} # BEGIN {throw :good}; ruby_file_content", file) }
     rescue SyntaxError, LoadError, ArgumentError => err
       PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
     # check librarian puppet style
     else
       if style
-        warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--require', 'rubocop-performance', '--format', 'json', file]) }
+        warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--plugin', 'rubocop-performance', '--format', 'json', file]) }
         offenses = JSON.parse(warnings)['files'][0]['offenses'].map { |warning| "#{warning['location']['line']}:#{warning['location']['column']} #{warning['message']}" }
 
         # collect style warnings

data/lib/puppet-check/tasks.rb

@@ -16,7 +16,8 @@ class PuppetCheck::Tasks < Rake::TaskLib
     namespace :puppetcheck do
       desc 'Execute Puppet-Check file checks'
       task :file, [:settings] do |_, wrapped_settings|
-        PuppetCheck.new.run(wrapped_settings[:settings], Dir.glob('*'))
+        wrapped_settings = wrapped_settings[:settings] || {}
+        PuppetCheck.new.run(wrapped_settings, Dir.glob('*'))
       end
 
       # rspec and rspec-puppet tasks

data/lib/puppet-check/utils.rb

@@ -1,22 +1,26 @@
+require 'stringio'
+
 # utility methods totally not edited from StackOverflow
 class Utils
   # captures stdout from a block: out = capture_stdout { code }
   def self.capture_stdout
-    old_stdout = $stdout
+    Thread.current[:old_stdout] = $stdout
     $stdout = StringIO.new
     yield
     $stdout.string
   ensure
-    $stdout = old_stdout
+    $stdout = Thread.current[:old_stdout] if Thread.current[:old_stdout]
+    Thread.current[:old_stdout] = nil
   end
 
   # captures stderr from a block: err = capture_stderr { code }
   def self.capture_stderr
-    old_stderr = $stderr
+    Thread.current[:old_stderr] = $stderr
     $stderr = StringIO.new
     yield
     $stderr.string
   ensure
-    $stderr = old_stderr
+    $stderr = Thread.current[:old_stderr] if Thread.current[:old_stderr]
+    Thread.current[:old_stderr] = nil
   end
 end

data/lib/puppet_check.rb

@@ -33,18 +33,15 @@ class PuppetCheck
     OutputResults.run(parsed_files.clone, settings[:output_format])
 
     # progress to regression checks if no errors in file checks
-    if parsed_files[:errors].empty? && (!settings[:fail_on_warning] || parsed_files[:warnings].empty?)
+    if parsed_files[:errors].empty? && (!settings[:fail_on_warnings] || parsed_files[:warnings].empty?)
       begin
         require_relative 'puppet-check/regression_check'
-      # if octocatalog-diff is not installed then return immediately
-      rescue LoadError
-        warn 'octocatalog-diff is not installed, and therefore the regressions check will be skipped'
-        return 0
-      end
 
-      # perform smoke checks if there were no errors and the user desires
-      begin
+        # perform smoke checks if there were no errors and the user desires
         catalog = RegressionCheck.smoke(settings[:octonodes], settings[:octoconfig]) if settings[:smoke]
+      # if octocatalog-diff is not installed then continue immediately
+      rescue NameError
+        puts 'puppet-check: immediately continuing to results'
       # smoke check failure? output message and return 2
       rescue OctocatalogDiff::Errors::CatalogError => err
         puts 'There was a smoke check error:'
@@ -61,6 +58,7 @@ class PuppetCheck
       #   puts catalog.error_message unless catalog.valid?
       #   2
       # end
+
       # code to output differences in catalog?
       # everything passed? return 0
       0
@@ -70,10 +68,10 @@ class PuppetCheck
     end
   end
 
+  private
+
   # establish default settings
   def self.defaults(settings = {})
-    private_class_method :method
-
     # return settings with defaults where unspecified
     {
       # initialize fail on warning,  style check, and regression check bools
@@ -97,7 +95,6 @@ class PuppetCheck
 
   # parse the paths and return the array of files
   def self.parse_paths(paths = [])
-    private_class_method :method
     files = []
 
     # traverse the unique paths and return all files not explicitly in fixtures
@@ -117,8 +114,6 @@ class PuppetCheck
     files.map { |file| file.gsub('//', '/') }.uniq
   end
 
-  private
-
   # categorize and pass the files out to the parsers to determine their status
   def execute_parsers(files, style, puppetlint_args, rubocop_args, public, private)
     # check manifests
@@ -143,7 +138,7 @@ class PuppetCheck
     eyamls, files = files.partition { |file| File.extname(file) =~ /\.eya?ml$/ }
     DataParser.eyaml(eyamls, public, private) unless eyamls.empty?
     # check misc ruby
-    librarians, files = files.partition { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem)file$/ }
+    librarians, files = files.partition { |file| File.basename(file) =~ /^(?:Puppet|Module|Rake|Gem|Vagrant)file|\.gemspec$/ && File.extname(file) != '.lock' }
     RubyParser.librarian(librarians, style, rubocop_args) unless librarians.empty?
     # ignore everything else
     files.each { |file| self.class.files[:ignored].push(file.to_s) }

data/puppet-check.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'puppet-check'
+  spec.version       = '2.4.0'
+  spec.authors       = ['Matt Schuchard']
+  spec.description   = 'Puppet Check is a gem that provides a comprehensive, streamlined, and efficient analysis of the syntax, style, and validity of your entire Puppet code and data.'
+  spec.summary       = 'A streamlined comprehensive set of checks for your entire Puppet code and data'
+  spec.homepage      = 'https://www.github.com/mschuchard/puppet-check'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['bin/**/*', 'lib/**/*', 'spec/**/*', 'CHANGELOG.md', 'LICENSE.md', 'README.md', 'puppet-check.gemspec']
+  spec.executables   = spec.files.grep(%r{^bin/}) { |file| File.basename(file) }
+  spec.require_paths = Dir['lib']
+
+  spec.required_ruby_version = '>= 3.0.0'
+  spec.add_dependency 'puppet', '>= 5.5', '< 9'
+  spec.add_dependency 'puppet-lint', '~> 4.0'
+  spec.add_dependency 'reek', '~> 6.0'
+  spec.add_dependency 'rubocop', '~> 1.72'
+  spec.add_dependency 'rubocop-performance', '~> 1.0'
+  spec.add_dependency 'rubocop-rspec', '~> 3.0'
+  # spec.add_development_dependency 'octocatalog-diff', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/spec/puppet-check/cli_spec.rb

@@ -3,46 +3,52 @@ 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 file paths specified; try using --help')
+    it 'targets the current working directory if no paths were specified' do
+      expect { PuppetCheck::CLI.run(%w[--fail-on-warnings]) }.not_to raise_exception
+      expect(PuppetCheck.files[:clean].length).to eql(30)
+      if ci_env
+        expect(PuppetCheck.files[:ignored].length).to eql(8)
+      else
+        expect(PuppetCheck.files[:ignored].length).to eql(7)
+      end
     end
   end
 
   context '.parse' do
     it 'raises an error if an invalid option was specified' do
-      expect { PuppetCheck::CLI.parse(%w[-s -f -asdf foo]) }.to raise_error(OptionParser::InvalidOption)
+      expect { PuppetCheck::CLI.send(:parse, %w[-s -asdf foo]) }.to raise_error(OptionParser::InvalidOption)
     end
 
     it 'allows fail on warnings, style, smoke, and regression checks to be enabled' do
-      expect(PuppetCheck::CLI.parse(%w[--fail-on-warnings -s -r --smoke foo])).to include(fail_on_warnings: true, style: true, smoke: true, regression: true)
+      expect(PuppetCheck::CLI.send(:parse, %w[--fail-on-warnings -s -r --smoke foo])).to include(fail_on_warnings: true, style: true, smoke: true, regression: true)
     end
 
     it 'correctly parser EYAML options' do
-      expect(PuppetCheck::CLI.parse(%w[--public pub.pem --private priv.pem])).to include(public: 'pub.pem', private: 'priv.pem')
+      expect(PuppetCheck::CLI.send(:parse, %w[--public pub.pem --private priv.pem])).to include(public: 'pub.pem', private: 'priv.pem')
     end
 
     it 'correctly parses a formatting option' do
-      expect(PuppetCheck::CLI.parse(%w[-o text])).to include(output_format: 'text')
+      expect(PuppetCheck::CLI.send(:parse, %w[-o text])).to include(output_format: 'text')
     end
 
     it 'correctly parses octocatalog-diff options' do
-      expect(PuppetCheck::CLI.parse(%w[--octoconfig config.cfg.rb --octonodes server1,server2])).to include(octoconfig: 'config.cfg.rb', octonodes: %w[server1 server2])
+      expect(PuppetCheck::CLI.send(:parse, %w[--octoconfig config.cfg.rb --octonodes server1,server2])).to include(octoconfig: 'config.cfg.rb', octonodes: %w[server1 server2])
     end
 
     it 'correctly parses PuppetLint arguments' do
-      expect(PuppetCheck::CLI.parse(%w[--puppet-lint puppetlint-arg-one,puppetlint-arg-two foo])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
+      expect(PuppetCheck::CLI.send(:parse, %w[--puppet-lint puppetlint-arg-one,puppetlint-arg-two foo])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
     end
 
     it 'correctly loads a .puppet-lint.rc' do
-      expect(PuppetCheck::CLI.parse(%W[-c #{fixtures_dir}/manifests/.puppet-lint.rc])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
+      expect(PuppetCheck::CLI.send(:parse, %W[-c #{fixtures_dir}/manifests/.puppet-lint.rc])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
     end
 
     it 'correctly parses Rubocop arguments' do
-      expect(PuppetCheck::CLI.parse(%w[--rubocop rubocop-arg-one,rubocop-arg-two foo])).to include(rubocop_args: ['--except', 'rubocop-arg-one,rubocop-arg-two'])
+      expect(PuppetCheck::CLI.send(:parse, %w[--rubocop rubocop-arg-one,rubocop-arg-two foo])).to include(rubocop_args: ['--except', 'rubocop-arg-one,rubocop-arg-two'])
     end
 
     it 'correctly parses multiple sets of arguments' do
-      expect(PuppetCheck::CLI.parse(%w[-s --puppet-lint puppetlint-arg-one,puppetlint-arg-two --rubocop rubocop-arg-one,rubocop-arg-two foo])).to include(style: true, puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'], rubocop_args: ['--except', 'rubocop-arg-one,rubocop-arg-two'])
+      expect(PuppetCheck::CLI.send(:parse, %w[-s --puppet-lint puppet-lint-arg-one,puppet-lint-arg-two --rubocop rubocop-arg-one,rubocop-arg-two foo])).to include(style: true, puppetlint_args: ['--puppet-lint-arg-one', '--puppet-lint-arg-two'], rubocop_args: ['--except', 'rubocop-arg-one,rubocop-arg-two'])
     end
   end
 end

data/spec/puppet-check/data_parser_spec.rb

@@ -15,7 +15,7 @@ describe DataParser do
     it 'puts a bad syntax yaml file in the error files hash' do
       DataParser.yaml(["#{fixtures_dir}hieradata/syntax.yaml"])
       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[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(/^block sequence entries are not allowed/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -23,7 +23,7 @@ describe DataParser do
       DataParser.yaml(["#{fixtures_dir}hieradata/style.yaml"])
       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[:warnings]["#{fixtures_dir}hieradata/style.yaml"].join("\n")).to match(/^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
@@ -47,7 +47,7 @@ describe DataParser 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.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.eyaml"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.eyaml"].join("\n")).to match(%r{^block sequence entries are not allowed})
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.eyaml"].join("\n")).to match(/^block sequence entries are not allowed/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -55,7 +55,7 @@ describe DataParser do
       DataParser.eyaml(["#{fixtures_dir}hieradata/style.eyaml"], "#{fixtures_dir}keys/public_key.pkcs7.pem", "#{fixtures_dir}keys/private_key.pkcs7.pem")
       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"].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[:warnings]["#{fixtures_dir}hieradata/style.eyaml"].join("\n")).to match(/^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 eyaml file in the clean files array' do
@@ -70,14 +70,14 @@ describe DataParser do
     it 'puts a bad syntax json file in the error files hash' do
       DataParser.json(["#{fixtures_dir}hieradata/syntax.json"])
       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[:errors]["#{fixtures_dir}hieradata/syntax.json"].join("\n")).to match(/after object value, got.*at line 2 column 3/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad metadata json file in the error files hash' do
       DataParser.json(["#{fixtures_dir}metadata_syntax/metadata.json"])
       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[:errors]["#{fixtures_dir}metadata_syntax/metadata.json"].join("\n")).to match(/^Required field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -85,7 +85,7 @@ describe DataParser do
       DataParser.json(["#{fixtures_dir}metadata_style/metadata.json"])
       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[:warnings]["#{fixtures_dir}metadata_style/metadata.json"].join("\n")).to match(/^'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
@@ -99,7 +99,7 @@ describe DataParser do
       DataParser.json(["#{fixtures_dir}task_metadata/task_bad.json"])
       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[:warnings]["#{fixtures_dir}task_metadata/task_bad.json"].join("\n")).to match(/^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

data/spec/puppet-check/output_results_spec.rb

@@ -5,19 +5,19 @@ describe OutputResults do
   context '.text' do
     it 'outputs files with errors' do
       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\n").to_stdout
+      expect { OutputResults.send(:text, files) }.to output("\033[31mThe following files have errors:\033[0m\n-- foo:\ni had an error\n\n").to_stdout
     end
     it 'outputs files with warnings' do
       files = { warnings: { 'foo' => ['i had a warning'] } }
-      expect { OutputResults.text(files) }.to output("\033[33mThe following files have warnings:\033[0m\n-- foo:\ni had a warning\n\n").to_stdout
+      expect { OutputResults.send(:text, files) }.to output("\033[33mThe following files have warnings:\033[0m\n-- foo:\ni had a warning\n\n").to_stdout
     end
     it 'outputs files with no errors or warnings' do
       files = { clean: ['foo'] }
-      expect { OutputResults.text(files) }.to output("\033[32mThe following files have no errors or warnings:\033[0m\n-- foo\n\n").to_stdout
+      expect { OutputResults.send(:text, files) }.to output("\033[32mThe following files have no errors or warnings:\033[0m\n-- foo\n\n").to_stdout
     end
     it 'outputs files that were not processed' do
       files = { ignored: ['foo'] }
-      expect { OutputResults.text(files) }.to output("\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo\n\n").to_stdout
+      expect { OutputResults.send(:text, files) }.to output("\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo\n\n").to_stdout
     end
   end
 

data/spec/puppet-check/puppet_parser_spec.rb

@@ -16,9 +16,9 @@ describe PuppetParser 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.files[:errors]["#{fixtures_dir}manifests/syntax.pp"].join("\n")).to match(%r{^Language validation logged 2 errors})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}manifests/syntax.pp"].join("\n")).to match(/^Language validation logged 2 errors/)
       else
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(%r{^This Variable has no effect.*\nIllegal variable name})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(/^This Variable has no effect.*\nIllegal variable name/)
       end
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
@@ -28,7 +28,7 @@ describe PuppetParser 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.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[:errors]["#{fixtures_dir}manifests/eof_syntax.pp"].join("\n")).to match(/^Syntax error at end of input/)
         expect(PuppetCheck.files[:warnings]).to eql({})
         expect(PuppetCheck.files[:clean]).to eql([])
       end
@@ -36,7 +36,7 @@ describe PuppetParser do
     it 'puts a bad syntax Puppet plan in the error files hash' do
       PuppetParser.manifest(["#{fixtures_dir}plans/syntax.pp"], false, [])
       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[:errors]["#{fixtures_dir}plans/syntax.pp"].join("\n")).to match(/^Syntax error at '\)'/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -44,14 +44,14 @@ describe PuppetParser do
       PuppetParser.manifest(["#{fixtures_dir}manifests/style_parser.pp"], true, [])
       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[:warnings]["#{fixtures_dir}manifests/style_parser.pp"].join("\n")).to match(/^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.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[:warnings]["#{fixtures_dir}manifests/style_lint.pp"].join("\n")).to match(/(?: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
@@ -64,7 +64,7 @@ describe PuppetParser do
       PuppetParser.manifest(["#{fixtures_dir}plans/style.pp"], true, [])
       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[:warnings]["#{fixtures_dir}plans/style.pp"].join("\n")).to match(/variable not enclosed in {}/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good Puppet manifest in the clean files array' do
@@ -88,7 +88,7 @@ describe PuppetParser do
     it 'puts a bad syntax Puppet template in the error files hash' do
       PuppetParser.template(["#{fixtures_dir}templates/syntax.epp"])
       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[:errors]["#{fixtures_dir}templates/syntax.epp"].join("\n")).to match(/^This Name has no effect/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end

data/spec/puppet-check/regression_check_spec.rb

@@ -1,35 +1,41 @@
 require_relative '../spec_helper'
-require_relative '../../lib/puppet-check/regression_check'
+begin
+  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
-    # json gem got messed up for the EOL Ruby versions
-    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
-    it 'loads in a good octocatalog-diff config file' do
-      expect { RegressionCheck.config("#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
-    end
-    it 'loads in the settings from the file correctly' do
+  # 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
+      # json gem is messed up for the EOL Ruby versions
+      it 'raise an appropriate error if the file is malformed' do
+        expect { RegressionCheck.send(:config, "#{fixtures_dir}metadata.json") }.to raise_error(OctocatalogDiff::Errors::ConfigurationFileContentError, 'Configuration must define OctocatalogDiff::Config!')
+      end
+      it 'loads in a good octocatalog-diff config file' do
+        expect { RegressionCheck.send(:config, "#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
+      end
+      it 'loads in the settings from the file correctly' do
+        # TODO
+      end
     end
-  end
 
-  context '.smoke' do
-    # octocatalog-diff is returning a blank error for these tests
-    unless ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-      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
+    context '.smoke' do
+      # octocatalog-diff is returning a blank error for these tests
+      unless ci_env
+        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
+        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 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 good and bad catalog' do
+        # RegressionCheck.smoke(['good.example.com', 'syntax_error.example.com'], "#{fixtures_dir}octocatalog_diff.cfg.rb")
       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")
-    end
-  end
 
-  context '.regression' do
+    context '.regression' do
+      # TODO
+    end
   end
+rescue NameError
+  puts 'puppet-check+rspec: octocatalog-diff is not installed, and its unit tests will be skipped'
 end

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -15,7 +15,7 @@ describe RSpecPuppetSupport do
 
     it 'creates missing directories, missing site.pp, missing symlinks, and a missing spec_helper' do
       # circle ci and gh actions
-      if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      if ci_env
         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
@@ -29,7 +29,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' || ENV['GITHUB_ACTIONS'] == 'true'
+      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless ci_env
       expect(File.directory?('spec/fixtures/modules/stdlib')).to be true
     end
   end

data/spec/puppet-check/ruby_parser_spec.rb

@@ -15,7 +15,7 @@ describe RubyParser do
     it 'puts a bad syntax ruby file in the error files hash' do
       RubyParser.ruby(["#{fixtures_dir}lib/syntax.rb"], false, [])
       expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}lib/syntax.rb"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}lib/syntax.rb"].join("\n")).to match(%r{^.*syntax error})
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}lib/syntax.rb"].join("\n")).to match(/^.*syntax error/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -23,7 +23,11 @@ describe RubyParser do
       RubyParser.ruby(["#{fixtures_dir}lib/style.rb"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}lib/style.rb"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(%r{Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment})
+      unless ci_env
+        expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(/Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment/)
+      else
+        expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(/Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty/)
+      end
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style ruby file in the clean files array when rubocop_args ignores its warnings' do
@@ -45,9 +49,9 @@ describe RubyParser do
       RubyParser.template(["#{fixtures_dir}templates/syntax.erb"])
       expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}templates/syntax.erb"])
       if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(%r{1: syntax error, unexpected.*\n.*ruby})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(/1: syntax error, unexpected.*\n.*ruby/)
       else
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(%r{syntax error, unexpected tIDENTIFIER})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(/syntax error, unexpected tIDENTIFIER/)
       end
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
@@ -56,7 +60,7 @@ describe RubyParser do
       RubyParser.template(["#{fixtures_dir}templates/style.erb"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}templates/style.erb"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}templates/style.erb"].join("\n")).to match(%r{already initialized constant.*\n.*previous definition of})
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}templates/style.erb"].join("\n")).to match(/already initialized constant.*\n.*previous definition of/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a ruby template file with ignored errors in the clean files array' do
@@ -75,30 +79,30 @@ describe RubyParser do
 
   context '.librarian' do
     it 'puts a bad syntax librarian Puppet file in the error files hash' do
-      RubyParser.librarian(["#{fixtures_dir}librarian_syntax/Puppetfile"], false, [])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}librarian_syntax/Puppetfile"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}librarian_syntax/Puppetfile"].join("\n")).to match(%r{^.*syntax error})
+      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_syntax"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}librarian/Puppetfile_syntax"])
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}librarian/Puppetfile_syntax"].join("\n")).to match(/^.*syntax error/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).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, [])
+      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_style"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}librarian_style/Puppetfile"].join("\n")).to match(%r{Align the arguments.*\n.*Use the new})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}librarian/Puppetfile_style"])
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}librarian/Puppetfile_style"].join("\n")).to match(/Align the arguments.*\n.*Use the new/)
       expect(PuppetCheck.files[:clean]).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', 'Layout/ArgumentAlignment,Style/HashSyntax'])
+      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_style"], true, ['--except', 'Layout/ArgumentAlignment,Style/HashSyntax'])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian/Puppetfile_style"])
     end
     it 'puts a good librarian Puppet file in the clean files array' do
-      RubyParser.librarian(["#{fixtures_dir}librarian_good/Puppetfile"], true, [])
+      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_good"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian/Puppetfile_good"])
     end
   end
 end

data/spec/puppet_check_spec.rb

@@ -33,7 +33,7 @@ describe PuppetCheck do
 
   context 'defaults' do
     it 'returns defaults correctly' do
-      expect(PuppetCheck.defaults).to eql(
+      expect(PuppetCheck.send(:defaults)).to eql(
         {
           fail_on_warning: false,
           style: false,
@@ -64,18 +64,18 @@ describe PuppetCheck do
         puppetlint_args: %w[--puppetlint-arg-one --puppetlint-arg-two],
         rubocop_args: %w[--rubocop-arg-one --rubocop-arg-two]
       }
-      expect(PuppetCheck.defaults(settings)).to eql(settings)
+      expect(PuppetCheck.send(:defaults, settings)).to eql(settings)
     end
   end
 
   context '.parse_paths' do
     before(:each) { Dir.chdir(fixtures_dir) }
 
-    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(:repeats) { PuppetCheck.parse_paths(['hieradata', 'hieradata', 'lib', 'hieradata/good.json', 'manifests/good.pp', 'manifests/good.pp']) }
+    let(:no_files) { PuppetCheck.send(:parse_paths, %w[foo bar baz]) }
+    let(:file) { PuppetCheck.send(:parse_paths, ['lib/good.rb']) }
+    let(:dir) { PuppetCheck.send(:parse_paths, ['.']) }
+    let(:multi_dir) { PuppetCheck.send(:parse_paths, %w[hieradata lib manifests]) }
+    let(:repeats) { PuppetCheck.send(:parse_paths, ['hieradata', 'hieradata', 'lib', 'hieradata/good.json', 'manifests/good.pp', 'manifests/good.pp']) }
 
     it 'raises an error if no files were found' do
       expect { no_files }.to raise_error(RuntimeError, 'puppet-check: no files found in supplied paths \'foo, bar, baz\'.')
@@ -87,7 +87,7 @@ describe PuppetCheck do
 
     it 'correctly parses one directory and returns all of its files' do
       dir.each { |file| expect(File.file?(file)).to be true }
-      if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      if ci_env
         expect(dir.length).to eql(37)
       else
         expect(dir.length).to eql(40)

data/spec/spec_helper.rb

@@ -11,6 +11,10 @@ module Variables
   def octocatalog_diff_dir
     @octocatalog_diff_dir = "#{File.dirname(__FILE__)}/octocatalog-diff/"
   end
+
+  def ci_env
+    @ci_env = ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+  end
 end
 
 RSpec.configure do |config|

data/spec/system/system_spec.rb

@@ -5,24 +5,20 @@ require_relative '../../lib/puppet-check/tasks'
 
 describe PuppetCheck do
   context 'executed as a system from the CLI with arguments and various files to be processed' do
-    # see regression_check_spec
-    if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem .]) }
-    else
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem --smoke -n good.example.com --octoconfig spec/octocatalog-diff/octocatalog-diff.cfg.rb .]) }
-    end
-
     it 'outputs diagnostic results correctly after processing all of the files' do
       Dir.chdir(fixtures_dir)
 
-      expect { cli }.not_to raise_exception
+      # see regression_check_spec
+      if ci_env
+        expect(PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem .])).to eql(2)
+      else
+        expect(PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem --smoke -n good.example.com --octoconfig spec/octocatalog-diff/octocatalog-diff.cfg.rb .])).to eql(2)
+      end
 
       expect(PuppetCheck.files[:errors].length).to eql(11)
-      expect(PuppetCheck.files[:warnings].length).to eql(12)
-      expect(PuppetCheck.files[:clean].length).to eql(14)
+      expect(PuppetCheck.files[:warnings].length).to eql(13)
+      expect(PuppetCheck.files[:clean].length).to eql(13)
       expect(PuppetCheck.files[:ignored].length).to eql(3)
-
-      expect(cli).to eql(2)
     end
   end
 
@@ -38,16 +34,9 @@ describe PuppetCheck do
         clean: [],
         ignored: []
       }
-      settings = { style: true }
-      # see regression_check_spec
-      unless ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-        settings[:smoke] = true
-        settings[:octonodes] = %w[good.example.com]
-        settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'
-      end
 
       # cannot re-use plan fixture between system tests
-      expect { Rake::Task[:'puppetcheck:file'].invoke(settings) }.to raise_error(ArgumentError, /Attempt to redefine entity/)
+      expect { Rake::Task[:'puppetcheck:file'].execute }.to raise_error(ArgumentError, /Attempt to redefine entity/)
 
       # current puppet pops limitations no longer allow testing this
       # expect(PuppetCheck.files[:errors].length).to eql(11)
@@ -55,5 +44,36 @@ describe PuppetCheck do
       # expect(PuppetCheck.files[:clean].length).to eql(14)
       # expect(PuppetCheck.files[:ignored].length).to eql(3)
     end
+
+    it 'uses override settings and 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 files member from previous system test
+        PuppetCheck.files = {
+          errors: {},
+          warnings: {},
+          clean: [],
+          ignored: []
+        }
+
+        # assign settings
+        settings = { style: true }
+        # see regression_check_spec
+        unless ci_env
+          settings[:smoke] = true
+          settings[:octonodes] = %w[good.example.com]
+          settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'
+        end
+
+        # cannot re-use plan fixture between system tests
+        expect { Rake::Task[:'puppetcheck:file'].invoke(settings) }.to raise_error(ArgumentError, /Attempt to redefine entity/)
+
+        # current puppet pops limitations no longer allow testing this
+        # expect(PuppetCheck.files[:errors].length).to eql(11)
+        # expect(PuppetCheck.files[:warnings].length).to eql(12)
+        # expect(PuppetCheck.files[:clean].length).to eql(14)
+        # expect(PuppetCheck.files[:ignored].length).to eql(3)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-check
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Matt Schuchard
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-12 00:00:00.000000000 Z
+date: 2025-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.72'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.72'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -87,19 +87,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: octocatalog-diff
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
+        version: '3.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -151,6 +151,7 @@ files:
 - lib/puppet-check/tasks.rb
 - lib/puppet-check/utils.rb
 - lib/puppet_check.rb
+- puppet-check.gemspec
 - spec/fixtures/foobarbaz
 - spec/fixtures/hieradata/good.eyaml
 - spec/fixtures/hieradata/good.json
@@ -166,9 +167,9 @@ files:
 - spec/fixtures/lib/rubocop_style.rb
 - spec/fixtures/lib/style.rb
 - spec/fixtures/lib/syntax.rb
-- spec/fixtures/librarian_good/Puppetfile
-- spec/fixtures/librarian_style/Puppetfile
-- spec/fixtures/librarian_syntax/Puppetfile
+- spec/fixtures/librarian/Puppetfile_good
+- spec/fixtures/librarian/Puppetfile_style
+- spec/fixtures/librarian/Puppetfile_syntax
 - spec/fixtures/manifests/eof_syntax.pp
 - spec/fixtures/manifests/good.pp
 - spec/fixtures/manifests/style_lint.pp
@@ -220,14 +221,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: A streamlined comprehensive set of checks for your entire Puppet code and