bundler 0.4.1 → 0.5.0

data/lib/bundler/repository/directory_repository.rb

@@ -0,0 +1,46 @@
+module Bundler
+  class Repository
+    class Directory
+      attr_reader :path, :bindir
+
+      def initialize(path, bindir)
+        @path   = path
+        @bindir = bindir
+
+        FileUtils.mkdir_p(path.to_s)
+      end
+
+      def source_index
+        index = Gem::SourceIndex.from_gems_in(@path.join("specifications"))
+        index.each { |n, spec| spec.loaded_from = @path.join("specifications", "#{spec.full_name}.gemspec") }
+        index
+      end
+
+      def gems
+        source_index.gems.values
+      end
+
+      def add_spec(spec)
+        destination = path.join('specifications')
+        destination.mkdir unless destination.exist?
+
+        File.open(destination.join("#{spec.full_name}.gemspec"), 'w') do |f|
+          f.puts spec.to_ruby
+        end
+      end
+
+      def download_path_for
+        @path.join("dirs")
+      end
+
+      # Checks whether a gem is installed
+      def expand(options)
+        # raise NotImplementedError
+      end
+
+      def cleanup(gems)
+        # raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/bundler/repository/gem_repository.rb

@@ -0,0 +1,108 @@
+module Bundler
+  class Repository
+    class Gems
+      attr_reader :path, :bindir
+
+      def initialize(path, bindir)
+        @path   = path
+        @bindir = bindir
+      end
+
+      # Returns the source index for all gems installed in the
+      # repository
+      def source_index
+        index = Gem::SourceIndex.from_gems_in(@path.join("specifications"))
+        index.each { |n, spec| spec.loaded_from = @path.join("specifications", "#{spec.full_name}.gemspec") }
+        index
+      end
+
+      def gems
+        source_index.gems.values
+      end
+
+      # Checks whether a gem is installed
+      def expand(options)
+        cached_gems.each do |name, version|
+          unless installed?(name, version)
+            install_cached_gem(name, version, options)
+          end
+        end
+      end
+
+      def cleanup(gems)
+        glob = gems.map { |g| g.full_name }.join(',')
+        base = path.join("{cache,specifications,gems}")
+
+        (Dir[base.join("*")] - Dir[base.join("{#{glob}}{.gemspec,.gem,}")]).each do |file|
+          if File.basename(file) =~ /\.gem$/
+            name = File.basename(file, '.gem')
+            Bundler.logger.info "Deleting gem: #{name}"
+          end
+          FileUtils.rm_rf(file)
+        end
+      end
+
+      def add_spec(spec)
+        raise NotImplementedError
+      end
+
+      def download_path_for
+        path
+      end
+
+    private
+
+      def cache_path
+        @path.join("cache")
+      end
+
+      def cache_files
+        Dir[cache_path.join("*.gem")]
+      end
+
+      def cached_gems
+        cache_files.map do |f|
+          full_name = File.basename(f).gsub(/\.gem$/, '')
+          full_name.split(/-(?=[^-]+$)/)
+        end
+      end
+
+      def spec_path
+        @path.join("specifications")
+      end
+
+      def spec_files
+        Dir[spec_path.join("*.gemspec")]
+      end
+
+      def gem_path
+        @path.join("gems")
+      end
+
+      def gem_paths
+        Dir[gem_path.join("*")]
+      end
+
+      def installed?(name, version)
+        spec_files.any? { |g| File.basename(g) == "#{name}-#{version}.gemspec" } &&
+          gem_paths.any? { |g| File.basename(g) == "#{name}-#{version}" }
+      end
+
+      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(
+            :install_dir         => @path,
+            :ignore_dependencies => true,
+            :env_shebang         => true,
+            :wrappers            => true,
+            :bin_dir             => @bindir
+          ))
+          installer.install
+        end
+      end
+    end
+  end
+end

data/lib/bundler/resolver.rb

@@ -20,6 +20,7 @@ end
 
 module Bundler
   class GemNotFound < StandardError; end
+  class VersionConflict < StandardError; end
 
   class Resolver
 
@@ -35,21 +36,39 @@ 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, index = Gem.source_index)
+    def self.resolve(requirements, sources)
       Bundler.logger.info "Calculating dependencies..."
 
-      resolver = new(index)
+      resolver = new(sources)
       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"
+          o << "    All possible versions of origin requirements conflict."
+        end
+        raise VersionConflict, "No compatible versions could be found for required dependencies:\n  #{output}"
         nil
       end
       result && GemBundle.new(result.values)
     end
 
