Module: Bundler::Plugin::API::Source (Ruby 2.7.5)
Description: Module : Bundler::Plugin::API::Source - Ruby 2.7.5

### Home Classes Methods

### In Files

- bundler/plugin/api/source.rb

### Methods

- ::new
- #==
- #app_cache_dirname
- #app_cache_path
- #bundler_plugin_api_source?
- #cache
- #cached!
- #can_lock?
- #double_check_for
- #eql?
- #fetch_gemspec_files
- #gem_install_dir
- #hash
- #include?
- #install
- #install_path
- #installed?
- #options_to_lock
- #post_install
- #remote!
- #root
- #specs
- #to_lock
- #to_s
- #unlock!
- #unmet_deps
- #uri_hash

### Class/Module Index

Quicksearch

- AmbiguousCommandError
- AmbiguousTaskError
- Bundler
- Bundler::APIResponseMismatchError
- Bundler::BuildMetadata
- Bundler::BundlerError
- Bundler::CLI
- Bundler::CLI::Add
- Bundler::CLI::Binstubs
- Bundler::CLI::Cache
- Bundler::CLI::Check
- Bundler::CLI::Clean
- Bundler::CLI::Common
- Bundler::CLI::Config
- Bundler::CLI::Config::Base
- Bundler::CLI::Console
- Bundler::CLI::Doctor
- Bundler::CLI::Exec
- Bundler::CLI::Gem
- Bundler::CLI::Info
- Bundler::CLI::Init
- Bundler::CLI::Inject
- Bundler::CLI::Install
- Bundler::CLI::Issue
- Bundler::CLI::List
- Bundler::CLI::Lock
- Bundler::CLI::Open
- Bundler::CLI::Outdated
- Bundler::CLI::Package
- Bundler::CLI::Platform
- Bundler::CLI::Plugin
- Bundler::CLI::Pristine
- Bundler::CLI::Remove
- Bundler::CLI::Show
- Bundler::CLI::Update
- Bundler::CLI::Viz
- Bundler::CompactIndexClient
- Bundler::CompactIndexClient::Cache
- Bundler::CompactIndexClient::Error
- Bundler::CompactIndexClient::Updater
- Bundler::CompactIndexClient::Updater::MisMatchedChecksumError
- Bundler::ConnectionPool
- Bundler::ConnectionPool::Error
- Bundler::ConnectionPool::PoolShuttingDownError
- Bundler::ConnectionPool::TimedStack
- Bundler::ConnectionPool::Wrapper
- Bundler::CurrentRuby
- Bundler::CyclicDependencyError
- Bundler::Definition
- Bundler::DepProxy
- Bundler::Dependency
- Bundler::Deployment
- Bundler::Deprecate
- Bundler::DeprecatedError
- Bundler::Dsl
- Bundler::Dsl::DSLError
- Bundler::EndpointSpecification
- Bundler::Env
- Bundler::EnvironmentPreserver
- Bundler::FeatureFlag
- Bundler::Fetcher
- Bundler::Fetcher::AuthenticationRequiredError
- Bundler::Fetcher::BadAuthenticationError
- Bundler::Fetcher::Base
- Bundler::Fetcher::CertificateFailureError
- Bundler::Fetcher::CompactIndex
- Bundler::Fetcher::Dependency
- Bundler::Fetcher::Downloader
- Bundler::Fetcher::FallbackError
- Bundler::Fetcher::Index
- Bundler::Fetcher::NetworkDownError
- Bundler::Fetcher::SSLError
- Bundler::Fetcher::TooManyRequestsError
- Bundler::FileUtils
- Bundler::FileUtils::DryRun
- Bundler::FileUtils::NoWrite
- Bundler::FileUtils::StreamUtils_
- Bundler::FileUtils::Verbose
- Bundler::FriendlyErrors
- Bundler::GemHelper
- Bundler::GemHelpers
- Bundler::GemHelpers::PlatformMatch
- Bundler::GemInstaller
- Bundler::GemNotFound
- Bundler::GemRemoteFetcher
- Bundler::GemRequireError
- Bundler::GemVersionPromoter
- Bundler::Gemdeps
- Bundler::GemfileError
- Bundler::GemfileEvalError
- Bundler::GemfileLockNotFound
- Bundler::GemfileNotFound
- Bundler::GemspecError
- Bundler::GenericSystemCallError
- Bundler::GitError
- Bundler::Graph
- Bundler::Graph::GraphVizClient
- Bundler::HTTPError
- Bundler::Index
- Bundler::Injector
- Bundler::InstallError
- Bundler::InstallHookError
- Bundler::Installer
- Bundler::InvalidOption
- Bundler::LazySpecification
- Bundler::LazySpecification::Identifier
- Bundler::LockfileError
- Bundler::LockfileGenerator
- Bundler::LockfileParser
- Bundler::MarshalError
- Bundler::MatchPlatform
- Bundler::MirrorSockets
- Bundler::Molinillo
- Bundler::Molinillo::CircularDependencyError
- Bundler::Molinillo::Compatibility
- Bundler::Molinillo::Delegates
- Bundler::Molinillo::Delegates::ResolutionState
- Bundler::Molinillo::Delegates::SpecificationProvider
- Bundler::Molinillo::DependencyGraph
- Bundler::Molinillo::DependencyGraph::Action
- Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular
- Bundler::Molinillo::DependencyGraph::DeleteEdge
- Bundler::Molinillo::DependencyGraph::DetachVertexNamed
- Bundler::Molinillo::DependencyGraph::Log
- Bundler::Molinillo::DependencyGraph::Tag
- Bundler::Molinillo::DependencyGraph::Vertex
- Bundler::Molinillo::DependencyState
- Bundler::Molinillo::NoSuchDependencyError
- Bundler::Molinillo::PossibilityState
- Bundler::Molinillo::ResolutionState
- Bundler::Molinillo::Resolver
- Bundler::Molinillo::Resolver::Resolution
- Bundler::Molinillo::Resolver::Resolution::Conflict
- Bundler::Molinillo::Resolver::Resolution::PossibilitySet
- Bundler::Molinillo::Resolver::Resolution::UnwindDetails
- Bundler::Molinillo::ResolverError
- Bundler::Molinillo::SpecificationProvider
- Bundler::Molinillo::UI
- Bundler::Molinillo::VersionConflict
- Bundler::NoSpaceOnDeviceError
- Bundler::OperationNotSupportedError
- Bundler::ParallelInstaller
- Bundler::ParallelInstaller::SpecInstallation
- Bundler::PathError
- Bundler::PermissionError
- Bundler::Persistent
- Bundler::Persistent::Net
- Bundler::Persistent::Net::HTTP
- Bundler::Persistent::Net::HTTP::Persistent
- Bundler::Persistent::Net::HTTP::Persistent::Error
- Bundler::PersistentHTTP
- Bundler::Plugin
- Bundler::Plugin::API
- Bundler::Plugin::API::Source
- Bundler::Plugin::DSL
- Bundler::Plugin::DSL::PluginGemfileError
- Bundler::Plugin::Events
- Bundler::Plugin::Index
- Bundler::Plugin::Index::CommandConflict
- Bundler::Plugin::Index::SourceConflict
- Bundler::Plugin::Installer
- Bundler::Plugin::Installer::Git
- Bundler::Plugin::Installer::Rubygems
- Bundler::Plugin::MalformattedPlugin
- Bundler::Plugin::SourceList
- Bundler::Plugin::UndefinedCommandError
- Bundler::Plugin::UnknownSourceError
- Bundler::PluginError
- Bundler::ProcessLock
- Bundler::ProductionError
- Bundler::RemoteSpecification
- Bundler::Resolver
- Bundler::Resolver::SpecGroup
- Bundler::Retry
- Bundler::RubyDsl
- Bundler::RubyGemsGemInstaller
- Bundler::RubyVersion
- Bundler::RubyVersionMismatch
- Bundler::RubygemsIntegration
- Bundler::RubygemsIntegration::Gem
- Bundler::Runtime
- Bundler::SecurityError
- Bundler::Settings
- Bundler::Settings::Mirror
- Bundler::Settings::MirrorConfig
- Bundler::Settings::Mirrors
- Bundler::Settings::TCPSocketProbe
- Bundler::Settings::Validator
- Bundler::Settings::Validator::Rule
- Bundler::SharedHelpers
- Bundler::SimilarityDetector
- Bundler::SocketAddress
- Bundler::Source
- Bundler::Source::Gemspec
- Bundler::Source::Git
- Bundler::Source::Git::GitCommandError
- Bundler::Source::Git::GitNotAllowedError
- Bundler::Source::Git::GitNotInstalledError
- Bundler::Source::Git::GitProxy
- Bundler::Source::Git::MissingGitRevisionError
- Bundler::Source::Metadata
- Bundler::Source::Path
- Bundler::Source::Path::Installer
- Bundler::Source::Rubygems
- Bundler::Source::Rubygems::Remote
- Bundler::SourceList
- Bundler::SpecSet
- Bundler::Standalone
- Bundler::StubSpecification
- Bundler::SudoNotPermittedError
- Bundler::TemporaryResourceError
- Bundler::Thor::Actions
- Bundler::Thor::Actions::CapturableERB
- Bundler::Thor::Actions::ClassMethods
- Bundler::Thor::Base
- Bundler::Thor::Base::ClassMethods
- Bundler::Thor::Command
- Bundler::Thor::CoreExt
- Bundler::Thor::CoreExt::OrderedHash
- Bundler::Thor::DynamicCommand
- Bundler::Thor::DynamicTask
- Bundler::Thor::Group
- Bundler::Thor::HiddenCommand
- Bundler::Thor::HiddenTask
- Bundler::Thor::Invocation
- Bundler::Thor::Invocation::ClassMethods
- Bundler::Thor::LineEditor
- Bundler::Thor::LineEditor::Basic
- Bundler::Thor::LineEditor::Readline
- Bundler::Thor::LineEditor::Readline::PathCompletion
- Bundler::Thor::NestedContext
- Bundler::Thor::RakeCompat
- Bundler::Thor::Shell
- Bundler::Thor::Shell::Basic
- Bundler::Thor::Shell::Color
- Bundler::Thor::Shell::HTML
- Bundler::Thor::Task
- Bundler::Thor::Util
- Bundler::ThreadCreationError
- Bundler::UI
- Bundler::UI::RGProxy
- Bundler::UI::Shell
- Bundler::UI::Silent
- Bundler::URI
- Bundler::URI::BadURIError
- Bundler::URI::Error
- Bundler::URI::Escape
- Bundler::URI::FTP
- Bundler::URI::File
- Bundler::URI::Generic
- Bundler::URI::HTTP
- Bundler::URI::HTTPS
- Bundler::URI::InvalidComponentError
- Bundler::URI::InvalidURIError
- Bundler::URI::LDAP
- Bundler::URI::LDAPS
- Bundler::URI::MailTo
- Bundler::URI::Parser
- Bundler::URI::REGEXP
- Bundler::URI::RFC2396_Parser
- Bundler::URI::RFC2396_REGEXP
- Bundler::URI::RFC2396_REGEXP::PATTERN
- Bundler::URICredentialsFilter
- Bundler::VersionConflict
- Bundler::VersionRanges
- Bundler::VersionRanges::ReqR
- Bundler::VirtualProtocolError
- Bundler::Worker
- Bundler::Worker::WrappedException
- Bundler::YAMLSerializer
- Bundler::YamlSyntaxError
- Error
- Gem
- Gem::Dependency
- Gem::Platform
- Gem::Specification
- InvocationError
- Kernel
- MalformattedArgumentError
- Object
- RequiredArgumentMissingError
- UndefinedCommandError
- UndefinedCommandError::SpellChecker
- UndefinedTaskError
- UnknownArgumentError
- UnknownArgumentError::SpellChecker

