jbox-gitolite 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1d34e58c461358e45e656b0010599e9c38a3f39
-  data.tar.gz: ea3a1b7090e7bb575f06b9bc81818b715d2f1d95
+  metadata.gz: 6f75c8c516f589f46bd632bca406db19dcd203b0
+  data.tar.gz: f82ec5ddd831a347a618ea5ca3485e7d9c64967b
 SHA512:
-  metadata.gz: 37c0f9b48016346921c5397ea5b95dd1e2ee356f96f4d5400670ce4c2280379feffd39c74df00c68853acc6c93e217dc8b50594506bc164bbcdd302ff60bc0cb
-  data.tar.gz: be32a6b452143bb8a73a894e2a1c859390abcc19d1f2e9e5aab87e62fba6f61f89eafaabc70f8324f74d6587183a9d608cdfb8f99915e03e3fabf83998cd5a1f
+  metadata.gz: 7a57407c0b06c0aa6ccd885a6a3732923fa030edd28fcd920e6d246fa5873d03b4456893df3da25cbeeba06d758ee4d73be7fdf8334efeaf55889e529227eb8f
+  data.tar.gz: 95f921301d318b4e7f103da5a0cf79e191de48821478637b2900f54f5b2ea4534a9f6d9ccdb6755af2e9d5dd7250eb1c1a8b4072fc004cdcb5afe8db4002e420

data/Rakefile

@@ -44,7 +44,7 @@ desc "Start unit tests"
 task :test => :default
 task :default do
   RSpec::Core::RakeTask.new(:spec) do |config|
-    config.rspec_opts = "--color --format nested --fail-fast"
+    config.rspec_opts = "--color --format documentation"
   end
   Rake::Task["spec"].invoke
 end

data/gitolite.gemspec

@@ -15,21 +15,18 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "jbox-gitolite"
 
-  s.add_development_dependency "rake",        "~> 10.3.1"
-  s.add_development_dependency "rdoc",        "~> 4.1.1"
-  s.add_development_dependency "rspec",       "~> 2.14.1"
-  s.add_development_dependency "guard-rspec", "~> 4.2.8"
-  s.add_development_dependency "guard-spork", "~> 1.5.1"
-  s.add_development_dependency "forgery",     "~> 0.6.0"
-  s.add_development_dependency "travis-lint", "~> 1.8.0"
+  s.add_development_dependency 'rake', '~> 10.3', '>= 10.3.1'
+  s.add_development_dependency 'rdoc', '~> 4.1', '>= 4.1.1'
+  s.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+  s.add_development_dependency 'guard-rspec', '~> 4.2', '>= 4.2.8'
+  s.add_development_dependency 'guard-spork', '~> 1.5', '>= 1.5.1'
+  s.add_development_dependency 'forgery', '~> 0.6', '>= 0.6.0'
+  s.add_development_dependency 'simplecov', '~> 0.8', '>= 0.8.2'
+  s.add_development_dependency 'simplecov-rcov', '~> 0.2', '>= 0.2.3'
+  s.add_development_dependency 'rspec_junit_formatter', '~> 0.2', '>= 0.2.0'
 
-  s.add_development_dependency "simplecov",      "~> 0.8.2"
-  s.add_development_dependency "simplecov-rcov", "~> 0.2.3"
-
-  s.add_development_dependency "rspec_junit_formatter", "~> 0.1.6"
-
-  s.add_dependency "gitlab-grit", "~> 2.6.5"
-  s.add_dependency "gratr19",     "~> 0.4.4.1"
+  s.add_runtime_dependency 'gitlab-grit', '~> 2.7', '>= 2.7.0'
+  s.add_runtime_dependency 'gratr19', '~> 0.4', '>= 0.4.4.1'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/gitolite/gitolite_admin.rb

@@ -63,8 +63,8 @@ module Gitolite
         config = c.to_file(File.join(path, "conf"))
 
         gl_admin = Grit::Repo.init(path)
-        gl_admin.git.native(:add, {:chdir => gl_admin.working_dir}, config)
-        gl_admin.git.native(:commit, {:chdir => gl_admin.working_dir}, '-a', '-m', options[:message] || "Config bootstrapped by the gitolite gem")
+        gl_admin.git.native(:add, {}, config)
+        gl_admin.git.native(:commit, {}, '-a', '-m', options[:message] || "Config bootstrapped by the gitolite gem")
 
         self.new(path)
       end
