if s.respond_to?(:metadata=)

s.metadata = {

"homepage_uri" => "https://bundler.io/",

}

end

s.required_ruby_version = ">= 2.3.0"

s.required_rubygems_version = ">= 2.5.2"

s.executables = %w[bundle bundler]

s.require_paths = ["lib"]

end

desc "list", "List all gems in the bundle"

method_option "name-only", :type => :boolean, :banner => "print only the gem names"

method_option "paths", :type => :boolean, :banner => "print the path to each gem in the bundle"

def list

require_relative "cli/list"

method_option :ext, :type => :boolean, :default => false, :desc => "Generate the boilerplate for C extension code"

method_option :git, :type => :boolean, :default => true, :desc => "Initialize a git repo inside your library."

method_option :mit, :type => :boolean, :desc => "Generate an MIT license file. Set a default with `bundle config set gem.mit true`."

method_option :test, :type => :string, :lazy_default => "rspec", :aliases => "-t", :banner => "rspec",

def gem(name)

end

option = current_command.options[name]

flag_name = option.switch_name

return unless name_index

value = options[name]

Bundler::SharedHelpers.major_deprecation 2, "bundle console will be replaced " \

"by `bin/console` generated by `bundle gem <name>`"

ARGV.clear

console = get_console(Bundler.settings[:console] || "irb")

TEST_FRAMEWORK_VERSIONS = {

"rspec" => "3.0",

"minitest" => "5.0",

}.freeze

attr_reader :options, :gem_name, :thor, :name, :target

ensure_safe_gem_name(name, constant_array)

templates = {

"lib/newgem.rb.tt" => "lib/#{namespaced_path}.rb",

"lib/newgem/version.rb.tt" => "lib/#{namespaced_path}/version.rb",

"newgem.gemspec.tt" => "#{name}.gemspec",

"spec/spec_helper.rb.tt" => "spec/spec_helper.rb",

"spec/newgem_spec.rb.tt" => "spec/#{namespaced_path}_spec.rb"

)

when "minitest"

templates.merge!(

)

end

end

if ask_and_set(:mit, "Do you want to license your code permissively under the MIT license?",

"This means that any other developer or company will be legally allowed to use your code " \

"for free as long as they admit you created it. You can read more about the MIT license " \

templates.merge!("CODE_OF_CONDUCT.md.tt" => "CODE_OF_CONDUCT.md")

end

templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]

if options[:ext]

if test_framework.nil?

Bundler.ui.confirm "Do you want to generate tests with your gem?"

test_framework = result

else

test_framework = false

end

def print_gem_info(spec)

gem_info = String.new

gem_info << " * #{spec.name} (#{spec.version}#{spec.git_version})\n"

gem_info << "\tSummary: #{spec.summary}\n" if spec.summary

gem_info << "\tHomepage: #{spec.homepage}\n" if spec.homepage

gem_info << "\tPath: #{spec.full_gem_path}\n"

gem_info << "\tDefault Gem: yes" if spec.respond_to?(:default_gem?) && spec.default_gem?

Bundler.ui.info gem_info

private

def gemfile

end

end

end

be sure to check out these resources:

1. Check out our troubleshooting guide for quick fixes to common issues:

2. Instructions for common Bundler uses can be found on the documentation

site: https://bundler.io/

still aren't working the way you expect them to, please let us know so

that we can diagnose and help fix the problem you're having. Please

view the Filing Issues guide for more information:

EOS

class CLI::List

def initialize(options)

@options = options

end

def run

raise InvalidOption, "The `--name-only` and `--paths` options cannot be used together" if @options["name-only"] && @options[:paths]

filtered_specs_by_groups

else

Bundler.load.specs

private

def verify_group_exists(groups)

end

def filtered_specs_by_groups

verify_group_exists(groups)

show_groups =

else

groups

end.map(&:to_sym)

module Bundler

class CLI::Outdated

