Module: Spork

Defined in:
lib/spork.rb,
lib/spork/runner.rb

Defined Under Namespace

Modules: CustomIOStreams Classes: AppFramework, Diagnoser, Forker, RunStrategy, Runner, Server, TestFramework

Constant Summary collapse

BINARY = 
File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
LIBDIR = 
Pathname.new(File.expand_path(File.dirname(__FILE__)))

Class Method Summary collapse

Class Method Details

.after_each_run(prevent_double_run = true, &block) ⇒ Object

Run a block after specs are run.

Parameters

  • prevent_double_run - Pass false to disable double run prevention



45
46
47
48
 
# File 'lib/spork.rb', line 45

def after_each_run(prevent_double_run = true, &block)
  return if prevent_double_run && already_ran?(caller.first)
  after_each_run_procs << block
end

.detect_and_require(subfolder) ⇒ Object 



99
100
101
102
103
 
# File 'lib/spork.rb', line 99

def detect_and_require(subfolder)
  ([LIBDIR.to_s] + other_spork_gem_load_paths).uniq.each do |gem_path|
    Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
  end
end

.each_run(prevent_double_run = true, &block) ⇒ Object

Run a block AFTER the fork occurs. By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.

Parameters

  • prevent_double_run - Pass false to disable double run prevention



31
32
33
34
35
36
37
38
 
# File 'lib/spork.rb', line 31

def each_run(prevent_double_run = true, &block)
  return if prevent_double_run && already_ran?(caller.first)
  if state == :prefork
    each_run_procs << block
  else
    yield
  end
end

.exec_after_each_run ⇒ Object

Used by the server. Called to run all of the after_each_run blocks.



74
75
76
77
78
 
# File 'lib/spork.rb', line 74

def exec_after_each_run
  # processes in reverse order similar to at_exit
  while p = after_each_run_procs.pop; p.call; end
  true
end

.exec_each_run(&block) ⇒ Object

Used by the server. Called to run all of the prefork blocks.



65
66
67
68
69
70
71
 
# File 'lib/spork.rb', line 65

def exec_each_run(&block)
  @state = :run
  activate_after_each_run_at_exit_hook
  each_run_procs.each { |p| p.call }
  each_run_procs.clear
  yield if block_given?
end

.exec_prefork(&block) ⇒ Object

Used by the server. Called when loading the prefork blocks of the code.



59
60
61
62
 
# File 'lib/spork.rb', line 59

def exec_prefork(&block)
  @state = :prefork
  yield
end

.other_spork_gem_load_paths ⇒ Object 



105
106
107
108
109
110
111
 
# File 'lib/spork.rb', line 105

def other_spork_gem_load_paths
  @other_spork_gem_load_paths ||= (
    Gem.latest_load_paths.grep(/spork/).select do |g|
      not g.match(%r{/spork-[0-9\-.]+/lib}) # don't include other versions of spork
    end
  )
end

.prefork(prevent_double_run = true, &block) ⇒ Object

Run a block, during prefork mode. By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.

Parameters

  • prevent_double_run - Pass false to disable double run prevention



21
22
23
24
 
# File 'lib/spork.rb', line 21

def prefork(prevent_double_run = true, &block)
  return if prevent_double_run && already_ran?(caller.first)
  yield
end

.state ⇒ Object 



54
55
56
 
# File 'lib/spork.rb', line 54

def state
  @state ||= :not_using_spork
end

.trap_class_method(klass, method_name) ⇒ Object

Same as trap_method, but for class methods instead



95
96
97
 
# File 'lib/spork.rb', line 95

def trap_class_method(klass, method_name)
  trap_method((class << klass; self; end), method_name)
end

.trap_method(klass, method_name) ⇒ Object

Traps an instance method of a class (or module) so any calls to it don’t actually run until Spork.exec_each_run



81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/spork.rb', line 81

def trap_method(klass, method_name)
  method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :spork)
  
  klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
    alias :#{method_name_without_spork} :#{method_name} unless method_defined?(:#{method_name_without_spork}) 
    def #{method_name}(*args, &block)
      Spork.each_run(false) do
        #{method_name_without_spork}(*args, &block)
      end
    end
  EOF
end

.using_spork? ⇒ Boolean

Returns:

  • (Boolean) 


50
51
52
 
# File 'lib/spork.rb', line 50

def using_spork?
  state != :not_using_spork
end