@@ -125,8 +125,8 @@ module Gitolite
     # git repo to HEAD and reloading the entire repository
     # Note that this will also delete all untracked files
     def reset!
-      @gl_admin.git.native(:reset, {:env => @env, :chdir => @gl_admin.working_dir, :hard => true}, 'HEAD')
-      @gl_admin.git.native(:clean, {:env => @env, :chdir => @gl_admin.working_dir, :d => true, :q => true, :f => true})
+      @gl_admin.git.native(:reset, {:env => @env, :hard => true}, 'HEAD')
+      @gl_admin.git.native(:clean, {:env => @env, :d => true, :q => true, :f => true})
       reload!
     end
 
@@ -146,7 +146,7 @@ module Gitolite
       #Process config file (if loaded, i.e. may be modified)
       if @config
         new_conf = @config.to_file(@conf_dir_path)
-        @gl_admin.git.native(:add, {:env => @env, :chdir => @gl_admin.working_dir}, new_conf)
+        @gl_admin.git.native(:add, {:env => @env}, new_conf)
       end
 
       #Process ssh keys (if loaded, i.e. may be modified)
@@ -156,7 +156,7 @@ module Gitolite
 
         to_remove = (files - keys).map { |f| File.join(@key_dir, f) }
         to_remove.each do |key|
-          @gl_admin.git.native(:rm, {:env => @env, :chdir => @gl_admin.working_dir}, key)
+          @gl_admin.git.native(:rm, {:env => @env}, key)
         end
 
         @ssh_keys.each_value do |key|
@@ -164,24 +164,28 @@ module Gitolite
           next if key.respond_to?(:dirty?) && !key.dirty?
           key.each do |k|
             new_key = k.to_file(@key_dir_path)
-            @gl_admin.git.native(:add, {:env => @env, :chdir => @gl_admin.working_dir}, new_key)
+            @gl_admin.git.native(:add, {:env => @env}, new_key)
           end
         end
       end
 
       args = []
 
+      args << '-a'
+      args << '-m'
+      args << commit_message
+
       if options.has_key?(:author) && !options[:author].empty?
         args << "--author='#{options[:author]}'"
       end
 
-      @gl_admin.git.native(:commit, {:env => @env, :chdir => @gl_admin.working_dir}, '-a', '-m', commit_message, args.join(' '))
+      @gl_admin.git.native(:commit, {:env => @env}, *args)
     end
 
 
     # Push back to origin
     def apply
-      @gl_admin.git.native(:push, {:env => @env, :chdir => @gl_admin.working_dir}, "origin", "master")
+      @gl_admin.git.native(:push, {:env => @env}, "origin", "master")
     end
 
 
@@ -198,7 +202,7 @@ module Gitolite
 
       reset! if options[:reset]
 
-      @gl_admin.git.native(:pull, {:env => @env, :chdir => @gl_admin.working_dir, :rebase => options[:rebase]}, "origin", "master")
+      @gl_admin.git.native(:pull, {:env => @env, :rebase => options[:rebase]}, "origin", "master")
 
       reload!
     end

data/lib/gitolite/version.rb

@@ -1,3 +1,3 @@
 module Gitolite
-  VERSION = "1.2.2"
+  VERSION = "1.2.3"
 end

data/spec/config_spec.rb

@@ -9,14 +9,14 @@ describe Gitolite::Config do
   describe "#new" do
     it 'should read a simple configuration' do
       c = Gitolite::Config.new(File.join(conf_dir, 'simple.conf'))
-      c.repos.length.should == 2
-      c.groups.length.should == 0
+      expect(c.repos.length).to eq 2
+      expect(c.groups.length).to eq 0
     end
 
     it 'should read a complex configuration' do
       c = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
-      c.groups.length.should == 5
-      c.repos.length.should == 13
+      expect(c.groups.length).to eq 5
+      expect(c.repos.length).to eq 13
     end
 
     describe 'gitweb operations' do
