diff options
Diffstat (limited to 'lib/bundler/settings.rb')
-rw-r--r-- | lib/bundler/settings.rb | 254 |
1 files changed, 178 insertions, 76 deletions
diff --git a/lib/bundler/settings.rb b/lib/bundler/settings.rb index 1898738b7c..f33e9453be 100644 --- a/lib/bundler/settings.rb +++ b/lib/bundler/settings.rb @@ -1,60 +1,89 @@ # frozen_string_literal: true + require "uri" module Bundler class Settings autoload :Mirror, "bundler/mirror" autoload :Mirrors, "bundler/mirror" + autoload :Validator, "bundler/settings/validator" - BOOL_KEYS = %w( + BOOL_KEYS = %w[ + allow_bundler_dependency_conflicts + allow_deployment_source_credential_changes allow_offline_install + auto_clean_without_path auto_install cache_all cache_all_platforms + cache_command_is_package + console_command + default_install_uses_path + deployment + deployment_means_frozen disable_checksum_validation disable_exec_load disable_local_branch_check + disable_multisource disable_shared_gems disable_version_check + error_on_stderr force_ruby_platform + forget_cli_options frozen gem.coc gem.mit + global_gem_cache ignore_messages + init_gems_rb + list_command + lockfile_uses_separate_rubygems_sources major_deprecations no_install no_prune only_update_to_newer_versions + path.system plugins + prefer_gems_rb + print_only_version_number + setup_makes_kernel_gem_public silence_root_warning - ).freeze - - NUMBER_KEYS = %w( + skip_default_git_sources + specific_platform + suppress_install_using_messages + unlock_source_unlocks_spec + update_requires_all_flag + ].freeze + + NUMBER_KEYS = %w[ redirect retry ssl_verify_mode timeout - ).freeze + ].freeze + + ARRAY_KEYS = %w[ + with + without + ].freeze DEFAULT_CONFIG = { + :disable_version_check => true, :redirect => 5, :retry => 3, :timeout => 10, }.freeze - attr_accessor :cli_flags_given - def initialize(root = nil) @root = root @local_config = load_config(local_config_file) @global_config = load_config(global_config_file) - @cli_flags_given = false @temporary = {} end def [](name) key = key_for(name) - value = @temporary.fetch(name) do + value = @temporary.fetch(key) do @local_config.fetch(key) do ENV.fetch(key) do @global_config.fetch(key) do @@ -65,48 +94,59 @@ module Bundler converted_value(value, name) end - def []=(key, value) - if cli_flags_given + def set_command_option(key, value) + if Bundler.feature_flag.forget_cli_options? + temporary(key => value) + value + else command = if value.nil? "bundle config --delete #{key}" else "bundle config #{key} #{Array(value).join(":")}" end - Bundler::SharedHelpers.major_deprecation \ + Bundler::SharedHelpers.major_deprecation 2,\ "flags passed to commands " \ "will no longer be automatically remembered. Instead please set flags " \ "you want remembered between commands using `bundle config " \ "<setting name> <setting value>`, i.e. `#{command}`" + + set_local(key, value) end + end + + def set_command_option_if_given(key, value) + return if value.nil? + set_command_option(key, value) + end + + def set_local(key, value) local_config_file || raise(GemfileNotFound, "Could not locate Gemfile") + set_key(key, value, @local_config, local_config_file) end - alias_method :set_local, :[]= def temporary(update) - existing = Hash[update.map {|k, _| [k, @temporary[k]] }] - @temporary.update(update) + existing = Hash[update.map {|k, _| [k, @temporary[key_for(k)]] }] + update.each do |k, v| + set_key(k, v, @temporary, nil) + end return unless block_given? begin yield ensure - existing.each {|k, v| v.nil? ? @temporary.delete(k) : @temporary[k] = v } + existing.each {|k, v| set_key(k, v, @temporary, nil) } end end - def delete(key) - @local_config.delete(key_for(key)) - end - def set_global(key, value) set_key(key, value, @global_config, global_config_file) end def all - env_keys = ENV.keys.select {|k| k =~ /BUNDLE_.*/ } + env_keys = ENV.keys.grep(/\ABUNDLE_.+/) - keys = @global_config.keys | @local_config.keys | env_keys + keys = @temporary.keys | @global_config.keys | @local_config.keys | env_keys keys.map do |key| key.sub(/^BUNDLE_/, "").gsub(/__/, ".").downcase @@ -132,7 +172,7 @@ module Bundler def gem_mirrors all.inject(Mirrors.new) do |mirrors, k| - mirrors.parse(k, self[k]) if k =~ /^mirror\./ + mirrors.parse(k, self[k]) if k.start_with?("mirror.") mirrors end end @@ -140,6 +180,7 @@ module Bundler def locations(key) key = key_for(key) locations = {} + locations[:temporary] = @temporary[key] if @temporary.key?(key) locations[:local] = @local_config[key] if @local_config.key?(key) locations[:env] = ENV[key] if ENV[key] locations[:global] = @global_config[key] if @global_config.key?(key) @@ -151,6 +192,11 @@ module Bundler key = key_for(exposed_key) locations = [] + + if @temporary.key?(key) + locations << "Set for the current command: #{converted_value(@temporary[key], exposed_key).inspect}" + end + if @local_config.key?(key) locations << "Set for your local app (#{local_config_file}): #{converted_value(@local_config[key], exposed_key).inspect}" end @@ -167,37 +213,56 @@ module Bundler locations end - def without=(array) - set_array(:without, array) - end + # for legacy reasons, the ruby scope isnt appended when the setting comes from ENV or the global config, + # nor do we respect :disable_shared_gems + def path + key = key_for(:path) + path = ENV[key] || @global_config[key] + if path && !@temporary.key?(key) && !@local_config.key?(key) + return Path.new(path, false, false, false) + end - def with=(array) - set_array(:with, array) + system_path = self["path.system"] || (self[:disable_shared_gems] == false) + Path.new(self[:path], true, system_path, Bundler.feature_flag.default_install_uses_path?) end - def without - get_array(:without) - end + Path = Struct.new(:explicit_path, :append_ruby_scope, :system_path, :default_install_uses_path) do + def path + path = base_path + path = File.join(path, Bundler.ruby_scope) if append_ruby_scope && !use_system_gems? + path + end - def with - get_array(:with) - end + def use_system_gems? + return true if system_path + return false if explicit_path + !default_install_uses_path + end - # @local_config["BUNDLE_PATH"] should be prioritized over ENV["BUNDLE_PATH"] - def path - key = key_for(:path) - path = ENV[key] || @global_config[key] - return path if path && !@local_config.key?(key) + def base_path + path = explicit_path + path ||= ".bundle" unless use_system_gems? + path ||= Bundler.rubygems.gem_dir + path + end - if path = self[:path] - "#{path}/#{Bundler.ruby_scope}" - else - Bundler.rubygems.gem_dir + def validate! + return unless explicit_path && system_path + path = Bundler.settings.pretty_values_for(:path) + path.unshift(nil, "path:") unless path.empty? + system_path = Bundler.settings.pretty_values_for("path.system") + system_path.unshift(nil, "path.system:") unless system_path.empty? + disable_shared_gems = Bundler.settings.pretty_values_for(:disable_shared_gems) + disable_shared_gems.unshift(nil, "disable_shared_gems:") unless disable_shared_gems.empty? + raise InvalidOption, + "Using a custom path while using system gems is unsupported.\n#{path.join("\n")}\n#{system_path.join("\n")}\n#{disable_shared_gems.join("\n")}" end end def allow_sudo? - !@local_config.key?(key_for(:path)) + key = key_for(:path) + path_configured = @temporary.key?(key) || @local_config.key?(key) + !path_configured end def ignore_config? @@ -205,14 +270,17 @@ module Bundler end def app_cache_path - @app_cache_path ||= begin - path = self[:cache_path] || "vendor/cache" - raise InvalidOption, "Cache path must be relative to the bundle path" if path.start_with?("/") - path - end + @app_cache_path ||= self[:cache_path] || "vendor/cache" end - private + def validate! + all.each do |raw_key| + [@local_config, ENV, @global_config].each do |settings| + value = converted_value(settings[key_for(raw_key)], raw_key) + Validator.validate!(raw_key, value, settings.to_hash.dup) + end + end + end def key_for(key) key = Settings.normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key @@ -220,15 +288,17 @@ module Bundler "BUNDLE_#{key}" end + private + def parent_setting_for(name) - split_specfic_setting_for(name)[0] + split_specific_setting_for(name)[0] end - def specfic_gem_for(name) - split_specfic_setting_for(name)[1] + def specific_gem_for(name) + split_specific_setting_for(name)[1] end - def split_specfic_setting_for(name) + def split_specific_setting_for(name) name.split(".") end @@ -245,43 +315,57 @@ module Bundler end end - def is_num(value) - NUMBER_KEYS.include?(value.to_s) + def is_num(key) + NUMBER_KEYS.include?(key.to_s) end - def get_array(key) - self[key] ? self[key].split(":").map(&:to_sym) : [] + def is_array(key) + ARRAY_KEYS.include?(key.to_s) end - def set_array(key, array) - self[key] = (array.empty? ? nil : array.join(":")) if array + def to_array(value) + return [] unless value + value.split(":").map(&:to_sym) end - def set_key(key, value, hash, file) - key = key_for(key) + def array_to_s(array) + array = Array(array) + return nil if array.empty? + array.join(":").tr(" ", ":") + end - unless hash[key] == value - hash[key] = value - hash.delete(key) if value.nil? - SharedHelpers.filesystem_access(file) do |p| - FileUtils.mkdir_p(p.dirname) - require "bundler/yaml_serializer" - p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) } - end - end + def set_key(raw_key, value, hash, file) + raw_key = raw_key.to_s + value = array_to_s(value) if is_array(raw_key) + + key = key_for(raw_key) + + return if hash[key] == value + + hash[key] = value + hash.delete(key) if value.nil? - value + Validator.validate!(raw_key, converted_value(value, raw_key), hash) + + return unless file + SharedHelpers.filesystem_access(file) do |p| + FileUtils.mkdir_p(p.dirname) + require "bundler/yaml_serializer" + p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) } + end end def converted_value(value, key) - if value.nil? + if is_array(key) + to_array(value) + elsif value.nil? nil elsif is_bool(key) || value == "false" to_bool(value) elsif is_num(key) value.to_i else - value + value.to_s end end @@ -325,16 +409,34 @@ module Bundler end end + PER_URI_OPTIONS = %w[ + fallback_timeout + ].freeze + + NORMALIZE_URI_OPTIONS_PATTERN = + / + \A + (\w+\.)? # optional prefix key + (https?.*?) # URI + (\.#{Regexp.union(PER_URI_OPTIONS)})? # optional suffix key + \z + /ix + # TODO: duplicates Rubygems#normalize_uri # TODO: is this the correct place to validate mirror URIs? def self.normalize_uri(uri) uri = uri.to_s - uri = "#{uri}/" unless uri =~ %r{/\Z} + if uri =~ NORMALIZE_URI_OPTIONS_PATTERN + prefix = $1 + uri = $2 + suffix = $3 + end + uri = "#{uri}/" unless uri.end_with?("/") uri = URI(uri) unless uri.absolute? raise ArgumentError, format("Gem sources must be absolute. You provided '%s'.", uri) end - uri + "#{prefix}#{uri}#{suffix}" end end end |