Module: Bundler::CLI::Common

Defined in:
lib/bundler/cli/common.rb

Class Method Summary collapse

Class Method Details

.ask_for_spec_from(specs) ⇒ Object 



86
87
88
89
90
91
92
93
94
 
# File 'lib/bundler/cli/common.rb', line 86

def self.ask_for_spec_from(specs)
  specs.each_with_index do |spec, index|
    Bundler.ui.info "#{index.succ} : #{spec.name}", true
  end
  Bundler.ui.info "0 : - exit -", true

  num = Bundler.ui.ask("> ").to_i
  num > 0 ? specs[num - 1] : nil
end

.clean_after_install? ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
133
134
135
136
 
# File 'lib/bundler/cli/common.rb', line 130

def self.clean_after_install?
  clean = Bundler.settings[:clean]
  return clean unless clean.nil?
  clean ||= Bundler.feature_flag.auto_clean_without_path? && Bundler.settings[:path].nil?
  clean &&= !Bundler.use_system_gems?
  clean
end

.configure_gem_version_promoter(definition, options) ⇒ Object

Raises:



114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/bundler/cli/common.rb', line 114

def self.configure_gem_version_promoter(definition, options)
  patch_level = patch_level_options(options)
  patch_level << :patch if patch_level.empty? && Bundler.settings[:prefer_patch]
  raise InvalidOption, "Provide only one of the following options: #{patch_level.join(", ")}" unless patch_level.length <= 1

  definition.gem_version_promoter.tap do |gvp|
    gvp.level = patch_level.first || :major
    gvp.strict = options[:strict] || options["filter-strict"]
    gvp.pre = options[:pre]
  end
end

.default_gem_spec(name) ⇒ Object 



81
82
83
84
 
# File 'lib/bundler/cli/common.rb', line 81

def self.default_gem_spec(name)
  gem_spec = Gem::Specification.find_all_by_name(name).last
  gem_spec if gem_spec&.default_gem?
end

.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems) ⇒ Object 



105
106
107
108
109
110
111
112
 
# File 'lib/bundler/cli/common.rb', line 105

def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
  return unless locked_gems

  locked_names = locked_gems.specs.map(&:name).uniq
  names.-(locked_names).each do |g|
    raise GemNotFound, gem_not_found_message(g, locked_names)
  end
end

.gem_not_found_message(missing_gem_name, alternatives) ⇒ Object 



96
97
98
99
100
101
102
103
 
# File 'lib/bundler/cli/common.rb', line 96

def self.gem_not_found_message(missing_gem_name, alternatives)
  require_relative "../similarity_detector"
  message = "Could not find gem '#{missing_gem_name}'."
  alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
  suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
  message += "\nDid you mean #{suggestions}?" if suggestions
  message
end

.output_fund_metadata_summary ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/bundler/cli/common.rb', line 17

def self.output_fund_metadata_summary
  return if Bundler.settings["ignore_funding_requests"]
  definition = Bundler.definition
  current_dependencies = definition.requested_dependencies
  current_specs = definition.specs

  count = current_dependencies.count {|dep| current_specs[dep.name].first.metadata.key?("funding_uri") }

  return if count.zero?

  intro = count > 1 ? "#{count} installed gems you directly depend on are" : "#{count} installed gem you directly depend on is"
  message = "#{intro} looking for funding.\n  Run `bundle fund` for details"
  Bundler.ui.info message
end

.output_post_install_messages(messages) ⇒ Object 



5
6
7
8
9
10
 
# File 'lib/bundler/cli/common.rb', line 5

def self.output_post_install_messages(messages)
  return if Bundler.settings["ignore_messages"]
  messages.to_a.each do |name, msg|
    print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
  end
end

.output_without_groups_message(command) ⇒ Object 



32
33
34
35
 
# File 'lib/bundler/cli/common.rb', line 32

def self.output_without_groups_message(command)
  return if Bundler.settings[:without].empty?
  Bundler.ui.confirm without_groups_message(command)
end

.patch_level_options(options) ⇒ Object 



126
127
128
 
# File 'lib/bundler/cli/common.rb', line 126

def self.patch_level_options(options)
  [:major, :minor, :patch].select {|v| options.keys.include?(v.to_s) }
end

.print_post_install_message(name, msg) ⇒ Object 



12
13
14
15
 
# File 'lib/bundler/cli/common.rb', line 12

def self.print_post_install_message(name, msg)
  Bundler.ui.confirm "Post-install message from #{name}:"
  Bundler.ui.info msg
end

.select_spec(name, regex_match = nil) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/bundler/cli/common.rb', line 51

def self.select_spec(name, regex_match = nil)
  specs = []
  regexp = Regexp.new(name) if regex_match

  Bundler.definition.specs.each do |spec|
    return spec if spec.name == name
    specs << spec if regexp && spec.name.match?(regexp)
  end

  default_spec = default_gem_spec(name)
  specs << default_spec if default_spec

  case specs.count
  when 0
    dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }

    if dep_in_other_group
      raise GemNotFound, "Could not find gem '#{name}', because it's in the #{verbalize_groups(dep_in_other_group.groups)}, configured to be ignored."
    else
      raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
    end
  when 1
    specs.first
  else
    ask_for_spec_from(specs)
  end
rescue RegexpError
  raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
end

.verbalize_groups(groups) ⇒ Object 



43
44
45
46
47
48
49
 
# File 'lib/bundler/cli/common.rb', line 43

def self.verbalize_groups(groups)
  groups.map! {|g| "'#{g}'" }
  group_list = [groups[0...-1].join(", "), groups[-1..-1]].
    reject {|s| s.to_s.empty? }.join(" and ")
  group_str = groups.size == 1 ? "group" : "groups"
  "#{group_str} #{group_list}"
end

.without_groups_message(command) ⇒ Object 



37
38
39
40
41
 
# File 'lib/bundler/cli/common.rb', line 37

def self.without_groups_message(command)
  command_in_past_tense = command == :install ? "installed" : "updated"
  groups = Bundler.settings[:without]
  "Gems in the #{verbalize_groups(groups)} were not #{command_in_past_tense}."
end