Class: Tuile::FakeEventQueue

Inherits:
Object
  • Object
show all
Defined in:
lib/tuile/fake_event_queue.rb,
sig/tuile.rbs

Overview

A "synchronous" event queue – no loop is run, submitted blocks are run right away and submitted events are thrown away. Intended for testing only.

Defined Under Namespace

Classes: FakeTicker

Instance Method Summary collapse

Constructor Details

#initialize ⇒ FakeEventQueue

Returns a new instance of FakeEventQueue.



7
8
9
 
# File 'lib/tuile/fake_event_queue.rb', line 7

def initialize
  @tickers = []
end

Instance Method Details

#await_empty ⇒ void

This method returns an undefined value.



22
 
# File 'lib/tuile/fake_event_queue.rb', line 22

def await_empty; end

#locked? ⇒ Boolean

Returns:

  • (Boolean) 


12
13
 
# File 'lib/tuile/fake_event_queue.rb', line 12

def locked? = true
# @return [void]

#post(event) ⇒ void

This method returns an undefined value.

@param event

Parameters:

  • event (Object) 


33
 
# File 'lib/tuile/fake_event_queue.rb', line 33

def post(event); end

#run_loop ⇒ void

This method returns an undefined value.

Raises:



17
18
19
 
# File 'lib/tuile/fake_event_queue.rb', line 17

def run_loop
  raise Tuile::Error, "FakeEventQueue does not run an event loop"
end

#stop ⇒ void

This method returns an undefined value.



14
 
# File 'lib/tuile/fake_event_queue.rb', line 14

def stop; end

#submit { ... } ⇒ void

This method returns an undefined value.

Yields:

  • runs the block synchronously.

Yield Returns:

  • (void) 


27
28
29
 
# File 'lib/tuile/fake_event_queue.rb', line 27

def submit
  yield
end

#tick(seconds, &block) ⇒ void

This method returns an undefined value.

Mirrors EventQueue#tick but timeless: returns a FakeTicker that only fires when a test calls #tick_once. The seconds argument is validated the same way the real queue validates it, then discarded — the fake has no clock, so frame cadence is up to the test.

@param seconds — interval between firings, must be positive. Validated for parity with EventQueue#tick; otherwise unused.

Parameters:

  • seconds (Numeric) 


46
47
48
49
50
51
52
53
 
# File 'lib/tuile/fake_event_queue.rb', line 46

def tick(seconds, &block)
  raise ArgumentError, "block required" unless block
  unless seconds.is_a?(Numeric) && seconds.positive?
    raise ArgumentError, "seconds must be a positive Numeric, got #{seconds.inspect}"
  end

  FakeTicker.new(block).tap { |t| @tickers << t }
end

#tick_fps(fps, &block) ⇒ void

This method returns an undefined value.

Mirrors EventQueue#tick_fps: validates fps for parity, then delegates to #tick (the fake discards the interval regardless).

@param fps — firings per second, must be positive.

Parameters:

  • fps (Numeric) 


62
63
64
65
66
67
68
69
 
# File 'lib/tuile/fake_event_queue.rb', line 62

def tick_fps(fps, &block)
  raise ArgumentError, "block required" unless block
  unless fps.is_a?(Numeric) && fps.positive?
    raise ArgumentError, "fps must be a positive Numeric, got #{fps.inspect}"
  end

  tick(1.0 / fps, &block)
end

#tick_once ⇒ void

This method returns an undefined value.

Test helper: fires every live ticker's user block once and prunes cancelled tickers. No-op when no tickers are registered. Pumps once per call regardless of any ticker's fps — the fake has no clock, so tests pump N frames by calling this N times.



76
77
78
79
 
# File 'lib/tuile/fake_event_queue.rb', line 76

def tick_once
  @tickers.reject!(&:cancelled?)
  @tickers.each(&:fire)
end