@@ -26,26 +26,26 @@ describe Gitolite::Config do
 
       it 'should correctly read gitweb options for an existing repo' do
         r = @config.get_repo('gitolite')
-        r.owner.should == "Sitaram Chamarty"
-        r.description.should == "fast, secure, access control for git in a corporate environment"
+        expect(r.owner).to eq "Sitaram Chamarty"
+        expect(r.description).to eq "fast, secure, access control for git in a corporate environment"
       end
 
       it 'should correctly read a gitweb option with no owner for an existing repo' do
         r = @config.get_repo('foo')
-        r.owner.should be nil
-        r.description.should == "Foo is a nice test repo"
+        expect(r.owner).to be nil
+        expect(r.description).to eq "Foo is a nice test repo"
       end
 
       it 'should correctly read gitweb options for a new repo' do
         r = @config.get_repo('foobar')
-        r.owner.should == "Bob Zilla"
-        r.description.should == "Foobar is top secret"
+        expect(r.owner).to eq "Bob Zilla"
+        expect(r.description).to eq "Foobar is top secret"
       end
 
       it 'should correctly read gitweb options with no owner for a new repo' do
         r = @config.get_repo('bar')
-        r.owner.should be nil
-        r.description.should == "A nice place to get drinks"
+        expect(r.owner).to be nil
+        expect(r.description).to eq "A nice place to get drinks"
       end
 
       it 'should raise a ParseError when a description is not specified' do
@@ -53,7 +53,7 @@ describe Gitolite::Config do
         t.write('gitolite "Bob Zilla"')
         t.close
 
-        lambda { Gitolite::Config.new(t.path) }.should raise_error(Gitolite::Config::ParseError)
+        expect(lambda { Gitolite::Config.new(t.path) }).to raise_error(Gitolite::Config::ParseError)
 
         t.unlink
       end
@@ -63,7 +63,7 @@ describe Gitolite::Config do
         t.write('@gitolite "Bob Zilla" = "Test description"')
         t.close
 
-        lambda { Gitolite::Config.new(t.path) }.should raise_error(Gitolite::Config::ParseError)
+        expect(lambda { Gitolite::Config.new(t.path) }).to raise_error(Gitolite::Config::ParseError)
 
         t.unlink
       end
@@ -76,7 +76,7 @@ describe Gitolite::Config do
 
       it 'should correctly read in git config settings' do
         r = @config.get_repo(:gitolite)
-        r.config.length.should == 4
+        expect(r.config.length).to eq 4
       end
     end
 
@@ -87,7 +87,7 @@ describe Gitolite::Config do
 
       it 'should correctly read in gitolite options' do
         r = @config.get_repo(:foo)
-        r.options.length.should == 3
+        expect(r.options.length).to eq 3
       end
 
       it 'should raise a ParseError when a value is not specified' do
@@ -95,7 +95,7 @@ describe Gitolite::Config do
         t.write("repo foobar\n  option mirror.master =")
         t.close
 
-        lambda { Gitolite::Config.new(t.path) }.should raise_error(Gitolite::Config::ParseError)
+        expect(lambda { Gitolite::Config.new(t.path) }).to raise_error(Gitolite::Config::ParseError)
 
         t.unlink
       end
@@ -106,24 +106,24 @@ describe Gitolite::Config do
     it 'should create a valid, blank Gitolite::Config' do
       c = Gitolite::Config.init
 
-      c.should be_an_instance_of Gitolite::Config
-      c.repos.should_not be nil
-      c.repos.length.should be 0
-      c.groups.should_not be nil
-      c.groups.length.should be 0
-      c.filename.should == "gitolite.conf"
+      expect(c).to be_an_instance_of Gitolite::Config
+      expect(c.repos).to_not be nil
+      expect(c.repos.length).to be 0
+      expect(c.groups).to_not be nil
+      expect(c.groups.length).to be 0
+      expect(c.filename).to eq "gitolite.conf"
     end
 
     it 'should create a valid, blank Gitolite::Config with the given filename' do
       filename = "test.conf"
       c = Gitolite::Config.init(filename)
 
