Class: Gem::Uninstaller

Inherits:
Object
  • Object
show all
Includes:
InstallerUninstallerUtils, UserInteraction
Defined in:
lib/rubygems/uninstaller.rb

Overview

An Uninstaller.

The uninstaller fires pre and post uninstall hooks. Hooks can be added either through a rubygems_plugin.rb file in an installed gem or via a rubygems/defaults/#RUBY_ENGINE.rb or rubygems/defaults/operating_system.rb file. See Gem.pre_uninstall and Gem.post_uninstall for details.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from InstallerUninstallerUtils

#regenerate_plugins_for, #remove_plugins_for

Methods included from UserInteraction

#alert, #alert_error, #alert_warning, #ask, #ask_for_password, #ask_yes_no, #choose_from_list, #say, #terminate_interaction, #verbose

Methods included from DefaultUserInteraction

ui, #ui, ui=, #ui=, use_ui, #use_ui

Methods included from Text

#clean_text, #format_text, #levenshtein_distance, #min3, #truncate_text

Constructor Details

#initialize(gem, options = {}) ⇒ Uninstaller

Constructs an uninstaller that will uninstall gem



48
49
50
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
 
# File 'lib/rubygems/uninstaller.rb', line 48

def initialize(gem, options = {})
  # TODO: document the valid options
  @gem                = gem
  @version            = options[:version] || Gem::Requirement.default
  @install_dir        = options[:install_dir]
  @gem_home           = File.realpath(@install_dir || Gem.dir)
  @user_dir           = File.exist?(Gem.user_dir) ? File.realpath(Gem.user_dir) : Gem.user_dir
  @force_executables  = options[:executables]
  @force_all          = options[:all]
  @force_ignore       = options[:ignore]
  @bin_dir            = options[:bin_dir]
  @format_executable  = options[:format_executable]
  @abort_on_dependent = options[:abort_on_dependent]

  # Indicate if development dependencies should be checked when
  # uninstalling. (default: false)
  #
  @check_dev = options[:check_dev]

  if options[:force]
    @force_all = true
    @force_ignore = true
  end

  # only add user directory if install_dir is not set
  @user_install = false
  @user_install = options[:user_install] unless @install_dir

  # Optimization: populated during #uninstall
  @default_specs_matching_uninstall_params = []
end

Instance Attribute Details

#bin_dir ⇒ Object (readonly)

The directory a gem’s executables will be installed into



32
33
34
 
# File 'lib/rubygems/uninstaller.rb', line 32

def bin_dir
  @bin_dir
end

#gem_home ⇒ Object (readonly)

The gem repository the gem will be uninstalled from



37
38
39
 
# File 'lib/rubygems/uninstaller.rb', line 37

def gem_home
  @gem_home
end

#spec ⇒ Object (readonly)

The Gem::Specification for the gem being uninstalled, only set during #uninstall_gem



43
44
45
 
# File 'lib/rubygems/uninstaller.rb', line 43

def spec
  @spec
end

Instance Method Details

#abort_on_dependent? ⇒ Boolean

Should the uninstallation abort if a dependency will go unsatisfied?

See ::new.

Returns:

  • (Boolean) 


333
334
335
 
# File 'lib/rubygems/uninstaller.rb', line 333

def abort_on_dependent? # :nodoc:
  @abort_on_dependent
end

#ask_if_ok(spec) ⇒ Object

Asks if it is OK to remove spec. Returns true if it is OK.



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/rubygems/uninstaller.rb', line 340

def ask_if_ok(spec) # :nodoc:
  msg = [""]
  msg << "You have requested to uninstall the gem:"
  msg << "\t#{spec.full_name}"
  msg << ""

  siblings = Gem::Specification.select do |s|
    s.name == spec.name && s.full_name != spec.full_name
  end

  spec.dependent_gems(@check_dev).each do |dep_spec, dep, _satlist|
    unless siblings.any? {|s| s.satisfies_requirement? dep }
      msg << "#{dep_spec.name}-#{dep_spec.version} depends on #{dep}"
    end
  end

  msg << "If you remove this gem, these dependencies will not be met."
  msg << "Continue with Uninstall?"
  ask_yes_no(msg.join("\n"), false)
