bundler-prehistoric 1.6.2

data/man/index.txt

@@ -0,0 +1,7 @@
+Gemfile(5)         gemfile.5
+bundle-install     bundle-install.1
+bundle-update      bundle-update.1
+bundle-package     bundle-package.1
+bundle-exec        bundle-exec.1
+bundle-config      bundle-config.1
+bundle-platform    bundle-platform.1

data/spec/bundler/bundler_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require 'spec_helper'
+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) }
+
+    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
+
+      context "on Ruby 1.8", :ruby => "1.8" do
+        it "catches YAML syntax errors" do
+          expect { subject }.to raise_error(Bundler::GemspecError)
+        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'
+
+            expect { subject }.to raise_error(Bundler::GemspecError)
+
+            YAML::ENGINE.yamler = orig_yamler
+          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'
+
+            expect { subject }.to raise_error(Bundler::GemspecError)
+
+            YAML::ENGINE.yamler = orig_yamler
+          end
+        end
+      end
+    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(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
+
+        expect(subject.author).to eq("André the Giant")
+
+        Encoding.default_external = encoding if defined?(Encoding)
+      end
+    end
+
+  end
+end

data/spec/bundler/cli_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'bundler/cli'
+
+describe "bundle executable" do
+  let(:source_uri) { "http://localgemserver.test" }
+
+  it "returns non-zero exit status when passed unrecognized options" do
+    bundle '--invalid_argument', :exitstatus => true
+    expect(exitstatus).to_not be_zero
+  end
+
+  it "returns non-zero exit status when passed unrecognized task" do
+    bundle 'unrecognized-tast', :exitstatus => true
+    expect(exitstatus).to_not be_zero
+  end
+end

data/spec/bundler/definition_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'bundler/definition'
+
+describe Bundler::Definition do
+  before do
+    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, [], [], []) }
+
+      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

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Bundler::Dsl do
+  before do
+    @rubygems = double("rubygems")
+    allow(Bundler::Source::Rubygems).to receive(:new){ @rubygems }
+  end
+
+  describe "#git_source" 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 "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 "expects block passed" do
+      expect{ subject.git_source(:example) }.to raise_error(Bundler::InvalidOption)
+    end
+
+    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
+
+      it "converts :bitbucket to :git" do
+        subject.gem("not-really-a-gem", :bitbucket => "mcorp/flatlab-rails")
+        bitbucket_uri = "https://mcorp@bitbucket.org/mcorp/flatlab-rails.git"
+        expect(subject.dependencies.first.source.uri).to eq(bitbucket_uri)
+      end
+
+      it "converts 'mcorp' to 'mcorp/mcorp'" do
+        subject.gem("not-really-a-gem", :bitbucket => "mcorp")
+        bitbucket_uri = "https://mcorp@bitbucket.org/mcorp/mcorp.git"
+        expect(subject.dependencies.first.source.uri).to eq(bitbucket_uri)
+      end
+    end
+  end
+
+  describe "#method_missing" do
+    it "raises an error for unknown DSL methods" do
+      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") }.
+        to raise_error(Bundler::GemfileError, Regexp.new(error_msg))
+    end
+  end
+
+  describe "#eval_gemfile" do
+    it "handles syntax errors with a useful message" do
+      expect(Bundler).to receive(:read_file).with("Gemfile").and_return("}")
+      expect { subject.eval_gemfile("Gemfile") }.
+        to raise_error(Bundler::GemfileError, /Gemfile syntax error/)
+    end
+  end
+
+  describe "#gem" do
+    [:ruby, :ruby_18, :ruby_19, :ruby_20, :ruby_21, :mri, :mri_18, :mri_19,
+     :mri_20, :mri_21, :jruby, :rbx].each do |platform|
+      it "allows #{platform} as a valid platform" do
+        subject.gem("foo", :platform => platform)
+      end
+    end
+
+    it "rejects invalid platforms" do
+      expect { subject.gem("foo", :platform => :bogus) }.
+        to raise_error(Bundler::GemfileError, /is not a valid platform/)
+    end
+  end
+
+  describe "syntax errors" 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, /Gemfile syntax error/)
+    end
+  end
+end

data/spec/bundler/friendly_errors_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+require "bundler"
+require "bundler/friendly_errors"
+
+describe Bundler, "friendly errors" do
+  it "rescues Thor::AmbiguousTaskError and raises SystemExit" do
+    expect {
+      Bundler.with_friendly_errors do
+        raise Thor::AmbiguousTaskError.new("")
+      end
+    }.to raise_error(SystemExit)
+  end
+end

data/spec/bundler/gem_helper_spec.rb

@@ -0,0 +1,225 @@
+require "spec_helper"
+require 'rake'
+require 'bundler/gem_helper'
+
+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
+    subject { Bundler::GemHelper.new(app_path) }
+
+    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 "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
+
+    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 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)
+      expect(Bundler.ui).to receive(:confirm).with(message)
+    end
+
+    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
+      content = app_gemspec_content.gsub("TODO: ", "")
+      content.sub!(/homepage\s+= ".*"/, 'homepage = ""')
+      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" do
+      let!(:rake_application) { Rake.application }
+
+      before(:each) do
+        Rake.application = Rake::Application.new
+      end
+
+      after(:each) do
+        Rake.application = rake_application
+      end
+
+      context "defines Rake tasks" do
+        let(:task_names) { %w[build install release] }
+
+        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
+
+        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_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
+
+      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_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
+
+      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
+      end
+    end
+
+    describe "#release_gem" do
+      before do
+        Dir.chdir(app_path) do
+          `git init`
+          `git config user.email "you@example.com"`
+          `git config user.name "name"`
+        end
+      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 "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
+
+        it "when there is no git remote" do
+          # silence messages
+          allow(Bundler.ui).to receive(:confirm)
+          allow(Bundler.ui).to receive(:error)
+
+          Dir.chdir(app_path) { `git commit -a -m "initial commit"` }
+          expect { subject.release_gem }.to raise_error
+        end
+      end
+
+      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)
+
+          Dir.chdir(app_path) { sys_exec("git push origin master", true) }
+
+          subject.release_gem
+        end
+
+        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)
+
+          Dir.chdir(app_path) do
+            `git tag -a -m \"Version #{app_version}\" v#{app_version}`
+          end
+
+          subject.release_gem
+        end
+      end
+    end
+  end
+end