deps: use Formula#runtime_dependencies.

Library/Homebrew/cmd/deps.rb

@@ -75,30 +75,40 @@ module Homebrew
         raise FormulaUnspecifiedError if ARGV.named.empty?
         puts_deps_tree ARGV.formulae, !ARGV.one?
       end
+      return
     elsif mode.all?
       puts_deps Formula.sort
-    elsif ARGV.named.empty?
+      return
+    elsif !ARGV.named.empty? && mode.for_each?
+      puts_deps ARGV.formulae
+      return
+    end
+
+    @only_installed_arg = ARGV.include?("--installed") &&
+                          !ARGV.include?("--include-build") &&
+                          !ARGV.include?("--include-test") &&
+                          !ARGV.include?("--include-optional") &&
+                          !ARGV.include?("--skip-recommended")
+
+    if ARGV.named.empty?
       raise FormulaUnspecifiedError unless mode.installed?
       puts_deps Formula.installed.sort
-    elsif mode.for_each?
+      return
-      puts_deps ARGV.formulae
+    end
-    else
+
     all_deps = deps_for_formulae(ARGV.formulae, !ARGV.one?, &(mode.union? ? :| : :&))
     all_deps = condense_requirements(all_deps)
-      all_deps = all_deps.select(&:installed?) if mode.installed?
+    all_deps.select!(&:installed?) if mode.installed?
-      all_deps = all_deps.map(&method(:dep_display_name)).uniq
+    all_deps.map!(&method(:dep_display_name))
+    all_deps.uniq!
     all_deps.sort! unless mode.topo_order?
     puts all_deps
   end
-  end
 
   def condense_requirements(deps)
-    if ARGV.include?("--include-requirements")
+    return deps if ARGV.include?("--include-requirements")
-      deps
-    else
     deps.select { |dep| dep.is_a? Dependency }
   end
-  end
 
   def dep_display_name(dep)
     str = if dep.is_a? Requirement
@@ -108,26 +118,32 @@ module Homebrew
         # This shouldn't happen, but we'll put something here to help debugging
         "::#{dep.name}"
       end
+    elsif ARGV.include?("--full-name")
+      dep.to_formula.full_name
     else
-      ARGV.include?("--full-name") ? dep.to_formula.full_name : dep.name
+      dep.name
     end
+
     if ARGV.include?("--annotate")
       str = "#{str}  [build]" if dep.build?
       str = "#{str}  [test]" if dep.test?
       str = "#{str}  [optional" if dep.optional?
       str = "#{str}  [recommended]" if dep.recommended?
     end
+
     str
   end
 
   def deps_for_formula(f, recursive = false)
     includes, ignores = argv_includes_ignores(ARGV)
 
+    deps = f.runtime_dependencies if @only_installed_arg
+
     if recursive
-      deps = recursive_includes(Dependency,  f, includes, ignores)
+      deps ||= recursive_includes(Dependency,  f, includes, ignores)
       reqs   = recursive_includes(Requirement, f, includes, ignores)
     else
-      deps = reject_ignores(f.deps, ignores, includes)
+      deps ||= reject_ignores(f.deps, ignores, includes)
       reqs   = reject_ignores(f.requirements, ignores, includes)
     end
 
@@ -142,7 +158,8 @@ module Homebrew
     formulae.each do |f|
       deps = deps_for_formula(f)
       deps = condense_requirements(deps)
-      deps = deps.sort_by(&:name).map(&method(:dep_display_name))
+      deps.sort_by!(&:name)
+      deps.map!(&method(:dep_display_name))
       puts "#{f.full_name}: #{deps.join(" ")}"
     end
   end
@@ -160,33 +177,39 @@ module Homebrew
     reqs = f.requirements
     deps = f.deps
     dependables = reqs + deps
-    dependables = dependables.reject(&:optional?) unless ARGV.include?("--include-optional")
+    dependables.reject!(&:optional?) unless ARGV.include?("--include-optional")
-    dependables = dependables.reject(&:build?) unless ARGV.include?("--include-build")
+    dependables.reject!(&:build?) unless ARGV.include?("--include-build")
-    dependables = dependables.reject(&:test?) unless ARGV.include?("--include-test")
+    dependables.reject!(&:test?) unless ARGV.include?("--include-test")
-    dependables = dependables.reject(&:recommended?) if ARGV.include?("--skip-recommended")
+    dependables.reject!(&:recommended?) if ARGV.include?("--skip-recommended")
     max = dependables.length - 1
     @dep_stack.push f.name
     dependables.each_with_index do |dep, i|
       next if !ARGV.include?("--include-requirements") && dep.is_a?(Requirement)
+
       tree_lines = if i == max
         "└──"
       else
         "├──"
       end
+
       display_s = "#{tree_lines} #{dep_display_name(dep)}"
       is_circular = @dep_stack.include?(dep.name)
       display_s = "#{display_s} (CIRCULAR DEPENDENCY)" if is_circular
       puts "#{prefix}#{display_s}"
+
       next if !recursive || is_circular
+
       prefix_addition = if i == max
         "    "
       else
         "│   "
       end
+
       if dep.is_a? Dependency
         recursive_deps_tree(Formulary.factory(dep.name), prefix + prefix_addition, true)
       end
     end
+
     @dep_stack.pop
   end
 end