From 5eed35274437b8c52be1e627d97ad7d46965f164 Mon Sep 17 00:00:00 2001 From: Max Eisner <4730112+max-ae@users.noreply.github.com> Date: Wed, 5 Aug 2020 23:48:46 +0200 Subject: [PATCH] fixed arg passing due to Homebrew/brew#8144 (#42) --- cmd/brew-rmtree.rb | 73 +++++++++++++++++++++++----------------------- 1 file changed, 37 insertions(+), 36 deletions(-) diff --git a/cmd/brew-rmtree.rb b/cmd/brew-rmtree.rb index 57cbb72..c854624 100755 --- a/cmd/brew-rmtree.rb +++ b/cmd/brew-rmtree.rb @@ -126,7 +126,7 @@ def orphaned_dependencies(keg_name) end # A list of kegs that use keg_name, using homebrew code instead of shell cmd - def uses(keg_name, recursive=true, ignores=[]) + def uses(keg_name, recursive=true, ignores=[], args:) # https://raw.githubusercontent.com/Homebrew/brew/master/Library/Homebrew/cmd/uses.rb formulae = [Formulary.factory(keg_name)] uses = Formula.installed.select do |f| @@ -173,7 +173,7 @@ def uses(keg_name, recursive=true, ignores=[]) reqs = reqs_by_formula.map(&:last) else - includes, ignores = Homebrew.argv_includes_ignores(["--installed"]) + includes, ignores = Homebrew.args_includes_ignores(args) deps = f.deps.reject do |dep| ignores.any? { |ignore| dep.send(ignore) } && includes.none? { |include| dep.send(include) } end @@ -204,9 +204,9 @@ def uses(keg_name, recursive=true, ignores=[]) uses.map(&:full_name) end - def deps_for_formula(f) + def deps_for_formula(f, args:) # https://github.com/Homebrew/brew/blob/d1b83819deacd99b55c9d400149dc9b49fa795df/Library/Homebrew/cmd/deps.rb#L137 - includes, ignores = Homebrew.argv_includes_ignores(["--installed"]) + includes, ignores = Homebrew.args_includes_ignores(args) deps = f.runtime_dependencies reqs = Homebrew.reject_ignores(f.requirements, ignores, includes) @@ -215,8 +215,8 @@ def deps_for_formula(f) end # Gather complete list of packages used by root package - def dependency_tree(keg_name, recursive=true) - deps_for_formula(as_formula(keg_name) + def dependency_tree(keg_name, recursive=true, args:) + deps_for_formula(as_formula(keg_name), args: args ).map{ |x| as_formula(x) } .reject{ |x| x.nil? } .select(&:any_version_installed? @@ -224,8 +224,8 @@ def dependency_tree(keg_name, recursive=true) end # Returns a set of dependencies as their keg name - def dependency_tree_as_keg_names(keg_name, recursive=true) - @dependency_table[keg_name] ||= dependency_tree(keg_name, recursive).map!(&:name) + def dependency_tree_as_keg_names(keg_name, recursive=true, args:) + @dependency_table[keg_name] ||= dependency_tree(keg_name, recursive, args: args).map!(&:name) end # Return a formula for keg_name @@ -256,16 +256,16 @@ def find_active_formula(name) end end - def used_by(dep_name, del_formula) - @used_by_table[dep_name] ||= uses(dep_name, false).to_set.delete(del_formula.full_name) + def used_by(dep_name, del_formula, args:) + @used_by_table[dep_name] ||= uses(dep_name, false, args: args).to_set.delete(del_formula.full_name) end # Return list of installed formula that will still use this dependency # after deletion and thus cannot be removed. - def still_used_by(dep_name, del_formula, full_dep_list) + def still_used_by(dep_name, del_formula, full_dep_list, args:) # List of formulae that use this keg and aren't in the tree # of dependencies to be removed - return used_by(dep_name, del_formula).subtract(full_dep_list) + return used_by(dep_name, del_formula, args: args).subtract(full_dep_list) end def cant_remove(dep_set) @@ -328,31 +328,31 @@ def should_proceed_or_quit(prompt) end # Will mark any children and parents of dep as unremovable if dep is unremovable - def revisit_neighbors(of_dependency, del_formula, dep_set, wont_remove_because) + def revisit_neighbors(of_dependency, del_formula, dep_set, wont_remove_because, args:) # Prevent subsequent related formula from being flagged for removal dep_set.delete(of_dependency) # Update users of the dependency - used_by(of_dependency, del_formula).each do |user_of_d| + used_by(of_dependency, del_formula, args: args).each do |user_of_d| # Only update those we visited and think we can remove if wont_remove_because.has_key? user_of_d and can_remove(wont_remove_because[user_of_d]) wont_remove_because[user_of_d] << of_dependency - revisit_neighbors(user_of_d, del_formula, dep_set, wont_remove_because) + revisit_neighbors(user_of_d, del_formula, dep_set, wont_remove_because, args: args) end end # Update dependencies of the dependency - dependency_tree_as_keg_names(of_dependency, false).each do |d| + dependency_tree_as_keg_names(of_dependency, false, args: args).each do |d| # Only update those we visited and think we can remove if wont_remove_because.has_key? d and can_remove(wont_remove_because[d]) wont_remove_because[d] << of_dependency - revisit_neighbors(d, del_formula, dep_set, wont_remove_because) + revisit_neighbors(d, del_formula, dep_set, wont_remove_because, args: args) end end end # Walk the tree and decide which ones are safe to remove - def build_tree(keg_name, ignored_kegs=[]) + def build_tree(keg_name, ignored_kegs=[], args: ) # List used to save the status of all dependency packages wont_remove_because = {} @@ -363,7 +363,7 @@ def build_tree(keg_name, ignored_kegs=[]) f = as_formula(keg_name) # Get the complete list of dependencies and convert it to just keg names - dep_arr = dependency_tree_as_keg_names(keg_name) + dep_arr = dependency_tree_as_keg_names(keg_name, args: args) dep_set = dep_arr.to_set # For each possible dependency that we want to remove, check if anything @@ -376,7 +376,7 @@ def build_tree(keg_name, ignored_kegs=[]) # Save the list of formulae that use this keg and aren't in the tree # of dependencies to be removed - wont_remove_because[dep] = still_used_by(dep, f, dep_set) + wont_remove_because[dep] = still_used_by(dep, f, dep_set, args: args) # Allow user to keep dependencies that aren't used anymore by saying # something phony uses it @@ -390,7 +390,7 @@ def build_tree(keg_name, ignored_kegs=[]) # because at the time they didn't have this new information if cant_remove(wont_remove_because[dep]) # This dependency can't be removed. Users and dependencies need to be reconsidered. - revisit_neighbors(dep, f, dep_set, wont_remove_because) + revisit_neighbors(dep, f, dep_set, wont_remove_because, args: args) end set_spinner_progress " #{wont_remove_because.size} / #{dep_arr.length} " @@ -400,7 +400,7 @@ def build_tree(keg_name, ignored_kegs=[]) return wont_remove_because end - def order_to_be_removed_v2(start_from, wont_remove_because) + def order_to_be_removed_v2(start_from, wont_remove_because, args:) # Maintain stuff we delete deleted_formulae = [start_from] @@ -414,7 +414,7 @@ def order_to_be_removed_v2(start_from, wont_remove_because) while maybe_dependencies_to_delete.size != last_size last_size = maybe_dependencies_to_delete.size maybe_dependencies_to_delete.each do |dep| - _used_by = uses(dep, false).to_set.subtract(deleted_formulae.to_set) + _used_by = uses(dep, false, args: args).to_set.subtract(deleted_formulae.to_set) # puts "Deleted formulae are #{deleted_formulae.inspect()}" # puts "#{dep} is used by #{_used_by.inspect()}" if _used_by.size == 0 @@ -427,10 +427,10 @@ def order_to_be_removed_v2(start_from, wont_remove_because) return deleted_formulae, maybe_dependencies_to_delete end - def rmtree(keg_name, force=false, ignored_kegs=[]) + def rmtree(keg_name, force=false, ignored_kegs=[], args:) # Does anything use keg such that we can't remove it? if !force - keg_used_by = uses(keg_name, false) + keg_used_by = uses(keg_name, false, args: args) if !keg_used_by.empty? puts "#{keg_name} can't be removed because other formula depend on it:" puts keg_used_by.join(", ") @@ -445,9 +445,10 @@ def rmtree(keg_name, force=false, ignored_kegs=[]) end # Dependency list of what can be removed, and what can't, and why - wont_remove_because = build_tree(keg_name, ignored_kegs) + wont_remove_because = build_tree(keg_name, ignored_kegs, args: args) - kegs_to_delete_in_order, maybe_dependencies_to_delete = order_to_be_removed_v2(keg_name, wont_remove_because) + kegs_to_delete_in_order, maybe_dependencies_to_delete = order_to_be_removed_v2(keg_name, wont_remove_because, + args: args) # Dry run print out more information on what will happen if @dry_run @@ -463,7 +464,7 @@ def rmtree(keg_name, force=false, ignored_kegs=[]) describe_build_tree_wont_remove(wont_remove_because) if @dry_run maybe_dependencies_to_delete.each do |dep| - _used_by = uses(dep, false).to_set.subtract(kegs_to_delete_in_order) + _used_by = uses(dep, false, args: args).to_set.subtract(kegs_to_delete_in_order) puts "#{dep} is used by #{_used_by.to_a.join(', ')}" end end @@ -523,16 +524,16 @@ def rmtree_args end def main - rmtree_args.parse + args = rmtree_args.parse - force = Homebrew.args.force? + force = args.force? ignored_kegs = [] - ignored_kegs.push(*Homebrew.args.ignore) - rm_kegs = Homebrew.args.named - quiet = Homebrew.args.quiet? - @dry_run = Homebrew.args.dry_run? + ignored_kegs.push(*args.ignore) + rm_kegs = args.named + quiet = args.quiet? + @dry_run = args.dry_run? - raise KegUnspecifiedError if Homebrew.args.no_named? + raise KegUnspecifiedError if args.no_named? # Turn off output if 'quiet' is specified if quiet @@ -546,7 +547,7 @@ def main # Convert ignored kegs into full names ignored_kegs.map! { |k| as_formula(k).full_name } - rm_kegs.each { |keg_name| rmtree keg_name, force, ignored_kegs } + rm_kegs.each { |keg_name| rmtree keg_name, force, ignored_kegs, args: args } end end