bundler 0.8.1 → 0.9.0.pre1

data/lib/bundler/environment.rb

@@ -1,85 +1,125 @@
-require "rubygems/source_index"
-
 module Bundler
-  class InvalidCacheArgument < StandardError; end
-  class SourceNotCached < StandardError; end
-
   class Environment
-    attr_reader   :dependencies
-    attr_accessor :rubygems, :system_gems
-
-    def initialize(bundle)
-      @bundle = bundle # TODO: remove this
-      @default_sources  = default_sources
-      @sources          = []
-      @priority_sources = []
-      @dependencies     = []
-      @rubygems         = true
-      @system_gems      = true
+    attr_reader :root
+
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
     end
 
-    def environment_rb(specs, options)
-      load_paths = load_paths_for_specs(specs, options)
-      bindir     = @bundle.bindir.relative_path_from(@bundle.gem_path).to_s
-      filename   = @bundle.gemfile.relative_path_from(@bundle.gem_path).to_s
+    def setup(*groups)
+      # Has to happen first
+      cripple_rubygems
 
-      template = File.read(File.join(File.dirname(__FILE__), "templates", "environment.erb"))
-      erb = ERB.new(template, nil, '-')
-      erb.result(binding)
+      # Activate the specs
+      specs_for(*groups).each do |spec|
+        Gem.loaded_specs[spec.name] = spec
+        $LOAD_PATH.unshift(*spec.load_paths)
+      end
+      self
     end
 
-    def require_env(env = nil)
-      dependencies.each { |d| d.require_env(env) }
+    def dependencies
+      @definition.dependencies
     end
 
-    def sources
-      sources = @priority_sources + [SystemGemSource.new(@bundle)] + @sources + @default_sources
-      sources.reject! {|s| !s.local? } if Bundler.local?
-      sources
+    def lock
+      FileUtils.mkdir_p("#{root}/vendor")
+      write_yml_lock
+      write_rb_lock
     end
 
-    def add_source(source)
-      @sources << source
+    def specs_for(*groups)
+      return specs if groups.empty?
+
+      dependencies = @definition.actual_dependencies.select { |d| groups.include?(d.group) }
+      Resolver.resolve(dependencies, index)
     end
 
-    def add_priority_source(source)
-      @priority_sources << source
+    def specs
+      @specs ||= begin
+        source_requirements = {}
+        dependencies.each do |dep|
+          next unless dep.source && dep.source.respond_to?(:local_specs)
+          source_requirements[dep.name] = dep.source.local_specs
+        end
+
+        Resolver.resolve(@definition.actual_dependencies, index, source_requirements)
+      end
     end
 
-    def clear_sources
-      @sources.clear
-      @default_sources.clear
+    def index
+      @definition.local_index
     end
 
-    alias rubygems? rubygems
-    alias system_gems? system_gems
+    def pack
+      pack_path = "#{root}/vendor/cache/"
+      FileUtils.mkdir_p(pack_path)
+
+      specs.each do |spec|
+        next if spec.source && !spec.source.is_a?(Source::Rubygems)
+        possibilities = Gem.path.map { |p| "#{p}/cache/#{spec.full_name}.gem" }
+        cached_path = possibilities.find { |p| File.exist? p }
+        FileUtils.cp(cached_path, pack_path)
+      end
+    end
 
   private
 
-    def default_sources
-      [GemSource.new(@bundle, :uri => "http://gems.rubyforge.org")]
+    def sources
+      @definition.sources
     end
 
-    def load_paths_for_specs(specs, options)
-      load_paths = []
-      specs.each do |spec|
-        next if spec.no_bundle?
-        full_gem_path = Pathname.new(spec.full_gem_path)
+    def load_paths
+      specs.map { |s| s.load_paths }.flatten
+    end
+
+    def cripple_rubygems
+      # handle 1.9 where system gems are always on the load path
+      if defined?(::Gem)
+        me = File.expand_path("../../", __FILE__)
+        $LOAD_PATH.reject! do |p|
+          p != File.dirname(__FILE__) &&
+            Gem.path.any? { |gp| p.include?(gp) }
+        end
+        $LOAD_PATH.unshift me
+        $LOAD_PATH.uniq!
+      end
+
+      # Disable rubygems' gem activation system
+      ::Kernel.class_eval do
+        if private_method_defined?(:gem_original_require)
+          alias require gem_original_require
+        end
 
