puppet 3.8.7 → 4.0.0

data/spec/unit/util_spec.rb

@@ -31,20 +31,20 @@ describe Puppet::Util do
 
     it "should change environment variables within the block then reset environment variables to their original values" do
       Puppet::Util.withenv @new_env do
-        ENV["PATH"].should == "/some/bogus/path"
+        expect(ENV["PATH"]).to eq("/some/bogus/path")
       end
-      ENV["PATH"].should == @original_path
+      expect(ENV["PATH"]).to eq(@original_path)
     end
 
     it "should reset environment variables to their original values even if the block fails" do
       begin
         Puppet::Util.withenv @new_env do
-          ENV["PATH"].should == "/some/bogus/path"
+          expect(ENV["PATH"]).to eq("/some/bogus/path")
           raise "This is a failure"
         end
       rescue
       end
-      ENV["PATH"].should == @original_path
+      expect(ENV["PATH"]).to eq(@original_path)
     end
 
     it "should reset environment variables even when they are set twice" do
@@ -52,47 +52,47 @@ describe Puppet::Util do
       @new_env["PATH"] = "/someother/bogus/path"
       Puppet::Util.withenv @new_env do
         # When assigning duplicate keys, can't guarantee order of evaluation
-        ENV["PATH"].should =~ /\/some.*\/bogus\/path/
+        expect(ENV["PATH"]).to match(/\/some.*\/bogus\/path/)
       end
-      ENV["PATH"].should == @original_path
+      expect(ENV["PATH"]).to eq(@original_path)
     end
 
     it "should remove any new environment variables after the block ends" do
       @new_env[:FOO] = "bar"
       ENV["FOO"] = nil
       Puppet::Util.withenv @new_env do
-        ENV["FOO"].should == "bar"
+        expect(ENV["FOO"]).to eq("bar")
       end
-      ENV["FOO"].should == nil
+      expect(ENV["FOO"]).to eq(nil)
     end
 
   end
 
   describe "#absolute_path?" do
-    describe "on posix systems", :as_platform => :posix do
+    describe "on posix systems", :if => Puppet.features.posix? do
       it "should default to the platform of the local system" do
-        Puppet::Util.should be_absolute_path('/foo')
-        Puppet::Util.should_not be_absolute_path('C:/foo')
+        expect(Puppet::Util).to be_absolute_path('/foo')
+        expect(Puppet::Util).not_to be_absolute_path('C:/foo')
       end
     end
 
-    describe "on windows", :as_platform => :windows do
+    describe "on windows", :if => Puppet.features.microsoft_windows? do
       it "should default to the platform of the local system" do