end

#dependencies_ok?(spec) ⇒ Boolean

Returns true if it is OK to remove spec or this is a forced uninstallation.

Returns:

  • (Boolean) 


321
322
323
324
325
326
 
# File 'lib/rubygems/uninstaller.rb', line 321

def dependencies_ok?(spec) # :nodoc:
  return true if @force_ignore

  deplist = Gem::DependencyList.from_specs
  deplist.ok_to_remove?(spec.full_name, @check_dev)
end

#formatted_program_filename(filename) ⇒ Object

Returns the formatted version of the executable filename



364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/rubygems/uninstaller.rb', line 364

def formatted_program_filename(filename) # :nodoc:
  # TODO perhaps the installer should leave a small manifest
  # of what it did for us to find rather than trying to recreate
  # it again.
  if @format_executable
    require_relative "installer"
    Gem::Installer.exec_format % File.basename(filename)
  else
    filename
  end
end

#path_ok?(gem_dir, spec) ⇒ Boolean

Is spec in gem_dir?

Returns:

  • (Boolean) 


310
311
312
313
314
315
 
# File 'lib/rubygems/uninstaller.rb', line 310

def path_ok?(gem_dir, spec)
  full_path     = File.join gem_dir, "gems", spec.full_name
  original_path = File.join gem_dir, "gems", spec.original_name

  full_path == spec.full_gem_path || original_path == spec.full_gem_path
end

#regenerate_plugins ⇒ Object

Regenerates plugin wrappers after removal.



300
301
302
303
304
305
 
# File 'lib/rubygems/uninstaller.rb', line 300

def regenerate_plugins
  latest = specification_record.latest_spec_for(@spec.name)
  return if latest.nil?

  regenerate_plugins_for(latest, plugin_dir_for(@spec))
end

#remove(spec) ⇒ Object

spec

the spec of the gem to be uninstalled

Raises:



241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/rubygems/uninstaller.rb', line 241

def remove(spec)
  unless path_ok?(@gem_home, spec) ||
         (@user_install && path_ok?(@user_dir, spec))
    e = Gem::GemNotInHomeException.new \
      "Gem '#{spec.full_name}' is not installed in directory #{@gem_home}"
    e.spec = spec

    raise e
  end

  raise Gem::FilePermissionError, spec.base_dir unless
    File.writable?(spec.base_dir)

  full_gem_path = spec.full_gem_path
  exclusions = []

  if default_spec_matches?(spec) && spec.executables.any?
    exclusions = spec.executables.map {|exe| File.join(spec.bin_dir, exe) }
    exclusions << File.dirname(exclusions.last) until exclusions.last == full_gem_path
  end

  safe_delete { rm_r full_gem_path, exclusions: exclusions }
  safe_delete { FileUtils.rm_r spec.extension_dir }

  old_platform_name = spec.original_name

  gem = spec.cache_file
  gem = File.join(spec.cache_dir, "#{old_platform_name}.gem") unless
    File.exist? gem

  safe_delete { FileUtils.rm_r gem }

  begin
    Gem::RDoc.new(spec).remove
  rescue NameError
  end

  gemspec = spec.spec_file

  unless File.exist? gemspec
    gemspec = File.join(File.dirname(gemspec), "#{old_platform_name}.gemspec")
  end

  safe_delete { FileUtils.rm_r gemspec }
  announce_deletion_of(spec)
end

#remove_all(list) ⇒ Object

Removes all gems in list.

NOTE: removes uninstalled gems from list.



234
235
236
 
# File 'lib/rubygems/uninstaller.rb', line 234

def remove_all(list)
  list.each {|spec| uninstall_gem spec }
end

#remove_executables(spec) ⇒ Object

Removes installed executables and batch files (windows only) for spec.



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/rubygems/uninstaller.rb', line 180

