bundler 0.8.1 → 0.9.0.pre1

data/README

@@ -0,0 +1,7 @@
+This is a rewrite of bundler to offer more bundling power
+
+It currently lacks output and good exception handling for common cases. This is coming very soon. We wanted to open this so people could take a look at it.
+
+More soon.
+
+- carlhuda

data/bin/bundle

@@ -0,0 +1,3 @@
+require 'bundler/cli'
+
+Bundler::CLI.start

data/lib/bundler.rb

@@ -1,49 +1,84 @@
+require 'fileutils'
 require 'pathname'
-require 'logger'
-require 'set'
-require 'erb'
-# Required elements of rubygems
-require "rubygems/remote_fetcher"
-require "rubygems/installer"
-
-require "bundler/gem_bundle"
-require "bundler/source"
-require "bundler/finder"
-require "bundler/gem_ext"
-require "bundler/resolver"
-require "bundler/environment"
-require "bundler/dsl"
-require "bundler/cli"
-require "bundler/bundle"
-require "bundler/dependency"
-require "bundler/remote_specification"
+require 'yaml'
+require 'bundler/rubygems'
 
 module Bundler
-  VERSION = "0.8.1"
+  VERSION = "0.9.0.pre1"
 
-  class << self
-    attr_writer :logger, :mode
+  autoload :Definition,          'bundler/definition'
+  autoload :Dependency,          'bundler/dependency'
+  autoload :Dsl,                 'bundler/dsl'
+  autoload :Environment,         'bundler/environment'
+  autoload :Index,               'bundler/index'
+  autoload :Installer,           'bundler/installer'
+  autoload :RemoteSpecification, 'bundler/remote_specification'
+  autoload :Resolver,            'bundler/resolver'
+  autoload :Source,              'bundler/source'
+  autoload :Specification,       'bundler/specification'
+  autoload :UI,                  'bundler/ui'
 
-    def logger
-      @logger ||= begin
-        logger = Logger.new(STDOUT, Logger::INFO)
-        logger.formatter = proc {|_,_,_,msg| "#{msg}\n" }
-        logger
-      end
-    end
+  class GemfileNotFound < StandardError; end
+  class GemNotFound     < StandardError; end
+  class VersionConflict < StandardError; end
+  class GemfileError    < StandardError; end
 
-    def local?
-      @mode == :local
-    end
+  def self.ui
+    @ui ||= UI.new
+  end
 
-    def writable?
-      @mode != :readonly
+  def self.ui=(ui)
+    @ui = ui
+  end
+
+  def self.setup(*groups)
+    gemfile = default_gemfile
+    load(gemfile).setup(*groups)
+  end
+
+  def self.load(gemfile = default_gemfile)
+    root = Pathname.new(gemfile).dirname
+    Environment.new root, definition(gemfile)
+  end
+
+  def self.definition(gemfile = default_gemfile)
+    root = Pathname.new(gemfile).dirname
+    lockfile = root.join("vendor/lock.yml")
+    if lockfile.exist?
+      Definition.from_lock(lockfile)
+    else
+      Definition.from_gemfile(gemfile)
     end
+  end
 
-    def remote?
-      @mode == :readwrite
+  def self.home
+    Pathname.new(Gem.dir).join("bundler")
+  end
+
+  def self.install_path
+    home.join("gems")
+  end
+
+  def self.cache
+    home.join("cache")
+  end
+
+  def self.root
+    default_gemfile.dirname
+  end
+
+private
+
+  def self.default_gemfile
+    current = Pathname.new(Dir.pwd)
+
+    until current.root?
+      filename = current.join("Gemfile")
+      return filename if filename.exist?
+      current = current.parent
     end
+
+    raise GemfileNotFound, "The default Gemfile was not found"
   end
 
-  self.mode = :readonly
-end
+end

data/lib/bundler/cli.rb

@@ -1,89 +1,85 @@
-require "optparse"
+$:.unshift File.expand_path('../vendor', __FILE__)
+require 'thor'
+require 'bundler'
+require 'rubygems/config_file'
+
+# Work around a RubyGems bug
+Gem.configuration
 
 module Bundler
-  class CLI
-    def self.run(command, options = {})
-      new(options).run(command)
-    rescue DefaultManifestNotFound => e
-      Bundler.logger.error "Could not find a Gemfile to use"
-      exit 3
-    rescue InvalidEnvironmentName => e
-      Bundler.logger.error "Gemfile error: #{e.message}"
-      exit 4
-    rescue InvalidRepository => e
-      Bundler.logger.error e.message
-      exit 5
-    rescue VersionConflict => e
-      Bundler.logger.error e.message
-      exit 6
-    rescue GemNotFound => e
-      Bundler.logger.error e.message
-      exit 7
-    rescue InvalidCacheArgument => e
-      Bundler.logger.error e.message
-      exit 8
-    rescue SourceNotCached => e
-      Bundler.logger.error e.message
-      exit 9
-    rescue ManifestFileNotFound => e
-      Bundler.logger.error e.message
-      exit 10
+  class CLI < Thor
+    def self.banner(task)
+      task.formatted_usage(self, false)
     end
 