-      c.should be_an_instance_of Gitolite::Config
-      c.repos.should_not be nil
-      c.repos.length.should be 0
-      c.groups.should_not be nil
-      c.groups.length.should be 0
-      c.filename.should == filename
+      expect(c).to be_an_instance_of Gitolite::Config
+      expect(c.repos).to_not be nil
+      expect(c.repos.length).to be 0
+      expect(c.groups).to_not be nil
+      expect(c.groups.length).to be 0
+      expect(c.filename).to eq filename
     end
   end
 
@@ -134,40 +134,40 @@ describe Gitolite::Config do
 
     describe "#get_repo" do
       it 'should fetch a repo by a string containing the name' do
-        @config.get_repo('gitolite').should be_an_instance_of Gitolite::Config::Repo
+        expect(@config.get_repo('gitolite')).to be_an_instance_of Gitolite::Config::Repo
       end
 
       it 'should fetch a repo via a symbol representing the name' do
-        @config.get_repo(:gitolite).should be_an_instance_of Gitolite::Config::Repo
+        expect(@config.get_repo(:gitolite)).to be_an_instance_of Gitolite::Config::Repo
       end
 
       it 'should return nil for a repo that does not exist' do
-        @config.get_repo(:glite).should be nil
+        expect(@config.get_repo(:glite)).to be nil
       end
     end
 
     describe "#has_repo?" do
       it 'should return false for a repo that does not exist' do
-        @config.has_repo?(:glite).should be false
+        expect(@config.has_repo?(:glite)).to be false
       end
 
       it 'should check for the existance of a repo given a repo object' do
         r = @config.repos["gitolite"]
-        @config.has_repo?(r).should be true
+        expect(@config.has_repo?(r)).to be true
       end
 
       it 'should check for the existance of a repo given a string containing the name' do
-        @config.has_repo?('gitolite').should be true
+        expect(@config.has_repo?('gitolite')).to be true
       end
 
       it 'should check for the existance of a repo given a symbol representing the name' do
-        @config.has_repo?(:gitolite).should be true
+        expect(@config.has_repo?(:gitolite)).to be true
       end
     end
 
     describe "#add_repo" do
       it 'should throw an ArgumentError for non-Gitolite::Config::Repo objects passed in' do
-        lambda{ @config.add_repo("not-a-repo") }.should raise_error(ArgumentError)
+        expect(lambda{ @config.add_repo("not-a-repo") }).to raise_error(ArgumentError)
       end
 
       it 'should add a given repo to the list of repos' do
@@ -175,8 +175,8 @@ describe Gitolite::Config do
         nrepos = @config.repos.size
         @config.add_repo(r)
 
-        @config.repos.size.should == nrepos + 1
-        @config.has_repo?(:cool_repo).should be true
+        expect(@config.repos.size).to eq nrepos + 1
+        expect(@config.has_repo?(:cool_repo)).to be true
       end
 
       it 'should merge a given repo with an existing repo' do
@@ -227,28 +227,28 @@ describe Gitolite::Config do
       it 'should remove a repo for the Gitolite::Config::Repo object given' do
         r = @config.get_repo(:gitolite)
         r2 = @config.rm_repo(r)
-        r2.name.should == r.name
-        r2.permissions.length.should == r.permissions.length
-        r2.owner.should == r.owner
-        r2.description.should == r.description
+        expect(r2.name).to eq r.name
+        expect(r2.permissions.length).to eq r.permissions.length
+        expect(r2.owner).to eq r.owner
+        expect(r2.description).to eq r.description
       end
 
       it 'should remove a repo given a string containing the name' do
         r = @config.get_repo(:gitolite)
         r2 = @config.rm_repo('gitolite')
-        r2.name.should == r.name
-        r2.permissions.length.should == r.permissions.length
-        r2.owner.should == r.owner
-        r2.description.should == r.description
+        expect(r2.name).to eq r.name
+        expect(r2.permissions.length).to eq r.permissions.length
+        expect(r2.owner).to eq r.owner
+        expect(r2.description).to eq r.description
       end
 
       it 'should remove a repo given a symbol representing the name' do
         r = @config.get_repo(:gitolite)
         r2 = @config.rm_repo(:gitolite)
