Class: Spectroscope::Context::Scope

Inherits:
World
  • Object
show all
Defined in:
lib/spectroscope/context.rb

Overview

Context scope is used for defining sepcifications.

Instance Method Summary collapse

Constructor Details

#initialize(group) ⇒ Scope

Setup new evaluation scope.



208
209
210
211
212
213
214
215
216
217
 
# File 'lib/spectroscope/context.rb', line 208

def initialize(group)
  @_group = group
  @_hooks = group.hooks
  @_skips = group.skips
  @_omits = group.omits

  if group.parent
    include(group.parent.scope)
  end
end

Instance Method Details

#after(which = :each, *tags, &procedure) ⇒ Object

Define a complex after procedure. The #before method allows before procedures to be defined that are triggered by a match against the unit's target method name or aspect description. This allows groups of specs to be defined that share special teardown code.

Examples:

describe '#puts' do
  it "gives standard output (@stdout)" do
    puts "Hello"
  end

  before do
    $stdout = StringIO.new
  end

  after do
    $stdout = STDOUT
  end
end

Parameters:

  • which (Symbol) (defaults to: :each) —

    Must be either :all or :each, the later being the default.

  • tags (Array<Symbol>) —

    List of match critera that must be matched to trigger the after procedure.



333
334
335
 
# File 'lib/spectroscope/context.rb', line 333

def after(which=:each, *tags, &procedure)
  @_hooks.add(:after, which, *tags, &procedure)
end

#before(which = :each, *tags, &procedure) ⇒ Object

Define before procedure.

Examples:

describe '#puts' do
  it "gives standard output" do
    puts "Hello"
  end

  before do
    $stdout = StringIO.new
  end

  after do
    $stdout = STDOUT
  end
end

Parameters:

  • which (Symbol) (defaults to: :each) —

    Must be either :all or :each, the later being the default.

  • tags (Array<Symbol>) —

    List of match critera that must be matched against tags to trigger the before procedure.



300
301
302
 
# File 'lib/spectroscope/context.rb', line 300

def before(which=:each, *tags, &procedure)
  @_hooks.add(:before, which, *tags, &procedure)
end

#describe(topic, *tags, &block) ⇒ Object Also known as: context

Create a new sub-specification.



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/spectroscope/context.rb', line 222

def describe(topic, *tags, &block)
  settings = {}
  settings[:parent]  = @_group
  settings[:subject] = @_group.subject
  settings[:tags]    = tags

  if Class === topic
    settings[:subject] = topic
    settings[:label]   = topic.name
  else
    settings[:label]   = topic
  end

  group = Context.new(settings, &block)

  @_group.specs << group

  return group
end

#it(label = nil, *tags, &procedure) ⇒ Object Also known as: example

Create an example behavior.

If tags or keys are given, so must a label.



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/spectroscope/context.rb', line 249

def it(label=nil, *tags, &procedure)
  keys = (Hash===tags ? tags.pop : {})

  settings = {
    :parent => @_group,
    :hooks  => @_hooks,
    :skips  => @_skips,
    :omits  => @_omits,
    :topic  => @_topic,
    :label  => label,
    :tags   => tags,
    :keys   => keys
  }

  spec = Example.new(settings, &procedure)
 
  @_group.specs << spec

  spec
end

#it_behaves_like(label) ⇒ Object 



422
423
424
425
 
# File 'lib/spectroscope/context.rb', line 422

def it_behaves_like(label)
  proc = Spectroscope.shared_examples[label]
  module_eval(&proc)
end

#its(invocation, &block) ⇒ Object

Subject-oriented example.

RSpec itself wraps this whole thing in another describe(invocation) clause, but that seems completely extraneous.



397
398
399
400
401
402
403
404
405
406
407
408
409
410
 
# File 'lib/spectroscope/context.rb', line 397

def its(invocation, &block)
  case invocation
  when Symbol
    it(invocation.to_s) do
      subject.__send__(invocation).instance_eval(&block)
    end
  else
    it(invocation.to_s) do
      #eval("subject.#{invocation}", binding).instance_eval(&block)
      calls = invocation.to_s.split('.')
      calls.inject(subject){ |s,m| s.__send__(invocation) }.instance_eval(&block)
    end
  end
end

#let(name, &block) ⇒ Object 



368
369
370
371
372
373
 
# File 'lib/spectroscope/context.rb', line 368

def let(name, &block)
  define_method(name) do
    #_let[name] ||= block.call
    @_let.fetch(name){ |k| @_let[k] = instance_eval(&block) }
  end
end

#let!(name, &block) ⇒ Object 



378
379
380
381
 
# File 'lib/spectroscope/context.rb', line 378

def let!(name, &block)
  let(name, &block)
  before { __send__(name) }
end

#omit(reason = true, &block) ⇒ Object

Mark specs or sub-cases to be omitted. Omitting a test is different from skipping, in tha the later is still sent up to the test harness, where as omitted tests never get added at all.

Examples:

it "should do something" do
  ...
end
omit(/something/) if jruby?



361
362
363
 
# File 'lib/spectroscope/context.rb', line 361

def omit(reason=true, &block)
  @_omits << [reason, block]
end

#skip(reason, &block) ⇒ Object

Mark specs or sub-cases to be skipped.

Examples:

it "should do something" do
  ...
end
skip(/something/, "reason for skipping") if jruby?



346
347
348
 
# File 'lib/spectroscope/context.rb', line 346

def skip(reason, &block)
  @_skips << [reason, block]
end

#subject(topic = nil, &block) ⇒ Object 



386
387
388
389
 
# File 'lib/spectroscope/context.rb', line 386

def subject(topic=nil, &block)
  @_topic = topic
  define_method(:subject, &block)
end