No matching classes.

# Bundler::Plugin::API::Source

This class provides the base to build source plugins All the method here are required to build a source plugin (except `uri_hash`, `gem_install_dir`; they are helpers).

Defaults for methods, where ever possible are provided which is expected to work. But, all source plugins have to override `fetch_gemspec_files` and `install`. Defaults are also not provided for `remote!`, `cache!` and `unlock!`.

The defaults shall work for most situations but nevertheless they can be (preferably should be) overridden as per the plugins' needs safely (as long as they behave as expected). On overriding `initialize` you should call super first.

If required plugin should override `hash`, `==` and `eql?` methods to be able to match objects representing same sources, but may be created in different situation (like form gemfile and lockfile). The default ones checks only for class and uri, but elaborate source plugins may need more comparisons (e.g. git checking on branch or tag).

@!attribute [r] uri

    @return [String] the remote specified with `source` block in Gemfile

@!attribute [r] options

    @return [String] options passed during initialization (either from
      lockfile or Gemfile)

@!attribute [r] name

    @return [String] name that can be used to uniquely identify a source

@!attribute [rw] `dependency_names`

    @return [Array<String>] Names of dependencies that the source should
      try to resolve. It is not necessary to use this list internally. This
      is present to be compatible with `Definition` and is used by
      rubygems source.

