# frozen_string_literal: true

module Bundler

class Source

class Gemspec < Path

# frozen_string_literal: true

require "uri"

module Bundler

class Source

@allow_remote = false

# Stringify options that could be set as symbols

@uri = options["uri"] || ""

@branch = options["branch"]

out = String.new("GIT\n")

out << " remote: #{@uri}\n"

out << " revision: #{revision}\n"

out << " #{opt}: #{options[opt]}\n" if options[opt]

end

out << " glob: #{@glob}\n" unless @glob == DEFAULT_GLOB

def install(spec, options = {})

force = options[:force]

Bundler.ui.debug " * Checking out revision: #{ref}"

git_proxy.copy_to(install_path, submodules)

serialize_gemspecs_in(install_path)

@copied = true

end

generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }

def cache(spec, custom_path = nil)

app_cache_path = app_cache_path(custom_path)

return if path == app_cache_path

cached!

FileUtils.rm_rf(app_cache_path)

# When using local git repos, this is set to the local repo.

def cache_path

@cache_path ||= begin

else

end

end

# If there is no URI scheme, assume it is an ssh/git URI

input = uri

end

end

def cached_revision

def fetch

git_proxy.checkout

raise unless Bundler.feature_flag.allow_offline_install?

end

# no-op, since we validate when re-serializing the gemspec

StubSpecification.from_stub(stub)

end

end

end

end

end

# frozen_string_literal: true

require "shellwords"

require "tempfile"

module Bundler

begin

@revision ||= find_local_revision

rescue GitCommandError

end

@revision

end

def checkout

SharedHelpers.filesystem_access(path.dirname) do |p|

FileUtils.mkdir_p(p)

end

git_retry %(clone #{uri_escaped_with_configured_credentials} "#{path}" --bare --no-hardlinks --quiet)

end

end

end

def git_retry(command)

git(command)

end

end

def in_path(&blk)

checkout unless path.exist?

SharedHelpers.chdir(path, &blk)

end

# frozen_string_literal: true

module Bundler

class Source

class Path < Source

end

def remote!

@allow_remote = true

end

def cached!

@allow_cached = true

end

end

def install(spec, options = {})

generate_bin(spec, :disable_extensions => true)

nil # no post-install message

end

def cache(spec, custom_path = nil)

app_cache_path = app_cache_path(custom_path)

return if expand(@original_path).to_s.index(root_path.to_s + "/") == 0

unless @original_path.exist?

Bundler.root

end

def expanded_original_path

@expanded_original_path ||= expand(original_path)

end

spec,

:env_shebang => false,

:disable_extensions => options[:disable_extensions],

)

installer.post_install

rescue Gem::InvalidSpecificationException => e

"to modify their .gemspec so it can work with `gem build`."

end

end

end

end

# frozen_string_literal: true

module Bundler

class Source

class Path

attr_reader :spec

def initialize(spec, options = {})

@spec = spec

@gem_dir = Bundler.rubygems.path(spec.full_gem_path)

@wrappers = true

# frozen_string_literal: true

require "uri"

require "rubygems/user_interaction"

end

def cached!

@allow_cached = true

end

end

def can_lock?(spec)

spec.source.is_a?(Rubygems)

end

end

def to_s

end

alias_method :name, :to_s

end

end

return nil # no post-install message

end

:wrappers => true,

:env_shebang => true,

:build_args => opts[:build_args],

).install

end

spec.full_gem_path = installed_spec.full_gem_path

@remotes.unshift(uri) unless @remotes.include?(uri)

end

return false if other_remotes == @remotes

@remotes = []

other_remotes.reverse_each do |r|

add_remote r.to_s

end

end

def unmet_deps

end

end

protected

def credless_remotes

end

def suppress_configured_credentials(remote)

if remote.userinfo && remote.userinfo == Bundler.settings[remote_nouser]

remote_nouser

else

end

end

def installed_specs

Bundler.rubygems.all_specs.reverse_each do |spec|

spec.source = self

if Bundler.rubygems.spec_missing_extensions?(spec, false)

Bundler.ui.debug "Source #{self} is ignoring #{spec} because it is missing extensions"

end

idx << spec

end

end

end

end

idx << s

end

end

def api_fetchers

index_fetchers = fetchers - api_fetchers

# gather lists from non-api sites

# because ensuring we have all the gems we need involves downloading

# the gemspecs of those gems, if the non-api sites contain more than

allow_api = idx.size < API_REQUEST_LIMIT && dependency_names.size < API_REQUEST_LIMIT

Bundler.ui.debug "Need to query more than #{API_REQUEST_LIMIT} gems." \

" Downloading full index instead..." unless allow_api

end

end

end

def fetch_gem(spec)

return false unless spec.remote

spec.fetch_platform

download_path = requires_sudo? ? Bundler.tmp(spec.full_name) : rubygems_dir

gem_path = "#{rubygems_dir}/cache/#{spec.full_name}.gem"

SharedHelpers.filesystem_access("#{download_path}/cache") do |p|

FileUtils.mkdir_p(p)

end

if requires_sudo?

SharedHelpers.filesystem_access("#{rubygems_dir}/cache") do |p|

def cache_path

Bundler.app_cache

end

end

end

end

# frozen_string_literal: true

module Bundler

class Source

class Rubygems

#

def cache_slug

@cache_slug ||= begin

cache_uri = original_uri || uri

uri_parts = [cache_uri.host, cache_uri.user, cache_uri.port, cache_uri.path]

uri_parts[-1] = uri_digest

uri_parts.compact.join(".")