123456789_123456789_123456789_123456789_123456789_

Class: Gem::Commands::ExecCommand

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
Instance Chain:
Inherits: Gem::Command
Defined in: lib/rubygems/commands/exec_command.rb

Constant Summary

::Gem::Command - Inherited

HELP

Class Attribute Summary

::Gem::Command - Inherited

.build_args

Arguments used when building gems.

.build_args=, .extra_args, .extra_args=

Class Method Summary

::Gem::Command - Inherited

.add_common_option,
.add_specific_extra_args

Add a list of extra arguments for the given command.

.common_options,
.new

Initializes a generic gem command named command.

.specific_extra_args

Return an array of extra arguments for the command.

.specific_extra_args_hash

Accessor for the specific extra args hash (self initializing).

Instance Attribute Summary

::Gem::Command - Inherited

#command

The name of the command.

#defaults

The default options for the command.

#deprecated?,
#options

The options for the command.

#program_name

The name of the command for command-line invocation.

#summary

A short description of the command.

::Gem::DefaultUserInteraction - Included

Instance Method Summary

::Gem::VersionOption - Included

#add_platform_option

Add the –platform option to the option parser.

#add_prerelease_option

Add the –prerelease option to the option parser.

#add_version_option

Add the –version option to the option parser.

#get_platform_from_requirements

Extract platform given on the command line.

::Gem::Command - Inherited

#add_extra_args

Adds extra args from ~/.gemrc.

#add_option

Add a command-line option and handler to the command.

#arguments

Override to provide details of the arguments a command takes.

#begins?

True if long begins with the characters from short.

#check_deprecated_options,
#defaults_str

Override to display the default values of the command options.

#deprecate_option

Mark a command-line option as deprecated, and optionally specify a deprecation horizon.

#description

Override to display a longer description of what this command does.

#execute

Override to provide command handling.

#get_all_gem_names

Get all gem names from the command line.

#get_all_gem_names_and_versions

Get all [gem, version] from the command line.

#get_one_gem_name

Get a single gem name from the command line.

#get_one_optional_argument

Get a single optional argument from the command line.

#handle_options

Handle the given list of arguments by parsing them and recording the results.

#handles?

True if the command handles the given argument list.

#invoke

Invoke the command with the given list of arguments.

#invoke_with_build_args

Invoke the command with the given list of normal arguments and additional build arguments.

#merge_options

Merge a set of command options with the set of default options (without modifying the default option hash).

#remove_option

Remove previously defined command-line argument name.

#show_help

Display the help message for the command.

#show_lookup_failure

Display to the user that a gem couldn’t be found and reasons why –.

#usage

Override to display the usage for an individual gem command.

#when_invoked

Call the given block when invoked.

#add_parser_run_info

Adds a section with title and content to the parser help view.

#configure_options,
#create_option_parser

Creates an option parser and fills it in with the help info for the command.

#option_is_deprecated?,
#parser

Create on demand parser.

#wrap

Wraps text to width

#extract_gem_name_and_version, #add_parser_description, #add_parser_options, #add_parser_summary

::Gem::UserInteraction - Included

#alert

Displays an alert statement.

#alert_error

Displays an error statement to the error output location.

#alert_warning

Displays a warning statement to the warning output location.

#ask

Asks a question and returns the answer.

#ask_for_password

Asks for a password with a prompt

#ask_yes_no

Asks a yes or no question.

#choose_from_list

Asks the user to answer question with an answer from the given list.

#say

Displays the given statement on the standard output (or equivalent).

#terminate_interaction

Terminates the RubyGems process with the given exit_code

#verbose

Calls say with msg or the results of the block if really_verbose is true.

::Gem::DefaultUserInteraction - Included

::Gem::Text - Included

#clean_text

Remove any non-printable characters and make the text suitable for printing.

#format_text

Wraps text to wrap characters and optionally indents by indent characters.

#levenshtein_distance

Returns a value representing the “cost” of transforming str1 into str2 Vendored version of DidYouMean::Levenshtein.distance from the ruby/did_you_mean gem @ 1.4.0 github.com/ruby/did_you_mean/blob/2ddf39b874808685965dbc47d344cf6c7651807c/lib/did_you_mean/levenshtein.rb#L7-L37.

#truncate_text, #min3

Constructor Details

.newExecCommand

[ GitHub ]

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

def initialize
  super "exec", "Run a command from a gem", {
    version: Gem::Requirement.default,
  }

  add_version_option
  add_prerelease_option "to be installed"

  add_option "-g", "--gem GEM", "run the executable from the given gem" do |value, options|
    options[:gem_name] = value
  end

  add_option(:"Install/Update", "--conservative",
    "Prefer the most recent installed version, ",
    "rather than the latest version overall") do |value, options|
    options[:conservative] = true
  end
end

Instance Method Details

#activate! (private)

[ GitHub ]

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

def activate!
  gem(options[:gem_name], options[:version])
  Gem.finish_resolve

  verbose "activated #{options[:gem_name]} (#{Gem.loaded_specs[options[:gem_name]].version})"
end

#arguments

This method is for internal use only.
[ GitHub ]

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

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

#check_executable (private)

[ GitHub ]

  
# 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

#defaults_str

This method is for internal use only.
[ GitHub ]

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

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

#description

This method is for internal use only.
[ GitHub ]

  
# 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

#execute

[ GitHub ]

  
# 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

#handle_options(args) (private)

[ GitHub ]

  
# 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

#install (private)

[ GitHub ]

  
# 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

#install_if_needed (private)

[ GitHub ]

  
# 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

#load! (private)

[ GitHub ]

  
# 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

#set_gem_exec_install_paths (private)

[ GitHub ]

  
# 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

#suppress_always_install (private)

[ GitHub ]

  
# 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

#usage

This method is for internal use only.
[ GitHub ]

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

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