-# frozen_string_literal: true

-

-module Bundler

- class CLI::Package

- attr_reader :options

-

- def initialize(options)

- @options = options

- end

-

- def run

- Bundler.ui.level = "error" if options[:quiet]

- Bundler.settings.set_command_option_if_given :path, options[:path]

- Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]

-

- setup_cache_all

- install

-

- # TODO: move cache contents here now that all bundles are locked

- custom_path = Bundler.settings[:path] if options[:path]

-

- Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do

- Bundler.load.cache(custom_path)

- end

- end

-

- private

-

- def install

- require_relative "install"

- options = self.options.dup

- options["local"] = false if Bundler.settings[:cache_all_platforms]

- Bundler::CLI::Install.new(options).run

- end

-

- def setup_cache_all

- all = options.fetch(:all, Bundler.feature_flag.cache_all? || nil)

-

- Bundler.settings.set_command_option_if_given :cache_all, all

-

- if Bundler.definition.has_local_dependencies? && !Bundler.feature_flag.cache_all?

- Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want " \

- "to package them as well, please pass the --all flag. This will be the default " \

- "on Bundler 3.0."

- end

- end

- end

-end

-# frozen_string_literal: true

-

-require "rubygems/remote_fetcher"

-

-module Bundler

- # Adds support for setting custom HTTP headers when fetching gems from the

- # server.

- #

- # TODO: Get rid of this when and if gemstash only supports RubyGems versions

- # that contain https://.com/rubygems/rubygems/commit/3db265cc20b2f813.

- class GemRemoteFetcher < Gem::RemoteFetcher

- attr_accessor :headers

-

- # Extracted from RubyGems 2.4.

- def fetch_http(uri, last_modified = nil, head = false, depth = 0)

- fetch_type = head ? Net::HTTP::Head : Net::HTTP::Get

- # beginning of change

- response = request uri, fetch_type, last_modified do |req|

- headers.each {|k, v| req.add_field(k, v) } if headers

- end

- # end of change

-

- case response

- when Net::HTTPOK, Net::HTTPNotModified then

- response.uri = uri if response.respond_to? :uri

- head ? response : response.body

- when Net::HTTPMovedPermanently, Net::HTTPFound, Net::HTTPSeeOther,

- Net::HTTPTemporaryRedirect then

- raise FetchError.new("too many redirects", uri) if depth > 10

-

- location = URI.parse response["Location"]

-

- if https?(uri) && !https?(location)

- raise FetchError.new("redirecting to non-https resource: #{location}", uri)

- end

-

- fetch_http(location, last_modified, head, depth + 1)

- else

- raise FetchError.new("bad response #{response.message} #{response.code}", uri)

- end

- end

- end

-end

-require "test_helper"

-

-class <%= config[:constant_name] %>Test < Minitest::Test

- def test_that_it_has_a_version_number

- refute_nil ::<%= config[:constant_name] %>::VERSION

- end

-

- def test_it_does_something_useful

- assert false

- end

-end

-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)

-require "<%= config[:namespaced_path] %>"

-

-require "minitest/autorun"

-# Ignore vendored libraries, which are not RDoc.

-# frozen_string_literal: true

-

-module Bundler::FileUtils

- VERSION = "1.3.0"

-end

-class IO #:nodoc:

- class << self

- unless method_defined? :binread

- def binread(file, *args)

- raise ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3

- File.open(file, "rb") do |f|

- f.read(*args)

- end

- end

- end

- end

-end

-class Bundler::Thor

- module CoreExt

- class OrderedHash < ::Hash

- if RUBY_VERSION < "1.9"

- def initialize(*args, &block)

- super

- @keys = []

- end

-

- def initialize_copy(other)

- super

- # make a deep copy of keys

- @keys = other.keys

- end

-

- def []=(key, value)

- @keys << key unless key?(key)

- super

- end

-

- def delete(key)

- if key? key

- index = @keys.index(key)

- @keys.delete_at index

- end

- super

- end

-

- def delete_if

- super

- sync_keys!

- self

- end

-

- alias_method :reject!, :delete_if

-

- def reject(&block)

- dup.reject!(&block)

- end

-

- def keys

- @keys.dup

- end

-

- def values

- @keys.map { |key| self[key] }

- end

-

- def to_hash

- self

- end

-

- def to_a

- @keys.map { |key| [key, self[key]] }

- end

-

- def each_key

- return to_enum(:each_key) unless block_given?

- @keys.each { |key| yield(key) }

- self

- end

-

- def each_value

- return to_enum(:each_value) unless block_given?

- @keys.each { |key| yield(self[key]) }

- self

- end

-

- def each

- return to_enum(:each) unless block_given?

- @keys.each { |key| yield([key, self[key]]) }

- self

- end

-

- def each_pair

- return to_enum(:each_pair) unless block_given?

- @keys.each { |key| yield(key, self[key]) }

- self

- end

-

- alias_method :select, :find_all

-

- def clear

- super

- @keys.clear

- self

- end

-

- def shift

- k = @keys.first

- v = delete(k)

- [k, v]

- end

-

- def merge!(other_hash)

- if block_given?

- other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }

- else

- other_hash.each { |k, v| self[k] = v }

- end

- self

- end

-

- alias_method :update, :merge!

-

- def merge(other_hash, &block)

- dup.merge!(other_hash, &block)

- end

-

- # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.

- def replace(other)

- super

- @keys = other.keys

- self

- end

-

- def inspect

- "#<#{self.class} #{super}>"

- end

-

- private

-

- def sync_keys!

- @keys.delete_if { |k| !key?(k) }

- end

- end

- end

- end

-end