attr_reader :options, :gems, :options_include_groups, :filter_options_, :sources, :strict

def initialize(options, gems)

@options = options

@gems = gems

@sources = Array(options[:source])

@options_include_groups = [:group, :groups].any? do |v|

options.keys.include?(v.to_s)

# the level options imply strict is also true. It wouldn't make

# sense otherwise.

end

def run

end

specs.sort_by(&:name).each do |current_spec|

active_spec = retrieve_active_spec(definition, current_spec)

gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)

next unless gem_outdated || (current_spec.git_version != active_spec.git_version)

if dependency && !options[:parseable]

groups = dependency.groups.join(", ")

end

end

unless options[:parseable]

end

if options_include_groups

end

end

else

end

exit 1

"#{group_text}#{groups.split(",").size > 1 ? "s" : ""} \"#{groups}\""

end

def nothing_outdated_message

if filter_options_.any?

display = filter_options_.map do |o|

end

def retrieve_active_spec(definition, current_spec)

if strict

active_spec = definition.find_resolved_spec(current_spec)

else

active_spec

end

def print_gems(gems_list)

gems_list.each do |gem|

print_gem(

end

end

def print_gem(current_spec, active_spec, dependency, groups)

spec_version = "#{active_spec.version}#{active_spec.git_version}"

spec_version += " (from #{active_spec.loaded_from})" if Bundler.ui.debug? && active_spec.loaded_from

output_message = if options[:parseable]

spec_outdated_info.to_s

" * #{spec_outdated_info}"

else

" * #{spec_outdated_info} in #{groups_text("group", groups)}"

Bundler.ui.info output_message.rstrip

end

def check_for_deployment_mode!

return unless Bundler.frozen_bundle?

suggested_command = if Bundler.settings.locations("frozen")[:global]

version_section = spec.version.segments[version_portion_index, 1]

version_section.to_a[0].to_i

end

end

end

Bundler::Plugin.install(plugins, options)

end

desc "list", "List the installed plugins and available commands"

def list

Bundler::Plugin.list

FileUtils.rm_rf spec.full_gem_path

when Source::Git

source.remote!

if extension_cache_path = source.extension_cache_path(spec)

FileUtils.rm_rf extension_cache_path

# frozen_string_literal: true

module Bundler

class CompactIndexClient

class Cache

header ? lines[header + 1..-1] : lines

end

end

def info_roots

@locked_bundler_version = nil

@locked_ruby_version = nil

@locked_specs_incomplete_for_platform = false

if lockfile && File.exist?(lockfile)

@lockfile_contents = Bundler.read_file(lockfile)

@locked_gems = LockfileParser.new(@lockfile_contents)

@locked_platforms = @locked_gems.platforms

@locked_bundler_version = @locked_gems.bundler_version

@locked_ruby_version = @locked_gems.ruby_version

end

@unlocking ||= @unlock[:ruby] ||= (!@locked_ruby_version ^ !@ruby_version)

converge_path_sources_to_gemspec_sources

@path_changes = converge_paths

end

def current_dependencies

end

def specs_for(groups)

specs.for(expand_dependencies(deps))

end

@locked_deps.each {|name, d| both_sources[name][1] = d.source }

both_sources.each do |name, (dep, lock_source)|

gemfile_source_name = (dep && dep.source) || "no specified source"

changed << "* #{name} from `#{gemfile_source_name}` to `#{lockfile_source_name}`"

end

raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"

end

def find_resolved_spec(current_spec)

specs.find_by_name_and_platform(current_spec.name, current_spec.platform)

end

private

def current_platforms

current_platform = Bundler.local_platform

[].tap do |platforms|

elsif dep.source

dep.source = sources.get(dep.source)

end

end

changes = false

@metadata_dependencies ||= begin

ruby_versions = concat_ruby_version_requirements(@ruby_version)

if ruby_versions.empty? || !@ruby_version.exact?

end

[

Dependency.new("Ruby\0", ruby_versions),

dependencies.each do |dep|

dep = Dependency.new(dep, ">= 0") unless dep.respond_to?(:name)

next if !remote && !dep.current_platform?

deps << DepProxy.new(dep, p) if remote || p == generic_local_platform

end

end

deps

end

def requested_dependencies

groups = requested_groups

groups.map!(&:to_sym)

end

def source_requirements

:x64_mingw_26 => Gem::Platform::X64_MINGW,

}.freeze

def initialize(name, version, options = {}, &blk)

type = options["type"] || :runtime

super(name, version, type)

@gemspecs << spec

group(development_group) do

spec.development_dependencies.each do |dep|

].map(&:freeze).freeze

