bundler 1.6.0.pre.1 → 1.6.0.pre.2

data/lib/bundler/vendor/thor/base.rb

@@ -110,7 +110,7 @@ class Thor
       end
 
       # Whenever a class inherits from Thor or Thor::Group, we should track the
-      # class and the file on Thor::Base. This is the method responsable for it.
+      # class and the file on Thor::Base. This is the method responsible for it.
       #
       def register_klass_file(klass) #:nodoc:
         file = caller[1].match(/(.*):\d+/)[1]

data/lib/bundler/version.rb

@@ -2,5 +2,5 @@ module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.6.0.pre.1" unless defined?(::Bundler::VERSION)
+  VERSION = "1.6.0.pre.2" unless defined?(::Bundler::VERSION)
 end

data/spec/bundler/bundler_spec.rb

@@ -4,71 +4,70 @@ require 'bundler'
 
 describe Bundler do
   describe "#load_gemspec_uncached" do
+    let(:app_gemspec_path) { tmp("test.gemspec") }
+    subject { Bundler.load_gemspec_uncached(app_gemspec_path) }
 
-    before do
-      @gemspec = tmp("test.gemspec")
-      @gemspec.open('wb') do |f|
-        f.write strip_whitespace(<<-GEMSPEC)
-          ---
-            {:!00 ao=gu\g1= 7~f
-        GEMSPEC
+    context "with incorrect YAML file" do
+      before do
+        File.open(app_gemspec_path, "wb") do |f|
+          f.write strip_whitespace(<<-GEMSPEC)
+            ---
+              {:!00 ao=gu\g1= 7~f
+          GEMSPEC
+        end
       end
-    end
 
-    describe "on Ruby 1.8", :ruby => "1.8" do
-      it "should catch YAML syntax errors" do
-        expect { Bundler.load_gemspec_uncached(@gemspec) }.
-          to raise_error(Bundler::GemspecError)
+      context "on Ruby 1.8", :ruby => "1.8" do
+        it "catches YAML syntax errors" do
+          expect { subject }.to raise_error(Bundler::GemspecError)
+        end
       end
-    end
 
-    context "on Ruby 1.9", :ruby => "1.9" do
-      context "with Syck as YAML::Engine" do
-        it "raises a GemspecError after YAML load throws ArgumentError" do
-          orig_yamler, YAML::ENGINE.yamler = YAML::ENGINE.yamler, 'syck'
+      context "on Ruby 1.9", :ruby => "1.9" do
+        context "with Syck as YAML::Engine" do
+          it "raises a GemspecError after YAML load throws ArgumentError" do
+            orig_yamler, YAML::ENGINE.yamler = YAML::ENGINE.yamler, 'syck'
 
-          expect { Bundler.load_gemspec_uncached(@gemspec) }.
-            to raise_error(Bundler::GemspecError)
+            expect { subject }.to raise_error(Bundler::GemspecError)
 
-          YAML::ENGINE.yamler = orig_yamler
+            YAML::ENGINE.yamler = orig_yamler
+          end
         end
-      end
 
-      context "with Psych as YAML::Engine" do
-        it "raises a GemspecError after YAML load throws Psych::SyntaxError" do
-          orig_yamler, YAML::ENGINE.yamler = YAML::ENGINE.yamler, 'psych'
+        context "with Psych as YAML::Engine" do
+          it "raises a GemspecError after YAML load throws Psych::SyntaxError" do
+            orig_yamler, YAML::ENGINE.yamler = YAML::ENGINE.yamler, 'psych'
 
-          expect { Bundler.load_gemspec_uncached(@gemspec) }.
-            to raise_error(Bundler::GemspecError)
+            expect { subject }.to raise_error(Bundler::GemspecError)
 
-          YAML::ENGINE.yamler = orig_yamler
+            YAML::ENGINE.yamler = orig_yamler
+          end
         end
       end
     end
 
-    it "can load a gemspec with unicode characters with default ruby encoding" do
-      # spec_helper forces the external encoding to UTF-8 but that's not the
-      # ruby default.
-      encoding = nil
-
-      if defined?(Encoding)
-        encoding = Encoding.default_external
-        Encoding.default_external = "ASCII"
-      end
+    context "with correct YAML file" do
+      it "can load a gemspec with unicode characters with default ruby encoding" do
+        # spec_helper forces the external encoding to UTF-8 but that's not the
+        # ruby default.
+        if defined?(Encoding)
+          encoding = Encoding.default_external
+          Encoding.default_external = "ASCII"
+        end
 
-      File.open(tmp("test.gemspec"), "wb") do |file|
-        file.puts <<-G.gsub(/^\s+/, '')
-          # -*- encoding: utf-8 -*-
-          Gem::Specification.new do |gem|
-            gem.author = "André the Giant"
-          end
-        G
-      end
+        File.open(app_gemspec_path, "wb") do |file|
+          file.puts <<-GEMSPEC.gsub(/^\s+/, '')
+            # -*- encoding: utf-8 -*-
+            Gem::Specification.new do |gem|
+              gem.author = "André the Giant"
+            end
+          GEMSPEC
+        end
 
-      gemspec = Bundler.load_gemspec_uncached(tmp("test.gemspec"))
-      expect(gemspec.author).to eq("André the Giant")
+        expect(subject.author).to eq("André the Giant")
 
-      Encoding.default_external = encoding if defined?(Encoding)
+        Encoding.default_external = encoding if defined?(Encoding)
+      end
     end
 
   end

data/spec/bundler/{cli_rspec.rb → cli_spec.rb}

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 describe "bundle executable" do
   it "returns non-zero exit status when passed unrecognized options" do
     bundle '--invalid_argument', :exitstatus => true

data/spec/bundler/definition_spec.rb

@@ -3,23 +3,19 @@ require 'bundler/definition'
 
 describe Bundler::Definition do
   before do
-    Bundler.stub(:settings){ Bundler::Settings.new(".") }
+    allow(Bundler).to receive(:settings){ Bundler::Settings.new(".") }
   end
 
   describe "#lock" do
     context "when it's not possible to write to the file" do
       subject{ Bundler::Definition.new(nil, [], [], []) }
 
-      before do
-        File.should_receive(:open).with("Gemfile.lock", "wb").
-          and_raise(Errno::EACCES)
-      end
-
       it "raises an InstallError with explanation" do
+        expect(File).to receive(:open).with("Gemfile.lock", "wb").
+          and_raise(Errno::EACCES)
         expect{ subject.lock("Gemfile.lock") }.
           to raise_error(Bundler::InstallError)
       end
     end
   end
-
 end

data/spec/bundler/dsl_spec.rb

@@ -3,38 +3,60 @@ require 'spec_helper'
 describe Bundler::Dsl do
   before do
     @rubygems = double("rubygems")
-    Bundler::Source::Rubygems.stub(:new){ @rubygems }
+    allow(Bundler::Source::Rubygems).to receive(:new){ @rubygems }
   end
 
-  describe "#_normalize_options" do
-    it "converts :github to :git" do
-      subject.gem("sparks", :github => "indirect/sparks")
-      github_uri = "git://github.com/indirect/sparks.git"
-      expect(subject.dependencies.first.source.uri).to eq(github_uri)
+  describe "#register_host" do
+    it "registers custom hosts" do
+      subject.git_source(:example){ |repo_name| "git@git.example.com:#{repo_name}.git" }
+      subject.git_source(:foobar){ |repo_name| "git@foobar.com:#{repo_name}.git" }
+      subject.gem("dobry-pies", :example => "strzalek/dobry-pies")
+      example_uri = "git@git.example.com:strzalek/dobry-pies.git"
+      expect(subject.dependencies.first.source.uri).to eq(example_uri)
     end
 
-    it "converts numeric :gist to :git" do
-      subject.gem("not-really-a-gem", :gist => 2859988)
-      github_uri = "https://gist.github.com/2859988.git"
-      expect(subject.dependencies.first.source.uri).to eq(github_uri)
+    it "raises expection on invalid hostname" do
+      expect {
+        subject.git_source(:group){ |repo_name| "git@git.example.com:#{repo_name}.git" }
+      }.to raise_error(Bundler::InvalidOption)
     end
 
-    it "converts :gist to :git" do
-      subject.gem("not-really-a-gem", :gist => "2859988")
-      github_uri = "https://gist.github.com/2859988.git"
-      expect(subject.dependencies.first.source.uri).to eq(github_uri)
+    it "expects block passed" do
+      expect{ subject.git_source(:example) }.to raise_error(Bundler::InvalidOption)
     end
 
-    it "converts 'rails' to 'rails/rails'" do
-      subject.gem("rails", :github => "rails")
-      github_uri = "git://github.com/rails/rails.git"
-      expect(subject.dependencies.first.source.uri).to eq(github_uri)
+    context "default hosts (git, gist)" do
+      it "converts :github to :git" do
+        subject.gem("sparks", :github => "indirect/sparks")
+        github_uri = "git://github.com/indirect/sparks.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
+      end
+
+      it "converts numeric :gist to :git" do
+        subject.gem("not-really-a-gem", :gist => 2859988)
+        github_uri = "https://gist.github.com/2859988.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
+      end
+
+      it "converts :gist to :git" do
+        subject.gem("not-really-a-gem", :gist => "2859988")
+        github_uri = "https://gist.github.com/2859988.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
+      end
+
+      it "converts 'rails' to 'rails/rails'" do
+        subject.gem("rails", :github => "rails")
+        github_uri = "git://github.com/rails/rails.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
+      end
     end
   end
 
   describe "#method_missing" do
     it "raises an error for unknown DSL methods" do
-      Bundler.should_receive(:read_file).with("Gemfile").and_return("unknown")
+      expect(Bundler).to receive(:read_file).with("Gemfile").
+        and_return("unknown")
+
       error_msg = "Undefined local variable or method `unknown'" \
         " for Gemfile\\s+from Gemfile:1"
       expect { subject.eval_gemfile("Gemfile") }.
@@ -44,7 +66,7 @@ describe Bundler::Dsl do
 
   describe "#eval_gemfile" do
     it "handles syntax errors with a useful message" do
-      Bundler.should_receive(:read_file).with("Gemfile").and_return("}")
+      expect(Bundler).to receive(:read_file).with("Gemfile").and_return("}")
       expect { subject.eval_gemfile("Gemfile") }.
         to raise_error(Bundler::GemfileError, /Gemfile syntax error/)
     end
@@ -54,7 +76,7 @@ describe Bundler::Dsl do
     it "will raise a Bundler::GemfileError" do
       gemfile "gem 'foo', :path => /unquoted/string/syntax/error"
       expect { Bundler::Dsl.evaluate(bundled_app("Gemfile"), nil, true) }.
-        to raise_error(Bundler::GemfileError)
+        to raise_error(Bundler::GemfileError, /Gemfile syntax error/)
     end
   end
 end

data/spec/bundler/gem_helper_spec.rb

@@ -2,194 +2,223 @@ require "spec_helper"
 require 'rake'
 require 'bundler/gem_helper'
 
-describe "Bundler::GemHelper tasks" do
+describe Bundler::GemHelper do
+  let(:app_name) { "test" }
+  let(:app_path) { bundled_app app_name }
+  let(:app_gemspec_path) { app_path.join("#{app_name}.gemspec") }
+
+  before(:each) do
+    bundle "gem #{app_name}"
+  end
+
   context "determining gemspec" do
-    it "interpolates the name when there is only one gemspec" do
-      bundle 'gem test'
-      app = bundled_app("test")
-      helper = Bundler::GemHelper.new(app.to_s)
-      expect(helper.gemspec.name).to eq('test')
-    end
+    subject { Bundler::GemHelper.new(app_path) }
 
-    it "interpolates the name for a hidden gemspec" do
-      bundle 'gem test'
-      app = bundled_app("test")
-      FileUtils.mv app.join('test.gemspec'), app.join('.gemspec')
-      helper = Bundler::GemHelper.new(app.to_s)
-      expect(helper.gemspec.name).to eq('test')
-    end
+    context "fails" do
+      it "when there is no gemspec" do
+        FileUtils.rm app_gemspec_path
+        expect { subject }.to raise_error(/Unable to determine name/)
+      end
 
-    it "should fail when there is no gemspec" do
-      bundle 'gem test'
-      app = bundled_app("test")
-      FileUtils.rm(File.join(app.to_s, 'test.gemspec'))
-      expect { Bundler::GemHelper.new(app.to_s) }.to raise_error(/Unable to determine name/)
+      it "when there are two gemspecs and the name isn't specified" do
+        FileUtils.touch app_path.join("#{app_name}-2.gemspec")
+        expect { subject }.to raise_error(/Unable to determine name/)
+      end
     end
 
-    it "should fail when there are two gemspecs and the name isn't specified" do
-      bundle 'gem test'
-      app = bundled_app("test")
-      File.open(File.join(app.to_s, 'test2.gemspec'), 'w') {|f| f << ''}
-      expect { Bundler::GemHelper.new(app.to_s) }.to raise_error(/Unable to determine name/)
+    context "interpolates the name" do
+      it "when there is only one gemspec" do
+        expect(subject.gemspec.name).to eq(app_name)
+      end
+
+      it "for a hidden gemspec" do
+        FileUtils.mv app_gemspec_path, app_path.join(".gemspec")
+        expect(subject.gemspec.name).to eq(app_name)
+      end
     end
 
-    it "handles namespaces and converting to CamelCase" do
-      bundle 'gem test-foo_bar'
-      lib = bundled_app('test-foo_bar').join('lib/test/foo_bar.rb').read
-      expect(lib).to include("module Test")
+    it "handles namespaces and converts them to CamelCase" do
+      bundle "gem #{app_name}-foo_bar"
+      app_path = bundled_app "#{app_name}-foo_bar"
+
+      lib = app_path.join("lib/#{app_name}/foo_bar.rb").read
+      expect(lib).to include("module #{app_name.capitalize}")
       expect(lib).to include("module FooBar")
     end
   end
 
   context "gem management" do
     def mock_confirm_message(message)
-      Bundler.ui.should_receive(:confirm).with(message)
+      expect(Bundler.ui).to receive(:confirm).with(message)
     end
 
-    def mock_build_message
-      mock_confirm_message "test 0.0.1 built to pkg/test-0.0.1.gem."
+    def mock_build_message(name, version)
+      message = "#{name} #{version} built to pkg/#{name}-#{version}.gem."
+      mock_confirm_message message
     end
 
+    subject! { Bundler::GemHelper.new(app_path) }
+    let(:app_version) { "0.0.1" }
+    let(:app_gem_dir) { app_path.join("pkg") }
+    let(:app_gem_path) { app_gem_dir.join("#{app_name}-#{app_version}.gem") }
+    let(:app_gemspec_content) { File.read(app_gemspec_path) }
+
     before(:each) do
-      bundle 'gem test'
-      @app = bundled_app("test")
-      @gemspec = File.read("#{@app.to_s}/test.gemspec")
-      File.open("#{@app.to_s}/test.gemspec", 'w'){|f| f << @gemspec.gsub('TODO: ', '') }
-      @helper = Bundler::GemHelper.new(@app.to_s)
+      content = app_gemspec_content.gsub("TODO: ", "")
+      File.open(app_gemspec_path, "w") { |file| file << content }
     end
 
     it "uses a shell UI for output" do
       expect(Bundler.ui).to be_a(Bundler::UI::Shell)
     end
 
-    describe "install_tasks" do
+    describe "#install" do
+      let!(:rake_application) { Rake.application }
+
       before(:each) do
-        @saved, Rake.application = Rake.application, Rake::Application.new
+        Rake.application = Rake::Application.new
       end
 
       after(:each) do
-        Rake.application = @saved
+        Rake.application = rake_application
       end
 
-      it "defines Rake tasks" do
-        names = %w[build install release]
-
-        names.each { |name|
-          expect { Rake.application[name] }.to raise_error(/Don't know how to build task/)
-        }
+      context "defines Rake tasks" do
+        let(:task_names) { %w[build install release] }
 
-        @helper.install
-
-        names.each { |name|
-          expect { Rake.application[name] }.not_to raise_error
-          expect(Rake.application[name]).to be_instance_of Rake::Task
-        }
-      end
+        context "before installation" do
+          it "raises an error with appropriate message" do
+            task_names.each do |name|
+              expect { Rake.application[name] }.
+                to raise_error("Don't know how to build task '#{name}'")
+            end
+          end
+        end
 
-      it "provides a way to access the gemspec object" do
-        @helper.install
-        expect(Bundler::GemHelper.gemspec.name).to eq('test')
+        context "after installation" do
+          before do
+            subject.install
+          end
+
+          it "adds Rake tasks successfully" do
+            task_names.each do |name|
+              expect { Rake.application[name] }.not_to raise_error
+              expect(Rake.application[name]).to be_instance_of Rake::Task
+            end
+          end
+
+          it "provides a way to access the gemspec object" do
+            expect(subject.gemspec.name).to eq(app_name)
+          end
+        end
       end
     end
 
-    describe "build" do
-      it "builds" do
-        mock_build_message
-        @helper.build_gem
-        expect(bundled_app('test/pkg/test-0.0.1.gem')).to exist
+    describe "#build_gem" do
+      context "when build failed" do
+        it "raises an error with appropriate message" do
+          # break the gemspec by adding back the TODOs
+          File.open(app_gemspec_path, "w"){ |file| file << app_gemspec_content }
+          expect { subject.build_gem }.to raise_error(/TODO/)
+        end
       end
 
-      it "raises an appropriate error when the build fails" do
-        # break the gemspec by adding back the TODOs...
-        File.open("#{@app.to_s}/test.gemspec", 'w'){|f| f << @gemspec }
-        expect { @helper.build_gem }.to raise_error(/TODO/)
+      context "when build was successful" do
+        it "creates .gem file" do
+          mock_build_message app_name, app_version
+          subject.build_gem
+          expect(app_gem_path).to exist
+        end
       end
     end
 
-    describe "install" do
-      it "installs" do
-        mock_build_message
-        mock_confirm_message "test (0.0.1) installed."
-        @helper.install_gem
-        expect(bundled_app('test/pkg/test-0.0.1.gem')).to exist
-        expect(%x{gem list}).to include("test (0.0.1)")
+    describe "#install_gem" do
+      context "when installation was successful" do
+        it "gem is installed" do
+          mock_build_message app_name, app_version
+          mock_confirm_message "#{app_name} (#{app_version}) installed."
+          subject.install_gem
+          expect(app_gem_path).to exist
+          expect(`gem list`).to include("#{app_name} (#{app_version})")
+        end
       end
 
-      it "raises an appropriate error when the install fails" do
-        @helper.should_receive(:build_gem) do
-          # write an invalid gem file, so we can simulate install failure...
-          FileUtils.mkdir_p(File.join(@app.to_s, 'pkg'))
-          path = "#{@app.to_s}/pkg/test-0.0.1.gem"
-          File.open(path, 'w'){|f| f << "not actually a gem"}
-          path
+      context "when installation fails" do
+        it "raises an error with appropriate message" do
+          # create empty gem file in order to simulate install failure
+          allow(subject).to receive(:build_gem) do
+            FileUtils.mkdir_p(app_gem_dir)
+            FileUtils.touch app_gem_path
+            app_gem_path
+          end
+          expect { subject.install_gem }.to raise_error(/Couldn't install gem/)
         end
-        expect { @helper.install_gem }.to raise_error
       end
     end
 
-    describe "release" do
+    describe "#release_gem" do
       before do
-        Dir.chdir(@app) do
+        Dir.chdir(app_path) do
           `git init`
           `git config user.email "you@example.com"`
           `git config user.name "name"`
         end
       end
 
-      it "shouldn't push if there are unstaged files" do
-        expect { @helper.release_gem }.to raise_error(/files that need to be committed/)
-      end
-
-      it "shouldn't push if there are uncommitted files" do
-        %x{cd test; git add .}
-        expect { @helper.release_gem }.to raise_error(/files that need to be committed/)
-      end
+      context "fails" do
+        it "when there are unstaged files" do
+          expect { subject.release_gem }.
+            to raise_error("There are files that need to be committed first.")
+        end
 
-      it "raises an appropriate error if there is no git remote" do
-        Bundler.ui.stub(:confirm => nil, :error => nil) # silence messages
+        it "when there are uncommitted files" do
+          Dir.chdir(app_path) { `git add .` }
+          expect { subject.release_gem }.
+            to raise_error("There are files that need to be committed first.")
+        end
 
-        Dir.chdir(gem_repo1) { `git init --bare` }
-        Dir.chdir(@app) { `git commit -a -m "initial commit"` }
+        it "when there is no git remote" do
+          # silence messages
+          allow(Bundler.ui).to receive(:confirm)
+          allow(Bundler.ui).to receive(:error)
 
-        expect { @helper.release_gem }.to raise_error
+          Dir.chdir(app_path) { `git commit -a -m "initial commit"` }
+          expect { subject.release_gem }.to raise_error
+        end
       end
 
-      it "releases" do
-        mock_build_message
-        mock_confirm_message(/Tagged v0.0.1/)
-        mock_confirm_message("Pushed git commits and tags.")
+      context "succeeds" do
+        before do
+          Dir.chdir(gem_repo1) { `git init --bare` }
+          Dir.chdir(app_path) do
+            `git remote add origin file://#{gem_repo1}`
+            `git commit -a -m "initial commit"`
+          end
+        end
+
+        it "on releasing" do
+          mock_build_message app_name, app_version
+          mock_confirm_message "Tagged v#{app_version}."
+          mock_confirm_message "Pushed git commits and tags."
+          expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)
 
-        @helper.should_receive(:rubygem_push).with(bundled_app('test/pkg/test-0.0.1.gem').to_s)
+          Dir.chdir(app_path) { sys_exec("git push origin master", true) }
 
-        Dir.chdir(gem_repo1) { `git init --bare` }
-        Dir.chdir(@app) do
-          `git remote add origin file://#{gem_repo1}`
-          `git commit -a -m "initial commit"`
-          sys_exec("git push origin master", true)
-          `git commit -a -m "another commit"`
+          subject.release_gem
         end
-        @helper.release_gem
-      end
 
-      it "releases even if tag already exists" do
-        mock_build_message
-        mock_confirm_message("Tag v0.0.1 has already been created.")
+        it "even if tag already exists" do
+          mock_build_message app_name, app_version
+          mock_confirm_message "Tag v#{app_version} has already been created."
+          expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)
 
-        @helper.should_receive(:rubygem_push).with(bundled_app('test/pkg/test-0.0.1.gem').to_s)
+          Dir.chdir(app_path) do
+            `git tag -a -m \"Version #{app_version}\" v#{app_version}`
+          end
 
-        Dir.chdir(gem_repo1) {
-          `git init --bare`
-        }
-        Dir.chdir(@app) {
-          `git init`
-          `git config user.email "you@example.com"`
-          `git config user.name "name"`
-          `git commit -a -m "another commit"`
-          `git tag -a -m \"Version 0.0.1\" v0.0.1`
-        }
-        @helper.release_gem
+          subject.release_gem
+        end
       end
-
     end
   end
 end