### Attributes

dependency_names[RW]
name[R]
options[R]
uri[R]

### Public Class Methods

new(opts) click to toggle source

                   # File bundler/plugin/api/source.rb, line 45
    def initialize(opts)
      @options = opts
      @dependency_names = []
      @uri = opts["uri"]
      @type = opts["type"]
      @name = opts["name"] || "#{@type} at #{@uri}"
    end

### Public Instance Methods

==(other) click to toggle source

This shall check if two source object represent the same source.

The comparison shall take place only on the attribute that can be inferred from the options passed from Gemfile and not on attributes that are used to pin down the gem to specific version (e.g. Git sources should compare on branch and tag but not on commit hash)

The sources objects are constructed from Gemfile as well as from lockfile. To converge the sources, it is necessary that they match.

The same applies for `eql?` and `hash`

                   # File bundler/plugin/api/source.rb, line 205
    def ==(other)
      other.is_a?(self.class) && uri == other.uri
    end

Also aliased as: eql?
app_cache_dirname() click to toggle source

Name of directory where plugin the is expected to cache the gems when `cache` is called.

Also this name is matched against the directories in cache for pruning

This is used by `app_cache_path`

                   # File bundler/plugin/api/source.rb, line 170
    def app_cache_dirname
      base_name = File.basename(Bundler::URI.parse(uri).normalize.path)
      "#{base_name}-#{uri_hash}"
    end

