C0 code coverage information

Generated on Sun Aug 31 02:38:34 -0400 2008 with rcov 0.8.1.2


Code reported as executed by Ruby looks like this...
and this: this line is also marked as covered.
Lines considered as run by rcov, but not reported by Ruby, look like this,
and this: these lines were inferred by rcov (using simple heuristics).
Finally, here's a line marked as not executed.
Name Total lines Lines of code Total coverage Code coverage
/Library/Ruby/Site/1.8/rubygems/dependency_list.rb 165 104
52.7%  
25.0%  
  1 #--
  2 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
  3 # All rights reserved.
  4 # See LICENSE.txt for permissions.
  5 #++
  6 
  7 require 'tsort'
  8 
  9 class Gem::DependencyList
 10 
 11   include TSort
 12 
 13   def self.from_source_index(src_index)
 14     deps = new
 15 
 16     src_index.each do |full_name, spec|
 17       deps.add spec
 18     end
 19 
 20     deps
 21   end
 22 
 23   def initialize
 24     @specs = []
 25   end
 26 
 27   # Adds +gemspecs+ to the dependency list.
 28   def add(*gemspecs)
 29     @specs.push(*gemspecs)
 30   end
 31 
 32   # Return a list of the specifications in the dependency list,
 33   # sorted in order so that no spec in the list depends on a gem
 34   # earlier in the list.
 35   #
 36   # This is useful when removing gems from a set of installed gems.
 37   # By removing them in the returned order, you don't get into as
 38   # many dependency issues.
 39   #
 40   # If there are circular dependencies (yuck!), then gems will be
 41   # returned in order until only the circular dependents and anything
 42   # they reference are left.  Then arbitrary gemspecs will be returned
 43   # until the circular dependency is broken, after which gems will be
 44   # returned in dependency order again.
 45   def dependency_order
 46     sorted = strongly_connected_components.flatten
 47 
 48     result = []
 49     seen = {}
 50 
 51     sorted.each do |spec|
 52       if index = seen[spec.name] then
 53         if result[index].version < spec.version then
 54           result[index] = spec
 55         end
 56       else
 57         seen[spec.name] = result.length
 58         result << spec
 59       end
 60     end
 61 
 62     result.reverse
 63   end
 64 
 65   def find_name(full_name)
 66     @specs.find { |spec| spec.full_name == full_name }
 67   end
 68 
 69   # Are all the dependencies in the list satisfied?
 70   def ok?
 71     @specs.all? do |spec|
 72       spec.runtime_dependencies.all? do |dep|
 73         @specs.find { |s| s.satisfies_requirement? dep }
 74       end
 75     end
 76   end
 77 
 78   # Is is ok to remove a gem from the dependency list?
 79   #
 80   # If removing the gemspec creates breaks a currently ok dependency,
 81   # then it is NOT ok to remove the gem.
 82   def ok_to_remove?(full_name)
 83     gem_to_remove = find_name full_name
 84 
 85     siblings = @specs.find_all { |s|
 86       s.name == gem_to_remove.name &&
 87         s.full_name != gem_to_remove.full_name
 88     }
 89 
 90     deps = []
 91 
 92     @specs.each do |spec|
 93       spec.dependencies.each do |dep|
 94         deps << dep if gem_to_remove.satisfies_requirement?(dep)
 95       end
 96     end
 97 
 98     deps.all? { |dep|
 99       siblings.any? { |s|
100         s.satisfies_requirement? dep
101       }
102     }
103   end
104 
105   def remove_by_name(full_name)
106     @specs.delete_if { |spec| spec.full_name == full_name }
107   end
108 
109   # Return a hash of predecessors.  <tt>result[spec]</tt> is an
110   # Array of gemspecs that have a dependency satisfied by the named
111   # spec.
112   def spec_predecessors
113     result = Hash.new { |h,k| h[k] = [] }
114 
115     specs = @specs.sort.reverse
116 
117     specs.each do |spec|
118       specs.each do |other|
119         next if spec == other
120 
121         other.dependencies.each do |dep|
122           if spec.satisfies_requirement? dep then
123             result[spec] << other
124           end
125         end
126       end
127     end
128 
129     result
130   end
131 
132   def tsort_each_node(&block)
133     @specs.each(&block)
134   end
135 
136   def tsort_each_child(node, &block)
137     specs = @specs.sort.reverse
138 
139     node.dependencies.each do |dep|
140       specs.each do |spec|
141         if spec.satisfies_requirement? dep then
142           begin
143             yield spec
144           rescue TSort::Cyclic
145           end
146           break
147         end
148       end
149     end
150   end
151 
152   private
153 
154   # Count the number of gemspecs in the list +specs+ that are not in
155   # +ignored+.
156   def active_count(specs, ignored)
157     result = 0
158     specs.each do |spec|
159       result += 1 unless ignored[spec.full_name]
160     end
161     result
162   end
163 
164 end
165 

Generated using the rcov code coverage analysis tool for Ruby version 0.8.1.2.

Valid XHTML 1.0! Valid CSS!