bundler08 0.8.2

data/lib/bundler08/cli.rb

@@ -0,0 +1,89 @@
+require "optparse"
+
+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
+    end
+
+    def initialize(options)
+      Bundler.mode = options[:cached] ? :local : :readwrite
+      @options = options
+      @bundle = Bundle.load(@options[:manifest])
+    end
+
+    def bundle
+      @bundle.install(@options)
+    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."
+        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
+      Bundler.mode = :local
+      @bundle.prune(@options)
+    end
+
+    def list
+      @bundle.list(@options)
+    end
+
+    def list_outdated
+      @bundle.list_outdated(@options)
+    end
+
+    def exec
+      @bundle.setup_environment
+      # w0t?
+      super(*$command)
+    end
+
+    def run(command)
+      send(command)
+    end
+
+  end
+end

data/lib/bundler08/commands/bundle_command.rb

@@ -0,0 +1,83 @@
+class Gem::Commands::BundleCommand < Gem::Command
+
+  def initialize
+    super('bundle', 'Create a gem bundle based on your Gemfile', {:manifest => nil, :update => false})
+
+    add_option('-i', '--init',"Create a Gemfile") do
+      options[:init] = true
+    end
+
+    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 'bundler08'
+    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)
+    elsif options[:init]
+      if File.exists?("Gemfile")
+        Bundler.logger.error "The Gemfile already exists"
+      else
+        FileUtils.cp File.expand_path("../../templates/Gemfile", __FILE__), "Gemfile"
+        Bundler.logger.info "Initialized Gemfile in #{Dir.pwd}"
+      end
+    else
+      Bundler::CLI.run(:bundle, options)
+    end
+  end
+
+end

data/lib/bundler08/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 'bundler08'
+    Bundler::CLI.run(:exec, options)
+  end
+
+end

data/lib/bundler08/dependency.rb

@@ -0,0 +1,62 @@
+module Bundler
+  class InvalidEnvironmentName < StandardError; end
+
+  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 no_bundle?
+      source == SystemGemSource.instance
+    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

data/lib/bundler08/dsl.rb

@@ -0,0 +1,182 @@
+module Bundler
+  class ManifestFileNotFound < StandardError; end
+  class InvalidKey < StandardError; end
+  class DefaultManifestNotFound < 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
+    end
+
+    def initialize(bundle, environment)
+      @bundle = bundle
+      @environment = environment
+      @directory_sources = []
+      @git_sources = {}
+      @only, @except, @directory, @git = nil, nil, nil, nil
+    end
+
+    def bundle_path(path)
+      @bundle.path = Pathname.new(path)
+    end
+
+    def bin_path(path)
+      @bundle.bindir = Pathname.new(path)
+    end
+
+    def disable_rubygems
+      @environment.rubygems = false
+    end
+
+    def disable_system_gems
+      @environment.system_gems = false
+    end
+
+    def source(source)
+      source = GemSource.new(@bundle, :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(@bundle, 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(@bundle, 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
+
+      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
+    end
+
+  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?(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 = @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
+
+      nil
+    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
+      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