Class: QED::Reporter::Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/qed/reporter/abstract.rb

Overview

Reporter Absract Base Class

Serves as the base class for all other output formats.

Direct Known Subclasses

Dot, Html, Linear, TapY, Verbatim

Constant Summary collapse

INFO_SIGNAL =

Does the system support INFO signal?

Signal.list['INFO']

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Abstract

TODO: pass session into initialize



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/qed/reporter/abstract.rb', line 31

def initialize(options={})
  @io    = options[:io] || STDOUT
  @trace = options[:trace]

  @record = {
    :demo  => [],
    :step  => [],
    :omit  => [],
    :pass  => [],
    :fail  => [],
    :error => []
  }

  #@demos = 0
  #@steps = 0
  #@omit  = []
  #@pass  = []
  #@fail  = []
  #@error = []

  @source = {}
end

Instance Attribute Details

#io ⇒ Object (readonly)

Returns the value of attribute io.



25
26
27
 
# File 'lib/qed/reporter/abstract.rb', line 25

def io
  @io
end

#record ⇒ Object (readonly)

Returns the value of attribute record.



28
29
30
 
# File 'lib/qed/reporter/abstract.rb', line 28

def record
  @record
end

#session ⇒ Object (readonly)

Returns the value of attribute session.



22
23
24
 
# File 'lib/qed/reporter/abstract.rb', line 22

def session
  @session
end

Class Method Details

.After(type, &block) ⇒ Object 



89
90
91
92
93
 
# File 'lib/qed/reporter/abstract.rb', line 89

def self.After(type, &block)
#  raise ArgumentError unless %w{session demo demonstration step pass fail error}.include?(type.to_s)
#  type = :demonstration if type.to_s == 'demo'
  define_method("after_#{type}", &block)
end

.Before(type, &block) ⇒ Object 



83
84
85
86
87
 
# File 'lib/qed/reporter/abstract.rb', line 83

def self.Before(type, &block)
#  raise ArgumentError unless %w{session demo demonstration step}.include?(type.to_s)
#  type = :demonstration if type.to_s == 'demo'
  define_method("before_#{type}", &block)
end

.When(type, &block) ⇒ Object 



77
78
79
80
81
 
# File 'lib/qed/reporter/abstract.rb', line 77

def self.When(type, &block)
  #raise ArgumentError unless %w{session demo demonstration step}.include?(type.to_s)
  #type = :demonstration if type.to_s == 'demo'
  define_method(type, &block)
end

Instance Method Details

#after_demo(demo) ⇒ Object

End of a demonstration.



225
226
 
# File 'lib/qed/reporter/abstract.rb', line 225

def after_demo(demo)  #demo(demo)
end

#after_eval(step) ⇒ Object 



213
214
 
# File 'lib/qed/reporter/abstract.rb', line 213

def after_eval(step)
end

#after_import(file) ⇒ Object 



209
210
 
# File 'lib/qed/reporter/abstract.rb', line 209

def after_import(file)
end

#after_proc(step) ⇒ Object 



217
218
 
# File 'lib/qed/reporter/abstract.rb', line 217

def after_proc(step)
end

#after_session(session) ⇒ Object

After running all demonstrations. This is the place to output a summary of the session, if applicable.



230
231
 
# File 'lib/qed/reporter/abstract.rb', line 230

def after_session(session)
end

#after_step(step) ⇒ Object 



221
222
 
# File 'lib/qed/reporter/abstract.rb', line 221

def after_step(step)
end

#before_demo(demo) ⇒ Object

Beginning of a demonstration.



139
140
141
 
# File 'lib/qed/reporter/abstract.rb', line 139

def before_demo(demo) #demo(demo)
  #demos << demo
end

#before_eval(step) ⇒ Object 



156
157
 
# File 'lib/qed/reporter/abstract.rb', line 156

def before_eval(step)
end

#before_import(file) ⇒ Object 



144
145
 
# File 'lib/qed/reporter/abstract.rb', line 144

def before_import(file)
end

#before_proc(step) ⇒ Object 



152
153
 
# File 'lib/qed/reporter/abstract.rb', line 152

def before_proc(step)
end

#before_session(session) ⇒ Object

At the start of a session, before running any demonstrations.



133
134
135
136
 
# File 'lib/qed/reporter/abstract.rb', line 133

def before_session(session)
  @session    = session
  @start_time = Time.now
