Module: Bundler::Plugin

# File 'lib/bundler/plugin.rb', line 247

def add_hook(event, &block)
  unless Events.defined_event?(event)
    raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
  end
  @hooks_by_event[event.to_s] << block
end

# File 'lib/bundler/plugin.rb', line 205

def add_source(source, cls)
  @sources[source] = cls
end

# File 'lib/bundler/plugin.rb', line 180

def cache
  @cache ||= root.join("cache")
end

# File 'lib/bundler/plugin.rb', line 190

def command?(command)
  !index.command_plugin(command).nil?
end

# File 'lib/bundler/plugin.rb', line 196

def exec_command(command, args)
  raise UndefinedCommandError, "Command `#{command}` not found" unless command? command

  load_plugin index.command_plugin(command) unless @commands.key? command

  @commands[command].new.exec(command, args)
end

# File 'lib/bundler/plugin.rb', line 231

def from_lock(locked_opts)
  opts = locked_opts.merge("uri" => locked_opts["remote"])
  # when reading the lockfile while doing the plugin-install-from-gemfile phase,
  # we need to ignore any plugin sources
  return UnloadedSource.new(opts) if @gemfile_parse
  # use an inert placeholder when the plugin handling this source is not
  # installed, so that the lockfile can still be parsed
  return UnloadedSource.new(opts) unless source?(locked_opts["type"])

  src = source(locked_opts["type"])

  src.new(opts)
end

# File 'lib/bundler/plugin.rb', line 113

def gemfile_install(gemfile = nil, lockfile = nil, unlock = {}, &inline)
  @gemfile_parse = true
  Bundler.configure
  builder = DSL.new
  if block_given?
    builder.instance_eval(&inline)
  else
    builder.eval_gemfile(gemfile)
  end
  builder.check_primary_source_safety

  plugins = builder.dependencies.map(&:name)
  return if plugins.empty?

  # skip the update if unlocking specific gems, but none of them are plugins
  # declared in the Gemfile
  if unlock.is_a?(Hash) && unlock[:gems] && !unlock[:gems].empty? &&
     (unlock[:gems] & plugins).empty?
    unlock = {}
  end

  # resolve remotely when unlocking, so that plugins can be updated.
  # Definition#initialize consumes the unlock hash, so this must be decided
  # before building the definition.
  updating = unlock == true || (unlock.is_a?(Hash) && !unlock.empty?)

  definition = builder.to_definition(lockfile, unlock)

  installed_specs = Installer.new.install_definition(definition, updating)

  save_plugins installed_specs.slice(*plugins), builder.inferred_plugins
rescue RuntimeError => e
  unless e.is_a?(GemfileError)
    Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
  end
  raise
ensure
  @gemfile_parse = false
end

# File 'lib/bundler/plugin.rb', line 175

def global_root
  Bundler.user_bundle_path("plugin")
end

# File 'lib/bundler/plugin.rb', line 260

def hook(event, *args, &arg_blk)
  return unless Bundler.settings[:plugins]
  unless Events.defined_event?(event)
    raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
  end

  plugins = index.hook_plugins(event)
  return unless plugins.any?

  plugins.each {|name| load_plugin(name) }

  @hooks_by_event[event].each {|blk| blk.call(*args, &arg_blk) }
end

# File 'lib/bundler/plugin.rb', line 154

def index
  @index ||= Index.new
end

# File 'lib/bundler/plugin.rb', line 48

def install(names, options)
  raise InvalidOption, "You cannot specify `--branch` and `--ref` at the same time." if options["branch"] && options["ref"]

  specs = Installer.new.install(names, options)

  save_plugins specs.slice(*names)
rescue PluginError
  specs_to_delete = specs.select {|k, _v| names.include?(k) && !index.commands.values.include?(k) }
  specs_to_delete.each_value {|spec| Bundler.rm_rf(spec.full_gem_path) }

  raise
end

# File 'lib/bundler/plugin.rb', line 277

def installed?(plugin)
  (path = index.installed?(plugin)) &&
    index.plugin_path(plugin).join(PLUGIN_FILE_NAME).file? &&
    path
end

# File 'lib/bundler/plugin.rb', line 90

def list
  installed_plugins = index.installed_plugins
  if installed_plugins.any?
    output = String.new
    installed_plugins.each do |plugin|
      output << "#{plugin}\n"
      output << "-----\n"
      index.plugin_commands(plugin).each do |command|
        output << "  #{command}\n"
      end
      output << "\n"
    end
  else
    output = "No plugins installed"
  end
  Bundler.ui.info output
end

# File 'lib/bundler/plugin.rb', line 373

