bundler 0.8.1 → 0.9.0.pre1

data/Rakefile

@@ -1,81 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
-require 'rubygems' unless ENV['NO_RUBYGEMS']
-require 'rubygems/specification'
-require 'bundler'
-require 'date'
-
-spec = Gem::Specification.new do |s|
-  s.name    = "bundler"
-  s.version = Bundler::VERSION
-  s.authors = ["Yehuda Katz", "Carl Lerche"]
-  s.email   = ["wycats@gmail.com", "clerche@engineyard.com"]
-  s.homepage = "http://github.com/wycats/bundler"
-  s.description = s.summary = "An easy way to vendor gem dependencies"
-
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README.markdown", "LICENSE"]
-
-  s.required_rubygems_version = ">= 1.3.5"
-
-  s.require_path = 'lib'
-  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("lib/**/*")
-end
-
-task :default => :spec
-
-begin
-  require 'spec/rake/spectask'
-rescue LoadError
-  task(:spec) { $stderr.puts '`gem install rspec` to run specs' }
-else
-  desc "Run specs"
-  Spec::Rake::SpecTask.new do |t|
-    t.spec_files = FileList['spec/**/*_spec.rb'] - FileList['spec/fixtures/**/*_spec.rb']
-    t.spec_opts = %w(-fs --color)
-    t.warning = true
-  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"
-end
-
-begin
-  require 'rake/gempackagetask'
-rescue LoadError
-  task(:gem) { $stderr.puts '`gem install rake` to package gems' }
-else
-  Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.gem_spec = spec
-  end
-end
-
-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
-
-desc "install the gem locally"
-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
-
-task :gem => :make_spec

data/lib/bundler/bundle.rb