BUNDLER_PREFIX = "BUNDLER_ORIG_".freeze

# @param keys [Array<String>]

def initialize(env, keys)

@keys = keys

@prefix = BUNDLER_PREFIX

end

# @return [Hash]

def backup

env = @original.clone

class SudoNotPermittedError < BundlerError; status_code(30); end

class ThreadCreationError < BundlerError; status_code(33); end

class APIResponseMismatchError < BundlerError; status_code(34); end

class GemfileEvalError < GemfileError; end

class MarshalError < StandardError; end

settings_flag(:allow_bundler_dependency_conflicts) { bundler_3_mode? }

settings_flag(:allow_offline_install) { bundler_3_mode? }

settings_flag(:auto_clean_without_path) { bundler_3_mode? }

settings_flag(:cache_all) { bundler_3_mode? }

settings_flag(:default_install_uses_path) { bundler_3_mode? }

settings_flag(:deployment_means_frozen) { bundler_3_mode? }

"BUILDBOX" => "buildbox",

"GO_SERVER_URL" => "go",

"SNAP_CI" => "snap",

"CI_NAME" => ENV["CI_NAME"],

"CI" => "ci",

}

Bundler.ui.error error.message

when LoadError

raise error unless error.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/

when Interrupt

Bundler.ui.error "\nQuitting..."

Bundler.ui.trace error

I tried...

...

#{issues_url(e)}

If there aren't any reports for this error yet, please create copy and paste the report template above into a new issue. Don't forget to anonymize any private data! The new issue form is located at:

EOS

end

message = exception.message.lines.first.tr(":", " ").chomp

message = message.split("-").first if exception.is_a?(Errno)

require "cgi"

"#{CGI.escape(message)}&type=Issues"

end

end

attr_reader :spec_path, :base, :gemspec

def initialize(base = nil, name = nil)

raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1

@spec_path = gemspecs.first

@gemspec = Bundler.load_gemspec(@spec_path)

def build_gem

file_name = nil

file_name = File.basename(built_gem_path)

SharedHelpers.filesystem_access(File.join(base, "pkg")) {|p| FileUtils.mkdir_p(p) }

FileUtils.mv(built_gem_path, "pkg")

def install_gem(built_gem_path = nil, local = false)

built_gem_path ||= build_gem

unless status.success?

raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output"

end

protected

def rubygem_push(path)

cmd << "--key" << gem_key if gem_key

cmd << "--host" << allowed_push_host if allowed_push_host

unless allowed_push_host || Bundler.user_home.join(".gem/credentials").file?

end

sh_with_input(cmd)

Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_push_host}"

end

def gem_command

end

end

end

# available dependency versions as found in its index, before returning it to

# to the resolution engine to select the best version.

class GemVersionPromoter

attr_reader :level, :locked_specs, :unlock_gems

Bundler.ui = install ? ui : Bundler::UI::Silent.new

if install || definition.missing_specs?

installer = Bundler::Installer.install(Bundler.root, definition, :system => true)

installer.post_install_messages.each do |name, message|

Bundler.ui.info "Post-install message from #{name}:\n#{message}"

return 1 unless can_install_in_parallel?

end

def processor_count

