class Bundler::CLI

def cache
  Bundler.definition.resolve_with_cache!
  Bundler.load.cache
  Bundler.settings[:no_prune] = true if options[:no_prune]
  Bundler.load.lock
rescue GemNotFound => e
  Bundler.ui.error(e.message)
  Bundler.ui.warn "Run `bundle install` to install missing gems."
  exit 128
end

def check
  not_installed = Bundler.definition.missing_specs
  if not_installed.any?
    Bundler.ui.error "The following gems are missing"
    not_installed.each { |s| Bundler.ui.error " * #{s.name} (#{s.version})" }
    Bundler.ui.warn "Install missing gems with `bundle install`"
    exit 1
  else
    Bundler.load.lock
    Bundler.ui.info "The Gemfile's dependencies are satisfied"
  end
end

def config(name = nil, *args)
  values = ARGV.dup
  values.shift # remove config
  values.shift # remove the name
  unless name
    Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
    Bundler.settings.all.each do |setting|
      Bundler.ui.confirm "#{setting}"
      with_padding do
        Bundler.settings.pretty_values_for(setting).each do |line|
          Bundler.ui.info line
        end
      end
      Bundler.ui.confirm ""
    end
    return
  end
  if values.empty?
    Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
    with_padding do
      Bundler.settings.pretty_values_for(name).each { |line| Bundler.ui.info line }
    end
  else
    locations = Bundler.settings.locations(name)
    if local = locations[:local]
      Bundler.ui.info "Your application has set #{name} to #{local.inspect}. This will override the " \
        "system value you are currently setting"
    end
    if global = locations[:global]
      Bundler.ui.info "You are replacing the current system value of #{name}, which is currently #{global}"
    end
    if env = locations[:env]
      Bundler.ui.info "You have set a bundler environment variable for #{env}. This will take precedence " \
        "over the system value you are setting"
    end
    Bundler.settings.set_global(name, values.join(" "))
  end
end

def console(group = nil)
  require 'bundler/setup'
  group ? Bundler.require(:default, group) : Bundler.require
  ARGV.clear
  require 'irb'
  IRB.start
end

def exec(*)
  ARGV.delete("exec")
  Bundler.setup
  begin
    # Run
    Kernel.exec(*ARGV)
  rescue Errno::EACCES
    Bundler.ui.error "bundler: not executable: #{ARGV.first}"
  rescue Errno::ENOENT
    Bundler.ui.error "bundler: command not found: #{ARGV.first}"
    Bundler.ui.warn  "Install missing gem binaries with `bundle install`"
  end
end

def init
  opts = options.dup
  if File.exist?("Gemfile")
    Bundler.ui.error "Gemfile already exists at #{Dir.pwd}/Gemfile"
    exit 1
  end
  if opts[:gemspec]
    gemspec = File.expand_path(opts[:gemspec])
    unless File.exist?(gemspec)
      Bundler.ui.error "Gem specification #{gemspec} doesn't exist"
      exit 1
    end
    spec = Gem::Specification.load(gemspec)
    puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
    File.open('Gemfile', 'w') do |file|
      file << "# Generated from #{gemspec}\n"
      file << spec.to_gemfile
    end
  else
    puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
    FileUtils.cp(File.expand_path('../templates/Gemfile', __FILE__), 'Gemfile')
  end
end

def initialize(*)
  super
  use_shell = options["no-color"] ? Thor::Shell::Basic.new : shell
  Bundler.ui = UI::Shell.new(use_shell)
  Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
end

def install(path = nil)
  opts = options.dup
  opts[:without] ||= []
  opts[:without].map! { |g| g.to_sym }
  # Can't use Bundler.settings for this because settings needs gemfile.dirname
  ENV['BUNDLE_GEMFILE'] = opts[:gemfile] if opts[:gemfile]
  Bundler.settings[:path] = path if path
  Bundler.settings[:bin] = opts["binstubs"] if opts[:binstubs]
  Bundler.settings[:disable_shared_gems] = '1' if options["disable-shared-gems"] || path
  Bundler.settings.without = opts[:without]
  Bundler.ui.be_quiet! if opts[:quiet]
  Installer.install(Bundler.root, Bundler.definition, opts)
  Bundler.load.cache if Bundler.root.join("vendor/cache").exist?
  Bundler.ui.confirm "Your bundle is complete! " +
    "Use `bundle show [gemname]` to see where a bundled gem is installed."
rescue GemNotFound => e
  if Bundler.definition.no_sources?
    Bundler.ui.warn "Your Gemfile doesn't have any sources. You can add one with a line like 'source :gemcutter'"
  end
  raise e
end

def locate_gem(name)
  spec = Bundler.load.specs.find{|s| s.name == name }
  raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
  if spec.name == 'bundler'
    return File.expand_path('../../../', __FILE__)
  end
  spec.full_gem_path
end

def lock
  Bundler.ui.warn "Lock is deprecated. Your bundle is now locked whenever you run `bundle install`."
end

def open(name)
  editor = [ENV['BUNDLER_EDITOR'], ENV['VISUAL'], ENV['EDITOR']].find{|e| !e.nil? && !e.empty? }
  if editor
    command = "#{editor} #{locate_gem(name)}"
    success = system(command)
    Bundler.ui.info "Could not run '#{command}'" unless success
  else
    Bundler.ui.info("To open a bundled gem, set $EDITOR or $BUNDLER_EDITOR")
  end
end

def package
  install
  # TODO: move cache contents here now that all bundles are locked
  Bundler.load.cache
end

def show(gem_name = nil)
  Bundler.load.lock
  if gem_name
    Bundler.ui.info locate_gem(gem_name)
  else
    Bundler.ui.info "Gems included by the bundle:"
    Bundler.load.specs.sort_by { |s| s.name }.each do |s|
      Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})"
    end
  end
end

def unlock
  Bundler.ui.warn "Unlock is deprecated. To update to newer gem versions, use `bundle update`."
end

def update(*gems)
  sources = Array(options[:source])
  if gems.empty? && sources.empty?
    # We're doing a full update
    Bundler.definition(true)
  else
    Bundler.definition(:gems => gems, :sources => sources)
  end
  Installer.install Bundler.root, Bundler.definition, "update" => true
  Bundler.load.cache if Bundler.root.join("vendor/cache").exist?
  Bundler.ui.confirm "Your bundle is updated! " +
    "Use `bundle show [gemname]` to see where a bundled gem is installed."
end

def version
  Bundler.ui.info "Bundler version #{Bundler::VERSION}"
end

def viz
  output_file = File.expand_path(options[:file])
  graph = Graph.new( Bundler.load )
  begin
    graph.viz(output_file, options[:version], options[:requirements])
    Bundler.ui.info output_file
  rescue LoadError => e
    Bundler.ui.error e.inspect
    Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
    Bundler.ui.warn "`gem install ruby-graphviz`"
  rescue StandardError => e
    if e.message =~ /GraphViz not installed or dot not in PATH/
      Bundler.ui.error e.message
      Bundler.ui.warn "The ruby graphviz gem requires GraphViz to be installed"
    else
      raise
    end
  end
end