Class: Gem::Installer

# File 'lib/rubygems/installer.rb', line 92

attr_writer :exec_format

# File 'lib/rubygems/installer.rb', line 83

attr_reader :install_lock

# File 'lib/rubygems/installer.rb', line 77

attr_accessor :path_warning

# File 'lib/rubygems/installer.rb', line 140

def self.for_spec(spec, options = {})
  # FIXME: we should have a real Package class for this
  new FakePackage.new(spec), options
end

# File 'lib/rubygems/installer_test_case.rb', line 10

attr_writer :bin_dir

# File 'lib/rubygems/installer_test_case.rb', line 15

attr_writer :build_args

# File 'lib/rubygems/installer.rb', line 56

attr_reader :build_root # :nodoc:

# File 'lib/rubygems/installer_test_case.rb', line 40

attr_writer :env_shebang

# File 'lib/rubygems/installer_test_case.rb', line 25

attr_writer :force

# File 'lib/rubygems/installer_test_case.rb', line 30

attr_writer :format

# File 'lib/rubygems/installer_test_case.rb', line 50

attr_writer :format_executable

# File 'lib/rubygems/installer.rb', line 49

attr_reader :gem

# File 'lib/rubygems/installer.rb', line 269

def gem_dir
  @gem_dir ||= File.join(gem_home, "gems", spec.full_name)
end

# File 'lib/rubygems/installer_test_case.rb', line 20

attr_writer :gem_dir

# File 'lib/rubygems/installer.rb', line 61

attr_reader :gem_home

# File 'lib/rubygems/installer_test_case.rb', line 35

attr_writer :gem_home

# File 'lib/rubygems/installer_test_case.rb', line 45

attr_writer :ignore_dependencies

# File 'lib/rubygems/installer.rb', line 66

attr_reader :options

# File 'lib/rubygems/installer_test_case.rb', line 55

attr_writer :security_policy

# File 'lib/rubygems/installer_test_case.rb', line 60

attr_writer :wrappers

# File 'lib/rubygems/installer.rb', line 827

def build_extensions
  builder = Gem::Ext::Builder.new spec, @build_args

  builder.build_extensions
end

# File 'lib/rubygems/installer.rb', line 212

