bundler_ext 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 58fa76105a9f07c591192a8fe4b9ad433429fc68
-  data.tar.gz: d5892b331e740da469c0ad159cdb817e29059e35
+SHA256:
+  metadata.gz: 231e9a2fab9c5f11cd70a494ac3be9b6dfa7d4b06a9426f416d2acaf511f6cd1
+  data.tar.gz: 81eafc716126fdbcc6ecec515283970b9b7442dba2a94f8c02eaf47b8aba5c4a
 SHA512:
-  metadata.gz: 5d4e8bfcc04b6bb3e6f73441a6e43c5a3fdf8e566668d496fcbf56c4ad82bf7243786ac5db11e143c59536d853447e01768537c9e89883347d18b3511db52e8a
-  data.tar.gz: 2489f94d3473cec5065664bd493c75181a58b3cb1c14840346c9e740a62c31de82ff8e9da3d2c7bdf2ef4ca296b0917e60c48c573cfb4772457119170e67f5b5
+  metadata.gz: 4bd7ffbb8314041170c0ea1d0d43b12683c2da415ade6b4d22613ff705f40ccee253b84bc2410fd88273af214f69e23111f43fdc39f3b130de2b7017e7bd39c4
+  data.tar.gz: a5478231a4f88594a43086e07a723bbde6e38cc519c774d91d71ba479d162f686a2c246b83842c4ce60b802c4bc08f40de5a784dcf8523e997d3bea0867dde49

data/.rspec

@@ -1,2 +1,2 @@
 --colour
---format nested
+--format documentation

data/CHANGELOG

@@ -1,3 +1,28 @@
+====== version 0.4.2 =========
+
+Vít Ondruch (2020-09-16)
+  - Fix Bundler 1.8.1+ test failures
+
+Ewoud Kohl van Wijngaarden (2022-07-12)
+  - Update test suite to rspec 3
+  - Correct expectations for modern Bundler output
+  - Add CI using GitHub Actions
+
+====== version 0.4.1 =========
+
+Lukas Zapletal (2014-06-09)
+  - Fix loading of namespaced gems
+  - Add BEXT_VERBOSE environment variable
+
+====== version 0.4.0 =========
+
+Mo Morsi (2013-12-19)
+  - Refactored into smaller modules
+  - Drop linux_admin dependency
+  - Add BundlerExt#system_setup analogous to Bundler#setup
+  - Update README
+  - Improve test coverage
+
 ====== version 0.3.2 =========
 
 Mo Morsi (2013-11-19) 

data/lib/bundler_ext/version.rb

@@ -1,3 +1,3 @@
 module BundlerExt
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/spec/bundler_ext/bundler_ext_spec.rb

@@ -4,19 +4,19 @@ require 'bundler_ext'
 describe BundlerExt do
   describe "#runtime" do
     it "returns handle to runtime instance" do
-      described_class.runtime.should be_an_instance_of(BundlerExt::Runtime)
-      described_class.runtime.should == described_class.runtime
+      expect(described_class.runtime).to be_an_instance_of(BundlerExt::Runtime)
+      expect(described_class.runtime).to eq(described_class.runtime)
     end
   end
 
   describe "#system_require" do
     it "sets up runtime env" do
-      described_class.runtime.should_receive(:setup_env)
+      expect(described_class.runtime).to receive(:setup_env)
       described_class.system_require('spec/fixtures/Gemfile.in')
     end
 
     it "parses specified gemfile" do
-      BundlerExt::Gemfile.should_receive(:parse).
+      expect(BundlerExt::Gemfile).to receive(:parse).
         with('spec/fixtures/Gemfile.in', *['mygroups']).
         and_call_original
       described_class.system_require('spec/fixtures/Gemfile.in', 'mygroups')
@@ -24,52 +24,52 @@ describe BundlerExt do
 
     context "System.activate? is true" do
       it "activates system dependencies" do
-        BundlerExt::Gemfile.should_receive(:parse).
+        expect(BundlerExt::Gemfile).to receive(:parse).
           and_return({'rails' => {:files => []}})
-        BundlerExt::System.should_receive(:activate?).and_return(true)
-        BundlerExt::System.should_receive(:activate!).with('rails')
+        expect(BundlerExt::System).to receive(:activate?).and_return(true)
+        expect(BundlerExt::System).to receive(:activate!).with('rails')
         described_class.system_require('my_gemfile')
       end
     end
 
     it "requires dependency files" do
       files = ['rails-includes']
-      BundlerExt::Gemfile.should_receive(:parse).
+      expect(BundlerExt::Gemfile).to receive(:parse).
         and_return({'rails' => {:files => files}})