-        Puppet::Util.should be_absolute_path('C:/foo')
-        Puppet::Util.should_not be_absolute_path('/foo')
+        expect(Puppet::Util).to be_absolute_path('C:/foo')
+        expect(Puppet::Util).not_to be_absolute_path('/foo')
       end
     end
 
     describe "when using platform :posix" do
       %w[/ /foo /foo/../bar //foo //Server/Foo/Bar //?/C:/foo/bar /\Server/Foo /foo//bar/baz].each do |path|
         it "should return true for #{path}" do
-          Puppet::Util.should be_absolute_path(path, :posix)
+          expect(Puppet::Util).to be_absolute_path(path, :posix)
         end
       end
 
       %w[. ./foo \foo C:/foo \\Server\Foo\Bar \\?\C:\foo\bar \/?/foo\bar \/Server/foo foo//bar/baz].each do |path|
         it "should return false for #{path}" do
-          Puppet::Util.should_not be_absolute_path(path, :posix)
+          expect(Puppet::Util).not_to be_absolute_path(path, :posix)
         end
       end
     end
@@ -100,13 +100,13 @@ describe Puppet::Util do
     describe "when using platform :windows" do
       %w[C:/foo C:\foo \\\\Server\Foo\Bar \\\\?\C:\foo\bar //Server/Foo/Bar //?/C:/foo/bar /\?\C:/foo\bar \/Server\Foo/Bar c:/foo//bar//baz].each do |path|
         it "should return true for #{path}" do
-          Puppet::Util.should be_absolute_path(path, :windows)
+          expect(Puppet::Util).to be_absolute_path(path, :windows)
         end
       end
 
       %w[/ . ./foo \foo /foo /foo/../bar //foo C:foo/bar foo//bar/baz].each do |path|
         it "should return false for #{path}" do
-          Puppet::Util.should_not be_absolute_path(path, :windows)
+          expect(Puppet::Util).not_to be_absolute_path(path, :windows)
         end
       end
     end
@@ -115,12 +115,12 @@ describe Puppet::Util do
   describe "#path_to_uri" do
     %w[. .. foo foo/bar foo/../bar].each do |path|
       it "should reject relative path: #{path}" do
-        lambda { Puppet::Util.path_to_uri(path) }.should raise_error(Puppet::Error)
+        expect { Puppet::Util.path_to_uri(path) }.to raise_error(Puppet::Error)
       end
     end
 
     it "should perform URI escaping" do
-      Puppet::Util.path_to_uri("/foo bar").path.should == "/foo%20bar"
+      expect(Puppet::Util.path_to_uri("/foo bar").path).to eq("/foo%20bar")
     end
 
     describe "when using platform :posix" do
@@ -131,7 +131,7 @@ describe Puppet::Util do
 
       %w[/ /foo /foo/../bar].each do |path|
         it "should convert #{path} to URI" do
-          Puppet::Util.path_to_uri(path).path.should == path
+          expect(Puppet::Util.path_to_uri(path).path).to eq(path)
         end
       end
     end
@@ -143,20 +143,20 @@ describe Puppet::Util do
       end
 
       it "should normalize backslashes" do
-        Puppet::Util.path_to_uri('c:\\foo\\bar\\baz').path.should == '/' + 'c:/foo/bar/baz'
+        expect(Puppet::Util.path_to_uri('c:\\foo\\bar\\baz').path).to eq('/' + 'c:/foo/bar/baz')
       end
 
       %w[C:/ C:/foo/bar].each do |path|
         it "should convert #{path} to absolute URI" do
-          Puppet::Util.path_to_uri(path).path.should == '/' + path
+          expect(Puppet::Util.path_to_uri(path).path).to eq('/' + path)
         end
       end
 
       %w[share C$].each do |path|
         it "should convert UNC #{path} to absolute URI" do
           uri = Puppet::Util.path_to_uri("\\\\server\\#{path}")
-          uri.host.should == 'server'
-          uri.path.should == '/' + path
+          expect(uri.host).to eq('server')
+          expect(uri.path).to eq('/' + path)
         end
       end
     end
@@ -166,50 +166,50 @@ describe Puppet::Util do
     require 'uri'
 
     it "should strip host component" do
-      Puppet::Util.uri_to_path(URI.parse('http://foo/bar')).should == '/bar'
+      expect(Puppet::Util.uri_to_path(URI.parse('http://foo/bar'))).to eq('/bar')
     end
 
     it "should accept puppet URLs" do
-      Puppet::Util.uri_to_path(URI.parse('puppet:///modules/foo')).should == '/modules/foo'
+      expect(Puppet::Util.uri_to_path(URI.parse('puppet:///modules/foo'))).to eq('/modules/foo')
     end
 
     it "should return unencoded path" do
-      Puppet::Util.uri_to_path(URI.parse('http://foo/bar%20baz')).should == '/bar baz'
+      expect(Puppet::Util.uri_to_path(URI.parse('http://foo/bar%20baz'))).to eq('/bar baz')
     end
 
     it "should be nil-safe" do
-      Puppet::Util.uri_to_path(nil).should be_nil
+      expect(Puppet::Util.uri_to_path(nil)).to be_nil
     end
 
     describe "when using platform :posix",:if => Puppet.features.posix? do
       it "should accept root" do
-        Puppet::Util.uri_to_path(URI.parse('file:/')).should == '/'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:/'))).to eq('/')
       end
 
       it "should accept single slash" do
-        Puppet::Util.uri_to_path(URI.parse('file:/foo/bar')).should == '/foo/bar'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:/foo/bar'))).to eq('/foo/bar')
       end
 
       it "should accept triple slashes" do
-        Puppet::Util.uri_to_path(URI.parse('file:///foo/bar')).should == '/foo/bar'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:///foo/bar'))).to eq('/foo/bar')
       end
     end
 
     describe "when using platform :windows", :if => Puppet.features.microsoft_windows? do
       it "should accept root" do
-        Puppet::Util.uri_to_path(URI.parse('file:/C:/')).should == 'C:/'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:/C:/'))).to eq('C:/')
       end
 
       it "should accept single slash" do
-        Puppet::Util.uri_to_path(URI.parse('file:/C:/foo/bar')).should == 'C:/foo/bar'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:/C:/foo/bar'))).to eq('C:/foo/bar')
       end
 
       it "should accept triple slashes" do
-        Puppet::Util.uri_to_path(URI.parse('file:///C:/foo/bar')).should == 'C:/foo/bar'
+        expect(Puppet::Util.uri_to_path(URI.parse('file:///C:/foo/bar'))).to eq('C:/foo/bar')
       end
 
       it "should accept file scheme with double slashes as a UNC path" do
-        Puppet::Util.uri_to_path(URI.parse('file://host/share/file')).should == '//host/share/file'
+        expect(Puppet::Util.uri_to_path(URI.parse('file://host/share/file'))).to eq('//host/share/file')
       end
     end
   end
@@ -229,30 +229,11 @@ describe Puppet::Util do
       (0..256).each {|n| IO.stubs(:new) }
     end
 
-    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd exists" do
-      # This is ugly, but I can't really think of a better way to do it without
-      # letting it actually close fds, which seems risky
-      fds = [".", "..","0","1","2","3","5","100","1000"]
-      fds.each do |fd|
-        if fd == '.' || fd == '..'
-          next
-        elsif ['0', '1', '2'].include? fd
-          IO.expects(:new).with(fd.to_i).never
-        else
-          IO.expects(:new).with(fd.to_i).returns mock('io', :close)
-        end
-      end
-
-      Dir.stubs(:foreach).with('/proc/self/fd').multiple_yields(*fds)
-      Puppet::Util.safe_posix_fork
-    end
-
-    it "should close all open file descriptors except stdin/stdout/stderr when /proc/self/fd doesn't exists" do
+    it "should close all open file descriptors except stdin/stdout/stderr" do
       # This is ugly, but I can't really think of a better way to do it without
       # letting it actually close fds, which seems risky
       (0..2).each {|n| IO.expects(:new).with(n).never}
-      (3..256).each { |n| IO.expects(:new).with(n).returns mock('io', :close)  }
-      Dir.stubs(:foreach).with('/proc/self/fd') { raise Errno::ENOENT }
+      (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
 
       Puppet::Util.safe_posix_fork
     end
@@ -266,7 +247,7 @@ describe Puppet::Util do
     end
 
     it "should return the pid of the child process" do
-      Puppet::Util.safe_posix_fork.should == pid
+      expect(Puppet::Util.safe_posix_fork).to eq(pid)
     end
   end
 
@@ -283,11 +264,11 @@ describe Puppet::Util do
     end
 
     it "should accept absolute paths" do
-      Puppet::Util.which(path).should == path
+      expect(Puppet::Util.which(path)).to eq(path)
     end
 
     it "should return nil if no executable found" do
-      Puppet::Util.which('doesnotexist').should be_nil
+      expect(Puppet::Util.which('doesnotexist')).to be_nil
     end
 
     it "should warn if the user's HOME is not set but their PATH contains a ~" do
@@ -303,7 +284,7 @@ describe Puppet::Util do
     end
 
     it "should reject directories" do
-      Puppet::Util.which(base).should be_nil
+      expect(Puppet::Util.which(base)).to be_nil
     end
 
     it "should ignore ~user directories if the user doesn't exist" do
@@ -313,7 +294,7 @@ describe Puppet::Util do
       # the lookup for real) it should just work transparently.
       baduser = 'if_this_user_exists_I_will_eat_my_hat'
       Puppet::Util.withenv("PATH" => "~#{baduser}#{File::PATH_SEPARATOR}#{base}") do
-        Puppet::Util.which('foo').should == path
+        expect(Puppet::Util.which('foo')).to eq(path)
       end
     end
 
@@ -326,7 +307,7 @@ describe Puppet::Util do
       it "should walk the search PATH returning the first executable" do
         ENV.stubs(:[]).with('PATH').returns(File.expand_path('/bin'))
 
-        Puppet::Util.which('foo').should == path
+        expect(Puppet::Util.which('foo')).to eq(path)
       end
     end
 
@@ -345,7 +326,7 @@ describe Puppet::Util do
           FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
 
           ENV.expects(:[]).with('PATHEXT').never
-          Puppet::Util.which('foo.CMD').should == path
+          expect(Puppet::Util.which('foo.CMD')).to eq(path)
         end
       end
 
@@ -361,7 +342,7 @@ describe Puppet::Util do
           FileTest.expects(:file?).in_sequence(exts).with(File.join(base, 'foo.EXE')).returns false
           FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
-          Puppet::Util.which('foo').should == path
+          expect(Puppet::Util.which('foo')).to eq(path)
         end
 
         it "should walk the default extension path if the environment variable is not defined" do
@@ -374,7 +355,7 @@ describe Puppet::Util do
           end
           FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
-          Puppet::Util.which('foo').should == path
+          expect(Puppet::Util.which('foo')).to eq(path)
         end
 
         it "should fall back if no extension matches" do
@@ -385,27 +366,12 @@ describe Puppet::Util do
           FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true
           FileTest.stubs(:executable?).with(File.join(base, 'foo')).returns true
 
-          Puppet::Util.which('foo').should == File.join(base, 'foo')
+          expect(Puppet::Util.which('foo')).to eq(File.join(base, 'foo'))
         end
       end
     end
   end
 
-  describe "#binread" do
-    let(:contents) { "foo\r\nbar" }
-
-    it "should preserve line endings" do
-      path = tmpfile('util_binread')
-      File.open(path, 'wb') { |f| f.print contents }
-
-      Puppet::Util.binread(path).should == contents
-    end
-
-    it "should raise an error if the file doesn't exist" do
-      expect { Puppet::Util.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
-    end
-  end
-
   describe "hash symbolizing functions" do
     let (:myhash) { { "foo" => "bar", :baz => "bam" } }
     let (:resulthash) { { :foo => "bar", :baz => "bam" } }
@@ -413,14 +379,14 @@ describe Puppet::Util do
     describe "#symbolizehash" do
       it "should return a symbolized hash" do
         newhash = Puppet::Util.symbolizehash(myhash)
-        newhash.should == resulthash
+        expect(newhash).to eq(resulthash)
       end
     end
   end
 
   context "#replace_file" do
     subject { Puppet::Util }
-    it { should respond_to :replace_file }
+    it { is_expected.to respond_to :replace_file }
 
     let :target do
       target = Tempfile.new("puppet-util-replace-file")
@@ -437,7 +403,7 @@ describe Puppet::Util do
 
     it "should replace a file when invoked" do
       # Check that our file has the expected content.
-      File.read(target.path).should == "hello, world\n"
+      expect(File.read(target.path)).to eq("hello, world\n")
 
       # Replace the file.
       subject.replace_file(target.path, 0600) do |fh|
@@ -445,7 +411,7 @@ describe Puppet::Util do
       end
 
       # ...and check the replacement was complete.
-      File.read(target.path).should == "I am the passenger...\n"
+      expect(File.read(target.path)).to eq("I am the passenger...\n")
     end
 
     # When running with the same user and group sid, which is the default,
@@ -457,12 +423,12 @@ describe Puppet::Util do
       it "should copy 0#{mode.to_s(8)} permissions from the target file by default" do
         set_mode(mode, target.path)
 
-        get_mode(target.path).should == mode
+        expect(get_mode(target.path)).to eq(mode)
 
         subject.replace_file(target.path, 0000) {|fh| fh.puts "bazam" }
 
-        get_mode(target.path).should == mode
-        File.read(target.path).should == "bazam\n"
+        expect(get_mode(target.path)).to eq(mode)
+        expect(File.read(target.path)).to eq("bazam\n")
       end
     end
 
@@ -472,22 +438,22 @@ describe Puppet::Util do
 
       yielded = false
       subject.replace_file(target.path, 0600) do |fh|
-        get_mode(fh.path).should == 0555
+        expect(get_mode(fh.path)).to eq(0555)
         yielded = true
       end
-      yielded.should be_true
+      expect(yielded).to be_truthy
 
-      Puppet::FileSystem.stat(target.path).ino.should_not == inode
-      get_mode(target.path).should == 0555
+      expect(Puppet::FileSystem.stat(target.path).ino).not_to eq(inode)
+      expect(get_mode(target.path)).to eq(0555)
     end
 
     it "should use the default permissions if the source file doesn't exist" do
       new_target = target.path + '.foo'
-      Puppet::FileSystem.exist?(new_target).should be_false
+      expect(Puppet::FileSystem.exist?(new_target)).to be_falsey
 
       begin
         subject.replace_file(new_target, 0555) {|fh| fh.puts "foo" }
-        get_mode(new_target).should == 0555
+        expect(get_mode(new_target)).to eq(0555)
       ensure
         Puppet::FileSystem.unlink(new_target) if Puppet::FileSystem.exist?(new_target)
       end
@@ -511,22 +477,22 @@ describe Puppet::Util do
         end
       end
 
-      yielded.should be_true
-      threw.should be_true
+      expect(yielded).to be_truthy
+      expect(threw).to be_truthy
 
       # ...and check the replacement was complete.
-      File.read(target.path).should == "hello, world\n"
+      expect(File.read(target.path)).to eq("hello, world\n")
     end
 
     {:string => '664', :number => 0664, :symbolic => "ug=rw-,o=r--" }.each do |label,mode|
       it "should support #{label} format permissions" do
         new_target = target.path + "#{mode}.foo"
-        Puppet::FileSystem.exist?(new_target).should be_false
+        expect(Puppet::FileSystem.exist?(new_target)).to be_falsey
 
         begin
           subject.replace_file(new_target, mode) {|fh| fh.puts "this is an interesting content" }
 
-          get_mode(new_target).should == 0664
+          expect(get_mode(new_target)).to eq(0664)
         ensure
           Puppet::FileSystem.unlink(new_target) if Puppet::FileSystem.exist?(new_target)
         end
@@ -539,33 +505,16 @@ describe Puppet::Util do
     it "should include lines that don't match the standard backtrace pattern" do
       line = "non-standard line\n"
       trace = caller[0..2] + [line] + caller[3..-1]
-      Puppet::Util.pretty_backtrace(trace).should =~ /#{line}/
+      expect(Puppet::Util.pretty_backtrace(trace)).to match(/#{line}/)
     end
 
     it "should include function names" do
-      Puppet::Util.pretty_backtrace.should =~ /:in `\w+'/
+      expect(Puppet::Util.pretty_backtrace).to match(/:in `\w+'/)
     end
 
     it "should work with Windows paths" do
-      Puppet::Util.pretty_backtrace(["C:/work/puppet/c.rb:12:in `foo'\n"]).
-        should == "C:/work/puppet/c.rb:12:in `foo'"
-    end
-  end
-
-  describe "#execute" do
-    let(:command) { 'mycommand' }
-
-    it "should pass arguments through" do
-      arguments = 'myarg'
-      Puppet::Util::Execution.expects(:execute).with(command, arguments)
-
-      subject.execute(command, arguments)
-    end
-
-    it "should not supply default arguments" do
-      Puppet::Util::Execution.expects(:execute).with(command)
-
-      subject.execute(command)
+      expect(Puppet::Util.pretty_backtrace(["C:/work/puppet/c.rb:12:in `foo'\n"])).
+        to eq("C:/work/puppet/c.rb:12:in `foo'")
     end
   end
 
@@ -575,21 +524,21 @@ describe Puppet::Util do
       Puppet::Util.deterministic_rand(123,20)
       rand_one = rand()
       Puppet::Util.deterministic_rand(123,20)
-      rand().should_not eql(rand_one)
+      expect(rand()).not_to eql(rand_one)
     end
 
     if defined?(Random) == 'constant' && Random.class == Class
       it "should not fiddle with the global seed" do
         srand(1234)
         Puppet::Util.deterministic_rand(123,20)
-        srand().should eql(1234)
+        expect(srand()).to eql(1234)
       end
     # ruby below 1.9.2 variant
     else
       it "should set a new global seed" do
         srand(1234)
         Puppet::Util.deterministic_rand(123,20)
-        srand().should_not eql(1234)
+        expect(srand()).not_to eql(1234)
       end
     end
   end

data/spec/unit/version_spec.rb

@@ -17,11 +17,11 @@ describe "Puppet.version Public API" do
     end
 
     it "is Puppet::PUPPETVERSION" do
-      Puppet.version.should == Puppet::PUPPETVERSION
+      expect(Puppet.version).to eq(Puppet::PUPPETVERSION)
     end
     it "respects the version= setter" do
       Puppet.version = '1.2.3'
-      Puppet.version.should == '1.2.3'
+      expect(Puppet.version).to eq('1.2.3')
     end
   end
 
@@ -32,11 +32,11 @@ describe "Puppet.version Public API" do
         pathname.basename.to_s == "VERSION"
       end.returns('3.0.1-260-g9ca4e54')
 
-      Puppet.version.should == '3.0.1-260-g9ca4e54'
+      expect(Puppet.version).to eq('3.0.1-260-g9ca4e54')
     end
     it "respects the version= setter" do
       Puppet.version = '1.2.3'
-      Puppet.version.should == '1.2.3'
+      expect(Puppet.version).to eq('1.2.3')
     end
   end
 end

data/spec/watchr.rb

@@ -14,11 +14,7 @@ def run_comp(cmd)
         putc c
         line << c
         if c == ?\n
-          results << if RUBY_VERSION >= "1.9" then
-                       line.join
-                     else
-                       line.pack "c*"
-                     end
+          results << line.join
           line.clear
         end
       end

data/tasks/benchmark.rake

@@ -36,14 +36,9 @@ namespace :benchmark do
 
       desc "Run the #{name} scenario."
       task :run, [*run_args] =>  :generate do |_, args|
-        format = if RUBY_VERSION =~ /^1\.8/
-                   Benchmark::FMTSTR
-                 else
-                   Benchmark::FORMAT
-                 end
         report = []
         details = []
-        Benchmark.benchmark(Benchmark::CAPTION, 10, format, "> total:", "> avg:") do |b|
+        Benchmark.benchmark(Benchmark::CAPTION, 10, Benchmark::FORMAT, "> total:", "> avg:") do |b|
           times = []
           ENV['ITERATIONS'].to_i.times do |i|
             start_time = Time.now.to_i

data/tasks/ci.rake

@@ -4,7 +4,7 @@ require 'time'
 namespace "ci" do
   task :spec do
     ENV["LOG_SPEC_ORDER"] = "true"
-    sh %{rspec -r yarjuf -f JUnit -o result.xml -fp spec}
+    sh %{rspec --require rspec/legacy_formatters -r yarjuf -f JUnit -o result.xml -fp spec}
   end
 
   desc "Tar up the acceptance/ directory so that package test runs have tests to run against."

data/tasks/manpages.rake

@@ -15,15 +15,6 @@ task :gen_manpages do
   helpface = Puppet::Face[:help, '0.0.1']
   manface  = Puppet::Face[:man, '0.0.1']
 
-  # TODO: This line is terrible.  The reason we need this here is because we
-  #  handle state initialization differently when we run via command line
-  #  (application.rb) than we do when we try to use Faces as library code.
-  #  This is bad, we need to come up with an official stance on what our
-  #  API is and what the entry points, so that we can make sure that
-  #  state initialization is consistent.  See:
-  # http://projects.puppetlabs.com/issues/14441
-  Puppet::Util::Instrumentation.init()
-
   sbins = Dir.glob(%w{sbin/*})
   bins  = Dir.glob(%w{bin/*})
   non_face_applications = helpface.legacy_applications

data/tasks/parallel.rake

@@ -158,8 +158,6 @@ else
       # Responsible for parallelizing spec testing.
       #
       class Parallelizer
-        include ::RSpec::Core::Formatters::Helpers
-
         # Number of processes to use
         attr_reader :process_count
         # Approximate size of each group of tests
@@ -341,7 +339,7 @@ else
           end
 
           # Print out the run time
-          puts "\nFinished in #{format_duration(Time.now - @start_time)}"
+          puts "\nFinished in #{::RSpec::Core::Formatters::Helpers.format_duration(Time.now - @start_time)}"
 
           # Count all of the examples
           examples = 0
@@ -373,8 +371,8 @@ else
         end
 
         def summary_count_line(examples, failures, pending)
-          summary = pluralize(examples, "example")
-          summary << ", " << pluralize(failures, "failure")
+          summary = ::RSpec::Core::Formatters::Helpers.pluralize(examples, "example")
+          summary << ", " << ::RSpec::Core::Formatters::Helpers.pluralize(failures, "failure")
           summary << ", #{pending} pending" if pending > 0
           summary
         end
@@ -389,7 +387,6 @@ else
       config.error_stream = $stderr
       config.output_stream = $stdout
       options = ::RSpec::Core::ConfigurationOptions.new []
-      options.parse_options
       options.configure config
       config.color
     end
@@ -399,7 +396,7 @@ else
       # Default group size in rspec examples
       DEFAULT_GROUP_SIZE = 1000
 
-      process_count = [(args[:process_count] || Facter["processorcount"].value).to_i, 1].max
+      process_count = [(args[:process_count] || Facter.value("processorcount")).to_i, 1].max
       group_size = [(args[:group_size] || DEFAULT_GROUP_SIZE).to_i, 1].max
 
       abort unless Parallel::RSpec::Parallelizer.new(process_count, group_size, color_output?).run

data/tasks/parser.rake

@@ -1,8 +1,3 @@
-desc "Generate the 3.x 'current' parser"
-task :gen_parser do
-  %x{racc -olib/puppet/parser/parser.rb lib/puppet/parser/grammar.ra}
-end
-
 desc "Generate the 4.x 'future' parser"
 task :gen_eparser do
   %x{racc -olib/puppet/pops/parser/eparser.rb lib/puppet/pops/parser/egrammar.ra}