class Bundler::Plugin::Installer

def check_sources_consistency!(options)

def check_sources_consistency!(options)
  if options.key?(:git) && options.key?(:local_git)
    raise InvalidOption, "Remote and local plugin git sources can't be both specified"
  end
  # back-compat; local_git is an alias for git
  if options.key?(:local_git)
    Bundler::SharedHelpers.major_deprecation(2, "--local_git is deprecated, use --git")
    options[:git] = options.delete(:local_git)
  end
  if (options.keys & [:source, :git, :path]).length > 1
    raise InvalidOption, "Only one of --source, --git, or --path may be specified"
  end
  if (options.key?(:branch) || options.key?(:ref)) && !options.key?(:git)
    raise InvalidOption, "--#{options.key?(:branch) ? "branch" : "ref"} can only be used with git sources"
  end
  if options.key?(:branch) && options.key?(:ref)
    raise InvalidOption, "--branch and --ref can't be both specified"
  end
end

def install(names, options)

def install(names, options)
  check_sources_consistency!(options)
  version = options[:version] || [">= 0"]
  if options[:git]
    install_git(names, version, options)
  elsif options[:path]
    install_path(names, version, options[:path])
  else
    sources = options[:source] || Gem.sources
    install_rubygems(names, version, sources)
  end
end

def install_all_sources(names, version, source_list, source = nil)

def install_all_sources(names, version, source_list, source = nil)
  deps = names.map {|name| Dependency.new(name, version, { "source" => source }) }
  Bundler.configure_gem_home_and_path(Plugin.root)
  Bundler.settings.temporary(deployment: false, frozen: false) do
    definition = Definition.new(nil, deps, source_list, true)
    install_definition(definition)
  end
end

def install_definition(definition)

Returns:
  • (Hash) - map of names to their specs they are installed with

Parameters:
  • definition (Definition) -- object
def install_definition(definition)
  def definition.lock(*); end
  definition.resolve_remotely!
  specs = definition.specs
  install_from_specs specs
end

def install_from_specs(specs)

Returns:
  • (Hash) - map of names to the specs

Parameters:
  • specs () -- to install
def install_from_specs(specs)
  paths = {}
  specs.each do |spec|
    spec.source.install spec
    paths[spec.name] = spec
  end
  paths
end

def install_git(names, version, options)

def install_git(names, version, options)
  source_list = SourceList.new
  source = source_list.add_git_source({ "uri" => options[:git],
                                        "branch" => options[:branch],
                                        "ref" => options[:ref] })
  install_all_sources(names, version, source_list, source)
end

def install_path(names, version, path)

def install_path(names, version, path)
  source_list = SourceList.new
  source = source_list.add_path_source({ "path" => path, "root_path" => SharedHelpers.pwd })
  install_all_sources(names, version, source_list, source)
end

def install_rubygems(names, version, sources)

Returns:
  • (Hash) - map of names to the specs of plugins installed

Parameters:
  • source(s) (String, Array) -- to resolve the gem
  • version (Array) -- of the gem to install
  • name (String) -- of the plugin gem to search in the source
def install_rubygems(names, version, sources)
  source_list = SourceList.new
  Array(sources).each {|remote| source_list.add_global_rubygems_remote(remote) }
  install_all_sources(names, version, source_list)
end