app_cache_path(custom_path = nil) click to toggle source

The full path where the plugin should cache the gem so that it can be installed latter.

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 229
    def app_cache_path(custom_path = nil)
      @app_cache_path ||= Bundler.app_cache(custom_path).join(app_cache_dirname)
    end

bundler_plugin_api_source?() click to toggle source

@private Returns true

                   # File bundler/plugin/api/source.rb, line 291
    def bundler_plugin_api_source?
      true
    end

cache(spec, custom_path = nil) click to toggle source

This method is called while caching to save copy of the gems that the source can resolve to path provided by `app_cache_app`so that they can be reinstalled from the cache without querying the remote (i.e. an alternative to remote)

This is stored with the app and source plugins should try to provide specs and install only from this cache when `cached!` is called.

This cache is different from the internal caching that can be done at sub paths of `cache_path` (from `API`). This can be though as caching by bundler.

                   # File bundler/plugin/api/source.rb, line 186
    def cache(spec, custom_path = nil)
      new_cache_path = app_cache_path(custom_path)

      FileUtils.rm_rf(new_cache_path)
      FileUtils.cp_r(install_path, new_cache_path)
      FileUtils.touch(app_cache_path.join(".bundlecache"))
    end

cached!() click to toggle source

Set internal representation to fetch the gems/specs from app cache.

When this is called, the source should try to fetch the specs and install from the path provided by `app_cache_path`.

                   # File bundler/plugin/api/source.rb, line 154
    def cached!
    end

can_lock?(spec) click to toggle source

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 241
    def can_lock?(spec)
      spec.source == self
    end

double_check_for(*) click to toggle source

