peritor-bundler 0.7.0

data/lib/bundler/commands/bundle_command.rb

@@ -0,0 +1,72 @@
+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 from the bundle's 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

data/lib/bundler/commands/exec_command.rb

@@ -0,0 +1,36 @@
+if exec = ARGV.index("exec")
+  $command = ARGV[(exec + 1)..-1]
+  ARGV.replace ARGV[0..exec]
+end
+
+class Gem::Commands::ExecCommand < Gem::Command
+
+  def initialize
+    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] = manifest
+    end
+  end
+
+  def usage
+    "#{program_name} COMMAND"
+  end
+
+  def arguments # :nodoc:
+    "COMMAND  command to run in context of the gem bundle"
+  end
+
+  def description # :nodoc:
+    <<-EOF.gsub('      ', '')
+      Run in context of a bundle
+    EOF
+  end
+
+  def execute
+    # Prevent the bundler from getting required unless it is actually being used
+    require 'bundler'
+    Bundler::CLI.run(:exec, options)
+  end
+
+end

data/lib/bundler/dependency.rb

@@ -0,0 +1,64 @@
+module Bundler
+  class InvalidEnvironmentName < StandardError; end
+
+  class 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
+
+      @name       = name
+      @version    = 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 to_s
+      to_gem_dependency.to_s
+    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 to_gem_dependency
+      @gem_dep ||= Gem::Dependency.new(name, version)
+    end
+
+    def ==(o)
+      [name, version, require_as, only, except] ==
+        [o.name, o.version, o.require_as, o.only, o.except]
+    end
+
+  end
+end

data/lib/bundler/dsl.rb

@@ -0,0 +1,174 @@
+module Bundler
+  class ManifestFileNotFound < StandardError; end
+
+  class Dsl
+    def self.evaluate(environment, file)
+      builder = new(environment)
+      builder.instance_eval(File.read(file.to_s), file.to_s, 1)
+    end
+
+    def initialize(environment)
+      @environment = environment
+      @directory_sources = []
+      @git_sources = {}
+      @only, @except, @directory, @git = nil, nil, nil, nil
+    end
+
+    def bundle_path(path)
+      path = Pathname.new(path)
+      @environment.gem_path = (path.relative? ?
+        @environment.root.join(path) : path).expand_path
+    end
+
+    def bin_path(path)
+      path = Pathname.new(path)
+      @environment.bindir = (path.relative? ?
+        @environment.root.join(path) : path).expand_path
+    end
+
+    def disable_rubygems
+      @environment.rubygems = false
+    end
+
+    def disable_system_gems
+      @environment.system_gems = false
+    end
+
+    def source(source)
+      source = GemSource.new(:uri => source)
+      unless @environment.sources.include?(source)
+        @environment.add_source(source)
+      end
+    end
+
+    def only(*env)
+      old, @only = @only, _combine_only(env)
+      yield
+      @only = old
+    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(options.merge(:location => path))
+      @directory_sources << @directory
+      @environment.add_priority_source(@directory)
+      retval = yield if block_given?
+      @directory = nil
+      retval
+    end
+
+    def git(uri, options = {})
+      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
+      @git = GitSource.new(options.merge(:uri => uri))
+      @git_sources[uri] = @git
+      @environment.add_priority_source(@git)
+      retval = yield if block_given?
+      @git = nil
+      retval
+    end
+
+    def clear_sources
+      @environment.clear_sources
+    end
+
+    def gem(name, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      version = args.last
+
+      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.instance
+      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
+    end
+
+  private
+
+    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
+      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 || '')
+      end
+
+      path = @environment.filename.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
+
+      nil
+    end
+
+    def _handle_git_option(name, version, options)
+      git    = options[:git].to_s
+      ref    = options[:commit] || options[:tag]
+      branch = options[:branch]
+      shallow = options[:shallow]
+
+      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
+        source
+      else
+        git(git, :ref => ref, :branch => branch, :shallow => shallow) do
+          _handle_git_option(name, version, options)
+        end
+      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

