Module: Cucumber::Formatter::Console

Extended by:
ANSIColor
Includes:
Duration
Included in:
ConsoleCounts, ConsoleIssues, Pretty, Progress, Steps, Summary, Usage
Defined in:
lib/cucumber/formatter/console.rb

Overview

This module contains helper methods that are used by formatters that print output to the terminal.

FORMAT is a hash of Proc objects, keyed by step-definition types, e.g. “FORMAT”. The Proc is called for each line of the step’s output.

format_step calls format_string, format_string calls format_for to obtain the formatting Proc.

Example:

The ANSI color console formatter defines a map of step-type to output color (e.g. “passed” to “green”), then builds methods named for the step-types (e.g. “def passed”), which themselves wrap the corresponding color-named methods provided by Term::ANSIColor (e.g. “def red”).

During output, each line is processed by passing it to the formatter Proc which returns the formatted (e.g. colored) string.

Defined Under Namespace

Classes: SnippetData

Constant Summary

Constants included from ANSIColor

ANSIColor::ALIASES

Constants included from Term::ANSIColor

Term::ANSIColor::ATTRIBUTES, Term::ANSIColor::ATTRIBUTE_NAMES, Term::ANSIColor::COLORED_REGEXP

Instance Method Summary collapse

Methods included from ANSIColor

apply_custom_colors, cukes, green_cukes, red_cukes, yellow_cukes

Methods included from Term::ANSIColor

#attributes, included, #uncolored

Methods included from Duration

#format_duration

Instance Method Details

#attach(src, media_type, filename) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/cucumber/formatter/console.rb', line 172

def attach(src, media_type, filename)
  return unless media_type == 'text/x.cucumber.log+plain'
  return unless @io

  @io.puts
  if filename
    @io.puts("#{filename}: #{format_string(src, :tag)}")
  else
    @io.puts(format_string(src, :tag))
  end

  @io.flush
end

#collect_snippet_data(test_step, ast_lookup) ⇒ Object 



116
117
118
119
120
 
# File 'lib/cucumber/formatter/console.rb', line 116

def collect_snippet_data(test_step, ast_lookup)
  # collect snippet data for undefined steps
  keyword = ast_lookup.snippet_step_keyword(test_step)
  @snippets_input << Console::SnippetData.new(keyword, test_step)
end

#collect_undefined_parameter_type_names(undefined_parameter_type) ⇒ Object 



122
123
124
 
# File 'lib/cucumber/formatter/console.rb', line 122

def collect_undefined_parameter_type_names(undefined_parameter_type)
  @undefined_parameter_types << undefined_parameter_type.type_name
end

#do_print_passing_wip(passed_messages) ⇒ Object 



163
164
165
166
167
168
169
170
 
# File 'lib/cucumber/formatter/console.rb', line 163

def do_print_passing_wip(passed_messages)
  if passed_messages.any?
    @io.puts format_string("\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:", :failed)
    print_element_messages(passed_messages, :passed, 'scenarios')
  else
    @io.puts format_string("\nThe --wip switch was used, so the failures were expected. All is good.\n", :passed)
  end
end

#do_print_profile_information(profiles) ⇒ Object 



192
193
194
195
196
197
198
199
200
 
# File 'lib/cucumber/formatter/console.rb', line 192

def do_print_profile_information(profiles)
  profiles_sentence = if profiles.size == 1
                        profiles.first
                      else
                        "#{profiles[0...-1].join(', ')} and #{profiles.last}"
                      end

  @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
end

#do_print_snippets(snippet_text_proc) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/cucumber/formatter/console.rb', line 139

def do_print_snippets(snippet_text_proc)
  snippets = @snippets_input.map do |data|
    snippet_text_proc.call(data.actual_keyword, data.step.text, data.step.multiline_arg)
  end.uniq

  text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
  text += snippets.join("\n\n")
  @io.puts format_string(text, :undefined)

  @io.puts
  @io.flush
end

#do_print_undefined_parameter_type_snippet(type_name) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/cucumber/formatter/console.rb', line 202

def do_print_undefined_parameter_type_snippet(type_name)
  camelized = type_name.split(/_|-/).collect(&:capitalize).join

  @io.puts [
    "The parameter #{type_name} is not defined. You can define a new one with:",
    '',
    'ParameterType(',
    "  name:        '#{type_name}',",
    '  regexp:      /some regexp here/,',
    "  type:        #{camelized},",
    '  # The transformer takes as many arguments as there are capture groups in the regexp,',
    '  # or just one if there are none.',
    "  transformer: ->(s) { #{camelized}.new(s) }",
    ')',
    ''
  ].join("\n")