Bundler.ui.debug "#{worker}: #{spec.name} (#{spec.version}) from #{spec.loaded_from}"

generate_executable_stubs

return true, post_install_message

raise

rescue Errno::ENOSPC

return false, out_of_space_message

return false, specific_failure_message(e)

end

install_serially

end

@specs

ensure

worker_pool && worker_pool.stop

private

def install_with_worker

enqueue_specs

process_specs until finished_installing?

gem_installer = Bundler::GemInstaller.new(

spec_install.spec, @installer, @standalone, worker_num, @force

)

if success

spec_install.state = :installed

spec_install.post_install_message = message unless message.nil?

end

def handle_error

if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }

raise exception

end

end

def require_tree_for_spec(spec)

identifier == other.identifier

end

def satisfies?(dependency)

@name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))

end

@specification = if source.is_a?(Source::Gemspec) && source.gemspec.name == name

source.gemspec.tap {|s| s.source = source }

else

Bundler.ui.warn "Unable to use the platform-specific (#{search.platform}) version of #{name} (#{version}) " \

"because it has different dependencies from the #{platform} version. " \

"To use the platform-specific version of the gem, run `bundle config set specific_platform true` and install again."

Bundler.ui.error "Failed to install plugin #{name}: #{e.message}\n #{e.backtrace.join("\n ")}"

end

# List installed plugins and commands

#

def list

raise

end

# Path of default index file

def index_file

Plugin.root.join("index")

YamlLibrarySyntaxError = ::ArgumentError

end

end

# once the remote gem is downloaded, the backend specification will

# be swapped out.

def __swap__(spec)

SharedHelpers.ensure_same_dependencies(self, dependencies, spec.dependencies)

@_remote_specification = spec

end

deps = method_missing(:dependencies)

# allow us to handle when the specs dependencies are an array of array of string

deps = deps.map {|d| d.is_a?(Gem::Dependency) ? d : Gem::Dependency.new(*d) }

deps

return unless debug?

debug_info = yield

debug_info = debug_info.inspect unless debug_info.is_a?(String)

end

def debug?

return @debug_mode if defined?(@debug_mode)

end

def before_resolution

@gem_version_promoter.sort_versions(dependency, spec_groups)

end

end

end

def index_for(dependency)

end

def requirement_satisfied_by?(requirement, activated, spec)

end

def relevant_sources_for_vertex(vertex)

end

def self.platform_sort_key(platform)

end

private

attr_accessor :ignores_bundler_dependencies

def initialize(all_specs)

raise ArgumentError, "cannot initialize with an empty value" unless exemplary_spec = all_specs.first

@name = exemplary_spec.name

@version = exemplary_spec.version

lazy_spec = LazySpecification.new(name, version, s.platform, source)

lazy_spec.dependencies.replace s.dependencies

lazy_spec

end

def activate_platform!(platform)

@activated_platforms << platform

end

def for?(platform)

end

def to_s

end

def dependencies_for_activated_platforms

return unless other.is_a?(SpecGroup)

name == other.name &&

version == other.version &&

source == other.source

end

return unless other.is_a?(SpecGroup)

name.eql?(other.name) &&

version.eql?(other.version) &&

source.eql?(other.source)

end

def hash

end

private

alias_method :rg_extension_dir, :extension_dir

def extension_dir

@bundler_extension_dir ||= if source.respond_to?(:extension_dir_name)

else

rg_extension_dir

end

raise e

end

kernel_class.send(:public, :gem) if Bundler.feature_flag.setup_makes_kernel_gem_public?

end

end

Gem.clear_paths

end

def undo_replacements

@replaced_methods.each do |(sym, klass), method|

redefine_method(klass, sym, method)

def backport_ext_builder_monitor

# So we can avoid requiring "rubygems/ext" in its entirety

module Ext

end

require "rubygems/ext/builder"

allow_offline_install

auto_clean_without_path

auto_install

cache_all