end

#before_step(step) ⇒ Object 



148
149
 
# File 'lib/qed/reporter/abstract.rb', line 148

def before_step(step)
end

#call(type, *args) ⇒ Object 



72
73
74
75
 
# File 'lib/qed/reporter/abstract.rb', line 72

def call(type, *args)
  __send__("count_#{type}", *args) if respond_to?("count_#{type}")
  __send__(type, *args) if respond_to?(type)
end

#count_demo(demo) ⇒ Object

def After(type, target, *args)

type = :demonstration if type.to_s == 'demo'
__send__("after_#{type}", target, *args)

end



107
108
109
 
# File 'lib/qed/reporter/abstract.rb', line 107

def count_demo(demo)
  @record[:demo] << demo
end

#count_error(step, exception) ⇒ Object 



127
128
129
 
# File 'lib/qed/reporter/abstract.rb', line 127

def count_error(step, exception)
  @record[:error] << [step, exception]
end

#count_fail(step, exception) ⇒ Object 



123
124
125
 
# File 'lib/qed/reporter/abstract.rb', line 123

def count_fail(step, exception)
  @record[:fail] << [step, exception]
end

#count_pass(step) ⇒ Object

def count_eval(step)

@record[:eval] << step

end



119
120
121
 
# File 'lib/qed/reporter/abstract.rb', line 119

def count_pass(step)
  @record[:pass] << step
end

#count_step(step) ⇒ Object 



111
112
113
 
# File 'lib/qed/reporter/abstract.rb', line 111

def count_step(step)
  @record[:step] << step
end

#demo(demo) ⇒ Object

Reight before demo.



165
166
 
# File 'lib/qed/reporter/abstract.rb', line 165

def demo(demo)
end

#demos ⇒ Object 



54
 
# File 'lib/qed/reporter/abstract.rb', line 54

def demos  ; @record[:demo]  ; end

#error(step, exception) ⇒ Object

After running a step that raised an error.



203
204
205
206
 
# File 'lib/qed/reporter/abstract.rb', line 203

def error(step, exception)
  raise exception if $DEBUG  # TODO: do we really want to do it like this?
  ## @error << [step, exception]
end

#errors ⇒ Object 



58
 
# File 'lib/qed/reporter/abstract.rb', line 58

def errors ; @record[:error] ; end

#eval(step) ⇒ Object

Right before evaluation.



185
186
 
# File 'lib/qed/reporter/abstract.rb', line 185

def eval(step)
end

#fail(step, assertion) ⇒ Object

After running a step that failed.



198
199
200
 
# File 'lib/qed/reporter/abstract.rb', line 198

def fail(step, assertion)
  ## @fail << [step, assertion]
end

#fails ⇒ Object 



59
 
# File 'lib/qed/reporter/abstract.rb', line 59

def fails  ; @record[:fail]  ; end

#import(file) ⇒ Object

Right before import.



169
170
 
# File 'lib/qed/reporter/abstract.rb', line 169

def import(file)
end

#omits ⇒ Object 



56
 
# File 'lib/qed/reporter/abstract.rb', line 56

def omits  ; @record[:omit]  ; end

#pass(step) ⇒ Object

After running a step that passed.



193
194
195
 
# File 'lib/qed/reporter/abstract.rb', line 193

def pass(step)
  #@pass << step
end

#passes ⇒ Object 



57
 
# File 'lib/qed/reporter/abstract.rb', line 57

def passes ; @record[:pass]  ; end

#proc(step) ⇒ Object

Right before evaluation.



181
182
 
# File 'lib/qed/reporter/abstract.rb', line 181

def proc(step)
end

#rule(step) ⇒ Object

Right before rule section.



173
174
 
# File 'lib/qed/reporter/abstract.rb', line 173

def rule(step)
end

#step(step) ⇒ Object

Right before text section.



177
178
 
# File 'lib/qed/reporter/abstract.rb', line 177

def step(step)  #show text ?
end

#steps ⇒ Object 



55
 
# File 'lib/qed/reporter/abstract.rb', line 55

def steps  ; @record[:step]  ; end

#success? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
 
# File 'lib/qed/reporter/abstract.rb', line 67

def success?
  record[:error].size + record[:fail].size == 0
end

#trace? ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/qed/reporter/abstract.rb', line 62

def trace?
  @trace
end