-    def initialize(index)
+    def initialize(sources)
       @errors = {}
       @stack  = []
-      @index  = index
+      @specs  = Hash.new { |h,k| h[k] = {} }
+      @cache  = {}
+      @index  = {}
+
+      sources.reverse_each do |source|
+        source.gems.values.each do |spec|
+          # TMP HAX FOR OPTZ
+          spec.source = source
+          next unless Gem::Platform.match(spec.platform)
+          @specs[spec.name][spec.version] = spec
+        end
+      end
     end
 
     def resolve(reqs, activated)
@@ -61,7 +80,7 @@ module Bundler
       # 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
+        activated[req.name] ? 0 : search(req).size
       end
 
       activated = activated.dup
@@ -77,7 +96,7 @@ module Bundler
           # the remaining requirements.
           resolve(reqs, activated)
         else
-          @errors[existing.name] = { :gem => existing, :requirement => current }
+          @errors[existing.name] = [existing, 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
@@ -99,7 +118,7 @@ module Bundler
         # Fetch all gem versions matching the requirement
         #
         # TODO: Warn / error when no matching versions are found.
-        matching_versions = @index.search(current)
+        matching_versions = search(current)
 
         if matching_versions.empty?
           if current.required_by.empty?
@@ -159,5 +178,12 @@ module Bundler
       retval
     end
 
+    def search(dependency)
+      @cache[dependency.hash] ||= begin
+        @specs[dependency.name].values.select do |spec|
+          dependency =~ spec
+        end.sort_by {|s| s.version }
+      end
+    end
   end
 end

data/lib/bundler/source.rb

@@ -2,14 +2,19 @@ module Bundler
   # Represents a source of rubygems. Initially, this is only gem repositories, but
   # eventually, this will be git, svn, HTTP
   class Source
+    attr_accessor :tmp_path
+  end
+
+  class GemSource < Source
     attr_reader :uri
 
-    def initialize(uri)
-      @uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+    def initialize(options)
+      @uri = options[:uri]
+      @uri = URI.parse(@uri) unless @uri.is_a?(URI)
       raise ArgumentError, "The source must be an absolute URI" unless @uri.absolute?
     end
 
-    def specs
+    def gems
       @specs ||= fetch_specs
     end
 
@@ -21,9 +26,18 @@ module Bundler
       @uri.to_s
     end
 
-    def download(spec, destination)
+    class RubygemsRetardation < StandardError; end
+
+    def download(spec, repository)
       Bundler.logger.info "Downloading #{spec.full_name}.gem"
-      Gem::RemoteFetcher.fetcher.download(spec, uri, destination)
+
+      destination = repository.download_path_for(:gem)
+
+      unless destination.writable?
+        raise RubygemsRetardation
+      end
+
+      Gem::RemoteFetcher.fetcher.download(spec, uri, repository.download_path_for(:gem))
     end
 
   private
@@ -35,17 +49,102 @@ module Bundler
       inflated = Gem.inflate deflated
 
       index = Marshal.load(inflated)
-      specs = Hash.new { |h,k| h[k] = {} }
+      index.gems
+    rescue Gem::RemoteFetcher::FetchError => e
+      raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+    end
+  end
+
+  class DirectorySource < Source
+    def initialize(options)
+      @name          = options[:name]
+      @version       = options[:version]
+      @location      = options[:location]
+      @require_paths = options[:require_paths] || %w(lib)
+    end
+
+    def gems
+      @gems ||= begin
+        specs = {}
+
+        # Find any gemspec files in the directory and load those specs
+        Dir[@location.join('**', '*.gemspec')].each do |file|
+          path = Pathname.new(file).relative_path_from(@location).dirname
+          spec = eval(File.read(file))
+          spec.require_paths.map! { |p| path.join(p) }
+          specs[spec.full_name] = spec
+        end
 
-      index.gems.values.each do |spec|
-        next unless Gem::Platform.match(spec.platform)
-        spec.source = self
-        specs[spec.name][spec.version] = spec
+        # If a gemspec for the dependency was not found, add it to the list
+        if specs.keys.grep(/^#{Regexp.escape(@name)}/).empty?
+          case
+          when @version.nil?
+            raise ArgumentError, "If you use :at, you must specify the gem" \
+              "and version you wish to stand in for"
+          when !Gem::Version.correct?(@version)
+            raise ArgumentError, "If you use :at, you must specify a gem and" \
+              "version. You specified #{@version} for the version"
+          end
+
+          default = Gem::Specification.new do |s|
+            s.name = @name
+            s.version = Gem::Version.new(@version) if @version
+          end
+          specs[default.full_name] = default
+        end
+
+        specs
       end
+    end
 
-      specs
-    rescue Gem::RemoteFetcher::FetchError => e
-      raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+    def ==(other)
+      # TMP HAX
+      other.is_a?(DirectorySource)
+    end
+
+    def to_s
+      "#{@name} (#{@version}) Located at: '#{@location}'"
+    end
+
+    def download(spec, repository)
+      spec.require_paths.map! { |p| File.join(@location, p) }
+      repository.add_spec(:directory, spec)
+    end
+  end
+
+  class GitSource < DirectorySource
+    def initialize(options)
+      super
+      @uri = options[:uri]
+      @ref = options[:ref]
+      @branch = options[:branch]
+    end
+
+    def gems
+      FileUtils.mkdir_p(tmp_path.join("gitz"))
+
+      # TMP HAX to get the *.gemspec reading to work
+      @location = tmp_path.join("gitz", @name)
+
+      Bundler.logger.info "Cloning git repository at: #{@uri}"
+      `git clone #{@uri} #{@location} --no-hardlinks`
+
+      if @ref
+        Dir.chdir(@location) { `git checkout #{@ref}` }
+      elsif @branch && @branch != "master"
+        Dir.chdir(@location) { `git checkout origin/#{@branch}` }
+      end
+      super
+    end
+
+    def download(spec, repository)
+      dest = repository.download_path_for(:directory).join(@name)
+      spec.require_paths.map! { |p| File.join(dest, p) }
+      repository.add_spec(:directory, spec)
+      if spec.name == @name
+        FileUtils.mkdir_p(dest.dirname)
+        FileUtils.mv(tmp_path.join("gitz", spec.name), dest)
+      end
     end
   end
 end

data/lib/bundler/templates/environment.erb

@@ -1,7 +1,8 @@
+# DO NOT MODIFY THIS FILE
 module Bundler
   dir = File.dirname(__FILE__)
 
-<% unless @system_gems -%>
+<% unless options[:system_gems] -%>
   ENV["GEM_HOME"] = dir
   ENV["GEM_PATH"] = dir
 <% end -%>
@@ -9,12 +10,12 @@ module Bundler
   ENV["RUBYOPT"]  = "-r#{__FILE__} #{ENV["RUBYOPT"]}"
 
 <% load_paths.each do |load_path| -%>
-  $LOAD_PATH.unshift "#{dir}/<%= load_path %>"
+  $LOAD_PATH.unshift File.expand_path("#{dir}/<%= load_path %>")
 <% end -%>
 
   @gemfile = "#{dir}/<%= filename %>"
 
-<% if @rubygems -%>
+<% if options[:rubygems] -%>
   require "rubygems"
 
   @bundled_specs = {}
@@ -37,10 +38,52 @@ module Bundler
   add_specs_to_index
 <% end -%>
 
-  require File.join(dir, "bundler", "runtime")
+  def self.require_env(env = nil)
+    context = Class.new do
+      def initialize(env) @env = env && env.to_s ; end
+      def method_missing(*) ; end
+      def only(env)
+        old, @only = @only, _combine_onlys(env)
+        yield
+        @only = old
+      end
+      def except(env)
+        old, @except = @except, _combine_excepts(env)
+        yield
+        @except = old
+      end
+      def gem(name, *args)
+        opt = args.last || {}
+        only = _combine_onlys(opt[:only] || opt["only"])
+        except = _combine_excepts(opt[:except] || opt["except"])
+        files = opt[:require_as] || opt["require_as"] || name
+
+        return unless !only || only.any? {|e| e == @env }
+        return if except && except.any? {|e| e == @env }
+
+        files.each { |f| require f }
+        yield if block_given?
+        true
+      end
+      private
+      def _combine_onlys(only)
+        return @only unless only
+        only = [only].flatten.compact.uniq.map { |o| o.to_s }
+        only &= @only if @only
+        only
+      end
+      def _combine_excepts(except)
+        return @except unless except
+        except = [except].flatten.compact.uniq.map { |o| o.to_s }
+        except |= @except if @except
+        except
+      end
+    end
+    context.new(env && env.to_s).instance_eval(File.read(@gemfile))
+  end
 end
 
-<% if @rubygems -%>
+<% if options[:rubygems] -%>
 module Gem
   def source_index.refresh!
     super