-    def initialize(options)
-      Bundler.mode = options[:cached] ? :local : :readwrite
-      @options = options
-      @bundle = Bundle.load(@options[:manifest])
+    desc "init", "Generates a Gemfile into the current working directory"
+    def init
+      if File.exist?("Gemfile")
+        puts "Gemfile already exists at `#{Dir.pwd}/Gemfile`"
+      else
+        puts "Writing new Gemfile to `#{Dir.pwd}/Gemfile`"
+        FileUtils.cp(File.expand_path('../templates/Gemfile', __FILE__), 'Gemfile')
+      end
     end
 
-    def bundle
-      @bundle.install(@options)
+    def initialize(*)
+      super
+      Bundler.ui = UI::Shell.new(shell)
+      Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
     end
 
-    def cache
-      gemfile = @options[:cache]
-
-      if File.extname(gemfile) == ".gem"
-        if !File.exist?(gemfile)
-          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
-        end
-        @bundle.cache(gemfile)
-      elsif File.directory?(gemfile) || gemfile.include?('/')
-        if !File.directory?(gemfile)
-          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
+    desc "check", "Checks if the dependencies listed in Gemfile are satisfied by currently installed gems"
+    def check
+      with_rescue do
+        env = Bundler.load
+        # Check top level dependencies
+        missing = env.dependencies.select { |d| env.index.search(d).empty? }
+        if missing.any?
+          puts "The following dependencies are missing"
+          missing.each do |d|
+            puts "  * #{d}"
+          end
+        else
+          env.specs
+          puts "The Gemfile's dependencies are satisfied"
         end
-        gemfiles = Dir["#{gemfile}/*.gem"]
-        if gemfiles.empty?
-          raise InvalidCacheArgument, "'#{gemfile}' contains no gemfiles"
-        end
-        @bundle.cache(*gemfiles)
-      else
-        raise InvalidCacheArgument, "w0t? '#{gemfile}' means nothing to me."
       end
+    rescue VersionConflict => e
+      puts e.message
     end
 
-    def prune
-      Bundler.mode = :local
-      @bundle.prune(@options)
-    end
+    desc "install", "Install the current environment to the system"
+    method_option :without, :type => :array, :banner => "Exclude gems thar are part of the specified named group"
+    def install
+      opts = options.dup
+      opts[:without] ||= []
+      opts[:without].map! { |g| g.to_sym }
 
-    def list
-      @bundle.list(@options)
+      Installer.install(Bundler.root, Bundler.definition, opts)
+    rescue Bundler::GemNotFound => e
+      puts e.message
+      exit 1
     end
 
-    def list_outdated
-      @bundle.list_outdated(@options)
+    desc "lock", "Locks a resolve"
+    def lock
+      environment = Bundler.load
+      environment.lock
     end
 
-    def exec
-      @bundle.setup_environment
-      # w0t?
-      super(*$command)
+    desc "pack", "Packs all the gems to vendor/cache"
+    def pack
+      environment = Bundler.load
+      environment.pack
     end
 
-    def run(command)
-      send(command)
-    end
+  private
 
+    def with_rescue
+      yield
+    rescue GemfileNotFound => e
+      puts e.message
+      exit 1
+    end
   end
-end
+end

data/lib/bundler/definition.rb

