Class: Gem::Commands::ExecCommand

# File 'lib/rubygems/commands/exec_command.rb', line 31

def arguments # :nodoc:
  "COMMAND  the executable command to run"
end

# File 'lib/rubygems/commands/exec_command.rb', line 119

def check_executable
  if options[:executable].nil?
    raise Gem::CommandLineError,
      "Please specify an executable to run (e.g. #{program_name} COMMAND)"
  end
end

# File 'lib/rubygems/commands/exec_command.rb', line 35

def defaults_str # :nodoc:
  "--version '#{Gem::Requirement.default}'"
end

# File 'lib/rubygems/commands/exec_command.rb', line 39

def description # :nodoc:
  <<-EOF
The exec command handles installing (if necessary) and running an executable
from a gem, regardless of whether that gem is currently installed.

The exec command can be thought of as a shortcut to running `gem install` and
then the executable from the installed gem.

For example, `gem exec rails new .` will run `rails new .` in the current
directory, without having to manually run `gem install rails`.
Additionally, the exec command ensures the most recent version of the gem
is used (unless run with `--conservative`), and that the gem is not installed
to the same gem path as user-installed gems.
  EOF
end

# File 'lib/rubygems/commands/exec_command.rb', line 59

def execute
  gem_paths = { "GEM_HOME" => Gem.paths.home, "GEM_PATH" => Gem.paths.path.join(File::PATH_SEPARATOR), "GEM_SPEC_CACHE" => Gem.paths.spec_cache_dir }.compact

  check_executable

  print_command
  if options[:gem_name] == "gem" && options[:executable] == "gem"
    set_gem_exec_install_paths
    Gem::GemRunner.new.run options[:args]
    return
  elsif options[:conservative]
    install_if_needed
  else
    install
    activate!
  end

  load!
ensure
  ENV.update(gem_paths) if gem_paths
  Gem.clear_paths
end

# File 'lib/rubygems/commands/exec_command.rb', line 84

def handle_options(args)
  args = add_extra_args(args)
  check_deprecated_options(args)
  @options = Marshal.load Marshal.dump @defaults # deep copy
  parser.order!(args) do |v|
    # put the non-option back at the front of the list of arguments
    args.unshift(v)

    # stop parsing once we hit the first non-option,
    # so you can call `gem exec rails --version` and it prints the rails
    # version rather than rubygem's
    break
  end
  @options[:args] = args

  options[:executable], gem_version = extract_gem_name_and_version(options[:args].shift)
  options[:gem_name] ||= options[:executable]

  if gem_version
    if options[:version].none?
      options[:version] = Gem::Requirement.new(gem_version)
    else
      options[:version].concat [gem_version]
    end
  end

  if options[:prerelease] && !options[:version].prerelease?
    if options[:version].none?
      options[:version] = Gem::Requirement.default_prerelease
    else
      options[:version].concat [Gem::Requirement.default_prerelease]
    end
  end
end

# File 'lib/rubygems/commands/exec_command.rb', line 153

def install
  set_gem_exec_install_paths

  gem_name = options[:gem_name]
  gem_version = options[:version]

  install_options = options.merge(
    minimal_deps: false,
    wrappers: true
  )

  suppress_always_install do
    dep_installer = Gem::DependencyInstaller.new install_options

    request_set = dep_installer.resolve_dependencies gem_name, gem_version

    verbose "Gems to install:"
    request_set.sorted_requests.each do |activation_request|
      verbose "\t#{activation_request.full_name}"
    end

    request_set.install install_options
  end

  Gem::Specification.reset
rescue Gem::InstallError => e
  alert_error "Error installing #{gem_name}:\n\t#{e.message}"
  terminate_interaction 1
rescue Gem::GemNotFoundException => e
  show_lookup_failure e.name, e.version, e.errors, false

  terminate_interaction 2
rescue Gem::UnsatisfiableDependencyError => e
  show_lookup_failure e.name, e.version, e.errors, false,
                      "'#{gem_name}' (#{gem_version})"

  terminate_interaction 2
end

# File 'lib/rubygems/commands/exec_command.rb', line 137

def install_if_needed
  activate!
rescue Gem::MissingSpecError
  verbose "#{Gem::Dependency.new(options[:gem_name], options[:version])} not available locally, installing from remote"
  install
  activate!
end

# File 'lib/rubygems/commands/exec_command.rb', line 199

def load!
  argv = ARGV.clone
  ARGV.replace options[:args]

  exe = executable = options[:executable]

  contains_executable = Gem.loaded_specs.values.select do |spec|
    spec.executables.include?(executable)
  end

  if contains_executable.any? {|s| s.name == executable }
    contains_executable.select! {|s| s.name == executable }
  end

  if contains_executable.empty?
    if (spec = Gem.loaded_specs[executable]) && (exe = spec.executable)
      contains_executable << spec
    else
      alert_error "Failed to load executable `#{executable}`," \
            " are you sure the gem `#{options[:gem_name]}` contains it?"
      terminate_interaction 1
    end
  end

  if contains_executable.size > 1
    alert_error "Ambiguous which gem `#{executable}` should come from: " \
          "the options are #{contains_executable.map(&:name)}, " \
          "specify one via `-g`"
    terminate_interaction 1
  end

  load Gem.activate_bin_path(contains_executable.first.name, exe, ">= 0.a")
ensure
  ARGV.replace argv
end

# File 'lib/rubygems/commands/exec_command.rb', line 126

def print_command
  verbose "running #{program_name} with:\n"
  opts = options.reject {|_, v| v.nil? || Array(v).empty? }
  max_length = opts.map {|k, _| k.size }.max
  opts.each do |k, v|
    next if v.nil?
    verbose "\t#{k.to_s.rjust(max_length)}: #{v}"
  end
  verbose ""
end

# File 'lib/rubygems/commands/exec_command.rb', line 145

def set_gem_exec_install_paths
  home = File.join(Gem.dir, "gem_exec")

  ENV["GEM_PATH"] = ([home] + Gem.path).join(File::PATH_SEPARATOR)
  ENV["GEM_HOME"] = home
  Gem.clear_paths
end

# File 'lib/rubygems/commands/exec_command.rb', line 235

def suppress_always_install
  name = :always_install
  cls = ::Gem::Resolver::InstallerSet
  method = cls.instance_method(name)
  cls.remove_method(name)
  cls.define_method(name) { [] }

  begin
    yield
  ensure
    cls.remove_method(name)
    cls.define_method(name, method)
  end
end

# File 'lib/rubygems/commands/exec_command.rb', line 55

def usage # :nodoc:
  "#{program_name} [options --] COMMAND [args]"
end