bundler 0.3.0 → 0.3.1

data/README.markdown

@@ -119,7 +119,7 @@ to follow.
 
 * In your rails app, create a Gemfile and specify the gems that your
   application depends on. Make sure to specify rails as well:
-  
+
         gem "rails", "2.1.2"
         gem "will_paginate"
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'spec/rake/spectask'
 
 spec = Gem::Specification.new do |s|
   s.name    = "bundler"
-  s.version = "0.3.0"
+  s.version = "0.3.1"
   s.author  = "Yehuda Katz"
   s.email   = "wycats@gmail.com"
   s.homepage = "http://github.com/wycats/bundler"

data/lib/bundler.rb

@@ -7,6 +7,7 @@ require "rubygems/remote_fetcher"
 require "rubygems/installer"
 
 require "bundler/gem_bundle"
+require "bundler/source"
 require "bundler/finder"
 require "bundler/gem_ext"
 require "bundler/resolver"

data/lib/bundler/commands/bundle_command.rb

@@ -4,7 +4,7 @@ class Gem::Commands::BundleCommand < Gem::Command
     super('bundle', 'Create a gem bundle based on your Gemfile', {:manifest => nil, :update => false})
 
     add_option('-m', '--manifest MANIFEST', "Specify the path to the manifest file") do |manifest, options|
-      options[:manifest] = Pathname.new(manifest)
+      options[:manifest] = manifest
     end
 
     add_option('-u', '--update', "Force a remote check for newer gems") do
@@ -23,6 +23,8 @@ Bundle stuff
   end
 
   def execute
+    # Prevent the bundler from getting required unless it is actually being used
+    require 'bundler'
     Bundler::CLI.run(:bundle, options)
   end
 

data/lib/bundler/commands/exec_command.rb

@@ -4,7 +4,7 @@ class Gem::Commands::ExecCommand < Gem::Command
     super('exec', 'Run a command in context of a gem bundle', {:manifest => nil})
 
     add_option('-m', '--manifest MANIFEST', "Specify the path to the manifest file") do |manifest, options|
-      options[:manifest] = Pathname.new(manifest)
+      options[:manifest] = manifest
     end
   end
 
@@ -20,9 +20,11 @@ class Gem::Commands::ExecCommand < Gem::Command
     <<-EOF.gsub('      ', '')
       Run in context of a bundle
     EOF
-  end  
+  end
 
   def execute
+    # Prevent the bundler from getting required unless it is actually being used
+    require 'bundler'
     Bundler::CLI.run(:exec, options)
   end
 

data/lib/bundler/finder.rb

@@ -13,10 +13,9 @@ module Bundler
     # ==== Parameters
     # *sources<String>:: URI pointing to the gem repository
     def initialize(*sources)
-      @results = {}
-      @index   = Hash.new { |h,k| h[k] = {} }
-
-      sources.each { |source| fetch(source) }
+      @cache   = {}
+      @index   = {}
+      @sources = sources
     end
 
     # Figures out the best possible configuration of gems that satisfies
@@ -36,39 +35,6 @@ module Bundler
       resolved && GemBundle.new(resolved)
     end
 
-    # Fetches the index from the remote source
-    #
-    # ==== Parameters
-    # source<String>:: URI pointing to the gem repository
-    #
-    # ==== Raises
-    # ArgumentError:: If the source is not a valid gem repository
-    def fetch(source)
-      Bundler.logger.info "Updating source: #{source}"
-
-      deflated = Gem::RemoteFetcher.fetcher.fetch_path("#{source}/Marshal.4.8.Z")
-      inflated = Gem.inflate deflated
-
-      append(Marshal.load(inflated), source)
-    rescue Gem::RemoteFetcher::FetchError => e
-      raise ArgumentError, "#{source} is not a valid source: #{e.message}"
-    end
-
-    # Adds a new gem index linked to a gem source to the over all
-    # gem index that gets searched.
-    #
-    # ==== Parameters
-    # index<Gem::SourceIndex>:: The index to append to the list
-    # source<String>:: The original source
-    def append(index, source)
-      index.gems.values.each do |spec|
-        next unless Gem::Platform.match(spec.platform)
-        spec.source = source
-        @index[spec.name][spec.version] ||= spec
-      end
-      self
-    end
-
     # Searches for a gem that matches the dependency
     #
     # ==== Parameters