cache_all_platforms

default_install_uses_path

disable_exec_load

disable_local_branch_check

disable_multisource

disable_shared_gems

disable_version_check

force_ruby_platform

@allow_remote || @allow_cached

end

private

def serialize_gemspecs_in(destination)

cached_revision && super

end

def requires_checkout?

allow_git_ops? && !local? && !cached_revision_checked_out?

end

def initialize(command)

msg = String.new

msg << "Bundler is trying to run a `git #{command}` at runtime. You probably need to run `bundle install`. However, "

msg << "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"

super msg

end

class GitCommandError < GitError

attr_reader :command

@command = command

msg = String.new

msg << "\n#{extra_info}" if extra_info

super msg

end

end

class MissingGitRevisionError < GitCommandError

msg = "Revision #{ref} does not exist in the repository #{repo}. Maybe you misspelled it?"

end

end

end

def revision

end

def branch

end

end

def contains?(commit)

status.success? && result =~ /^\* (.*)$/

end

end

return unless extra_ref

end

end

end

end

end

# method 2

end

end

private

out, status = SharedHelpers.with_clean_git_env do

end

[URICredentialsFilter.credential_filtered_string(out, uri), status]

end

Bundler::Retry.new("`git #{URICredentialsFilter.credential_filtered_string(command, uri)}`", GitNotAllowedError).attempts do

end

end

out, status = SharedHelpers.with_clean_git_env do

end

end

def has_revision_cached?

return unless @revision

true

rescue GitError

false

end

def find_local_revision

end

end

# Escape the URI for git commands

@git ? @git.allow_git_ops? : true

end

checkout unless path.exist?

end

raise GitError, "The git source #{uri} is not yet checked out. Please run `bundle install` before trying to start your application"

end

require "open3"

Bundler.ui.warn URICredentialsFilter.credential_filtered_string(captured_err, uri) if uri && !captured_err.empty?

[return_value, status]

end

require "open3"

[return_value, status]

end

end

end

def expand(somepath)

rescue ArgumentError => e

Bundler.ui.debug(e)

raise PathError, "There was an error while trying to use the path " \

end

def post_install

ensure

Bundler.rm_rf(@tmp_dir) if Bundler.requires_sudo?

end

## Our Pledge

## Our Standards

* Public or private harassment

* Other conduct which could reasonably be considered inappropriate in a

professional setting

## Scope

## Enforcement

## Attribution

# Specify your gem's dependencies in <%= config[:name] %>.gemspec

gemspec

<%- if config[:ext] -%>

gem "rake-compiler"

<%- end -%>

<%- if config[:test] -%>

gem "<%= config[:test] %>", "~> <%= config[:test_framework_version] %>"

<%- end -%>

require "bundler/gem_tasks"

require "rake/testtask"

Rake::TestTask.new(:test) do |t|

t.test_files = FileList["test/**/*_test.rb"]

end

require "rspec/core/rake_task"

RSpec::Core::RakeTask.new(:spec)

<% end -%>

<% if config[:ext] -%>

require "rake/extensiontask"

task :build => :compile

ext.lib_dir = "lib/<%= config[:namespaced_path] %>"

end

<% end -%>

Gem::Specification.new do |spec|

spec.name = <%= config[:name].inspect %>

# Specify which files should be added to the gem when it is released.

# The `git ls-files -z` loads the files in the RubyGem that have been added into git.