-        r2.name.should == r.name
-        r2.permissions.length.should == r.permissions.length
-        r2.owner.should == r.owner
-        r2.description.should == r.description
+        expect(r2.name).to eq r.name
+        expect(r2.permissions.length).to eq r.permissions.length
+        expect(r2.owner).to eq r.owner
+        expect(r2.description).to eq r.description
       end
     end
   end
@@ -260,44 +260,44 @@ describe Gitolite::Config do
 
     describe "#has_group?" do
       it 'should find the staff group using a symbol' do
-        @config.has_group?(:staff).should be true
+        expect(@config.has_group?(:staff)).to be true
       end
 
       it 'should find the staff group using a string' do
-       @config.has_group?('staff').should be true
+       expect(@config.has_group?('staff')).to be true
       end
 
       it 'should find the staff group using a Gitolite::Config::Group object' do
         g = Gitolite::Config::Group.new("staff")
-        @config.has_group?(g).should be true
+        expect(@config.has_group?(g)).to be true
       end
     end
 
     describe "#get_group" do
       it 'should return the Gitolite::Config::Group object for the group name String' do
         g = @config.get_group("staff")
-        g.is_a?(Gitolite::Config::Group).should be true
-        g.size.should == 6
+        expect(g.is_a?(Gitolite::Config::Group)).to be true
+        expect(g.size).to eq 6
       end
 
       it 'should return the Gitolite::Config::Group object for the group name Symbol' do
         g = @config.get_group(:staff)
-        g.is_a?(Gitolite::Config::Group).should be true
-        g.size.should == 6
+        expect(g.is_a?(Gitolite::Config::Group)).to be true
+        expect(g.size).to eq 6
       end
     end
 
     describe "#add_group" do
       it 'should throw an ArgumentError for non-Gitolite::Config::Group objects passed in' do
-        lambda{ @config.add_group("not-a-group") }.should raise_error(ArgumentError)
+        expect(lambda{ @config.add_group("not-a-group") }).to raise_error(ArgumentError)
       end
 
       it 'should add a given group to the groups list' do
         g = Gitolite::Config::Group.new('cool_group')
         ngroups = @config.groups.size
         @config.add_group(g)
-        @config.groups.size.should be ngroups + 1
-        @config.has_group?(:cool_group).should be true
+        expect(@config.groups.size).to be ngroups + 1
+        expect(@config.has_group?(:cool_group)).to be true
       end
 
     end
@@ -306,20 +306,20 @@ describe Gitolite::Config do
       it 'should remove a group for the Gitolite::Config::Group object given' do
         g = @config.get_group(:oss_repos)
         g2 = @config.rm_group(g)
-        g.should_not be nil
-        g2.name.should == g.name
+        expect(g).to_not be nil
+        expect(g2.name).to eq g.name
       end
 
       it 'should remove a group given a string containing the name' do
         g = @config.get_group(:oss_repos)
         g2 = @config.rm_group('oss_repos')
-        g2.name.should == g.name
+        expect(g2.name).to eq g.name
       end
 
       it 'should remove a group given a symbol representing the name' do
         g = @config.get_group(:oss_repos)
         g2 = @config.rm_group(:oss_repos)
-        g2.name.should == g.name
+        expect(g2.name).to eq g.name
       end
     end
 
@@ -329,14 +329,14 @@ describe Gitolite::Config do
     it 'should create a file at the given path with the config\'s file name' do
       c = Gitolite::Config.init
       file = c.to_file(output_dir)
-      File.file?(File.join(output_dir, c.filename)).should be true
+      expect(File.file?(File.join(output_dir, c.filename))).to be true
       File.unlink(file)
     end
 
     it 'should create a file at the given path with the config file passed' do
       c = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
       file = c.to_file(output_dir)
-      File.file?(File.join(output_dir, c.filename)).should be true
+      expect(File.file?(File.join(output_dir, c.filename))).to be true
     end
 
     it 'should create a file at the given path when a different filename is specified' do
@@ -344,18 +344,18 @@ describe Gitolite::Config do
       c = Gitolite::Config.init
       c.filename = filename
       file = c.to_file(output_dir)
-      File.file?(File.join(output_dir, filename)).should be true
+      expect(File.file?(File.join(output_dir, filename))).to be true
       File.unlink(file)
     end
 
     it 'should raise an ArgumentError when an invalid path is specified' do
       c = Gitolite::Config.init