@@ -78,12 +44,25 @@ module Bundler
     # [Gem::Specification]:: A collection of gem specifications
     #   matching the search
     def search(dependency)
-      @results[dependency.hash] ||= begin
-        possibilities = @index[dependency.name].values
-        possibilities.select do |spec|
+      @cache[dependency.hash] ||= begin
+        find_by_name(dependency.name).select do |spec|
           dependency =~ spec
         end.sort_by {|s| s.version }
       end
     end
+
+  private
+
+    def find_by_name(name)
+      matches = @index[name] ||= begin
+        versions = {}
+        @sources.reverse_each do |source|
+          versions.merge! source.specs[name] || {}
+        end
+        versions
+      end
+      matches.values
+    end
+
   end
 end

data/lib/bundler/gem_bundle.rb

@@ -1,13 +1,8 @@
 module Bundler
   class GemBundle < Array
-    def download(directory)
-      FileUtils.mkdir_p(directory)
-
-      each do |spec|
-        unless directory.join("cache", "#{spec.full_name}.gem").file?
-          Bundler.logger.info "Downloading #{spec.full_name}.gem"
-          Gem::RemoteFetcher.fetcher.download(spec, spec.source, directory)
-        end
+    def download(repository)
+      sort_by {|s| s.full_name.downcase }.each do |spec|
+        repository.download(spec)
       end
 
       self

data/lib/bundler/gem_ext.rb

@@ -12,8 +12,8 @@ module Gem
     attribute :source
 
     def source=(source)
-      @source = source.is_a?(URI) ? source : URI.parse(source)
-      raise ArgumentError, "The source must be an absolute URI" unless @source.absolute?
+      source = Bundler::Source.new(source) unless source.is_a?(Bundler::Source)
+      @source = source
     end
   end
 end

data/lib/bundler/manifest.rb

@@ -7,7 +7,6 @@ module Bundler
     attr_reader :sources, :dependencies, :path
 
     def initialize(sources, dependencies, bindir, repository_path, rubygems, system_gems)
-      sources.map! {|s| s.is_a?(URI) ? s : URI.parse(s) }
       @sources      = sources
       @dependencies = dependencies
       @bindir       = bindir
@@ -58,7 +57,7 @@ module Bundler
         raise VersionConflict, "No compatible versions could be found for:\n#{gems}"
       end
 
-      bundle.download(@repository.path)
+      bundle.download(@repository)
     end
 
     def gem_dependencies

data/lib/bundler/manifest_file.rb

@@ -11,7 +11,7 @@ module Bundler
 
     def initialize(filename)
       @filename      = filename