-      described_class.runtime.should_receive(:system_require).with(files)
+      expect(described_class.runtime).to receive(:system_require).with(files)
       described_class.system_require('my_gemfile')
     end
   end
 
   describe "#system_setup" do
     it "sets up gemfile env" do
-      BundlerExt::Gemfile.should_receive(:setup_env).
+      expect(BundlerExt::Gemfile).to receive(:setup_env).
         with('spec/fixtures/Gemfile.in').at_least(:once)
-      described_class.runtime.should_receive(:clear) # stub out clear
+      expect(described_class.runtime).to receive(:clear) # stub out clear
       described_class.system_setup('spec/fixtures/Gemfile.in')
     end
 
     it "sets runtime gemfile" do
-      described_class.runtime.should_receive(:clear) # stub out clear
+      expect(described_class.runtime).to receive(:clear) # stub out clear
       described_class.system_setup('spec/fixtures/Gemfile.in')
-      described_class.runtime.gemfile.to_s.should == 'spec/fixtures/Gemfile.in'
+      expect(described_class.runtime.gemfile.to_s).to eq('spec/fixtures/Gemfile.in')
     end
 
     it "sets up runtime env" do
-      described_class.runtime.should_receive(:clear) # stub out clear
-      described_class.runtime.should_receive(:setup_env)
+      expect(described_class.runtime).to receive(:clear) # stub out clear
+      expect(described_class.runtime).to receive(:setup_env)
       described_class.system_setup('spec/fixtures/Gemfile.in')
     end
 
     it "clears runtime" do
-      described_class.runtime.should_receive(:clear) # stub out clear
-      described_class.runtime.should_receive(:setup_env)
+      expect(described_class.runtime).to receive(:clear) # stub out clear
+      expect(described_class.runtime).to receive(:setup_env)
       described_class.system_setup('spec/fixtures/Gemfile.in')
     end
 
     it "parses specified gemfile" do
-      described_class.runtime.should_receive(:clear) # stub out clear
-      BundlerExt::Gemfile.should_receive(:parse).
+      expect(described_class.runtime).to receive(:clear) # stub out clear
+      expect(BundlerExt::Gemfile).to receive(:parse).
         with('spec/fixtures/Gemfile.in', *['mygroups']).
         and_call_original
       described_class.system_setup('spec/fixtures/Gemfile.in', 'mygroups')
@@ -77,21 +77,21 @@ describe BundlerExt do
 
     context "System.activate? is true" do
       it "activates system dependencies" do
-        described_class.runtime.should_receive(:clear) # stub out clear
-        BundlerExt::Gemfile.should_receive(:parse).
+        expect(described_class.runtime).to receive(:clear) # stub out clear
+        expect(BundlerExt::Gemfile).to receive(:parse).
           and_return({'rails' => {:dep => ::Gem::Dependency.new('rails')}})
-        BundlerExt::System.should_receive(:activate?).and_return(true)
-        BundlerExt::System.should_receive(:activate!).with('rails')
+        expect(BundlerExt::System).to receive(:activate?).and_return(true)
+        expect(BundlerExt::System).to receive(:activate!).with('rails')
         described_class.system_setup('spec/fixtures/Gemfile.in')
       end
     end
 
     it "adds dependency specs to runtime" do
       dep = ::Gem::Dependency.new('rails')
-      described_class.runtime.should_receive(:clear) # stub out clear
-      BundlerExt::Gemfile.should_receive(:parse).
+      expect(described_class.runtime).to receive(:clear) # stub out clear
+      expect(BundlerExt::Gemfile).to receive(:parse).
         and_return({'rails' => {:dep => dep}})
-      described_class.runtime.should_receive(:add_spec).with(dep.to_spec())
+      expect(described_class.runtime).to receive(:add_spec).with(dep.to_spec())
       described_class.system_setup('spec/fixtures/Gemfile.in')
     end
   end

data/spec/bundler_ext/gemfile_spec.rb

@@ -12,7 +12,7 @@ module BundlerExt
 
       it "sets BUNDLE_GEMFILE env varialbe" do
         described_class.setup_env('Gemfile.custom')
-        ENV['BUNDLE_GEMFILE'].should == 'Gemfile.custom'
+        expect(ENV['BUNDLE_GEMFILE']).to eq('Gemfile.custom')
       end
     end
 
@@ -26,39 +26,39 @@ module BundlerExt
       end
 
       it "converts specified groups to symbols" do
-        described_class.parse_env(['development', 'test'])[:groups].should == [:development, :test]
+        expect(described_class.parse_env(['development', 'test'])[:groups]).to eq([:development, :test])
       end
 
       it "retrieves extra groups from BUNDLER_EXT_GROUPS env variable" do
         ENV['BUNDLER_EXT_GROUPS'] = 'development test'
         env = described_class.parse_env([])