def remove_executables(spec)
  return if spec.executables.empty? || default_spec_matches?(spec)

  executables = spec.executables.clone

  # Leave any executables created by other installed versions
  # of this gem installed.

  list = Gem::Specification.find_all do |s|
    s.name == spec.name && s.version != spec.version
  end

  list.each do |s|
    s.executables.each do |exe_name|
      executables.delete exe_name
    end
  end

  return if executables.empty?

  executables = executables.map {|exec| formatted_program_filename exec }

  remove = if @force_executables.nil?
    ask_yes_no("Remove executables:\n" \
               "\t#{executables.join ", "}\n\n" \
               "in addition to the gem?",
               true)
  else
    @force_executables
  end

  if remove
    bin_dir = @bin_dir || Gem.bindir(spec.base_dir)

    raise Gem::FilePermissionError, bin_dir unless File.writable? bin_dir

    executables.each do |exe_name|
      say "Removing #{exe_name}"

      exe_file = File.join bin_dir, exe_name

      safe_delete { FileUtils.rm exe_file }
      safe_delete { FileUtils.rm "#{exe_file}.bat" }
    end
  else
    say "Executables and scripts will remain installed."
  end
end

#remove_plugins(spec) ⇒ Object

Remove any plugin wrappers for spec.



291
292
293
294
295
 
# File 'lib/rubygems/uninstaller.rb', line 291

def remove_plugins(spec) # :nodoc:
  return if spec.plugins.empty?

  remove_plugins_for(spec, plugin_dir_for(spec))
end

#safe_delete(&block) ⇒ Object 



376
377
378
379
380
381
382
383
384
385
 
# File 'lib/rubygems/uninstaller.rb', line 376

def safe_delete(&block)
  block.call
rescue Errno::ENOENT
  nil
rescue Errno::EPERM
  e = Gem::UninstallError.new
  e.spec = @spec

  raise e
end

#uninstall ⇒ Object

Performs the uninstall of the gem. This removes the spec, the Gem directory, and the cached .gem file.



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/rubygems/uninstaller.rb', line 84

def uninstall
  dependency = Gem::Dependency.new @gem, @version

  list = []

  specification_record.stubs.each do |spec|
    next unless dependency.matches_spec? spec

    list << spec
  end

  if list.empty?
    raise Gem::InstallError, "gem #{@gem.inspect} is not installed"
  end

  default_specs, list = list.partition(&:default_gem?)
  warn_cannot_uninstall_default_gems(default_specs - list)
  @default_specs_matching_uninstall_params = default_specs.map(&:to_spec)

  list, other_repo_specs = list.partition do |spec|
    @gem_home == spec.base_dir ||
      (@user_install && spec.base_dir == @user_dir)
  end

  list.sort!

  if list.empty?
    return unless other_repo_specs.any?

    other_repos = other_repo_specs.map(&:base_dir).uniq

    message = ["#{@gem} is not installed in GEM_HOME, try:"]
    message.concat other_repos.map {|repo|
      "\tgem uninstall -i #{repo} #{@gem}"
    }

    raise Gem::InstallError, message.join("\n")
  elsif @force_all
    remove_all list

  elsif list.size > 1
    gem_names = list.map(&:full_name_with_location)
    gem_names << "All versions"

    say
    _, index = choose_from_list "Select gem to uninstall:", gem_names

    if index == list.size
      remove_all list
    elsif index && index >= 0 && index < list.size
      uninstall_gem list[index]
    else
      say "Error: must enter a number [1-#{list.size + 1}]"
    end
  else
    uninstall_gem list.first
  end
end

#uninstall_gem(stub) ⇒ Object

Uninstalls gem spec



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/rubygems/uninstaller.rb', line 146

def uninstall_gem(stub)
  spec = stub.to_spec

  @spec = spec

  unless dependencies_ok? spec
    if abort_on_dependent? || !ask_if_ok(spec)
      raise Gem::DependencyRemovalException,
        "Uninstallation aborted due to dependent gem(s)"
    end
  end

  Gem.pre_uninstall_hooks.each do |hook|
    hook.call self
  end

  remove_executables @spec
  remove_plugins @spec
  remove @spec

  specification_record.remove_spec(stub)

  regenerate_plugins

  Gem.post_uninstall_hooks.each do |hook|
    hook.call self
  end

  @spec = nil
end