bundler-prehistoric 1.6.2

data/lib/bundler/lockfile_parser.rb

@@ -0,0 +1,146 @@
+require "strscan"
+
+# Some versions of the Bundler 1.1 RC series introduced corrupted
+# lockfiles. There were two major problems:
+#
+# * multiple copies of the same GIT section appeared in the lockfile
+# * when this happened, those sections got multiple copies of gems
+#   in those sections.
+#
+# As a result, Bundler 1.1 contains code that fixes the earlier
+# corruption. We will remove this fix-up code in Bundler 1.2.
+
+module Bundler
+  class LockfileParser
+    attr_reader :sources, :dependencies, :specs, :platforms
+
+    DEPENDENCIES = "DEPENDENCIES"
+    PLATFORMS    = "PLATFORMS"
+    GIT          = "GIT"
+    GEM          = "GEM"
+    PATH         = "PATH"
+    SVN          = "SVN"
+    SPECS        = "  specs:"
+    OPTIONS      = /^  ([a-z]+): (.*)$/i
+
+    def initialize(lockfile)
+      @platforms    = []
+      @sources      = []
+      @dependencies = []
+      @state        = :source
+      @specs        = {}
+
+      if lockfile.match(/<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|/)
+        raise LockfileError, "Your Gemfile.lock contains merge conflicts.\n" \
+          "Run `git checkout HEAD -- Gemfile.lock` first to get a clean lock."
+      end
+
+      lockfile.split(/(?:\r?\n)+/).each do |line|
+        if line == DEPENDENCIES
+          @state = :dependency
+        elsif line == PLATFORMS
+          @state = :platform
+        else
+          send("parse_#{@state}", line)
+        end
+      end
+      @specs = @specs.values
+    end
+
+  private
+
+    TYPES = {
+      "GIT"  => Bundler::Source::Git,
+      "GEM"  => Bundler::Source::Rubygems,
+      "PATH" => Bundler::Source::Path,
+      "SVN"  => Bundler::Source::SVN
+    }
+
+    def parse_source(line)
+      case line
+      when GIT, GEM, PATH, SVN
+        @current_source = nil
+        @opts, @type = {}, line
+      when SPECS
+        @current_source = TYPES[@type].from_lock(@opts)
+
+        # Strip out duplicate GIT / SVN sections
+        if @sources.include?(@current_source) && (@current_source.is_a?(Bundler::Source::Git) || @current_source.is_a?(Bundler::Source::SVN))
+          @current_source = @sources.find { |s| s == @current_source }
+        end
+
+        @sources << @current_source
+      when OPTIONS
+        value = $2
+        value = true if value == "true"
+        value = false if value == "false"
+
+        key = $1
+
+        if @opts[key]
+          @opts[key] = Array(@opts[key])
+          @opts[key] << value
+        else
+          @opts[key] = value
+        end
+      else
+        parse_spec(line)
+      end
+    end
+
+    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+    NAME_VERSION_2 = %r{^ {2}#{NAME_VERSION}(!)?$}
+    NAME_VERSION_4 = %r{^ {4}#{NAME_VERSION}$}
+    NAME_VERSION_6 = %r{^ {6}#{NAME_VERSION}$}
+
+    def parse_dependency(line)
+      if line =~ NAME_VERSION_2
+        name, version, pinned = $1, $2, $4
+        version = version.split(",").map { |d| d.strip } if version
+
+        dep = Bundler::Dependency.new(name, version)
+
+        if pinned && dep.name != 'bundler'
+          spec = @specs.find {|k, v| v.name == dep.name }
+          dep.source = spec.last.source if spec
+
+          # Path sources need to know what the default name / version
+          # to use in the case that there are no gemspecs present. A fake
+          # gemspec is created based on the version set on the dependency
+          # TODO: Use the version from the spec instead of from the dependency
+          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
+            dep.source.name    = name
+            dep.source.version = $1
+          end
+        end
+
+        @dependencies << dep
+      end
+    end
+
+    def parse_spec(line)
+      if line =~ NAME_VERSION_4
+        name, version = $1, Gem::Version.new($2)
+        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        @current_spec = LazySpecification.new(name, version, platform)
+        @current_spec.source = @current_source
+
+        # Avoid introducing multiple copies of the same spec (caused by
+        # duplicate GIT sections)
+        @specs[@current_spec.identifier] ||= @current_spec
+      elsif line =~ NAME_VERSION_6
+        name, version = $1, $2
+        version = version.split(',').map { |d| d.strip } if version
+        dep = Gem::Dependency.new(name, version)
+        @current_spec.dependencies << dep
+      end
+    end
+
+    def parse_platform(line)
+      if line =~ /^  (.*)$/
+        @platforms << Gem::Platform.new($1)
+      end
+    end
+
+  end
+end

data/lib/bundler/match_platform.rb

@@ -0,0 +1,13 @@
+require 'bundler/gem_helpers'
+
+module Bundler
+  module MatchPlatform
+    include GemHelpers
+
+    def match_platform(p)
+      Gem::Platform::RUBY == platform or
+      platform.nil? or p == platform or
+      generic(Gem::Platform.new(platform)) == p
+    end
+  end
+end

data/lib/bundler/parallel_workers.rb

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

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

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

@@ -0,0 +1,69 @@
+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/psyched_yaml.rb

@@ -0,0 +1,26 @@
+# Psych could be a gem, so try to ask for it
+begin
+  gem 'psych'
+rescue LoadError
+end if defined?(gem)
+
+# Psych could just be in the stdlib
+# but it's too late if Syck is already loaded
+begin
+  require 'psych' unless defined?(Syck)
+rescue LoadError
+  # Apparently Psych wasn't available. Oh well.
+end
+
+# At least load the YAML stdlib, whatever that may be
+require 'yaml' unless defined?(YAML.dump)
+
+module Bundler
+  # On encountering invalid YAML,
+  # Psych raises Psych::SyntaxError
+  if defined?(::Psych::SyntaxError)
+    YamlSyntaxError = ::Psych::SyntaxError
+  else # Syck raises ArgumentError
+    YamlSyntaxError = ::ArgumentError
+  end
+end

data/lib/bundler/remote_specification.rb

@@ -0,0 +1,57 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Bundler
+  # Represents a lazily loaded gem specification, where the full specification
+  # is on the source server in rubygems' "quick" index. The proxy object is to
+  # be seeded with what we're given from the source's abbreviated index - the
+  # full specification will only be fetched when necessary.
+  class RemoteSpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :platform
+    attr_accessor :source, :source_uri
+
+    def initialize(name, version, platform, spec_fetcher)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @spec_fetcher = spec_fetcher
+    end
+
+    # Needed before installs, since the arch matters then and quick
+    # specs don't bother to include the arch in the platform string
+    def fetch_platform
+      @platform = _remote_specification.platform
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    # Because Rubyforge cannot be trusted to provide valid specifications
+    # once the remote gem is downloaded, the backend specification will
+    # be swapped out.
+    def __swap__(spec)
+      @specification = spec
+    end
+
+  private
+
+    def _remote_specification
+      @specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
+    end
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        _remote_specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end