bundler 1.7.15 → 1.8.0.pre

data/lib/bundler/parallel_workers.rb

@@ -1,18 +0,0 @@
-require 'thread'
-
-require "bundler/parallel_workers/worker"
-
-module Bundler
-  module ParallelWorkers
-    autoload :UnixWorker, "bundler/parallel_workers/unix_worker"
-    autoload :ThreadWorker, "bundler/parallel_workers/thread_worker"
-
-    def self.worker_pool(size, job)
-      if Bundler.current_ruby.mswin? || Bundler.current_ruby.jruby? || Bundler.current_ruby.rbx?
-        ThreadWorker.new(size, job)
-      else
-        UnixWorker.new(size, job)
-      end
-    end
-  end
-end

data/lib/bundler/parallel_workers/thread_worker.rb

@@ -1,30 +0,0 @@
-module Bundler
-  module ParallelWorkers
-    class ThreadWorker < Worker
-
-      private
-
-      # On platforms where fork is not available
-      # use Threads for parallely downloading gems
-      #
-      # @param size [Integer] Size of thread worker pool
-      # @param func [Proc] Job to be run inside thread worker pool
-      def prepare_workers(size, func)
-        @threads = size.times.map do |i|
-          Thread.start do
-            loop do
-              obj = @request_queue.deq
-              break if obj.equal? POISON
-              begin
-                @response_queue.enq func.call(obj, i)
-              rescue Exception => e
-                @response_queue.enq(WrappedException.new(e))
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/bundler/parallel_workers/unix_worker.rb

@@ -1,101 +0,0 @@
-module Bundler
-  module ParallelWorkers
-    # UnixWorker is used only on platforms where fork is available. The way
-    # this code works is, it forks a preconfigured number of workers and then
-    # It starts preconfigured number of threads that write to the connected pipe.
-    class UnixWorker < Worker
-
-      class JobHandler < Struct.new(:pid, :io_r, :io_w)
-        def work(obj)
-          Marshal.dump obj, io_w
-          Marshal.load io_r
-        rescue IOError, Errno::EPIPE
-          nil
-        end
-      end
-
-      def initialize(size, job)
-        # Close the persistent connections for the main thread before forking
-        Net::HTTP::Persistent.new('bundler', :ENV).shutdown
-        super
-      end
-
-      private
-
-      # Start forked workers for downloading gems. This version of worker
-      # is only used on platforms where fork is available.
-      #
-      # @param size [Integer] Size of worker pool
-      # @param func [Proc] Job that should be executed in the worker
-      def prepare_workers(size, func)
-        @workers = size.times.map do |num|
-          child_read, parent_write = IO.pipe
-          parent_read, child_write = IO.pipe
-
-          pid = Process.fork do
-            begin
-              parent_read.close
-              parent_write.close
-
-              while !child_read.eof?
-                obj = Marshal.load child_read
-                Marshal.dump func.call(obj, num), child_write
-              end
-            rescue Exception => e
-              begin
-                Marshal.dump WrappedException.new(e), child_write
-              rescue Errno::EPIPE
-                nil
-              end
-            ensure
-              child_read.close
-              child_write.close
-            end
-          end
-
-          child_read.close
-          child_write.close
-          JobHandler.new pid, parent_read, parent_write
-        end
-      end
-
-      # Start the threads whose job is basically to wait for incoming messages
-      # on request queue and write that message to the connected pipe. Also retrieve
-      # messages from child worker via connected pipe and write the message to response queue
-      #
-      # @param size [Integer] Number of threads to be started
-      def prepare_threads(size)
-        @threads = size.times.map do |i|
-          Thread.start do
-            worker = @workers[i]
-            loop do
-              obj = @request_queue.deq
-              break if obj.equal? POISON
-              @response_queue.enq worker.work(obj)
-            end
-          end
-        end
-      end
-
-      # Kill the forked workers by sending SIGINT to them
-      def stop_workers
-        @workers.each do |worker|
-          worker.io_r.close unless worker.io_r.closed?
-          worker.io_w.close unless worker.io_w.closed?
-          begin
-            Process.kill :INT, worker.pid
-          rescue Errno::ESRCH
-            nil
-          end
-        end
-        @workers.each do |worker|
-          begin
-            Process.waitpid worker.pid
-          rescue Errno::ECHILD
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bundler/parallel_workers/worker.rb