-        env[:groups].should == [:development, :test]
-        env[:extra_groups].should == 'development test'
+        expect(env[:groups]).to eq([:development, :test])
+        expect(env[:extra_groups]).to eq('development test')
       end
 
       it "retrieves extra groups from BEXT_GROUPS env variable" do
         ENV['BEXT_GROUPS'] = 'development test'
         env = described_class.parse_env([])
-        env[:groups].should == [:development, :test]
-        env[:extra_groups].should == 'development test'
+        expect(env[:groups]).to eq([:development, :test])
+        expect(env[:extra_groups]).to eq('development test')
       end
 
       context "groups == [:all] and no extra groups specified" do
         it "sets all_groups true" do
-          described_class.parse_env([:all])[:all_groups].should be_true
+          expect(described_class.parse_env([:all])[:all_groups]).to be true
         end
       end
 
       context "groups != [:all]" do
         it "sets all_groups false" do
-          described_class.parse_env([:dev])[:all_groups].should be_false
+          expect(described_class.parse_env([:dev])[:all_groups]).to be false
         end
       end
 
       context "extra groups specified" do
         it "sets all_groups false" do
           ENV['BEXT_GROUPS'] = 'development'
-          described_class.parse_env([:all])[:all_groups].should be_false
+          expect(described_class.parse_env([:all])[:all_groups]).to be false
         end
       end
     end
@@ -72,8 +72,8 @@ module BundlerExt
       context "dep.current_platform? is false" do
         it "returns false" do
           @env[:all_groups] = true
-          @dep.should_receive(:current_platform?).and_return(false)
-          described_class.dependency_in_env?(@dep, @env).should be_false
+          expect(@dep).to receive(:current_platform?).and_return(false)
+          expect(described_class.dependency_in_env?(@dep, @env)).to be false
         end
       end
 
@@ -81,15 +81,15 @@ module BundlerExt
         it "returns false" do
           @env[:all_groups] = false
           @env[:groups] << :dev
-          described_class.dependency_in_env?(@dep, @env).should be_false
+          expect(described_class.dependency_in_env?(@dep, @env)).to be false
         end
       end
 
       context ":all_groups and dep.current_platform? are true" do
         it "returns true" do
           @env[:all_groups] = true
-          @dep.should_receive(:current_platform?).and_return(true)
-          described_class.dependency_in_env?(@dep, @env).should be_true
+          expect(@dep).to receive(:current_platform?).and_return(true)
+          expect(described_class.dependency_in_env?(@dep, @env)).to be true
         end
       end
 
@@ -97,8 +97,8 @@ module BundlerExt
         it "returns true" do
           @env[:groups] << :dev
           @dep.groups   << :dev
-          @dep.should_receive(:current_platform?).and_return(true)
-          described_class.dependency_in_env?(@dep, @env).should be_true
+          expect(@dep).to receive(:current_platform?).and_return(true)
+          expect(described_class.dependency_in_env?(@dep, @env)).to be true
         end
       end
     end
@@ -107,15 +107,15 @@ module BundlerExt
       context "dependency in env" do
         it "returns dependency autorequires" do
           dep = Bundler::Dependency.new 'rake', '1.0.0', 'require' => [:foo]
-          described_class.should_receive(:dependency_in_env?).and_return(true)
-          described_class.files_for_dependency(dep, {}).should == [:foo]
+          expect(described_class).to receive(:dependency_in_env?).and_return(true)
+          expect(described_class.files_for_dependency(dep, {})).to eq([:foo])
         end
 
         context "autorequires is nil" do
           it("returns depenency name") do
             dep = Bundler::Dependency.new 'rake', '1.0.0'
-            described_class.should_receive(:dependency_in_env?).and_return(true)
-            described_class.files_for_dependency(dep, {}).should == ['rake']
+            expect(described_class).to receive(:dependency_in_env?).and_return(true)
+            expect(described_class.files_for_dependency(dep, {})).to eq(['rake'])
           end
         end
       end
@@ -123,8 +123,8 @@ module BundlerExt
       context "dependency not in env" do
         it "returns empty array" do
           dep = Bundler::Dependency.new 'rake', '1.0.0'
-          described_class.should_receive(:dependency_in_env?).and_return(false)
-          described_class.files_for_dependency(dep, {}).should == []
+          expect(described_class).to receive(:dependency_in_env?).and_return(false)
+          expect(described_class.files_for_dependency(dep, {})).to eq([])
         end
       end
     end
@@ -134,7 +134,7 @@ module BundlerExt
         ENV['BUNDLE_GEMFILE'] = 'spec/fixtures/Gemfile.in'
         @dep = Bundler::Dependency.new 'rake', '1.0.0'
         @gemfile = Bundler::Dsl.evaluate 'spec/fixtures/Gemfile.in', nil, true