`git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

end

spec.bindir = "exe"

# servers you wish to talk to. For each host:port you communicate with a

# single persistent connection is created.

#

#

#

# Example:

#

#

# uri = Bundler::URI 'http://example.com/awesome/web/service'

#

#

# # perform a GET

# response = http.request uri

# to use Bundler::URI#request_uri not Bundler::URI#path. The request_uri contains the query

# params which are sent in the body for other requests.

#

#

# certificate store for your computer. You can override this by changing

# verify_mode or by specifying an alternate cert_store.

#

#

# #certificate :: This client's certificate

# #ca_file :: The certificate-authorities

# #private_key :: The client's SSL private key

# #reuse_ssl_sessions :: Reuse a previously opened SSL session for a new

# connection

# #ssl_version :: Which specific SSL version to use

# #verify_callback :: For server certificate verification

# #verify_depth :: Depth of certificate verification

#

# === Segregation

#

#

# === Idle Timeout

#

#

# Reducing this value may help avoid the "too many connection resets" error

# when sending non-idempotent requests while increasing this value will cause

#

# The number of requests that should be made before opening a new connection.

# Typically many keep-alive capable servers tune this to 100 or less, so the

#

# === Open Timeout

#

# Socket options may be set on newly-created connections. See #socket_options

# for details.

#

# === Connection Termination

#

# If you are done using the Bundler::Persistent::Net::HTTP::Persistent instance you may shut down

HAVE_OPENSSL = defined? OpenSSL::SSL # :nodoc:

##

DEFAULT_POOL_SIZE = Process.getrlimit(Process::RLIMIT_NOFILE).first / 4

end

##

# The version of Bundler::Persistent::Net::HTTP::Persistent you are using

##

# Error class for errors raised by Bundler::Persistent::Net::HTTP::Persistent. Various

attr_accessor :max_requests

##

# The value sent in the Keep-Alive header. Defaults to 30. Not needed for

# HTTP/1.1 servers.

#

attr_accessor :keep_alive

##

attr_reader :name

attr_reader :verify_mode

##

# Creates a new Bundler::Persistent::Net::HTTP::Persistent.

#

#

# +proxy+ may be set to a Bundler::URI::HTTP or :ENV to pick up proxy options from

# the environment. See proxy_from_env for details.

# proxy.password = 'hunter2'

#

# Set +pool_size+ to limit the maximum number of connections allowed.

def initialize name: nil, proxy: nil, pool_size: DEFAULT_POOL_SIZE

@name = name

@write_timeout = nil

@idle_timeout = 5

@max_requests = nil

@socket_options = []

@ssl_generation = 0 # incremented when SSL session variables change

@reuse_ssl_sessions = OpenSSL::SSL.const_defined? :Session

end

self.proxy = proxy if proxy

end

net_http_args = [uri.hostname, uri.port]

net_http_args.concat @proxy_args

else

net_http_args.concat [nil, nil, nil, nil]

reset connection

end

return yield connection

rescue Errno::ECONNREFUSED

end

##

def escape str

CGI.escape str if str

end

##

def unescape str

CGI.unescape str if str

def finish connection

connection.finish

connection.http.instance_variable_set :@ssl_session, nil unless

@reuse_ssl_sessions

end

# Returns the HTTP protocol version for +uri+

def http_version uri

end

##

end

##

end

##

if @proxy_uri then

@proxy_args = [

@proxy_uri.port,

unescape(@proxy_uri.user),

unescape(@proxy_uri.password),

end

##

def reconnect

@generation += 1

end

##

def reconnect_ssl

@ssl_generation += 1

# the response will not have been read).

#

# +req+ must be a Net::HTTPGenericRequest subclass (see Net::HTTP for a list).

def request uri, req = nil, &block

uri = Bundler::URI uri

req = request_setup req || uri

response = nil

response = http.request req, &block

if req.connection_close? or

not response.connection_keep_alive?) or

finish connection

end

finish connection

raise

end

end

response

end

##

# Creates a GET request if +req_or_uri+ is a Bundler::URI and adds headers to the

# request.

#

# Returns the request.

def request_setup req_or_uri # :nodoc:

Net::HTTP::Get.new req_or_uri.request_uri

else

req_or_uri

reconnect_ssl

end

end

require_relative 'persistent/connection'

# frozen_string_literal: false

module Bundler

def self.bundler_major_version

@bundler_major_version ||= VERSION.split(".").first.to_i