Module: Spork

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

Defined Under Namespace

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

Class Method Summary collapse

Class Method Details

.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



19
20
21
22
23
24
25
26
 
# File 'lib/spork.rb', line 19

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

.exec_each_run(&block) ⇒ Object

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



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

def exec_each_run(&block)
  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.



39
40
41
42
 
# File 'lib/spork.rb', line 39

def exec_prefork(&block)
  using_spork!
  yield
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



9
10
11
12
 
# File 'lib/spork.rb', line 9

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

.state ⇒ Object

Used by the server. Returns the current state of Spork.



34
35
36
 
# File 'lib/spork.rb', line 34

def state
  @state ||= :not_using_spork
end

.trap_class_method(klass, method_name) ⇒ Object

Same as trap_method, but for class methods instead



66
67
68
 
# File 'lib/spork.rb', line 66

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



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/spork.rb', line 52

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)
      Spork.each_run(false) do
        #{method_name_without_spork}(*args)
      end
    end
  EOF
end

.using_spork! ⇒ Object

Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.



29
30
31
 
# File 'lib/spork.rb', line 29

def using_spork!
  @state = :using_spork
end