-        load_paths << load_path_for(full_gem_path, spec.bindir) if spec.bindir
-        spec.require_paths.each do |path|
-          load_paths << load_path_for(full_gem_path, path)
+        def gem(*)
+          # Silently ignore calls to gem
         end
       end
-      load_paths
     end
 
-    def load_path_for(gem_path, path)
-      gem_path.join(path).relative_path_from(@bundle.gem_path).to_s
+    def write_rb_lock
+      template = File.read(File.expand_path("../templates/environment.erb", __FILE__))
+      erb = ERB.new(template, nil, '-')
+      File.open("#{root}/vendor/environment.rb", 'w') do |f|
+        f.puts erb.result(binding)
+      end
     end
 
-    def spec_file_for(spec)
-      spec.loaded_from.relative_path_from(@bundle.gem_path).to_s
+    def write_yml_lock
+      yml = details.to_yaml
+      File.open("#{root}/vendor/lock.yml", 'w') do |f|
+        f.puts yml
+      end
     end
+
+    def details
+      details = {}
+      details["sources"] = sources.map { |s| { s.class.name.split("::").last => s.options} }
+      details["specs"] = specs.map { |s| {s.name => s.version.to_s} }
+      details["dependencies"] = dependencies.map { |d| {d.name => d.version_requirements.to_s} }
+      details
+    end
+
   end
-end
+end

data/lib/bundler/index.rb

@@ -0,0 +1,98 @@
+module Bundler
+  class Index
+    def self.from_installed_gems
+      # TODO: Why can't we memoize this? It is being mutated somewhere
+      from_gem_index(Gem::SourceIndex.from_installed_gems)
+    end
+
+    def self.from_gem_index(gem_index)
+      index = new
+      gem_index.each { |name, spec| index << spec }
+      index
+    end
+
+    def initialize
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+      merge!(o)
+    end
+
+    def empty?
+      @specs.values.flatten.empty?
+    end
+
+    def search(query)
+      case query
+      when Gem::Specification, RemoteSpecification then search_by_spec(query)
+      when String then @specs[query]
+      else search_by_dependency(query)
+      end
+    end
+
+    alias [] search
+
+    def <<(spec)
+      arr = @specs[spec.name]
+
+      arr.delete_if do |s|
+        s.version == spec.version && s.platform == spec.platform
+      end
+
+      arr << spec
+      spec
+    end
+
+    def each
+      @specs.values.flatten.each do |spec|
+        yield spec
+      end
+    end
+
+    def merge!(other)
+      other.each do |spec|
+        self << spec
+      end
+      self
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def freeze
+      @specs.each do |k,v|
+        v.freeze
+      end
+      super
+    end
+
+  private
+
+    def search_by_spec(spec)
+      @specs[spec.name].select { |s| s.version == spec.version }
+    end
+
+    def search_by_dependency(dependency)
+      @cache[dependency.hash] ||= begin
+        specs = @specs[dependency.name]
+
+        wants_prerelease = dependency.version_requirements.prerelease?
+        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+        found = specs.select { |spec| dependency =~ spec }
+
+        unless wants_prerelease || only_prerelease
+          found.reject! { |spec| spec.version.prerelease? }
+        end
+
+        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+      end
+    end
+
+  end
+end

data/lib/bundler/installer.rb