@@ -1,314 +0,0 @@
-module Bundler
-  class InvalidRepository < StandardError ; end
-
-  class Bundle
-    attr_reader :gemfile, :environment
-
-    def self.load(gemfile = nil)
-      gemfile = Pathname.new(gemfile || default_gemfile).expand_path
-
-      unless gemfile.file?
-        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
-      end
-
-      new(gemfile)
-    end
-
-    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 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
-        valid = nil
-        # valid = Resolver.resolve(dependencies, [source_index], source_requirements)
-      rescue Bundler::GemNotFound
-      end
-
-      sources = only_local(sources) if options[:cached]
-
-      # Check the remote sources if the existing cache does not meet the requirements
-      # or the user passed --update
-      if options[:update] || !valid
-        Bundler.logger.info "Calculating dependencies..."
-        bundle = Resolver.resolve(dependencies, [@cache] + sources)
-        download(bundle, options)
-        do_install(bundle, options)
-        valid = bundle
-      end
-
-      generate_bins(valid, options)
-      cleanup(valid, options)
-      configure(valid, options)
-
-      Bundler.logger.info "Done."
-    end
-
-    def cache(*gemfiles)
-      FileUtils.mkdir_p(@cache_path)
-      gemfiles.each do |gemfile|
-        Bundler.logger.info "Caching: #{File.basename(gemfile)}"
-        FileUtils.cp(gemfile, @cache_path)
-      end
-    end
-
-    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)
-      @cache.gems.each do |name, specs|
-        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 @cache_path.join("#{spec.full_name}.gem")
-          end
-        end
-      end
-    end
-
-    def list(options = {})
-      Bundler.logger.info "Currently bundled gems:"
-      gems.each do |spec|
-        Bundler.logger.info " * #{spec.name} (#{spec.version})"
-      end
-    end
-
-    def gems
-      source_index.gems.values
-    end
-
-    def source_index
-      index = Gem::SourceIndex.from_gems_in(@specs_path)
-      index.each { |n, spec| spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec") }
-      index
-    end
-
-    def download_path_for(type)
-      @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.local? }
-    end
-
-    def download(bundle, options)
-      bundle.sort_by {|s| s.full_name.downcase }.each do |spec|
-        next if spec.no_bundle?
-        spec.source.download(spec)
-      end
-    end
-
-    def do_install(bundle, options)
-      bundle.each do |spec|
-        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 @gems_path.join(spec.full_name).directory?
-
-        case spec.source
-        when GemSource, GemDirectorySource, SystemGemSource
-          expand_gemfile(spec, options)
-        else
-          expand_vendored_gem(spec, options)
-        end
-      end
-    end
-
-    def generate_bins(bundle, options)
-      bundle.each do |spec|
-        next if spec.no_bundle?
-        # HAX -- Generate the bin
-        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  = gems_path.join(spec.full_name)
-          @gem_home = path
-          @wrappers = true
-          @format_executable = false
-          @env_shebang = false
-        end
-        installer.generate_bin
-      end
-    end
-
-    def expand_gemfile(spec, options)
-      Bundler.logger.info "Installing #{spec.name} (#{spec.version})"
-
-      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         => gem_path,
-        :ignore_dependencies => true,
-        :env_shebang         => true,
-        :wrappers            => true,
-        :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(@gems_path)
-      File.symlink(spec.location, @gems_path.join(spec.full_name))
-    end
-
-    def add_spec(spec)
-      destination = @specs_path
-      destination.mkdir unless destination.exist?
-
-      File.open(destination.join("#{spec.full_name}.gemspec"), 'w') do |f|
-        f.puts spec.to_ruby
-      end
-    end
-
-    def cleanup(valid, options)
-      to_delete = gems
-      to_delete.delete_if do |spec|
-        valid.any? { |other| spec.name == other.name && spec.version == other.version }
-      end
-
-      valid_executables = valid.map { |s| s.executables }.flatten.compact
-
-      to_delete.each do |spec|
-        Bundler.logger.info "Deleting gem: #{spec.name} (#{spec.version})"
-        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))
-        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)
-      end
-    end
-
-    def configure(specs, options)
-      FileUtils.mkdir_p(gem_path)
-
-      File.open(gem_path.join("environment.rb"), "w") do |file|
-        file.puts @environment.environment_rb(specs, options)
-      end
-
-      generate_environment_picker
-    end
-
-    def generate_environment_picker
-      FileUtils.cp("#{File.dirname(__FILE__)}/templates/environment_picker.erb", path.join("environment.rb"))
-    end
-
-    def require_code(file, dep)
-      constraint = case
-      when dep.only   then %{ if #{dep.only.inspect}.include?(env)}
-      when dep.except then %{ unless #{dep.except.inspect}.include?(env)}
-      end
-      "require #{file.inspect}#{constraint}"
-    end
-  end
-end

data/lib/bundler/commands/bundle_command.rb

@@ -1,72 +0,0 @@
-class Gem::Commands::BundleCommand < Gem::Command
-
-  def initialize
-    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] = manifest
-    end
-
-    add_option('-u', '--update', "Force a remote check for newer gems") do
-      options[:update] = true
-    end
-
-    add_option('--cached', "Only use cached gems when expanding the bundle") do
-      options[:cached] = true
-    end
-
-    add_option('--cache GEM', "Specify a path to a .gem file to add to the bundled gem cache") do |gem, options|
-      options[:cache] = gem
-    end
-
-    add_option('--prune-cache', "Removes all .gem files that are not a part of the bundle from the cache") do
-      options[:prune] = true
-    end
-
-    add_option('--list', "List all gems that are part of the active bundle") do
-      options[:list] = true
-    end
-
-    add_option('--list-outdated', "List all outdated gems that are part of the active bundle") do
-      options[:list_outdated] = true
-    end
-
-    add_option('-b', '--build-options OPTION_FILE', "Specify a path to a yml file with build options for binary gems") do |option_file, options|
-      if File.exist?(option_file)
-        options[:build_options] = YAML.load_file(option_file)
-      end
-    end
-
-    add_option('--only ENV', "Only expand the given environment.  To specify multiple environments, use --only multiple times.") do |env, options|
-      options[:only] ||= []
-      options[:only] << env
-    end
-  end
-
-  def usage
-    "#{program_name}"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-Bundle stuff
-    EOF
-  end
-
-  def execute
-    # Prevent the bundler from getting required unless it is actually being used
-    require 'bundler'
-    if options[:cache]
-      Bundler::CLI.run(:cache, options)
-    elsif options[:prune]
-      Bundler::CLI.run(:prune, options)
-    elsif options[:list]
-      Bundler::CLI.run(:list, options)
-    elsif options[:list_outdated]
-      Bundler::CLI.run(:list_outdated, options)
-    else
-      Bundler::CLI.run(:bundle, options)
-    end
-  end
-
-end