@@ -1,69 +0,0 @@
-module Bundler
-  module ParallelWorkers
-    class Worker
-      POISON = Object.new
-
-      class WrappedException < StandardError
-        attr_reader :exception
-        def initialize(exn)
-          @exception = exn
-        end
-      end
-
-      # Creates a worker pool of specified size
-      #
-      # @param size [Integer] Size of pool
-      # @param func [Proc] job to run in inside the worker pool
-      def initialize(size, func)
-        @request_queue = Queue.new
-        @response_queue = Queue.new
-        prepare_workers size, func
-        prepare_threads size
-        trap("INT") { @threads.each {|i| i.exit }; stop_workers; exit 1 }
-      end
-
-      # Enqueue a request to be executed in the worker pool
-      #
-      # @param obj [String] mostly it is name of spec that should be downloaded
-      def enq(obj)
-        @request_queue.enq obj
-      end
-
-      # Retrieves results of job function being executed in worker pool
-      def deq
-        result = @response_queue.deq
-        if result.is_a?(WrappedException)
-          raise result.exception
-        end
-        result
-      end
-
-      # Stop the forked workers and started threads
-      def stop
-        stop_threads
-        stop_workers
-      end
-
-      private
-      # Stop the worker threads by sending a poison object down the request queue
-      # so as worker threads after retrieving it, shut themselves down
-      def stop_threads
-        @threads.each do
-          @request_queue.enq POISON
-        end
-        @threads.each do |thread|
-          thread.join
-        end
-      end
-
-      # To be overridden by child classes
-      def prepare_threads(size)
-      end
-
-      # To be overridden by child classes
-      def stop_workers
-      end
-
-    end
-  end
-end

data/lib/bundler/templates/newgem/bin/newgem.tt

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-require '<%= config[:namespaced_path] %>'

data/spec/bundler/anonymizable_uri_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'bundler/anonymizable_uri'
-
-describe Bundler::AnonymizableURI do
-  let(:anonymizable_uri) { Bundler::AnonymizableURI.new(original_uri) }
-
-  describe "#without_credentials" do
-    context "when the original URI has no credentials" do
-      let(:original_uri) { URI('https://rubygems.org') }
-
-      it "returns the original URI" do
-        expect(anonymizable_uri.without_credentials).to eq(original_uri)
-      end
-    end
-
-    context "when the original URI has a username and password" do
-      let(:original_uri) { URI("https://username:password@gems.example.com") }
-
-      it "returns the URI without username and password" do
-        expect(anonymizable_uri.without_credentials).to eq(URI("https://gems.example.com"))
-      end
-    end
-
-    context "when the original URI has only a username" do
-      let(:original_uri) { URI("https://SeCrEt-ToKeN@gem.fury.io/me/") }
-
-      it "returns the URI without username and password" do
-        expect(anonymizable_uri.without_credentials).to eq(URI("https://gem.fury.io/me/"))
-      end
-    end
-  end
-end

data/spec/bundler/bundler_spec.rb

@@ -1,72 +0,0 @@
-# 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
-
-      it "catches YAML syntax errors" do
-        expect { subject }.to raise_error(Bundler::GemspecError)
-      end
-
-      context "on Rubies with a settable YAML engine", :if => defined?(YAML::ENGINE) 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

@@ -1,16 +0,0 @@
-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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'bundler/definition'
-
-describe Bundler::Definition do
-  before do
-    allow(Bundler).to receive(:settings){ Bundler::Settings.new(".") }
-    allow(Bundler).to receive(:default_gemfile){ Pathname.new("Gemfile") }
-  end
-
-  describe "#lock" do
-    context "when it's not possible to write to the file" do
-      subject{ Bundler::Definition.new(nil, [], Bundler::SourceList.new, []) }
-
-      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

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Bundler::Dsl do
-  before do
-    @rubygems = double("rubygems")
-    allow(Bundler::Source::Rubygems).to receive(:new){ @rubygems }
-  end
-
-  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 "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
-    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 "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