data/lib/bundler/environment.rb

@@ -0,0 +1,181 @@
+require "rubygems/source_index"
+
+module Bundler
+  class DefaultManifestNotFound < StandardError; end
+  class InvalidCacheArgument < StandardError; end
+  class SourceNotCached < StandardError; end
+
+  class Environment
+    attr_reader :filename, :dependencies
+    attr_accessor :rubygems, :system_gems
+    attr_writer :gem_path, :bindir
+
+    def self.load(file = nil)
+      gemfile = Pathname.new(file || default_manifest_file).expand_path
+
+      unless gemfile.file?
+        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
+      end
+
+      new(gemfile)
+    end
+
+    def self.default_manifest_file
+      current = Pathname.new(Dir.pwd)
+
+      until current.root?
+        filename = current.join("Gemfile")
+        return filename if filename.exist?
+        current = current.parent
+      end
+
+      raise DefaultManifestNotFound
+    end
+
+    def initialize(filename)
+      @filename         = filename
+      @default_sources  = default_sources
+      @sources          = []
+      @priority_sources = []
+      @dependencies     = []
+      @rubygems         = true
+      @system_gems      = true
+
+      # Evaluate the Gemfile
+      Dsl.evaluate(self, filename)
+    end
+
+    def install(options = {})
+      if only_envs = options[:only]
+        dependencies.reject! { |d| !only_envs.any? {|env| d.in?(env) } }
+      end
+
+      no_bundle = dependencies.map do |dep|
+        dep.source == SystemGemSource.instance && dep.name
+      end.compact
+
+      update = options[:update]
+      cached = options[:cached]
+
+      repository.install(dependencies, sources,
+        :rubygems      => rubygems,
+        :system_gems   => system_gems,
+        :manifest      => filename,
+        :update        => options[:update],
+        :cached        => options[:cached],
+        :build_options => options[:build_options],
+        :no_bundle     => no_bundle
+      )
+      Bundler.logger.info "Done."
+    end
+
+    def cache(options = {})
+      gemfile = options[:cache]
+
+      if File.extname(gemfile) == ".gem"
+        if !File.exist?(gemfile)
+          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
+        end
+        repository.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
+        repository.cache(*gemfiles)
+      else
+        local = Gem::SourceIndex.from_installed_gems.find_name(gemfile).last
+
+        if !local
+          raise InvalidCacheArgument, "w0t? '#{gemfile}' means nothing to me."
+        end
+
+        gemfile = Pathname.new(local.loaded_from)
+        gemfile = gemfile.dirname.join('..', 'cache', "#{local.full_name}.gem").expand_path
+        repository.cache(gemfile)
+      end
+    end
+
+    def prune(options = {})
+      repository.prune(gem_dependencies, sources)
+    end
+
+    def list(options = {})
+      Bundler.logger.info "Currently bundled gems:"
+      repository.gems.each do |spec|
+        Bundler.logger.info " * #{spec.name} (#{spec.version})"
+      end
+    end
+
+    def list_outdated(options={})
+      outdated_gems = repository.outdated_gems
+      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 setup_environment
+      unless 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
+
+    def require_env(env = nil)
+      dependencies.each { |d| d.require_env(env) }
+    end
+
+    def root
+      filename.parent
+    end
+
+    def gem_path
+      @gem_path ||= root.join("vendor", "gems")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def sources
+      @priority_sources + @sources + @default_sources
+    end
+
+    def add_source(source)
+      @sources << source
+    end
+
+    def add_priority_source(source)
+      @priority_sources << source
+    end
+
+    def clear_sources
+      @sources.clear
+      @default_sources.clear
+    end
+
+  private
+
+    def default_sources
+      [GemSource.new(:uri => "http://gems.rubyforge.org"), SystemGemSource.instance]
+    end
+
+    def repository
+      @repository ||= Repository.new(gem_path, bindir)
+    end
+
+    def gem_dependencies
+      @gem_dependencies ||= dependencies.map { |d| d.to_gem_dependency }
+    end
+  end
+end