end

#exception_message_string(exception, indent_amount) ⇒ Object 



100
101
102
103
104
105
 
# File 'lib/cucumber/formatter/console.rb', line 100

def exception_message_string(exception, indent_amount)
  message = "#{exception.message} (#{exception.class})".dup.force_encoding('UTF-8')
  message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)

  indent("#{message}\n#{exception.backtrace.join("\n")}", indent_amount)
end

#format_step(keyword, step_match, status, source_indent) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/cucumber/formatter/console.rb', line 33

def format_step(keyword, step_match, status, source_indent)
  comment = if source_indent
              c = indent("# #{step_match.location}", source_indent)
              format_string(c, :comment)
            else
              ''
            end

  format = format_for(status, :param)
  line = keyword + step_match.format_args(format) + comment
  format_string(line, status)
end

#format_string(input, status) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
 
# File 'lib/cucumber/formatter/console.rb', line 46

def format_string(input, status)
  fmt = format_for(status)
  input.to_s.split("\n").map do |line|
    if fmt.instance_of?(Proc)
      fmt.call(line)
    else
      fmt % line
    end
  end.join("\n")
end

#indent(string, padding) ⇒ Object 



220
221
222
223
224
225
226
 
# File 'lib/cucumber/formatter/console.rb', line 220

def indent(string, padding)
  if padding >= 0
    string.gsub(/^/, ' ' * padding)
  else
    string.gsub(/^ {0,#{-padding}}/, '')
  end
end

#linebreaks(msg, max) ⇒ Object

blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655



108
109
110
111
112
113
114
 
# File 'lib/cucumber/formatter/console.rb', line 108

def linebreaks(msg, max)
  return msg unless max.positive?

  msg.gsub(/.{1,#{max}}(?:\s|\Z)/) do
    (Regexp.last_match(0) + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n")
  end.rstrip
end

#print_element_messages(element_messages, status, kind) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/cucumber/formatter/console.rb', line 64

def print_element_messages(element_messages, status, kind)
  if element_messages.any?
    @io.puts(format_string("(::) #{status} #{kind} (::)", status))
    @io.puts
    @io.flush
  end

  element_messages.each do |message|
    @io.puts(format_string(message, status))
    @io.puts
    @io.flush
  end
end

#print_elements(elements, status, kind) ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/cucumber/formatter/console.rb', line 57

def print_elements(elements, status, kind)
  return if elements.empty?

  element_messages = element_messages(elements, status)
  print_element_messages(element_messages, status, kind)
end

#print_exception(exception, status, indent) ⇒ Object 



95
96
97
98
 
# File 'lib/cucumber/formatter/console.rb', line 95

def print_exception(exception, status, indent)
  string = exception_message_string(exception, indent)
  @io.puts(format_string(string, status))
end

#print_passing_wip(config, passed_test_cases, ast_lookup) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
 
# File 'lib/cucumber/formatter/console.rb', line 152

def print_passing_wip(config, passed_test_cases, ast_lookup)
  return unless config.wip?

  messages = passed_test_cases.map do |test_case|
    scenario_source = ast_lookup.scenario_source(test_case)
    keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
    linebreaks("#{test_case.location.on_line(test_case.location.lines.max)}:in `#{keyword}: #{test_case.name}'", ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
  end
  do_print_passing_wip(messages)
end

#print_profile_information ⇒ Object 



186
187
188
189
190
 
# File 'lib/cucumber/formatter/console.rb', line 186

def print_profile_information
  return if @options[:skip_profile_information] || @options[:profiles].nil? || @options[:profiles].empty?

  do_print_profile_information(@options[:profiles])
end

#print_snippets(options) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/cucumber/formatter/console.rb', line 126

def print_snippets(options)
  return unless options[:snippets]

  snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
    snippet_text(step_keyword, step_name, multiline_arg)
  end
  do_print_snippets(snippet_text_proc) unless @snippets_input.empty?

  @undefined_parameter_types.map do |type_name|
    do_print_undefined_parameter_type_snippet(type_name)
  end
end

#print_statistics(duration, config, counts, issues) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/cucumber/formatter/console.rb', line 78

def print_statistics(duration, config, counts, issues)
  if issues.any?
    @io.puts issues.to_s
    @io.puts
  end

  @io.puts counts.to_s
  @io.puts(format_duration(duration)) if duration && config.duration?

  if config.randomize?
    @io.puts
    @io.puts "Randomized with seed #{config.seed}"
  end

  @io.flush
end