-        @gemfile.should_receive(:dependencies).and_return([@dep])
+        expect(@gemfile).to receive(:dependencies).and_return([@dep])
       end
 
       after(:each) do
@@ -142,14 +142,13 @@ module BundlerExt
       end
 
       it "returns gemfile dependencies with files" do
-        described_class.should_receive(:files_for_dependency).and_return([:files])
-        described_class.process(@gemfile, {}).should ==
-          {'rake' => {:dep => @dep, :files => [:files]}}
+        expect(described_class).to receive(:files_for_dependency).and_return([:files])
+        expect(described_class.process(@gemfile, {})).to eq({'rake' => {:dep => @dep, :files => [:files]}})
       end
 
       it "does not return gemfile dependencies without files" do
-        described_class.should_receive(:files_for_dependency).and_return([])
-        described_class.process(@gemfile, {}).should == {}
+        expect(described_class).to receive(:files_for_dependency).and_return([])
+        expect(described_class.process(@gemfile, {})).to eq({})
       end
     end
 
@@ -164,26 +163,26 @@ module BundlerExt
       end
 
       it "sets up env for gemfile" do
-        described_class.should_receive(:setup_env).with(@gemfile)
+        expect(described_class).to receive(:setup_env).with(@gemfile)
         described_class.parse(@gemfile)
       end
 
       it "retrieves env configured by gemfile" do
-        described_class.should_receive(:parse_env).with([:test]).and_call_original
+        expect(described_class).to receive(:parse_env).with([:test]).and_call_original
         described_class.parse(@gemfile, :test)
       end
 
       it "evaluates gemfile with bundler dsl" do
-        Bundler::Dsl.should_receive(:evaluate).with(@gemfile, nil, true).and_call_original
+        expect(Bundler::Dsl).to receive(:evaluate).with(@gemfile, nil, true).and_call_original
         described_class.parse(@gemfile, :test)
       end
 
       it "processes gemfile / returns results" do
         env = Object.new
         gemfile = Object.new
-        described_class.should_receive(:parse_env).and_return(env)
-        Bundler::Dsl.should_receive(:evaluate).and_return(gemfile)
-        described_class.should_receive(:process).with(gemfile, env)
+        expect(described_class).to receive(:parse_env).and_return(env)
+        expect(Bundler::Dsl).to receive(:evaluate).and_return(gemfile)
+        expect(described_class).to receive(:process).with(gemfile, env)
         described_class.parse(@gemfile, :test)
       end
     end

data/spec/bundler_ext/integration_spec.rb

@@ -24,89 +24,90 @@ end
       describe "with no group passed in" do
         it "should return nothing to require" do
           libs = BundlerExt::Gemfile.parse(@gemfile)
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
-          libs.keys.should_not include('vcr')
+          expect(libs).to be_an(Hash)
+          expect(libs.keys).to_not include('deltacloud-client')
+          expect(libs.keys).to_not include('vcr')
         end
       end
       describe "with :all passed in" do
         it "should return the list of system libraries in all groups to require" do
           libs = BundlerExt::Gemfile.parse(@gemfile, :all)
-          libs.should be_an(Hash)
-          libs.keys.should include('deltacloud-client')
-          libs['deltacloud-client'][:files].should == ['deltacloud']
-          libs.keys.should include('vcr')
+          expect(libs).to be_an(Hash)
+          expect(libs.keys).to include('deltacloud-client')
+          expect(libs['deltacloud-client'][:files]).to eq(['deltacloud'])
+          expect(libs.keys).to include('vcr')
         end
       end
       describe "with group passed in" do
         it "should not return any deps that are not in the 'development' group" do
           libs = BundlerExt::Gemfile.parse(@gemfile,'development')
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
+          expect(libs).to be_an(Hash)
+          expect(libs.keys).to_not include('deltacloud-client')
         end
         it "should return only deps that are in the :test group" do
           libs = BundlerExt::Gemfile.parse(@gemfile, :test)
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
-          libs.keys.should include('vcr')
+          expect(libs).to be_an(Hash)
+          expect(libs.keys).to_not include('deltacloud-client')
+          expect(libs.keys).to include('vcr')
         end
         it "should return deps from both the :default and :test groups" do
           libs = BundlerExt::Gemfile.parse(@gemfile, :default, :test)
-          libs.should be_an(Hash)
-          libs.keys.should include('deltacloud-client')
-          libs.keys.should include('vcr')
+          expect(libs).to be_an(Hash)
+          expect(libs.keys).to include('deltacloud-client')
+          expect(libs.keys).to include('vcr')
         end
       end
       it "should only return deps for the current platform" do
         libs = BundlerExt::Gemfile.parse(@gemfile)