@private This `API` on source might not be stable, and for now we expect plugins to download all specs in `#specs`, so we implement the method for compatibility purposes and leave it undocumented (and don't support) overriding it)

                   # File bundler/plugin/api/source.rb, line 300
    def double_check_for(*); end

eql?(other) click to toggle source

When overriding `eql?` please preserve the behaviour as mentioned in docstring for `==` method.

Alias for: ==
fetch_gemspec_files() click to toggle source

This is used by the default `spec` method to constructs the Specification objects for the gems and versions that can be installed by this source plugin.

Note: If the spec method is overridden, this function is not necessary

@return [Array<String>] paths of the gemspec files for gems that can

    be installed

                   # File bundler/plugin/api/source.rb, line 61
    def fetch_gemspec_files
      []
    end

gem_install_dir() click to toggle source

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 276
    def gem_install_dir
      Bundler.install_path
    end

hash() click to toggle source

When overriding `hash` please preserve the behaviour as mentioned in docstring for `==` method, i.e. two methods equal by above comparison should have same hash.

                   # File bundler/plugin/api/source.rb, line 216
    def hash
      [self.class, uri].hash
    end

include?(other) click to toggle source

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 267
    def include?(other)
      other == self
    end

install(spec, opts) click to toggle source

Install the gem specified by the spec at appropriate path. `install_path` provides a sufficient default, if the source can only satisfy one gem, but is not binding.

@return [String] post installation message (if any)

                   # File bundler/plugin/api/source.rb, line 81
    def install(spec, opts)
      raise MalformattedPlugin, "Source plugins need to override the install method."
    end

install_path() click to toggle source

A default installation path to install a single gem. If the source servers multiple gems, it's not of much use and the source should one of its own.

                   # File bundler/plugin/api/source.rb, line 106
    def install_path
      @install_path ||=
        begin
          base_name = File.basename(Bundler::URI.parse(uri).normalize.path)

          gem_install_dir.join("#{base_name}-#{uri_hash[0..11]}")
        end
    end

installed?() click to toggle source

A helper method, not necessary if not used internally.

                   # File bundler/plugin/api/source.rb, line 221
    def installed?
      File.directory?(install_path)
    end

options_to_lock() click to toggle source

Options to be saved in the lockfile so that the source plugin is able to check out same version of gem later.

There options are passed when the source plugin is created from the lock file.

@return [Hash]

                   # File bundler/plugin/api/source.rb, line 72
    def options_to_lock
      {}
    end

post_install(spec, disable_exts = false) click to toggle source

It builds extensions, generates bins and installs them for the spec provided.

It depends on `spec.loaded_from` to get full_gem_path. The source plugins should set that.

It should be called in `install` after the plugin is done placing the gem at correct install location.

It also runs `Gem` hooks `pre_install`, `post_build` and `post_install`

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 97
    def post_install(spec, disable_exts = false)
      opts = { :env_shebang => false, :disable_extensions => disable_exts }
      installer = Bundler::Source::Path::Installer.new(spec, opts)
      installer.post_install
    end

remote!() click to toggle source

Set internal representation to fetch the gems/specs from remote.

When this is called, the source should try to fetch the specs and install from remote path.

                   # File bundler/plugin/api/source.rb, line 147
    def remote!
    end

root() click to toggle source

It is used to obtain the full_gem_path.

spec's loaded_from path is expanded against this to get full_gem_path

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 285
    def root
      Bundler.root
    end

specs() click to toggle source

Parses the gemspec files to find the specs for the gems that can be satisfied by the source.

Few important points to keep in mind:

    - If the gems are not installed then it shall return specs for all
    the gems it can satisfy
    - If gem is installed (that is to be detected by the plugin itself)
    then it shall return at least the specs that are installed.
    - The `loaded_from` for each of the specs shall be correct (it is
    used to find the load path)

@return [Bundler::Index] index containing the specs

                   # File bundler/plugin/api/source.rb, line 127
    def specs
      files = fetch_gemspec_files

      Bundler::Index.build do |index|
        files.each do |file|
          next unless spec = Bundler.load_gemspec(file)
          Bundler.rubygems.set_installed_by_version(spec)

          spec.source = self
          Bundler.rubygems.validate(spec)

          index << spec
        end
      end
    end

to_lock() click to toggle source

Generates the content to be entered into the lockfile. Saves type and remote and also calls to `options_to_lock`.

`Plugin` should use `options_to_lock` to save information in lockfile and not override this.

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 252
    def to_lock
      out = String.new("#{LockfileParser::PLUGIN}\n")
      out << "  remote: #{@uri}\n"
      out << "  type: #{@type}\n"
      options_to_lock.each do |opt, value|
        out << "  #{opt}: #{value}\n"
      end
      out << "  specs:\n"
    end

to_s() click to toggle source

                   # File bundler/plugin/api/source.rb, line 262
    def to_s
      "plugin source for #{options[:type]} with uri #{uri}"
    end

unlock!() click to toggle source

This is called to update the spec and installation.

If the source plugin is loaded from lockfile or otherwise, it shall refresh the cache/specs (e.g. git sources can make a fresh clone).

                   # File bundler/plugin/api/source.rb, line 161
    def unlock!
    end

unmet_deps() click to toggle source

Used by definition.

Note: Do not override if you don't know what you are doing.

                   # File bundler/plugin/api/source.rb, line 236
    def unmet_deps
      specs.unmet_dependency_names
    end

uri_hash() click to toggle source

                   # File bundler/plugin/api/source.rb, line 271
    def uri_hash
      SharedHelpers.digest(:SHA1).hexdigest(uri)
    end