-      @sources       = %w(http://gems.rubyforge.org)
+      @sources       = [Source.new("http://gems.rubyforge.org")]
       @dependencies  = []
       @rubygems      = true
       @system_gems   = true
@@ -57,7 +57,7 @@ module Bundler
     end
 
     def filename
-      @filename ||= find_manifest_file
+      Pathname.new(@filename ||= find_manifest_file)
     end
 
     def find_manifest_file

data/lib/bundler/repository.rb

@@ -22,6 +22,14 @@ module Bundler
       (Dir[@path.join("*")] - Dir[@path.join("{cache,doc,gems,environments,specifications}")]).empty?
     end
 
+    def download(spec)
+      FileUtils.mkdir_p(@path)
+
+      unless @path.join("cache", "#{spec.full_name}.gem").file?
+        spec.source.download(spec, @path)
+      end
+    end
+
     # Checks whether a gem is installed
     def install_cached_gems(options = {})
       cached_gems.each do |name, version|
@@ -33,6 +41,7 @@ module Bundler
 
     def install_cached_gem(name, version, options = {})
       cached_gem = cache_path.join("#{name}-#{version}.gem")
+      # TODO: Add a warning if cached_gem is not a file
       if cached_gem.file?
         Bundler.logger.info "Installing #{name}-#{version}.gem"
         installer = Gem::Installer.new(cached_gem.to_s, options.merge(
@@ -58,7 +67,7 @@ module Bundler
     def cached_gems
       cache_files.map do |f|
         full_name = File.basename(f).gsub(/\.gem$/, '')
-        full_name.split(/-(?=[\d.]+$)/)
+        full_name.split(/-(?=[^-]+$)/)
       end
     end
 

data/lib/bundler/resolver.rb

@@ -1,3 +1,9 @@
+# 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.
+# The actual implementation of the algorithm is not as good as it could be yet, but that
+# can come later.
+
 # Extending Gem classes to add necessary tracking information
 module Gem
   class Dependency
@@ -19,8 +25,8 @@ module Bundler
     attr_reader :errors
 
     def self.resolve(requirements, index = Gem.source_index)
+      resolver = new(index)
       result = catch(:success) do
-        resolver = new(index)
         resolver.resolve(requirements, {})
         nil
       end
@@ -29,48 +35,108 @@ module Bundler
 
     def initialize(index)
       @errors = {}
+      @stack  = []
       @index  = index
     end
 
     def resolve(reqs, activated)
+      # If the requirements are empty, then we are in a success state. Aka, all
+      # gem dependencies have been resolved.
       throw :success, activated if reqs.empty?
 
+      # Sort requirements so that the ones that are easiest to resolve are first.
+      # Easiest to resolve is defined by: Is this gem already activated? Otherwise,
+      # check the number of child dependencies this requirement has.
       reqs = reqs.sort_by do |req|
         activated[req.name] ? 0 : @index.search(req).size
       end
 
       activated = activated.dup
+      # Pull off the first requirement so that we can resolve it
       current   = reqs.shift
 
+      # Check if the gem has already been activated, if it has, we will make sure
+      # that the currently activated gem satisfies the requirement.
       if existing = activated[current.name]
         if current.version_requirements.satisfied_by?(existing.version)
           @errors.delete(existing.name)
+          # Since the current requirement is satisfied, we can continue resolving
+          # the remaining requirements.
           resolve(reqs, activated)
         else
           @errors[existing.name] = { :gem => existing, :requirement => current }
+          # Since the current requirement conflicts with an activated gem, we need
+          # to backtrack to the current requirement's parent and try another version
+          # of it (maybe the current requirement won't be present anymore). If the
+          # current requirement is a root level requirement, we need to jump back to
+          # where the conflicting gem was activated.
           parent = current.required_by.last || existing.required_by.last
-          throw parent.name
+          # We track the spot where the current gem was activated because we need
+          # to keep a list of every spot a failure happened.
+          throw parent.name, existing.required_by.last.name
         end
       else
-        @index.search(current).reverse_each do |spec|
-          resolve_requirement(spec, current, reqs.dup, activated.dup)
+        # There are no activated gems for the current requirement, so we are going
+        # to find all gems that match the current requirement and try them in decending
+        # order. We also need to keep a set of all conflicts that happen while trying
+        # this gem. This is so that if no versions work, we can figure out the best
+        # place to backtrack to.
+        conflicts = Set.new
+
+        # Fetch all gem versions matching the requirement
+        #
+        # TODO: Warn / error when no matching versions are found.
+        matching_versions = @index.search(current)
+
+        matching_versions.reverse_each do |spec|
+          conflict = resolve_requirement(spec, current, reqs.dup, activated.dup)
+          conflicts << conflict if conflict
+        end
+        # If the current requirement is a root level gem and we have conflicts, we
+        # can figure out the best spot to backtrack to.
+        if current.required_by.empty? && !conflicts.empty?
+          # Check the current "catch" stack for the first one that is included in the
+          # conflicts set. That is where the parent of the conflicting gem was required.
+          # By jumping back to this spot, we can try other version of the parent of
+          # the conflicting gem, hopefully finding a combination that activates correctly.
+          @stack.reverse_each do |savepoint|
+            if conflicts.include?(savepoint)
+              throw savepoint
+            end
+          end
         end
       end
     end
 
     def resolve_requirement(spec, requirement, reqs, activated)
+      # We are going to try activating the spec. We need to keep track of stack of
+      # requirements that got us to the point of activating this gem.
       spec.required_by.replace requirement.required_by
+      spec.required_by << requirement
+
       activated[spec.name] = spec
 
+      # Now, we have to loop through all child dependencies and add them to our
+      # array of requirements.
       spec.dependencies.each do |dep|
         next if dep.type == :development
         dep.required_by << requirement
         reqs << dep
       end
 
-      catch(requirement.name) do
+      # We create a savepoint and mark it by the name of the requirement that caused
+      # the gem to be activated. If the activated gem ever conflicts, we are able to
+      # jump back to this point and try another version of the gem.
+      length = @stack.length
+      @stack << requirement.name
+      retval = catch(requirement.name) do
         resolve(reqs, activated)
       end
+      # Since we're doing a lot of throw / catches. A push does not necessarily match
+      # up to a pop. So, we simply slice the stack back to what it was before the catch
+      # block.
+      @stack.slice!(length..-1)
+      retval
     end
 
   end

data/lib/bundler/runtime.rb

@@ -41,8 +41,10 @@ module Bundler
     end
 
     def source(source)
-      @manifest_file.sources << source
-      @manifest_file.sources.uniq!
+      source = Source.new(source)
+      unless @manifest_file.sources.include?(source)
+        @manifest_file.sources << source
+      end
     end
 
     def sources

data/lib/bundler/source.rb

@@ -0,0 +1,51 @@
+module Bundler
+  # Represents a source of rubygems. Initially, this is only gem repositories, but
+  # eventually, this will be git, svn, HTTP
+  class Source
+    attr_reader :uri
+
+    def initialize(uri)
+      @uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+      raise ArgumentError, "The source must be an absolute URI" unless @uri.absolute?
+    end
+
+    def specs
+      @specs ||= fetch_specs
+    end
+
+    def ==(other)
+      uri == other.uri
+    end
+
+    def to_s
+      @uri.to_s
+    end
+
+    def download(spec, destination)
+      Bundler.logger.info "Downloading #{spec.full_name}.gem"
+      Gem::RemoteFetcher.fetcher.download(spec, uri, destination)
+    end
+
+  private
+
+    def fetch_specs
+      Bundler.logger.info "Updating source: #{to_s}"
+
+      deflated = Gem::RemoteFetcher.fetcher.fetch_path("#{uri}/Marshal.4.8.Z")
+      inflated = Gem.inflate deflated
+
+      index = Marshal.load(inflated)
+      specs = Hash.new { |h,k| h[k] = {} }
+
+      index.gems.values.each do |spec|
+        next unless Gem::Platform.match(spec.platform)
+        spec.source = self
+        specs[spec.name][spec.version] = spec
+      end
+
+      specs
+    rescue Gem::RemoteFetcher::FetchError => e
+      raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -1,5 +1,4 @@
 require 'rubygems/command_manager'
-require 'bundler'
 require 'bundler/commands/bundle_command'
 require 'bundler/commands/exec_command'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bundler
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-29 00:00:00 -07:00
+date: 2009-08-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,7 @@ files:
 - lib/bundler/repository.rb
 - lib/bundler/resolver.rb
 - lib/bundler/runtime.rb
+- lib/bundler/source.rb
 - lib/bundler/templates/app_script.rb
 - lib/bundler/templates/environment.rb
 - lib/bundler/templates/rubygems.rb