def check_executable_overwrite(filename) # :nodoc:
  return if @force

  generated_bin = File.join @bin_dir, formatted_program_filename(filename)

  return unless File.exist? generated_bin

  ruby_executable = false
  existing = nil

  File.open generated_bin, 'rb' do |io|
    next unless io.gets =~ /^#!/ # shebang
    io.gets # blankline

    # TODO detect a specially formatted comment instead of trying
    # to run a regexp against Ruby code.
    next unless io.gets =~ /This file was generated by RubyGems/

    ruby_executable = true
    existing = io.read.slice(%r{
        ^\s*(
          gem \s |
          load \s Gem\.bin_path\( |
          load \s Gem\.activate_bin_path\(
        )
        (['"])(.*?)(\2),
      }x, 3)
  end

  return if spec.name == existing

  # somebody has written to RubyGems' directory, overwrite, too bad
  return if Gem.default_bindir != @bin_dir and not ruby_executable

  question = "#{spec.name}'s executable \"#{filename}\" conflicts with ".dup

  if ruby_executable
    question << (existing || 'an unknown executable')

    return if ask_yes_no "#{question}\nOverwrite the executable?", false

    conflict = "installed executable from #{existing}"
  else
    question << generated_bin

    return if ask_yes_no "#{question}\nOverwrite the executable?", false

    conflict = generated_bin
  end

  raise Gem::InstallError,
    "\"#{filename}\" from #{spec.name} conflicts with #{conflict}"
end

# File 'lib/rubygems/installer.rb', line 699

def check_that_user_bin_dir_is_in_path # :nodoc:
  user_bin_dir = @bin_dir || Gem.bindir(gem_home)
  user_bin_dir = user_bin_dir.gsub(File::SEPARATOR, File::ALT_SEPARATOR) if
    File::ALT_SEPARATOR

  path = ENV['PATH']
  if Gem.win_platform?
    path = path.downcase
    user_bin_dir = user_bin_dir.downcase
  end

  path = path.split(File::PATH_SEPARATOR)

  unless path.include? user_bin_dir
    unless !Gem.win_platform? && (path.include? user_bin_dir.sub(ENV['HOME'], '~'))
      unless self.class.path_warning
        alert_warning "You don't have #{user_bin_dir} in your PATH,\n\t  gem executables will not run."
        self.class.path_warning = true
      end
    end
  end
end

# File 'lib/rubygems/installer.rb', line 437

def default_spec_file
  File.join Gem::Specification.default_specifications_dir, "#{spec.full_name}.gemspec"
end

# File 'lib/rubygems/installer.rb', line 880

def dir
  gem_dir.to_s
end

# File 'lib/rubygems/installer.rb', line 654

def ensure_dependencies_met # :nodoc:
  deps = spec.runtime_dependencies
  deps |= spec.development_dependencies if @development

  deps.each do |dep_gem|
    ensure_dependency spec, dep_gem
  end
end

# File 'lib/rubygems/installer.rb', line 400

def ensure_dependency(spec, dependency)
  unless installation_satisfies_dependency? dependency
    raise Gem::InstallError, "#{spec.name} requires #{dependency}"
  end
  true
end

# File 'lib/rubygems/installer.rb', line 621

def ensure_loadable_spec
  ruby = spec.to_ruby_for_cache
  ruby.untaint

  begin
    eval ruby
  rescue StandardError, SyntaxError => e
    raise Gem::InstallError,
          "The specification for #{spec.full_name} is corrupt (#{e.class})"
  end
end

# File 'lib/rubygems/installer.rb', line 633

def ensure_required_ruby_version_met # :nodoc:
  if rrv = spec.required_ruby_version
    ruby_version = Gem.ruby_version
    unless rrv.satisfied_by? ruby_version
      raise Gem::RuntimeRequirementNotMetError,
        "#{spec.name} requires Ruby version #{rrv}. The current ruby version is #{ruby_version}."
    end
  end
end

# File 'lib/rubygems/installer.rb', line 643

def ensure_required_rubygems_version_met # :nodoc:
  if rrgv = spec.required_rubygems_version
    unless rrgv.satisfied_by? Gem.rubygems_version
      rg_version = Gem::VERSION
      raise Gem::RuntimeRequirementNotMetError,
        "#{spec.name} requires RubyGems version #{rrgv}. The current RubyGems version is #{rg_version}. " +
        "Try 'gem update --system' to update RubyGems itself."
    end
  end
end

# File 'lib/rubygems/installer.rb', line 838

def extension_build_error(build_dir, output, backtrace = nil) # :nodoc:
  builder = Gem::Ext::Builder.new spec, @build_args

  builder.build_error build_dir, output, backtrace
end

# File 'lib/rubygems/installer.rb', line 859

def extract_bin
  @package.extract_files gem_dir, "bin/*"
end

# File 'lib/rubygems/installer.rb', line 850

def extract_files
  @package.extract_files gem_dir
end

# File 'lib/rubygems/installer.rb', line 866

def formatted_program_filename(filename)
  if @format_executable
    self.class.exec_format % File.basename(filename)
  else
    filename
  end
end

# File 'lib/rubygems/installer.rb', line 480

def generate_bin # :nodoc:
  return if spec.executables.nil? or spec.executables.empty?

  begin
    Dir.mkdir @bin_dir, *[options[:dir_mode] && 0755].compact
  rescue SystemCallError
    raise unless File.directory? @bin_dir
  end

  raise Gem::FilePermissionError.new(@bin_dir) unless File.writable? @bin_dir

  spec.executables.each do |filename|
    filename.untaint
    bin_path = File.join gem_dir, spec.bindir, filename

    unless File.exist? bin_path
      # TODO change this to a more useful warning
      warn "`#{bin_path}` does not exist, maybe `gem pristine #{spec.name}` will fix it?"
      next
    end

    mode = File.stat(bin_path).mode
    dir_mode = options[:prog_mode] || (mode | 0111)
    FileUtils.chmod dir_mode, bin_path unless dir_mode == mode

    check_executable_overwrite filename

    if @wrappers
      generate_bin_script filename, @bin_dir
    else
      generate_bin_symlink filename, @bin_dir
    end

  end
end

# File 'lib/rubygems/installer.rb', line 523

def generate_bin_script(filename, bindir)
  bin_script_path = File.join bindir, formatted_program_filename(filename)

  FileUtils.rm_f bin_script_path # prior install may have been --no-wrappers

  File.open bin_script_path, 'wb', 0755 do |file|
    file.print app_script_text(filename)
    file.chmod(options[:prog_mode] || 0755)
  end

  verbose bin_script_path

  generate_windows_script filename, bindir
end

# File 'lib/rubygems/installer.rb', line 542

def generate_bin_symlink(filename, bindir)
  src = File.join gem_dir, spec.bindir, filename
  dst = File.join bindir, formatted_program_filename(filename)

  if File.exist? dst
    if File.symlink? dst
      link = File.readlink(dst).split File::SEPARATOR
      cur_version = Gem::Version.create(link[-3].sub(/^.*-/, ''))
      return if spec.version < cur_version
    end
    File.unlink dst
  end

  FileUtils.symlink src, dst, :verbose => Gem.configuration.really_verbose
rescue NotImplementedError, SystemCallError
  alert_warning "Unable to use symlinks, installing wrapper"
  generate_bin_script filename, bindir
end

# File 'lib/rubygems/installer.rb', line 468

def generate_windows_script(filename, bindir)
  if Gem.win_platform?
    script_name = filename + ".bat"
    script_path = File.join bindir, File.basename(script_name)
    File.open script_path, 'w' do |file|
      file.puts windows_stub_script(bindir, filename)
    end

    verbose script_path
  end
end

# File 'lib/rubygems/installer.rb', line 293

def install
  pre_install_checks

  FileUtils.rm_f File.join gem_home, 'specifications', spec.spec_name

  run_pre_install_hooks

  # Set loaded_from to ensure extension_dir is correct
  if @options[:install_as_default]
    spec.loaded_from = default_spec_file
  else
    spec.loaded_from = spec_file
  end

  # Completely remove any previous gem files
  FileUtils.rm_rf gem_dir
  FileUtils.rm_rf spec.extension_dir

  dir_mode = options[:dir_mode]
  FileUtils.mkdir_p gem_dir, :mode => dir_mode && 0755

  if @options[:install_as_default]
    extract_bin
    write_default_spec
  else
    extract_files

    build_extensions
    write_build_info_file
    run_post_build_hooks

    generate_bin
    write_spec
    write_cache_file
  end

  File.chmod(dir_mode, gem_dir) if dir_mode

  say spec.post_install_message if options[:post_install_message] && !spec.post_install_message.nil?

  Gem::Installer.install_lock.synchronize { Gem::Specification.reset }

  run_post_install_hooks

  spec

# TODO This rescue is in the wrong place. What is raising this exception?
# move this rescue to around the code that actually might raise it.
rescue Zlib::GzipFile::Error
  raise Gem::InstallError, "gzip error installing #{gem}"
end

# File 'lib/rubygems/installer.rb', line 410

def installation_satisfies_dependency?(dependency)
  return true if @options[:development] and dependency.type == :development
  return true if installed_specs.detect { |s| dependency.matches_spec? s }
  return false if @only_install_dir
  not dependency.matching_specs.empty?
end

# File 'lib/rubygems/installer.rb', line 380

def installed_specs
  @specs ||= begin
    specs = []

    Gem::Util.glob_files_in_dir("*.gemspec", File.join(gem_home, "specifications")).each do |path|
      spec = Gem::Specification.load path.untaint
      specs << spec if spec
    end

    specs
  end
end

# File 'lib/rubygems/installer.rb', line 893

def pre_install_checks
  verify_gem_home options[:unpack]

  # The name and require_paths must be verified first, since it could contain
  # ruby code that would be eval'ed in #ensure_loadable_spec
  verify_spec

  ensure_loadable_spec

  if options[:install_as_default]
    Gem.ensure_default_gem_subdirectories gem_home
  else
    Gem.ensure_gem_subdirectories gem_home
  end

  return true if @force

  ensure_required_ruby_version_met
  ensure_required_rubygems_version_met
  ensure_dependencies_met unless @ignore_dependencies

  true
end

# File 'lib/rubygems/installer.rb', line 663

def process_options # :nodoc:
  @options = {
    :bin_dir      => nil,
    :env_shebang  => false,
    :force        => false,
    :only_install_dir => false,
    :post_install_message => true
  }.merge options

  @env_shebang         = options[:env_shebang]
  @force               = options[:force]
  @install_dir         = options[:install_dir]
  @gem_home            = options[:install_dir] || Gem.dir
  @ignore_dependencies = options[:ignore_dependencies]
  @format_executable   = options[:format_executable]
  @wrappers            = options[:wrappers]
  @only_install_dir    = options[:only_install_dir]

  # If the user has asked for the gem to be installed in a directory that is
  # the system gem directory, then use the system bin directory, else create
  # (or use) a new bin dir under the gem_home.
  @bin_dir             = options[:bin_dir] || Gem.bindir(gem_home)
  @development         = options[:development]
  @build_root          = options[:build_root]

  @build_args          = options[:build_args] || Gem::Command.build_args

  unless @build_root.nil?
    require 'pathname'
    @build_root = Pathname.new(@build_root).expand_path
    @bin_dir = File.join(@build_root, options[:bin_dir] || Gem.bindir(@gem_home))
    @gem_home = File.join(@build_root, @gem_home)
    alert_warning "You build with buildroot.\n  Build root: #{@build_root}\n  Bin dir: #{@bin_dir}\n  Gem home: #{@gem_home}"
  end
end

# File 'lib/rubygems/installer.rb', line 356

def run_post_build_hooks # :nodoc:
  Gem.post_build_hooks.each do |hook|
    if hook.call(self) == false
      FileUtils.rm_rf gem_dir

      location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/

      message = "post-build hook#{location} failed for #{spec.full_name}"
      raise Gem::InstallError, message
    end
  end
end

# File 'lib/rubygems/installer.rb', line 369

def run_post_install_hooks # :nodoc:
  Gem.post_install_hooks.each do |hook|
    hook.call self
  end
end

# File 'lib/rubygems/installer.rb', line 345

def run_pre_install_hooks # :nodoc:
  Gem.pre_install_hooks.each do |hook|
    if hook.call(self) == false
      location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/

      message = "pre-install hook#{location} failed for #{spec.full_name}"
      raise Gem::InstallError, message
    end
  end
end

# File 'lib/rubygems/installer.rb', line 576

def shebang(bin_file_name)
  ruby_name = RbConfig::CONFIG['ruby_install_name'] if @env_shebang
  path = File.join gem_dir, spec.bindir, bin_file_name
  first_line = File.open(path, "rb") {|file| file.gets}

  if /\A#!/ =~ first_line
    # Preserve extra words on shebang line, like "-w".  Thanks RPA.
    shebang = first_line.sub(/\A\#!.*?ruby\S*((\s\S)+)/, "#!#{Gem.ruby}")
    opts = $1
    shebang.strip! # Avoid nasty ^M issues.
  end

  if which = Gem.configuration[:custom_shebang]
    # replace bin_file_name with "ruby" to avoid endless loops
    which = which.gsub(/ #{bin_file_name}$/," #{RbConfig::CONFIG['ruby_install_name']}")

    which = which.gsub(/\$(\w+)/) do
      case $1
      when "env"
        @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path }
      when "ruby"
        "#{Gem.ruby}#{opts}"
      when "exec"
        bin_file_name
      when "name"
        spec.name
      end
    end

    "#!#{which}"
  elsif not ruby_name
    "#!#{Gem.ruby}#{opts}"
  elsif opts
    "#!/bin/sh\n'exec' #{ruby_name.dump} '-x' \"$0\" \"$@\"\n#{shebang}"
  else
    # Create a plain shebang line.
    @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path }
    "#!#{@env_path} #{ruby_name}"
  end
end

# File 'lib/rubygems/installer.rb', line 276

def spec
  @package.spec
rescue Gem::Package::Error => e
  raise Gem::InstallError, "invalid gem: #{e.message}"
end

# File 'lib/rubygems/installer.rb', line 429

def spec_file
  File.join gem_home, "specifications", "#{spec.full_name}.gemspec"
end

# File 'lib/rubygems/installer.rb', line 420

def unpack(directory)
  @gem_dir = directory
  extract_files
end

# File 'lib/rubygems/installer.rb', line 722

def verify_gem_home(unpack = false) # :nodoc:
  FileUtils.mkdir_p gem_home, :mode => options[:dir_mode] && 0755
  raise Gem::FilePermissionError, gem_home unless
    unpack or File.writable?(gem_home)
end

# File 'lib/rubygems/installer.rb', line 728

def verify_spec
  unless spec.name =~ Gem::Specification::VALID_NAME_PATTERN
    raise Gem::InstallError, "#{spec} has an invalid name"
  end

  if spec.raw_require_paths.any?{|path| path =~ /\R/ }
    raise Gem::InstallError, "#{spec} has an invalid require_paths"
  end

  if spec.extensions.any?{|ext| ext =~ /\R/ }
    raise Gem::InstallError, "#{spec} has an invalid extensions"
  end

  unless spec.specification_version.to_s =~ /\A\d+\z/
    raise Gem::InstallError, "#{spec} has an invalid specification_version"
  end

  if spec.dependencies.any? {|dep| dep.type =~ /\R/ || dep.name =~ /\R/ }
    raise Gem::InstallError, "#{spec} has an invalid dependencies"
  end
end

# File 'lib/rubygems/installer.rb', line 790

def windows_stub_script(bindir, bin_file_name)
  rb_config = RbConfig::CONFIG
  rb_topdir = RbConfig::TOPDIR || File.dirname(rb_config["bindir"])

  # get ruby executable file name from RbConfig
  ruby_exe = "#{rb_config['RUBY_INSTALL_NAME']}#{rb_config['EXEEXT']}"
  ruby_exe = "ruby.exe" if ruby_exe.empty?

  if File.exist?(File.join bindir, ruby_exe)
    # stub & ruby.exe withing same folder.  Portable
    <<-TEXT
@ECHO OFF
@"%~dp0ruby.exe" "%~dpn0" %*
    TEXT
  elsif bindir.downcase.start_with? rb_topdir.downcase
    # stub within ruby folder, but not standard bin.  Portable
    require 'pathname'
    from = Pathname.new bindir
    to   = Pathname.new "#{rb_topdir}/bin"
    rel  = to.relative_path_from from
    <<-TEXT
@ECHO OFF
@"%~dp0#{rel}/ruby.exe" "%~dpn0" %*
    TEXT
  else
    # outside ruby folder, maybe -user-install or bundler.  Portable, but ruby
    # is dependent on PATH
    <<-TEXT
@ECHO OFF
@ruby.exe "%~dpn0" %*
    TEXT
  end
end

# File 'lib/rubygems/installer.rb', line 921

def write_build_info_file
  return if @build_args.empty?

  build_info_dir = File.join gem_home, 'build_info'

  dir_mode = options[:dir_mode]
  FileUtils.mkdir_p build_info_dir, :mode => dir_mode && 0755

  build_info_file = File.join build_info_dir, "#{spec.full_name}.info"

  File.open build_info_file, 'w' do |io|
    @build_args.each do |arg|
      io.puts arg
    end
  end

  File.chmod(dir_mode, build_info_dir) if dir_mode
end

# File 'lib/rubygems/installer.rb', line 943

def write_cache_file
  cache_file = File.join gem_home, 'cache', spec.file_name
  @package.copy_to cache_file
end

# File 'lib/rubygems/installer.rb', line 459

def write_default_spec
  File.open(default_spec_file, "w") do |file|
    file.puts spec.to_ruby
  end
end

# File 'lib/rubygems/installer.rb', line 445

def write_spec
  File.open spec_file, 'w' do |file|
    spec.installed_by_version = Gem.rubygems_version

    file.puts spec.to_ruby_for_cache

    file.fsync rescue nil # for filesystems without fsync(2)
  end
end