@@ -0,0 +1,137 @@
+require 'rubygems/dependency_installer'
+
+module Bundler
+  class Installer
+    def self.install(root, definition, options)
+      new(root, definition).run(options)
+    end
+
+    attr_reader :root
+
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
+    end
+
+    def run(options)
+      if dependencies.empty?
+        Bundler.ui.warn "The Gemfile specifies no dependencies"
+        return
+      end
+
+      specs.each do |spec|
+        next unless spec.source.respond_to?(:install)
+        next if (spec.groups & options[:without]).any?
+        spec.source.install(spec)
+      end
+
+      Bundler.ui.confirm "You have bundles. Now, go have fun."
+    end
+
+    def dependencies
+      @definition.actual_dependencies
+    end
+
+    def specs
+      @specs ||= group_specs(resolve_locally || resolve_remotely)
+    end
+
+  private
+
+    def sources
+      @definition.sources
+    end
+
+    def resolve_locally
+      # Return unless all the dependencies have = version requirements
+      return unless dependencies.all? { |d| unambiguous?(d) }
+
+      index = local_index
+      sources.each do |source|
+        next unless source.respond_to?(:local_specs)
+        index = source.local_specs.merge(index)
+      end
+
+      source_requirements = {}
+      dependencies.each do |dep|
+        next unless dep.source && dep.source.respond_to?(:local_specs)
+        source_requirements[dep.name] = dep.source.local_specs
+      end
+
+      # Run a resolve against the locally available gems
+      specs = Resolver.resolve(dependencies, local_index, source_requirements)
+
+      # Simple logic for now. Can improve later.
+      specs.length == dependencies.length && specs
+    rescue Bundler::GemNotFound
+      nil
+    end
+
+    def resolve_remotely
+      index # trigger building the index
+      Bundler.ui.info "Resolving dependencies... "
+      source_requirements = {}
+      dependencies.each do |dep|
+        next unless dep.source
+        source_requirements[dep.name] = dep.source.specs
+      end
+
+      specs = Resolver.resolve(dependencies, index, source_requirements)
+      Bundler.ui.info "Done."
+      specs
+    end
+
+    def group_specs(specs)
+      dependencies.each do |d|
+        spec = specs.find { |s| s.name == d.name }
+        group_spec(specs, spec, d.group)
+      end
+      specs
+    end
+
+    def group_spec(specs, spec, group)
+      spec.groups << group
+      spec.groups.uniq!
+      spec.dependencies.select { |d| d.type != :development }.each do |d|
+        spec = specs.find { |s| s.name == d.name }
+        group_spec(specs, spec, group)
+      end
+    end
+
+    def unambiguous?(dep)
+      dep.version_requirements.requirements.all? { |op,_| op == '=' }
+    end
+
+    def index
+      @index ||= begin
+        index = local_index
+
+        sources.each do |source|
+          i = source.specs
+          Bundler.ui.info "Source: Processing index... "
+          index = i.merge(index).freeze
+          Bundler.ui.info "Done."
+        end
+
+        index
+      end
+    end
+
+    def local_index
+      @local_index ||= begin
+        index = Index.from_installed_gems.freeze
+
+        if File.directory?("#{root}/vendor/cache")
+          index = cache_source.specs.merge(index).freeze
+        end
+
+        index
+      end
+    end
+
+    def cache_source
+      Source::GemCache.new(:path => "#{root}/vendor/cache")
+    end
+
+  end
+end

data/lib/bundler/remote_specification.rb

@@ -29,7 +29,7 @@ module Bundler
       @specification = spec
     end
 
-    private
+  private
 
     def _remote_uri
       # "#{@source_uri}/quick/Marshal.4.8/#{@name}-#{@version}.gemspec.rz"

data/lib/bundler/resolver.rb

@@ -1,3 +1,4 @@
+require 'set'
 # This is the latest iteration of the gem dependency resolving algorithm. As of now,
 # it can resolve (as a success of failure) any set of gem dependencies we throw at it
 # in a reasonable amount of time. The most iterations I've seen it take is about 150.
@@ -19,9 +20,6 @@ module Gem
 end
 
 module Bundler