-        libs.should be_an(Hash)
+        expect(libs).to be_an(Hash)
         if RUBY_VERSION < "1.9"
-          libs.keys.should_not include('cinch')
+          expect(libs.keys).to_not include('cinch')
         else
-          libs.keys.should_not include('fastercsv')
+          expect(libs.keys).to_not include('fastercsv')
         end
       end
     end
     describe "#system_require" do
       it "strict mode should fail loading non existing gem" do
-        expect { BundlerExt.system_require(@gemfile, :fail) }.to raise_error
+        expect { BundlerExt.system_require(@gemfile, :fail) }.
+          to raise_error(RuntimeError, 'Gem loading error: cannot load such file -- not_existing_gem')
       end
 
       it "non-strict mode should load the libraries in the gemfile" do
         ENV['BEXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile)
-        defined?(Gem).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
 
       it "non-strict mode should load the libraries in the gemfile" do
         ENV['BUNDLER_EXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile)
-        defined?(Gem).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
 
       it "non-strict mode should load the libraries in the gemfile" do
         ENV['BEXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile, :fail)
-        defined?(Gem).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
 
       it "non-strict mode should load the libraries in the gemfile" do
         ENV['BUNDLER_EXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile, :fail)
-        defined?(Gem).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
       it "non-strict mode should load the libraries using env var list" do
         ENV['BEXT_GROUPS'] = 'test development blah'
         ENV['BEXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile)
-        defined?(Gem::Command).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
 
       it "non-strict mode should load the libraries using env var list" do
         ENV['BUNLDER_EXT_GROUPS'] = 'test development blah'
         ENV['BEXT_NOSTRICT'] = 'true'
         BundlerExt.system_require(@gemfile)
-        defined?(Gem::Command).should be_true
+        expect(defined?(Gem)).to be_truthy
       end
 
       unless skip_system
@@ -120,11 +121,11 @@ end
             gems = BundlerExt::Gemfile.parse(@gemfile, :all)
             gems.each { |gem,gdep|
               version = rand(100)
-              BundlerExt::System.should_receive(:system_name_for).with(gem).
+              expect(BundlerExt::System).to receive(:system_name_for).with(gem).
                          and_return(gem)
-              BundlerExt::System.should_receive(:system_version_for).with(gem).
+              expect(BundlerExt::System).to receive(:system_version_for).with(gem).
                          and_return(version)
-              BundlerExt::System.should_receive(:gem).with(gem, "=#{version}")
+              expect(BundlerExt::System).to receive(:gem).with(gem, "=#{version}")
             }
             BundlerExt.system_require(@gemfile, :all)
           end
@@ -134,7 +135,7 @@ end
               ENV['BEXT_PKG_PREFIX'] = 'rubygem-'
               gems = BundlerExt::Gemfile.parse(@gemfile, :all)
               gems.each { |gem,gdep|
-                BundlerExt::System.should_receive(:system_version_for).with("rubygem-#{gem}").
+                expect(BundlerExt::System).to receive(:system_version_for).with("rubygem-#{gem}").
                            and_return('0')
               }
               BundlerExt.system_require(@gemfile, :all)

data/spec/bundler_ext/runtime_spec.rb

@@ -6,14 +6,14 @@ module BundlerExt
     describe "#gemfile" do
       it "gets/sets bext_gemfile" do
         runtime = described_class.new
-        runtime.gemfile('Gemfile.in').should == 'Gemfile.in'
-        runtime.gemfile.should == 'Gemfile.in'
+        expect(runtime.gemfile('Gemfile.in')).to eq('Gemfile.in')
+        expect(runtime.gemfile).to eq('Gemfile.in')
       end
 
       it "defaults to Bundler.default_gemfile" do
-        Bundler.should_receive(:default_gemfile).and_return('DefaultGemfile')
+        expect(Bundler).to receive(:default_gemfile).and_return('DefaultGemfile')
         runtime = described_class.new
-        runtime.gemfile.should == 'DefaultGemfile'
+        expect(runtime.gemfile).to eq('DefaultGemfile')
       end
     end
 
@@ -21,7 +21,7 @@ module BundlerExt
       it "returns directory name of gemfile" do
         runtime = described_class.new
         runtime.gemfile(Pathname.new('spec/fixtures/Gemfile.in'))
-        runtime.root.to_s.should == File.expand_path('spec/fixtures')
+        expect(runtime.root.to_s).to eq(File.expand_path('spec/fixtures'))
       end
     end
 
@@ -30,9 +30,9 @@ module BundlerExt
         runtime = described_class.new
         runtime.gemfile(Pathname.new('spec/fixtures/Gemfile.in'))
         bundler = runtime.bundler
-        bundler.should be_an_instance_of(Bundler::Runtime)
-        bundler.root.to_s.should == File.expand_path('spec/fixtures')
-        runtime.bundler.should == bundler
+        expect(bundler).to be_an_instance_of(Bundler::Runtime)
+        expect(bundler.root.to_s).to eq(File.expand_path('spec/fixtures'))
+        expect(runtime.bundler).to eq(bundler)
       end
     end
 
@@ -40,8 +40,8 @@ module BundlerExt
       it "returns handle to bundler rubygems integration" do
         runtime  = described_class.new
         rubygems = runtime.rubygems
-        rubygems.should be_an_instance_of(Bundler::RubygemsIntegration)
-        runtime.rubygems.should == rubygems
+        expect(rubygems).to be_an_instance_of(Bundler::RubygemsIntegration)
+        expect(runtime.rubygems).to eq(rubygems)
       end
     end
 
@@ -55,76 +55,76 @@ module BundlerExt
       it "assigns env home variable to BEXT_HOME" do
         ENV['BEXT_HOME'] = '/home/foo'
         described_class.new.setup_env
-        ENV['HOME'].should == '/home/foo'
+        expect(ENV['HOME']).to eq('/home/foo')
       end
 
       it "assigns env home variable to BUNDLER_EXT_HOME" do
         ENV['BUNDLER_EXT_HOME'] = '/home/foo'
         described_class.new.setup_env
-        ENV['HOME'].should == '/home/foo'
+        expect(ENV['HOME']).to eq('/home/foo')
       end
     end
 
     describe "::namespaced_file" do
       context "file does not include '-'" do
         it "returns nil" do
-          described_class.namespaced_file('foobar').should be_nil
+          expect(described_class.namespaced_file('foobar')).to be_nil
         end
       end
 
       context "file responds to :name" do
         it "returns file name in path format" do
           file = Pathname.new 'foo-bar'
-          file.should_receive(:name).and_return('foo-bar')
-          described_class.namespaced_file(file).should == 'foo/bar'
+          expect(file).to receive(:name).and_return('foo-bar')
+          expect(described_class.namespaced_file(file)).to eq('foo/bar')
         end
       end
 
       it "returns file in path format" do
-        described_class.namespaced_file("foo-bar").should == 'foo/bar'
+        expect(described_class.namespaced_file("foo-bar")).to eq('foo/bar')
       end
     end
 
     describe "#system_require" do
       it "requires files" do
         runtime = described_class.new
-        runtime.should_receive(:require).with('file1')
+        expect(runtime).to receive(:require).with('file1')
         runtime.system_require(['file1'])
       end
 
       context "LoadError when requiring file" do
         it "requires namespaced file" do
-          described_class.should_receive(:namespaced_file).with('file1').
+          expect(described_class).to receive(:namespaced_file).with('file1').
             and_return('namespaced_file1')
           runtime = described_class.new
-          runtime.should_receive(:require).with('file1').and_call_original
-          runtime.should_receive(:require).with('namespaced_file1')
+          expect(runtime).to receive(:require).with('file1').and_call_original
+          expect(runtime).to receive(:require).with('namespaced_file1')
           runtime.system_require(['file1'])
         end
 
         context "LoadError when requiring namespaced file" do
           it "outputs strict error" do
             expected = 'Gem loading error: cannot load such file -- namespaced_file1'
-            Output.should_receive(:strict_err).with(expected)
+            expect(Output).to receive(:strict_err).with(expected)
 
-            described_class.should_receive(:namespaced_file).with('file1').
+            expect(described_class).to receive(:namespaced_file).with('file1').
               and_return('namespaced_file1')
             runtime = described_class.new
-            runtime.should_receive(:require).with('file1').and_call_original
-            runtime.should_receive(:require).with('namespaced_file1').and_call_original
+            expect(runtime).to receive(:require).with('file1').and_call_original
+            expect(runtime).to receive(:require).with('namespaced_file1').and_call_original
             runtime.system_require(['file1'])
           end
         end
 
         context "namespaced file is nil" do
           it "outputs strict error" do
-            expected = 'Gem loading error: cannot load such file -- file1'
-            Output.should_receive(:strict_err).with(expected)
+            expected = /^Gem loading error: cannot load such file -- file1($|\nDid you mean\?  )/
+            expect(Output).to receive(:strict_err).with(expected)
 
-            described_class.should_receive(:namespaced_file).with('file1').
+            expect(described_class).to receive(:namespaced_file).with('file1').
               and_return(nil)
             runtime = described_class.new
-            runtime.should_receive(:require).with('file1').and_call_original
+            expect(runtime).to receive(:require).with('file1').and_call_original
             runtime.system_require(['file1'])
           end
         end
@@ -134,14 +134,14 @@ module BundlerExt
     describe "clear" do
       it "cleans bundler load path" do
         runtime = described_class.new
-        runtime.bundler.should_receive(:clean_load_path)
+        expect(runtime.bundler).to receive(:clean_load_path)
         runtime.clear
       end
     end
 
     describe "add_spec" do
       around(:each) do |spec|
-        orig = $LOAD_PATH
+        orig = $LOAD_PATH.dup
         spec.run
 
         # XXX need to restore this way else we'll get an err:
@@ -150,28 +150,28 @@ module BundlerExt
         orig.each { |o| $LOAD_PATH << o }
       end
 
+      # XXX needed to require rubygems/ext/builder in with Bundler 1.8.1+.
+      let!(:runtime) { described_class.new.tap {|c| c.rubygems} }
+
       it "marks spec as loaded" do
         spec = Gem::Specification.new
-        runtime = described_class.new
-        runtime.rubygems.should_receive(:mark_loaded).with(spec)
+        expect(runtime.rubygems).to receive(:mark_loaded).with(spec)
         runtime.add_spec(spec)
       end
 
       it "adds spec load paths not already on LOAD_PATH to it" do
         $LOAD_PATH.clear
         spec = Gem::Specification.new :load_paths => ['foo']
-        runtime = described_class.new
         runtime.add_spec(spec)
-        $LOAD_PATH.should include(*spec.load_paths)
+        expect($LOAD_PATH).to eq(spec.load_paths)
       end
 
       it "skips paths already on the $LOAD_PATH" do
         spec = Gem::Specification.new :load_paths => ['foo']
         $LOAD_PATH.clear
         $LOAD_PATH << spec.load_paths.first
-        runtime = described_class.new
         runtime.add_spec(spec)
-        $LOAD_PATH.size.should == 1
+        expect($LOAD_PATH.size).to eq(1)
       end
     end
   end # describe Runtime

data/spec/bundler_ext/system_spec.rb

@@ -12,64 +12,64 @@ module BundlerExt
       it "sets pkg_prefix from BEXT_PKG_PREFIX env variable" do
         ENV['BEXT_PKG_PREFIX'] = 'rubygem-'
         described_class.parse_env
-        described_class.pkg_prefix.should == 'rubygem-'
+        expect(described_class.pkg_prefix).to eq('rubygem-')
       end
 
       it "defaults to blank pkg_prefix" do
         described_class.parse_env
-        described_class.pkg_prefix.should == ''
+        expect(described_class.pkg_prefix).to eq('')
       end
 
       it "sets activate_versions from BEXT_ACTIVATE_VERSIONS env variable" do
         ENV['BEXT_ACTIVATE_VERSIONS'] = 'true'
         described_class.parse_env
-        described_class.activate_versions.should == 'true'
+        expect(described_class.activate_versions).to eq('true')
       end
     end
 
     describe "#activate?" do
       context "activate_versions is false" do
         it "returns false" do
-          described_class.activate?.should be_false
+          expect(described_class.activate?).to be_nil
         end
       end
 
       context "not an rpm system" do
         it "returns false" do
           ENV['BEXT_ACTIVATE_VERSIONS'] = 'true'
-          described_class.should_receive(:is_rpm_system?).and_return(false)
-          described_class.activate?.should be_false
+          expect(described_class).to receive(:is_rpm_system?).and_return(false)
+          expect(described_class.activate?).to be false
         end
       end
 
       it "returns true" do
         ENV['BEXT_ACTIVATE_VERSIONS'] = 'true'
-        described_class.should_receive(:is_rpm_system?).and_return(true)
-        described_class.activate?.should be_true
+        expect(described_class).to receive(:is_rpm_system?).and_return(true)
+        expect(described_class.activate?).to be true
       end
     end
 
     describe "#system_name_for" do
       it "returns package name with package prefix" do
         ENV['BEXT_PKG_PREFIX'] = 'rubygem-'
-        described_class.system_name_for('rails').should == 'rubygem-rails'
+        expect(described_class.system_name_for('rails')).to eq('rubygem-rails')
       end
     end
 
     describe "#is_rpm_system?" do
       context "/usr/bin/rpm is not an executable file" do
         it "returns false" do
-          File.should_receive(:executable?).
+          expect(File).to receive(:executable?).
                with(described_class.rpm_cmd).and_return(false)
-          described_class.is_rpm_system?.should be_false
+          expect(described_class.is_rpm_system?).to be false
         end
       end
 
       context "/usr/bin/rpm is an executable file" do
         it "returns true" do
-          File.should_receive(:executable?).
+          expect(File).to receive(:executable?).
                with(described_class.rpm_cmd).and_return(true)
-          described_class.is_rpm_system?.should be_true
+          expect(described_class.is_rpm_system?).to be true
         end
       end
     end
@@ -83,55 +83,51 @@ module BundlerExt
 
       it "gets/sets rpm command" do
         described_class.rpm_cmd '/bin/rpm'
-        described_class.rpm_cmd.should == '/bin/rpm'
+        expect(described_class.rpm_cmd).to eq('/bin/rpm')
       end
 
       it "defaults to /usr/bin/rpm" do
-        described_class.rpm_cmd.should == '/usr/bin/rpm'
+        expect(described_class.rpm_cmd).to eq('/usr/bin/rpm')
       end
     end
 
     describe "#system_version_for" do
       context "rpm system" do
         it "uses rpm_cmd to retrieve version" do
-          described_class.should_receive(:is_rpm_system?).and_return(true)
-          described_class.should_receive(:`).
+          expect(described_class).to receive(:is_rpm_system?).and_return(true)
+          expect(described_class).to receive(:`).
             with("#{described_class.rpm_cmd} -qi rails").
             and_return("Name: rails\nVersion : 1.0.0 \nAnything")
-          described_class.system_version_for('rails').should == '1.0.0'
+          expect(described_class.system_version_for('rails')).to eq('1.0.0')
         end
       end
 
       it "returns nil" do
-        described_class.should_receive(:is_rpm_system?).and_return(false)
-        described_class.system_version_for('rails').should be_nil
+        expect(described_class).to receive(:is_rpm_system?).and_return(false)
+        expect(described_class.system_version_for('rails')).to be_nil
       end
     end
 
     describe "#activate!" do
       it "activates system version of gem" do
-        described_class.should_receive(:system_name_for).
+        expect(described_class).to receive(:system_name_for).
           with('rails').and_return('rubygem-rake')
-        described_class.should_receive(:system_version_for).
+        expect(described_class).to receive(:system_version_for).
           with('rubygem-rake').and_return('1.2.3')
-        described_class.should_receive(:gem).
+        expect(described_class).to receive(:gem).
           with('rails', '=1.2.3')
         described_class.activate!('rails')
       end
 
       it "gracefully handles load errors" do
-        described_class.should_receive(:gem).and_raise(LoadError)
-        lambda{
-          described_class.activate!('rails')
-        }.should_not raise_error
+        expect(described_class).to receive(:gem).and_raise(LoadError)
+        expect { described_class.activate!('rails') }.not_to raise_error
       end
 
       it "gracefully handles bad requirement errors" do
-        described_class.should_receive(:gem).
+        expect(described_class).to receive(:gem).
           and_raise(Gem::Requirement::BadRequirementError)
-        lambda{
-          described_class.activate!('rails')
-        }.should_not raise_error
+        expect { described_class.activate!('rails') }.not_to raise_error
       end
     end
   end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: bundler_ext
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Jason Guiditta
 - Mo Morsi
 - Lukas Zapletal
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-25 00:00:00.000000000 Z
+date: 2022-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,18 +28,38 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '12'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '12'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14'
 description: Simple library leveraging the Bundler Gemfile DSL to load gems already
   on the system and managed by the systems package manager (like yum/apt)
 email:
@@ -57,7 +77,6 @@ files:
 - lib/bundler_ext/gemfile.rb
 - lib/bundler_ext/output.rb
 - lib/bundler_ext/runtime.rb
-- lib/bundler_ext/setup.rb
 - lib/bundler_ext/system.rb
 - lib/bundler_ext/version.rb
 - spec/bundler_ext/bundler_ext_spec.rb
@@ -71,7 +90,7 @@ homepage: https://github.com/bundlerext/bundler_ext
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -88,17 +107,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Install the linux_admin gem and set BEXT_ACTIVATE_VERSIONS to true to activate rpm/deb
   installed gems
-rubyforge_project: 
-rubygems_version: 2.4.8
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Load system gems via Bundler DSL
 test_files:
+- spec/bundler_ext/bundler_ext_spec.rb
 - spec/bundler_ext/gemfile_spec.rb
-- spec/bundler_ext/system_spec.rb
-- spec/bundler_ext/runtime_spec.rb
 - spec/bundler_ext/integration_spec.rb
-- spec/bundler_ext/bundler_ext_spec.rb
+- spec/bundler_ext/runtime_spec.rb
+- spec/bundler_ext/system_spec.rb
 - spec/fixtures/Gemfile.in
 - spec/spec_helper.rb
 - ".rspec"

data/lib/bundler_ext/setup.rb

@@ -1,2 +0,0 @@
-gemfile = ENV['BEXT_GEMFILE'] || 'Gemfile.in'
-BundlerExt.system_setup gemfile, :all