Rspec Steps C0 Coverage Information - RCov

rcov/ruby/1.8/gems/rspec-core-2.5.1/lib/rspec/core/formatters/base_text_formatter.rb

Name Total Lines Lines of Code Total Coverage Code Coverage
rcov/ruby/1.8/gems/rspec-core-2.5.1/lib/rspec/core/formatters/base_text_formatter.rb 165 134
59.39%
51.49%

Key

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.

Coverage Details

1 require 'rspec/core/formatters/base_formatter'
2 
3 module RSpec
4   module Core
5     module Formatters
6 
7       class BaseTextFormatter < BaseFormatter
8 
9         def message(message)
10           output.puts message
11         end
12 
13         def dump_failures
14           return if failed_examples.empty?
15           output.puts
16           output.puts "Failures:"
17           failed_examples.each_with_index do |example, index|
18             output.puts
19             dump_pending_example_fixed(example, index) || dump_failure(example, index)
20             dump_backtrace(example)
21           end
22         end
23 
24         def colorise_summary(summary)
25           if failure_count == 0
26             if pending_count > 0
27               yellow(summary)
28             else
29               green(summary)
30             end
31           else
32             red(summary)
33           end
34         end
35 
36         def dump_summary(duration, example_count, failure_count, pending_count)
37           super(duration, example_count, failure_count, pending_count)
38           # Don't print out profiled info if there are failures, it just clutters the output
39           dump_profile if profile_examples? && failure_count == 0
40           output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
41           output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
42         end
43 
44         def dump_profile
45           sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
46           output.puts "\nTop #{sorted_examples.size} slowest examples:\n"
47           sorted_examples.each do |example|
48             output.puts "  #{example.full_description}"
49             output.puts grey("    #{red(format_seconds(example.execution_result[:run_time]))} #{red("seconds")} #{format_caller(example.location)}")
50           end
51         end
52 
53         def summary_line(example_count, failure_count, pending_count)
54           summary = pluralize(example_count, "example")
55           summary << ", " << pluralize(failure_count, "failure")
56           summary << ", #{pending_count} pending" if pending_count > 0
57           summary
58         end
59 
60         def dump_pending
61           unless pending_examples.empty?
62             output.puts
63             output.puts "Pending:"
64             pending_examples.each do |pending_example|
65               output.puts yellow("  #{pending_example.full_description}")
66               output.puts grey("    # #{pending_example.execution_result[:pending_message]}")
67               output.puts grey("    # #{format_caller(pending_example.location)}")
68             end
69           end
70         end
71 
72         def close
73           output.close if IO === output && output != $stdout
74         end
75 
76       protected
77 
78         def color(text, color_code)
79           color_enabled? ? "#{color_code}#{text}\e[0m" : text
80         end
81 
82         def bold(text)
83           color(text, "\e[1m")
84         end
85 
86         def white(text)
87           color(text, "\e[37m")
88         end
89 
90         def green(text)
91           color(text, "\e[32m")
92         end
93 
94         def red(text)
95           color(text, "\e[31m")
96         end
97 
98         def magenta(text)
99           color(text, "\e[35m")
100         end
101 
102         def yellow(text)
103           color(text, "\e[33m")
104         end
105 
106         def blue(text)
107           color(text, "\e[34m")
108         end
109 
110         def grey(text)
111           color(text, "\e[90m")
112         end
113 
114         def short_padding
115           '  '
116         end
117 
118         def long_padding
119           '     '
120         end
121 
122       private
123 
124         def pluralize(count, string)
125           "#{count} #{string}#{'s' unless count == 1}"
126         end
127 
128         def format_caller(caller_info)
129           backtrace_line(caller_info.to_s.split(':in `block').first)
130         end
131 
132         def dump_backtrace(example)
133           format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
134             output.puts grey("#{long_padding}# #{backtrace_info}")
135           end
136         end
137 
138         def dump_pending_example_fixed(example, index)
139           if RSpec::Core::PendingExampleFixedError === example.execution_result[:exception]
140             output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
141             output.puts blue("#{long_padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised.")
142             true
143           end
144         end
145 
146         def dump_failure(example, index)
147           exception = example.execution_result[:exception]
148           output.puts "#{short_padding}#{index.next}) #{example.full_description}"
149           output.puts "#{long_padding}#{red("Failure/Error:")} #{red(read_failed_line(exception, example).strip)}"
150           output.puts "#{long_padding}#{red(exception.class.name << ":")}" unless exception.class.name =~ /RSpec/
151           exception.message.split("\n").each { |line| output.puts "#{long_padding}  #{red(line)}" }
152 
153           example.example_group.ancestors.push(example.example_group).each do |group|
154             if group.metadata[:shared_group_name]
155               output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
156                 "#{backtrace_line(group.metadata[:example_group][:location])}"
157               break
158             end
159           end
160         end
161 
162       end
163     end
164   end
165 end

Generated on Fri Apr 22 17:22:42 -0700 2011 with rcov 0.9.8