-  class GemNotFound < StandardError; end
-  class VersionConflict < StandardError; end
-
   class Resolver
 
     attr_reader :errors
@@ -36,21 +34,19 @@ module Bundler
     # ==== Returns
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
-    def self.resolve(requirements, sources)
-      source_requirements = {}
-
-      requirements.each do |r|
-        next unless r.source
-        source_requirements[r.name] = r.source
-      end
-
-      resolver = new(sources, source_requirements)
+    def self.resolve(requirements, index, source_requirements = {})
+      resolver = new(index, source_requirements)
       result = catch(:success) do
         resolver.resolve(requirements, {})
         output = resolver.errors.inject("") do |o, (conflict, (origin, requirement))|
-          o << "  Conflict on: #{conflict.inspect}:\n"
-          o << "    * #{conflict} (#{origin.version}) activated by #{origin.required_by.first}\n"
-          o << "    * #{requirement} required by #{requirement.required_by.first}\n"
+          if origin
+            o << "  Conflict on: #{conflict.inspect}:\n"
+            o << "    * #{conflict} (#{origin.version}) activated by #{origin.required_by.first}\n"
+            o << "    * #{requirement} required by #{requirement.required_by.first}\n"
+          else
+            o << "  #{requirement} not found in any of the sources\n"
+            o << "      required by #{requirement.required_by.first}\n"
+          end
           o << "    All possible versions of origin requirements conflict."
         end
         raise VersionConflict, "No compatible versions could be found for required dependencies:\n  #{output}"
@@ -61,7 +57,6 @@ module Bundler
         # a smaller index in the array.
         ordered = []
         result.values.each do |spec1|
-          spec1.no_bundle = true if source_requirements[spec1.name] == SystemGemSource.instance
           index = nil
           place = ordered.detect do |spec2|
             spec1.dependencies.any? { |d| d.name == spec2.name }
@@ -74,24 +69,11 @@ module Bundler
       end
     end
 
-    def initialize(sources, source_requirements)
+    def initialize(index, source_requirements)
       @errors = {}
       @stack  = []
-      @specs  = Hash.new { |h,k| h[k] = [] }
-      @by_gem = source_requirements
-      @cache  = {}
-      @index  = {}
-
-      sources.each do |source|
-        source.gems.each do |name, specs|
-          # Hack to work with a regular Gem::SourceIndex
-          specs = [specs] unless specs.is_a?(Array)
-          specs.compact.each do |spec|
-            next if @specs[spec.name].any? { |s| s.version == spec.version && s.platform == spec.platform }
-            @specs[spec.name] << spec
-          end
-        end
-      end
+      @index  = index
+      @source_requirements = source_requirements
     end
 
     def debug
@@ -166,10 +148,11 @@ module Bundler
 
         if matching_versions.empty?
           if current.required_by.empty?
-            location = @by_gem[current.name] ? @by_gem[current.name] : "any of the sources"
+            location = current.source ? current.source.to_s : "any of the sources"
             raise GemNotFound, "Could not find gem '#{current}' in #{location}"
+          else
+            @errors[current.name] = [nil, current]
           end
-          Bundler.logger.warn "Could not find gem '#{current}' (required by '#{current.required_by.last}') in any of the sources"
         end
 
         matching_versions.reverse_each do |spec|
@@ -229,22 +212,9 @@ module Bundler
       retval
     end
 
-    def search(dependency)
-      @cache[dependency.hash] ||= begin
-        pinned = @by_gem[dependency.name].gems if @by_gem[dependency.name]
-        specs  = (pinned || @specs)[dependency.name]
-
-        wants_prerelease = dependency.version_requirements.prerelease?
-        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
-
-        found = specs.select { |spec| dependency =~ spec }
-
-        unless wants_prerelease || (pinned && only_prerelease)
-          found.reject! { |spec| spec.version.prerelease? }
-        end
-
-        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
-      end
+    def search(dep)
+      index = @source_requirements[dep.name] || @index
+      index.search(dep)
     end
   end
 end