moneypools-bundler 0.7.1.pre → 0.8.1

data/README.markdown

@@ -66,6 +66,15 @@ information, please refer to Bundler::ManifestBuilder.
     # the gemspec is found in.
     gem "rspec", "1.1.6", :vendored_at => "vendor/rspec"
 
+    # You can also control what will happen when you run Bundler.require_env
+    # by using the :require_as option, as per the next two examples.
+
+    # Don't auto-require this gem.
+    gem "rspec-rails", "1.2.9", :require_as => nil
+
+    # Require something other than the default.
+    gem "yajl-ruby", "0.6.7", :require_as => "yajl/json_gem"
+
     # Works exactly like :vendored_at, but first downloads the repo from
     # git and handles stashing the files for you. As with :vendored_at,
     # Bundler will automatically use *.gemspec files in the root or anywhere

data/Rakefile

@@ -37,6 +37,33 @@ else
   end
 end
 
+namespace :spec do
+  file "tmp/rg_deps" do
+    repo = File.dirname(__FILE__) + '/tmp/rg_deps'
+    FileUtils.mkdir_p(repo)
+    p repo
+    ENV['GEM_HOME'], ENV['GEM_PATH'] = repo, repo
+    system "gem install builder --no-rdoc --no-ri"
+  end
+
+  desc "Do all setup needed to run the specs"
+  task :setup => "tmp/rg_deps"
+
+  desc "Mount a ramdisk at ./tmp for faster specs"
+  task :ramdisk do
+    sh 'diskutil erasevolume HFS+ "tmpbundler" `hdiutil attach -nomount ram://116543`'
+    File.symlink "/Volumes/tmpbundler", File.expand_path('../tmp', __FILE__)
+  end
+end
+
+spec_file = "#{spec.name}.gemspec"
+desc "Create #{spec_file}"
+file spec_file => "Rakefile" do
+  File.open(spec_file, "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
 begin
   require 'rake/gempackagetask'
 rescue LoadError
@@ -45,16 +72,10 @@ else
   Rake::GemPackageTask.new(spec) do |pkg|
     pkg.gem_spec = spec
   end
+  task :gem => spec_file
 end
 
 desc "install the gem locally"
-task :install => [:package] do
+task :install => :package do
   sh %{gem install pkg/#{spec.name}-#{spec.version}}
 end
-
-desc "create a gemspec file"
-task :make_spec do
-  File.open("#{spec.name}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
-  end
-end

data/lib/bundler/{repository.rb → bundle.rb}

@@ -1,30 +1,81 @@
 module Bundler
   class InvalidRepository < StandardError ; end
 
-  class Repository
-    attr_reader :path
+  class Bundle
+    attr_reader :gemfile, :environment
 
-    def initialize(path, bindir)
-      FileUtils.mkdir_p(path)
+    def self.load(gemfile = nil)
+      gemfile = Pathname.new(gemfile || default_gemfile).expand_path
 
-      @path   = Pathname.new(path)
-      @bindir = Pathname.new(bindir)
+      unless gemfile.file?
+        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
+      end
 
-      @cache = GemDirectorySource.new(:location => @path.join("cache"))
+      new(gemfile)
     end
 
-    def install(dependencies, sources, options = {})
-      # TODO: clean this up
-      sources.each do |s|
-        s.repository = self
-        s.local = options[:cached]
+    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
 
-      source_requirements = {}
-      dependencies = dependencies.map do |dep|
-        source_requirements[dep.name] = dep.source if dep.source
-        dep.to_gem_dependency
+      raise DefaultManifestNotFound
+    end
+
+    # TODO: passing in the filename is not good
+    def initialize(gemfile)
+      @gemfile = gemfile
+      @environment = Environment.new(self)
+      Dsl.evaluate(gemfile, self, @environment)
+
+      # path   = env.gem_path
+
+      FileUtils.mkdir_p(gem_path)
+
+      @cache_path = gem_path.join('cache')
+      @cache = GemDirectorySource.new(self, :location => @cache_path)
+
+      @specs_path = gem_path.join('specifications')
+      @gems_path  = gem_path.join('gems')
+    end
+
+    def root
+      gemfile.parent
+    end
+
+    def path
+      @path ||= root.join("vendor/gems")
+    end
+
+    def path=(path)
+      @path = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def gem_path
+      path.join("#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def bindir=(path)
+      @bindir = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def install(options = {})
+      dependencies = @environment.dependencies
+      sources      = @environment.sources
+
+      # ========== from env
+      if only_envs = options[:only]
+        dependencies.reject! { |d| !only_envs.any? {|env| d.in?(env) } }
       end
+      # ==========
 
       # Check to see whether the existing cache meets all the requirements
       begin
@@ -39,7 +90,7 @@ module Bundler
       # or the user passed --update
       if options[:update] || !valid
         Bundler.logger.info "Calculating dependencies..."
-        bundle = Resolver.resolve(dependencies, [@cache] + sources, source_requirements)
+        bundle = Resolver.resolve(dependencies, [@cache] + sources)
         download(bundle, options)
         do_install(bundle, options)
         valid = bundle
@@ -48,21 +99,33 @@ module Bundler
       generate_bins(valid, options)
       cleanup(valid, options)
       configure(valid, options)
+
+      Bundler.logger.info "Done."
     end
 
     def cache(*gemfiles)
-      FileUtils.mkdir_p(@path.join("cache"))
+      FileUtils.mkdir_p(@cache_path)
       gemfiles.each do |gemfile|
         Bundler.logger.info "Caching: #{File.basename(gemfile)}"
-        FileUtils.cp(gemfile, @path.join("cache"))
+        FileUtils.cp(gemfile, @cache_path)
       end
     end
 
-    def prune(dependencies, sources)
-      sources.each do |s|
-        s.repository = self
-        s.local = true
+    def list_outdated(options={})
+      outdated_gems = source_index.outdated.sort
+
+      if outdated_gems.empty?
+        Bundler.logger.info "All gems are up to date."
+      else
+        Bundler.logger.info "Outdated gems:"
+        outdated_gems.each do |name|
+          Bundler.logger.info " * #{name}"
+        end
       end
+    end
+
+    def prune(options = {})
+      dependencies, sources = @environment.dependencies, @environment.sources
 
       sources = only_local(sources)
       bundle = Resolver.resolve(dependencies, [@cache] + sources)
@@ -70,23 +133,26 @@ module Bundler
         specs.each do |spec|
           unless bundle.any? { |s| s.name == spec.name && s.version == spec.version }
             Bundler.logger.info "Pruning #{spec.name} (#{spec.version}) from the cache"
-            FileUtils.rm @path.join("cache", "#{spec.full_name}.gem")
+            FileUtils.rm @cache_path.join("#{spec.full_name}.gem")
           end
         end
       end
     end
 
-    def gems
-      source_index.gems.values
+    def list(options = {})
+      Bundler.logger.info "Currently bundled gems:"
+      gems.each do |spec|
+        Bundler.logger.info " * #{spec.name} (#{spec.version})"
+      end
     end
 
-    def outdated_gems
-      source_index.outdated.sort
+    def gems
+      source_index.gems.values
     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 = Gem::SourceIndex.from_gems_in(@specs_path)
+      index.each { |n, spec| spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec") }
       index
     end
 
@@ -94,25 +160,34 @@ module Bundler
       @repos[type].download_path_for
     end
 
+    def setup_environment
+      unless @environment.system_gems
+        ENV["GEM_HOME"] = gem_path
+        ENV["GEM_PATH"] = gem_path
+      end
+      ENV["PATH"]     = "#{bindir}:#{ENV["PATH"]}"
+      ENV["RUBYOPT"]  = "-r#{gem_path}/environment #{ENV["RUBYOPT"]}"
+    end
+
   private
 
     def only_local(sources)
-      sources.select { |s| s.can_be_local? }
+      sources.select { |s| s.local? }
     end
 
     def download(bundle, options)
       bundle.sort_by {|s| s.full_name.downcase }.each do |spec|
-        next if options[:no_bundle].include?(spec.name)
+        next if spec.no_bundle?
         spec.source.download(spec)
       end
     end
 
     def do_install(bundle, options)
       bundle.each do |spec|
-        next if options[:no_bundle].include?(spec.name)
-        spec.loaded_from = @path.join("specifications", "#{spec.full_name}.gemspec")
+        next if spec.no_bundle?
+        spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec")
         # Do nothing if the gem is already expanded
-        next if @path.join("gems", spec.full_name).directory?
+        next if @gems_path.join(spec.full_name).directory?
 
         case spec.source
         when GemSource, GemDirectorySource, SystemGemSource
@@ -125,15 +200,16 @@ module Bundler
 
     def generate_bins(bundle, options)
       bundle.each do |spec|
-        next if options[:no_bundle].include?(spec.name)
+        next if spec.no_bundle?
         # HAX -- Generate the bin
-        bin_dir = @bindir
-        path    = @path
+        bin_dir = bindir
+        path    = gem_path
+        gems_path = @gems_path
         installer = Gem::Installer.allocate
         installer.instance_eval do
           @spec     = spec
           @bin_dir  = bin_dir
-          @gem_dir  = path.join("gems", "#{spec.full_name}")
+          @gem_dir  = gems_path.join(spec.full_name)
           @gem_home = path
           @wrappers = true
           @format_executable = false
@@ -146,32 +222,35 @@ module Bundler
     def expand_gemfile(spec, options)
       Bundler.logger.info "Installing #{spec.name} (#{spec.version})"
 
-      gemfile = @path.join("cache", "#{spec.full_name}.gem").to_s
+      gemfile = @cache_path.join("#{spec.full_name}.gem").to_s
 
       if build_args = options[:build_options] && options[:build_options][spec.name]
         Gem::Command.build_args = build_args.map {|k,v| "--with-#{k}=#{v}"}
       end
 
       installer = Gem::Installer.new(gemfile, options.merge(
-        :install_dir         => @path,
+        :install_dir         => gem_path,
         :ignore_dependencies => true,
         :env_shebang         => true,
         :wrappers            => true,
-        :bin_dir             => @bindir
+        :bin_dir             => bindir
       ))
       installer.install
+    rescue Gem::InstallError
+      cleanup_spec(spec)
+      raise
     ensure
       Gem::Command.build_args = []
     end
 
     def expand_vendored_gem(spec, options)
       add_spec(spec)
-      FileUtils.mkdir_p(@path.join("gems"))
-      File.symlink(spec.location, @path.join("gems", spec.full_name))
+      FileUtils.mkdir_p(@gems_path)
+      File.symlink(spec.location, @gems_path.join(spec.full_name))
     end
 
     def add_spec(spec)
-      destination = path.join('specifications')
+      destination = @specs_path
       destination.mkdir unless destination.exist?
 
       File.open(destination.join("#{spec.full_name}.gemspec"), 'w') do |f|
@@ -189,17 +268,21 @@ module Bundler
 
       to_delete.each do |spec|
         Bundler.logger.info "Deleting gem: #{spec.name} (#{spec.version})"
-        FileUtils.rm_rf(@path.join("specifications", "#{spec.full_name}.gemspec"))
-        FileUtils.rm_rf(@path.join("gems", spec.full_name))
+        cleanup_spec(spec)
         # Cleanup the bin directory
         spec.executables.each do |bin|
           next if valid_executables.include?(bin)
           Bundler.logger.info "Deleting bin file: #{bin}"
-          FileUtils.rm_rf(@bindir.join(bin))
+          FileUtils.rm_rf(bindir.join(bin))
         end
       end
     end
 
+    def cleanup_spec(spec)
+      FileUtils.rm_rf(@specs_path.join("#{spec.full_name}.gemspec"))
+      FileUtils.rm_rf(@gems_path.join(spec.full_name))
+    end
+
     def expand(options)
       each_repo do |repo|
         repo.expand(options)
@@ -207,42 +290,17 @@ module Bundler
     end
 
     def configure(specs, options)
-      generate_environment(specs, options)
-    end
-
-    def generate_environment(specs, options)
-      FileUtils.mkdir_p(path)
-
-      load_paths = load_paths_for_specs(specs, options)
-      bindir     = @bindir.relative_path_from(path).to_s
-      filename   = options[:manifest].relative_path_from(path).to_s
+      FileUtils.mkdir_p(gem_path)
 
-      File.open(path.join("environment.rb"), "w") do |file|
-        template = File.read(File.join(File.dirname(__FILE__), "templates", "environment.erb"))
-        erb = ERB.new(template, nil, '-')
-        file.puts erb.result(binding)
+      File.open(gem_path.join("environment.rb"), "w") do |file|
+        file.puts @environment.environment_rb(specs, options)
       end
-    end
-
-    def load_paths_for_specs(specs, options)
-      load_paths = []
-      specs.each do |spec|
-        next if options[:no_bundle].include?(spec.name)
-        gem_path = Pathname.new(spec.full_gem_path)
-        load_paths << load_path_for(gem_path, spec.bindir) if spec.bindir
-        spec.require_paths.each do |path|
-          load_paths << load_path_for(gem_path, path)
-        end
-      end
-      load_paths
-    end
 
-    def load_path_for(gem_path, path)
-      gem_path.join(path).relative_path_from(@path).to_s
+      generate_environment_picker
     end
 
-    def spec_file_for(spec)
-      spec.loaded_from.relative_path_from(@path).to_s
+    def generate_environment_picker
+      FileUtils.cp("#{File.dirname(__FILE__)}/templates/environment_picker.erb", path.join("environment.rb"))
     end
 
     def require_code(file, dep)

data/lib/bundler/cli.rb

@@ -31,32 +31,52 @@ module Bundler
     end
 
     def initialize(options)
+      Bundler.mode = options[:cached] ? :local : :readwrite
       @options = options
-      @environment = Bundler::Environment.load(@options[:manifest])
+      @bundle = Bundle.load(@options[:manifest])
     end
 
     def bundle
-      @environment.install(@options)
+      @bundle.install(@options)
     end
 
     def cache
-      @environment.cache(@options)
+      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."
+        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
     end
 
     def prune
-      @environment.prune(@options)
+      Bundler.mode = :local
+      @bundle.prune(@options)
     end
 
     def list
-      @environment.list(@options)
+      @bundle.list(@options)
     end
 
     def list_outdated
-      @environment.list_outdated(@options)
+      @bundle.list_outdated(@options)
     end
 
     def exec
-      @environment.setup_environment
+      @bundle.setup_environment
       # w0t?
       super(*$command)
     end

data/lib/bundler/commands/bundle_command.rb

@@ -19,7 +19,7 @@ class Gem::Commands::BundleCommand < Gem::Command
       options[:cache] = gem
     end
 
-    add_option('--prune-cache', "Removes all .gem files from the bundle's cache") do
+    add_option('--prune-cache', "Removes all .gem files that are not a part of the bundle from the cache") do
       options[:prune] = true
     end
 

data/lib/bundler/dependency.rb

@@ -1,7 +1,7 @@
 module Bundler
   class InvalidEnvironmentName < StandardError; end
 
-  class Dependency
+  class Dependency < Gem::Dependency
     attr_reader :name, :version, :require_as, :only, :except
     attr_accessor :source
 
@@ -10,8 +10,8 @@ module Bundler
         options[k.to_s] = v
       end
 
-      @name       = name
-      @version    = options["version"] || ">= 0"
+      super(name, options["version"] || ">= 0")
+
       @require_as = options["require_as"]
       @only       = options["only"]
       @except     = options["except"]
@@ -31,10 +31,6 @@ module Bundler
       true
     end
 
-    def to_s
-      to_gem_dependency.to_s
-    end
-
     def require_env(environment)
       return unless in?(environment)
 
@@ -51,8 +47,8 @@ module Bundler
       @block.call if @block
     end
 
-    def to_gem_dependency
-      @gem_dep ||= Gem::Dependency.new(name, version)
+    def no_bundle?
+      source == SystemGemSource.instance
     end
 
     def ==(o)
@@ -60,5 +56,7 @@ module Bundler
         [o.name, o.version, o.require_as, o.only, o.except]
     end
 
+    alias version version_requirements
+
   end
 end

data/lib/bundler/dsl.rb

@@ -1,13 +1,17 @@
 module Bundler
   class ManifestFileNotFound < StandardError; end
+  class InvalidKey < StandardError; end
+  class DefaultManifestNotFound < StandardError; end
 
   class Dsl
-    def self.evaluate(environment, file)
-      builder = new(environment)
+    def self.evaluate(file, bundle, environment)
+      builder = new(bundle, environment)
       builder.instance_eval(File.read(file.to_s), file.to_s, 1)
+      environment
     end
 
-    def initialize(environment)
+    def initialize(bundle, environment)
+      @bundle = bundle
       @environment = environment
       @directory_sources = []
       @git_sources = {}
@@ -15,15 +19,11 @@ module Bundler
     end
 
     def bundle_path(path)
-      path = Pathname.new(path)
-      @environment.gem_path = (path.relative? ?
-        @environment.root.join(path) : path).expand_path
+      @bundle.path = Pathname.new(path)
     end
 
     def bin_path(path)
-      path = Pathname.new(path)
-      @environment.bindir = (path.relative? ?
-        @environment.root.join(path) : path).expand_path
+      @bundle.bindir = Pathname.new(path)
     end
 
     def disable_rubygems
@@ -35,7 +35,7 @@ module Bundler
     end
 
     def source(source)
-      source = GemSource.new(:uri => source)
+      source = GemSource.new(@bundle, :uri => source)
       unless @environment.sources.include?(source)
         @environment.add_source(source)
       end
@@ -55,7 +55,7 @@ module Bundler
 
     def directory(path, options = {})
       raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
-      @directory = DirectorySource.new(options.merge(:location => path))
+      @directory = DirectorySource.new(@bundle, options.merge(:location => path))
       @directory_sources << @directory
       @environment.add_priority_source(@directory)
       retval = yield if block_given?
@@ -65,7 +65,7 @@ module Bundler
 
     def git(uri, options = {})
       raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
-      @git = GitSource.new(options.merge(:uri => uri))
+      @git = GitSource.new(@bundle, options.merge(:uri => uri))
       @git_sources[uri] = @git
       @environment.add_priority_source(@git)
       retval = yield if block_given?
@@ -81,6 +81,11 @@ module Bundler
       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]}"
@@ -92,7 +97,7 @@ module Bundler
       dep = Dependency.new(name, options.merge(:version => version))
 
       if options.key?(:bundle) && !options[:bundle]
-        dep.source = SystemGemSource.instance
+        dep.source = SystemGemSource.new(@bundle)
       elsif @git || options[:git]
         dep.source = _handle_git_option(name, version, options)
       elsif @directory || options[:path]
@@ -104,12 +109,16 @@ module Bundler
 
   private
 
+    def _version?(version)
+      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
+        dir.add_spec(path, name, version) if _version?(version)
         dir
       else
         directory options[:path] do
@@ -123,7 +132,7 @@ module Bundler
         return @directory, Pathname.new(path || '')
       end
 
-      path = @environment.filename.dirname.join(path)
+      path = @bundle.gemfile.dirname.join(path)
 
       @directory_sources.each do |s|
         if s.location.expand_path.to_s < path.expand_path.to_s
@@ -136,7 +145,7 @@ module Bundler
 
     def _handle_git_option(name, version, options)
       git    = options[:git].to_s
-      ref    = options[:commit] || options[:tag]
+      ref    = options[:ref] || options[:tag]
       branch = options[:branch]
 
       if source = @git || @git_sources[git]
@@ -147,7 +156,7 @@ module Bundler
         end
 
         source.required_specs << name
-        source.add_spec(Pathname.new(options[:path] || '.'), name, version) if version
+        source.add_spec(Pathname.new(options[:path] || '.'), name, version) if _version?(version)
         source
       else
         git(git, :ref => ref, :branch => branch) do