@@ -0,0 +1,78 @@
+module Bundler
+  class Definition
+    def self.from_gemfile(gemfile)
+      gemfile = Pathname.new(gemfile).expand_path
+
+      unless gemfile.file?
+        raise GemfileNotFound, "`#{gemfile}` not found"
+      end
+
+      Dsl.evaluate(gemfile)
+    end
+
+    def self.from_lock(lockfile)
+      # gemfile_definition = from_gemfile(nil)
+      locked_definition = Locked.new(YAML.load_file(lockfile))
+      # raise GemfileError unless gemfile_definition.equivalent?(locked_definition)
+      locked_definition
+    end
+
+    attr_reader :dependencies, :sources
+
+    alias actual_dependencies dependencies
+
+    def initialize(dependencies, sources)
+      @dependencies = dependencies
+      @sources = sources
+    end
+
+    def local_index
+      @local_index ||= begin
+        index = Index.from_installed_gems
+
+        sources.each do |source|
+          next unless source.respond_to?(:local_specs)
+          index = source.local_specs.merge(index)
+        end
+
+        index
+      end
+    end
+
+    # def equivalent?(other)
+    #   self.matches?(other) && other.matches?(self)
+    #   # other.matches?(self)
+    # end
+
+    # def matches?(other)
+    #   dependencies.all? do |dep|
+    #     dep =~ other.specs.find {|spec| spec.name == dep.name }
+    #   end
+    # end
+
+    class Locked < Definition
+      def initialize(details)
+        @details = details
+      end
+
+      def sources
+        @sources ||= @details["sources"].map do |args|
+          name, options = args.to_a.flatten
+          Bundler::Source.const_get(name).new(options)
+        end
+      end
+
+      def actual_dependencies
+        @actual_dependencies ||= @details["specs"].map do |args|
+          Gem::Dependency.new(*args.to_a.flatten)
+        end
+      end
+
+      def dependencies
+        @dependencies ||= @details["dependencies"].map do |args|
+          Gem::Dependency.new(*args.to_a.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/dependency.rb

@@ -1,62 +1,12 @@
-module Bundler
-  class InvalidEnvironmentName < StandardError; end
+require 'rubygems/dependency'
 
+module Bundler
   class Dependency < Gem::Dependency
-    attr_reader :name, :version, :require_as, :only, :except
-    attr_accessor :source
-
-    def initialize(name, options = {}, &block)
-      options.each do |k, v|
-        options[k.to_s] = v
-      end
-
-      super(name, options["version"] || ">= 0")
-
-      @require_as = options["require_as"]
-      @only       = options["only"]
-      @except     = options["except"]
-      @source     = options["source"]
-      @block      = block
-
-      if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
-        raise InvalidEnvironmentName, "'rubygems' is not a valid environment name"
-      end
-    end
-
-    def in?(environment)
-      environment = environment.to_s
-
-      return false unless !@only || @only.include?(environment)
-      return false if @except && @except.include?(environment)
-      true
-    end
-
-    def require_env(environment)
-      return unless in?(environment)
-
-      if @require_as
-        Array(@require_as).each { |file| require file }
-      else
-        begin
-          require name
-        rescue LoadError
-          # Do nothing
-        end
-      end
-
-      @block.call if @block
-    end
+    def initialize(name, version, options = {}, &blk)
+      super(name, version)
 
-    def no_bundle?
-      source == SystemGemSource.instance
+      @group  = options["group"] || :default
+      @source = options["source"]
     end
-
-    def ==(o)
-      [name, version, require_as, only, except] ==
-        [o.name, o.version, o.require_as, o.only, o.except]
-    end
-
-    alias version version_requirements
-
   end
-end
+end

data/lib/bundler/dsl.rb

@@ -1,110 +1,56 @@
 module Bundler
-  class ManifestFileNotFound < StandardError; end
-  class InvalidKey < StandardError; end
-  class DefaultManifestNotFound < StandardError; end
+  class DslError < StandardError; end
 
   class Dsl
-    def self.evaluate(file, bundle, environment)
-      builder = new(bundle, environment)
-      builder.instance_eval(File.read(file.to_s), file.to_s, 1)
-      environment
+    def self.evaluate(gemfile)
+      builder = new
+      builder.instance_eval(File.read(gemfile.to_s), gemfile.to_s, 1)
+      builder.to_definition
     end
 
-    def initialize(bundle, environment)
-      @bundle = bundle
-      @environment = environment
-      @directory_sources = []
-      @git_sources = {}
-      @only, @except, @directory, @git = nil, nil, nil, nil
+    def initialize
+      @sources = [] # Gem.sources.map { |s| Source::Rubygems.new(:uri => s) }
+      @dependencies = []
+      @group = nil
     end
 
-    def bundle_path(path)
-      @bundle.path = Pathname.new(path)
-    end
-
-    def bin_path(path)
-      @bundle.bindir = Pathname.new(path)
-    end
+    def gem(name, *args)
+      options = Hash === args.last ? args.pop : {}
+      version = args.last || ">= 0"
 
-    def disable_rubygems
-      @environment.rubygems = false
-    end
+      _normalize_options(name, version, options)
 
-    def disable_system_gems
-      @environment.system_gems = false
+      @dependencies << Dependency.new(name, version, options)
     end
 
     def source(source)
-      source = GemSource.new(@bundle, :uri => source)
-      unless @environment.sources.include?(source)
-        @environment.add_source(source)
+      source = case source
+      when :gemcutter, :rubygems, :rubyforge then Source::Rubygems.new(:uri => "http://gemcutter.org")
+      when String then Source::Rubygems.new(:uri => source)
+      else source
       end
-    end
 
-    def only(*env)
-      old, @only = @only, _combine_only(env)
-      yield
-      @only = old
+      @sources << source
+      source
     end
 
-    def except(*env)
-      old, @except = @except, _combine_except(env)
-      yield
-      @except = old
-    end
-
-    def directory(path, options = {})
-      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
-      @directory = DirectorySource.new(@bundle, options.merge(:location => path))
-      @directory_sources << @directory
-      @environment.add_priority_source(@directory)
-      retval = yield if block_given?
-      @directory = nil
-      retval
+    def path(path, options = {})
+      source Source::Path.new(options.merge(:path => path))
     end
 
     def git(uri, options = {})
-      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
-      @git = GitSource.new(@bundle, options.merge(:uri => uri))
-      @git_sources[uri] = @git
-      @environment.add_priority_source(@git)
-      retval = yield if block_given?
-      @git = nil
-      retval
+      source Source::Git.new(options.merge(:uri => uri))
     end
 
-    def clear_sources
-      @environment.clear_sources
+    def to_definition
+      Definition.new(@dependencies, @sources)
     end
 
-    def gem(name, *args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      version = args.last
-
-      keys = :vendored_at, :path, :only, :except, :git, :path, :bundle, :require_as, :tag, :branch, :ref
-      unless (invalid = options.keys - keys).empty?
-        raise InvalidKey, "Only #{keys.join(", ")} are valid options to #gem. You used #{invalid.join(", ")}"
-      end
-
-      if path = options.delete(:vendored_at)
-        options[:path] = path
-        warn "The :vendored_at option is deprecated. Use :path instead.\nFrom #{caller[0]}"
-      end
-
-      options[:only] = _combine_only(options[:only] || options["only"])
-      options[:except] = _combine_except(options[:except] || options["except"])
-
-      dep = Dependency.new(name, options.merge(:version => version))
-
-      if options.key?(:bundle) && !options[:bundle]
-        dep.source = SystemGemSource.new(@bundle)
-      elsif @git || options[:git]
-        dep.source = _handle_git_option(name, version, options)
-      elsif @directory || options[:path]
-        dep.source = _handle_vendored_option(name, version, options)
-      end
-
-      @environment.dependencies << dep
+    def group(name, options = {}, &blk)
+      old, @group = @group, name
+      yield
+    ensure
+      @group = old
     end
 
   private
@@ -113,70 +59,24 @@ module Bundler
       version && Gem::Version.new(version) rescue false
     end
 
-    def _handle_vendored_option(name, version, options)
-      dir, path = _find_directory_source(options[:path])
-
-      if dir
-        dir.required_specs << name
-        dir.add_spec(path, name, version) if _version?(version)
-        dir
-      else
-        directory options[:path] do
-          _handle_vendored_option(name, version, {})
-        end
-      end
-    end
-
-    def _find_directory_source(path)
-      if @directory
-        return @directory, Pathname.new(path || '')
+    def _normalize_options(name, version, opts)
+      opts.each do |k, v|
+        opts[k.to_s] = v
       end
 
-      path = @bundle.gemfile.dirname.join(path)
-
-      @directory_sources.each do |s|
-        if s.location.expand_path.to_s < path.expand_path.to_s
-          return s, path.relative_path_from(s.location)
-        end
-      end
+      opts["group"] ||= @group
 
-      nil
+      _normalize_git_options(name, version, opts)
     end
 
-    def _handle_git_option(name, version, options)
-      git    = options[:git].to_s
-      ref    = options[:ref] || options[:tag]
-      branch = options[:branch]
-
-      if source = @git || @git_sources[git]
-        if ref && source.ref != ref
-          raise GitSourceError, "'#{git}' already specified with ref: #{source.ref}"
-        elsif branch && source.branch != branch
-          raise GitSourceError, "'#{git}' already specified with branch: #{source.branch}"
-        end
-
-        source.required_specs << name
-        source.add_spec(Pathname.new(options[:path] || '.'), name, version) if _version?(version)
-        source
-      else
-        git(git, :ref => ref, :branch => branch) do
-          _handle_git_option(name, version, options)
-        end
+    def _normalize_git_options(name, version, opts)
+      # Normalize Git options
+      if opts["git"]
+        source  = git(opts["git"], :ref => opts["ref"])
+        source.default_spec name, version if _version?(version)
+        opts["source"] = source
       end
     end
 
-    def _combine_only(only)
-      return @only unless only
-      only = Array(only).compact.uniq.map { |o| o.to_s }
-      only &= @only if @only
-      only
-    end
-
-    def _combine_except(except)
-      return @except unless except
-      except = Array(except).compact.uniq.map { |o| o.to_s }
-      except |= @except if @except
-      except
-    end
   end
-end
+end