def load_plugin(name)
  return unless name && !name.empty?
  return if loaded?(name)

  # Need to ensure before this that plugin root where the rest of gems
  # are installed to be on load path to support plugin deps. Currently not
  # done to avoid conflicts
  path = index.plugin_path(name)

  paths = index.load_paths(name)
  invalid_paths = paths.reject {|p| File.directory?(p) }

  if invalid_paths.any?
    Bundler.ui.warn <<~MESSAGE
      The following plugin paths don't exist: #{invalid_paths.join(", ")}.

      This can happen if the plugin was installed with a different version of Ruby that has since been uninstalled.

      If you would like to reinstall the plugin, run:

      bundler plugin uninstall #{name} && bundler plugin install #{name}

      Continuing without installing plugin #{name}.
    MESSAGE

    return
  end

  Gem.add_to_load_path(*paths)

  load path.join(PLUGIN_FILE_NAME)

  @loaded_plugin_names << name
rescue RuntimeError => e
  Bundler.ui.error "Failed loading plugin #{name}: #{e.message}"
  raise
end

# File 'lib/bundler/plugin.rb', line 284

def loaded?(plugin)
  @loaded_plugin_names.include?(plugin)
end

# File 'lib/bundler/plugin.rb', line 170

def local_root
  Bundler.app_config_path.join("plugin")
end

# File 'lib/bundler/plugin.rb', line 337

def register_plugin(name, spec, optional_plugin = false)
  commands = @commands
  sources = @sources
  hooks = @hooks_by_event

  @commands = {}
  @sources = {}
  @hooks_by_event = Hash.new {|h, k| h[k] = [] }

  load_paths = spec.load_paths
  Gem.add_to_load_path(*load_paths)
  path = Pathname.new spec.full_gem_path

  begin
    load path.join(PLUGIN_FILE_NAME), true
  rescue StandardError => e
    raise MalformattedPlugin, "#{e.class}: #{e.message}"
  end

  if optional_plugin && @sources.keys.any? {|s| source_plugin(s) }
    Bundler.rm_rf(path)
    false
  else
    index.register_plugin(name, path.to_s, load_paths, @commands.keys,
      @sources.keys, @hooks_by_event.keys)
    true
  end
ensure
  @commands = commands
  @sources = sources
  @hooks_by_event = hooks
end

# File 'lib/bundler/plugin.rb', line 31

def reset!
  instance_variables.each {|i| remove_instance_variable(i) }

  @sources = {}
  @commands = {}
  @hooks_by_event = Hash.new {|h, k| h[k] = [] }
  @loaded_plugin_names = []
  @index = nil
end

# File 'lib/bundler/plugin.rb', line 162

def root
  @root ||= if SharedHelpers.in_bundle?
    local_root
  else
    global_root
  end
end

# File 'lib/bundler/plugin.rb', line 318

def save_plugin(name, spec, optional_plugin = false)
  return if index.up_to_date?(spec)

  validate_plugin! Pathname.new(spec.full_gem_path)
  installed = register_plugin(name, spec, optional_plugin)
  Bundler.ui.info "Installed plugin #{name}" if installed
rescue PluginError => e
  raise PluginInstallError, "Failed to install plugin `#{spec.name}`, due to #{e.class} (#{e.message})"
end

# File 'lib/bundler/plugin.rb', line 293

def save_plugins(specs, optional_plugins = [])
  specs.each do |name, spec|
    save_plugin(name, spec, optional_plugins.include?(name))
  end
end

# File 'lib/bundler/plugin.rb', line 220

def source(name)
  raise UnknownSourceError, "Source #{name} not found" unless source_plugin(name)

  load_plugin(index.source_plugin(name)) unless @sources.key? name

  @sources[name]
end

# File 'lib/bundler/plugin.rb', line 210

def source?(name)
  !!source_plugin(name)
end

# File 'lib/bundler/plugin.rb', line 215

def source_plugin(name)
  index.source_plugin(name.to_s)
end

# File 'lib/bundler/plugin.rb', line 64

def uninstall(names, options)
  if names.empty? && !options[:all]
    Bundler.ui.error "No plugins to uninstall. Specify at least 1 plugin to uninstall.\n"\
      "Use --all option to uninstall all the installed plugins."
    return
  end

  names = index.installed_plugins if options[:all]
  if names.any?
    names.each do |name|
      if index.installed?(name)
        path = index.plugin_path(name).to_s
        Bundler.rm_rf(path) if index.installed_in_plugin_root?(name)
        index.unregister_plugin(name)
        Bundler.ui.info "Uninstalled plugin #{name}"
      else
        Bundler.ui.error "Plugin #{name} is not installed \n"
      end
    end
  else
    Bundler.ui.info "No plugins installed"
  end
end

# File 'lib/bundler/plugin.rb', line 305

def validate_plugin!(plugin_path)
  plugin_file = plugin_path.join(PLUGIN_FILE_NAME)
  raise MalformattedPlugin, "#{PLUGIN_FILE_NAME} was not found in the plugin." unless plugin_file.file?
end