-      lambda { c.to_file('/does/not/exist') }.should raise_error(ArgumentError)
+      expect(lambda { c.to_file('/does/not/exist') }).to raise_error(ArgumentError)
     end
 
     it 'should raise an ArgumentError when a filename is specified in the path' do
       c = Gitolite::Config.init
-      lambda{ c.to_file('/home/test.rb') }.should raise_error(ArgumentError)
+      expect(lambda{ c.to_file('/home/test.rb') }).to raise_error(ArgumentError)
     end
 
     it 'should resolve group dependencies such that all groups are defined before they are used' do
@@ -387,10 +387,10 @@ describe Gitolite::Config do
       lines = f.lines.map {|l| l.strip}
 
       # Compare the file lines.  Spacing is important here since we are doing a direct comparision
-      lines[0].should == "@groupb             = andrew joe sam susan"
-      lines[1].should == "@groupc             = @groupb brandon jane"
-      lines[2].should == "@groupd             = @groupc larry"
-      lines[3].should == "@groupa             = @groupb bob"
+      expect(lines[0]).to eq "@groupb             = andrew joe sam susan"
+      expect(lines[1]).to eq "@groupc             = @groupb brandon jane"
+      expect(lines[2]).to eq "@groupd             = @groupc larry"
+      expect(lines[3]).to eq "@groupa             = @groupb bob"
 
       # Cleanup
       File.unlink(file)
@@ -418,7 +418,7 @@ describe Gitolite::Config do
       c.add_group(g)
 
       # Attempt to write the config file
-      lambda{ c.to_file(output_dir)}.should raise_error(Gitolite::Config::GroupDependencyError)
+      expect(lambda{ c.to_file(output_dir)}).to raise_error(Gitolite::Config::GroupDependencyError)
     end
 
     it 'should resolve group dependencies even when there are disconnected portions of the graph' do
@@ -450,10 +450,10 @@ describe Gitolite::Config do
       lines = f.lines.map {|l| l.strip}
 
       # Compare the file lines.  Spacing is important here since we are doing a direct comparision
-      lines[0].should == "@groupd             = chris emily larry"
-      lines[1].should == "@groupb             = andrew joe sam susan"
-      lines[2].should == "@groupa             = bob stephanie timmy"
-      lines[3].should == "@groupc             = @groupa brandon earl jane"
+      expect(lines[0]).to eq "@groupd             = chris emily larry"
+      expect(lines[1]).to eq "@groupb             = andrew joe sam susan"
+      expect(lines[2]).to eq "@groupa             = bob stephanie timmy"
+      expect(lines[3]).to eq "@groupc             = @groupa brandon earl jane"
 
       # Cleanup
       File.unlink(file)
@@ -467,32 +467,32 @@ describe Gitolite::Config do
 
     it 'should remove comments' do
       s = "#comment"
-      @config.instance_eval { cleanup_config_line(s) }.empty?.should == true
+      expect(@config.instance_eval { cleanup_config_line(s) }.empty?).to eq true
     end
 
     it 'should remove inline comments, keeping content before the comment' do
       s = "blablabla #comment"
-      @config.instance_eval { cleanup_config_line(s) }.should == "blablabla"
+      expect(@config.instance_eval { cleanup_config_line(s) }).to eq "blablabla"
     end
 
     it 'should pad = with spaces on each side' do
       s = "bob=joe"
-      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+      expect(@config.instance_eval { cleanup_config_line(s) }).to eq "bob = joe"
     end
 
     it 'should replace multiple space characters with a single space' do
       s = "bob       =        joe"
-      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+      expect(@config.instance_eval { cleanup_config_line(s) }).to eq "bob = joe"
     end
 
     it 'should cleanup whitespace at the beginning and end of lines' do
       s = "            bob = joe            "
-      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+      expect(@config.instance_eval { cleanup_config_line(s) }).to eq "bob = joe"
     end
 
     it 'should cleanup whitespace and comments effectively' do
       s = "            bob     =     joe             #comment"
-      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+      expect(@config.instance_eval { cleanup_config_line(s) }).to eq "bob = joe"
     end
   end
 end