polyphony 0.39 → 0.40

data/ext/gyro/queue.c

@@ -1,14 +1,14 @@
 #include "gyro.h"
 
-struct Gyro_Queue {
+typedef struct queue {
   VALUE items;
   VALUE shift_waiters;
-};
+} Gyro_Queue_t;
 
 VALUE cGyro_Queue = Qnil;
 
 static void Gyro_Queue_mark(void *ptr) {
-  struct Gyro_Queue *queue = ptr;
+  Gyro_Queue_t *queue = ptr;
   if (queue->items != Qnil) {
     rb_gc_mark(queue->items);
   }
@@ -17,59 +17,60 @@ static void Gyro_Queue_mark(void *ptr) {
   }
 }
 
-static void Gyro_Queue_free(void *ptr) {
-  struct Gyro_Queue *queue = ptr;
-  xfree(queue);
-}
-
 static size_t Gyro_Queue_size(const void *ptr) {
-  return sizeof(struct Gyro_Queue);
+  return sizeof(Gyro_Queue_t);
 }
 
 static const rb_data_type_t Gyro_Queue_type = {
-    "Gyro_Queue",
-    {Gyro_Queue_mark, Gyro_Queue_free, Gyro_Queue_size,},
-    0, 0, 0
+  "Gyro_Queue",
+  {Gyro_Queue_mark, RUBY_DEFAULT_FREE, Gyro_Queue_size,},
+  0, 0, 0
 };
 
 static VALUE Gyro_Queue_allocate(VALUE klass) {
-  struct Gyro_Queue *queue = ALLOC(struct Gyro_Queue);
+  Gyro_Queue_t *queue;
+  // return Data_Make_Struct(klass, Gyro_Queue_t, Gyro_Queue_mark, free, queue);
+
+  queue = ALLOC(Gyro_Queue_t);
+  // struct Gyro_Queue *queue = ALLOC(struct Gyro_Queue);
   return TypedData_Wrap_Struct(klass, &Gyro_Queue_type, queue);
 }
+
 #define GetGyro_Queue(obj, queue) \
-  TypedData_Get_Struct((obj), struct Gyro_Queue, &Gyro_Queue_type, (queue))
+  TypedData_Get_Struct((obj), Gyro_Queue_t, &Gyro_Queue_type, (queue))
 
 static VALUE Gyro_Queue_initialize(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   queue->items = rb_ary_new();
   queue->shift_waiters = rb_ary_new();
-  
+
   return self;
 }
 
 VALUE Gyro_Queue_push(VALUE self, VALUE value) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   if (RARRAY_LEN(queue->shift_waiters) > 0) {
     VALUE async = rb_ary_shift(queue->shift_waiters);
     rb_funcall(async, ID_signal, 1, Qnil);
   }
-  
+
   rb_ary_push(queue->items, value);
   return self;
 }
 
 VALUE Gyro_Queue_shift(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   if (RARRAY_LEN(queue->items) == 0) {
+    VALUE ret;
     VALUE async = Fiber_auto_async(rb_fiber_current());
     rb_ary_push(queue->shift_waiters, async);
-    VALUE ret = Gyro_Async_await_no_raise(async);
+    ret = Gyro_Async_await_no_raise(async);
     if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
       rb_ary_delete(queue->shift_waiters, async);
       return rb_funcall(rb_mKernel, ID_raise, 1, ret);
@@ -81,17 +82,17 @@ VALUE Gyro_Queue_shift(VALUE self) {
 }
 
 VALUE Gyro_Queue_shift_no_wait(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   return rb_ary_shift(queue->items);
 }
 
 VALUE Gyro_Queue_shift_each(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
+  VALUE old_queue;
   GetGyro_Queue(self, queue);
-
-  VALUE old_queue = queue->items;
+  old_queue = queue->items;
   queue->items = rb_ary_new();
 
   if (rb_block_given_p()) {
@@ -104,12 +105,13 @@ VALUE Gyro_Queue_shift_each(VALUE self) {
     return self;
   }
   else {
+    RB_GC_GUARD(old_queue);
     return old_queue;
   }
 }
 
 VALUE Gyro_Queue_clear(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   rb_ary_clear(queue->items);
@@ -117,7 +119,7 @@ VALUE Gyro_Queue_clear(VALUE self) {
 }
 
 VALUE Gyro_Queue_empty_p(VALUE self) {
-  struct Gyro_Queue *queue;
+  Gyro_Queue_t *queue;
   GetGyro_Queue(self, queue);
 
   return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
@@ -133,10 +135,12 @@ void Init_Gyro_Queue() {
 
   rb_define_method(cGyro_Queue, "pop", Gyro_Queue_shift, 0);
   rb_define_method(cGyro_Queue, "shift", Gyro_Queue_shift, 0);
-  
+
   rb_define_method(cGyro_Queue, "shift_no_wait", Gyro_Queue_shift_no_wait, 0);
 
   rb_define_method(cGyro_Queue, "shift_each", Gyro_Queue_shift_each, 0);
   rb_define_method(cGyro_Queue, "clear", Gyro_Queue_clear, 0);
   rb_define_method(cGyro_Queue, "empty?", Gyro_Queue_empty_p, 0);
 }
+
+

data/ext/gyro/selector.c

@@ -174,26 +174,6 @@ VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self) {
   return Qnil;
 }
 
-ID ID_deactivate_post_fork;
-
-static int deactivate_watcher(VALUE key, VALUE value, VALUE _) {
-    rb_funcall(key, ID_deactivate_post_fork, 0);
-    return ST_CONTINUE;
-}
-
-VALUE Gyro_Selector_deactivate_all_watchers_post_fork(VALUE self) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  VALUE old_active_watchers = selector->active_watchers;
-  selector->active_watchers = rb_hash_new();
-  
-  rb_hash_foreach(old_active_watchers, deactivate_watcher, Qnil);
-  
-  RB_GC_GUARD(old_active_watchers);
-  return self;
-}
-
 inline static VALUE Gyro_Selector_wait_readable(VALUE self, VALUE io) {
   VALUE watcher = IO_read_watcher(io);
   return Gyro_IO_await(watcher);
@@ -222,7 +202,4 @@ void Init_Gyro_Selector() {
   rb_define_method(cGyro_Selector, "wait_writable", Gyro_Selector_wait_writable, 1);
   rb_define_method(cGyro_Selector, "wait_timeout", Gyro_Selector_wait_timeout, 1);
   rb_define_method(cGyro_Selector, "break_out_of_ev_loop", Gyro_Selector_break_out_of_ev_loop, 0);
-  rb_define_method(cGyro_Selector, "deactivate_all_watchers_post_fork", Gyro_Selector_deactivate_all_watchers_post_fork, 0);
-
-  ID_deactivate_post_fork = rb_intern("deactivate_post_fork");
 }

data/ext/gyro/signal.c

@@ -1,38 +1,20 @@
 #include "gyro.h"
 
 struct Gyro_Signal {
-  struct  ev_signal ev_signal;
-  struct  ev_loop *ev_loop;
-  int     active;
-  int     signum;
-  VALUE   self;
-  VALUE   fiber;
-  VALUE   selector;
+  GYRO_WATCHER_DECL(ev_signal);
+  int signum;
 };
 
 static VALUE cGyro_Signal = Qnil;
 
 static void Gyro_Signal_mark(void *ptr) {
   struct Gyro_Signal *signal = ptr;
-  if (signal->fiber != Qnil) {
-    rb_gc_mark(signal->fiber);
-  }
-  if (signal->selector != Qnil) {
-    rb_gc_mark(signal->selector);
-  }
+  GYRO_WATCHER_MARK(signal);
 }
 
 static void Gyro_Signal_free(void *ptr) {
   struct Gyro_Signal *signal = ptr;
-  switch (signal->active) {
-    case GYRO_WATCHER_POST_FORK:
-      return;
-    case 1:
-      ev_clear_pending(signal->ev_loop, &signal->ev_signal);
-      ev_signal_stop(signal->ev_loop, &signal->ev_signal);
-    default:
-      xfree(signal);
-  }
+  GYRO_WATCHER_FREE(signal);
 }
 
 static size_t Gyro_Signal_size(const void *ptr) {
@@ -85,16 +67,10 @@ void Gyro_Signal_callback(struct ev_loop *ev_loop, struct ev_signal *ev_signal,
 static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
   struct Gyro_Signal *signal;
   VALUE signum = sig;
- 
+
   GetGyro_Signal(self, signal);
-  
-  signal->self = self;
-  signal->fiber = Qnil;
-  signal->selector = Qnil;
+  GYRO_WATCHER_INITIALIZE(signal, self);
   signal->signum = NUM2INT(signum);
-  signal->active = 0;
-  signal->ev_loop = 0;
-
   ev_signal_init(&signal->ev_signal, Gyro_Signal_callback, signal->signum);
 
   return Qnil;
@@ -102,10 +78,11 @@ static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
 
 static VALUE Gyro_Signal_await(VALUE self) {
   struct Gyro_Signal *signal;
+  VALUE ret;
   GetGyro_Signal(self, signal);
 
   signal_activate(signal);
-  VALUE ret = Gyro_switchpoint();
+  ret = Gyro_switchpoint();
   signal_deactivate(signal);
 
   TEST_RESUME_EXCEPTION(ret);
@@ -113,21 +90,10 @@ static VALUE Gyro_Signal_await(VALUE self) {
   return ret;
 }
 
-VALUE Gyro_Signal_deactivate_post_fork(VALUE self) {
-  struct Gyro_Signal *signal;
-  GetGyro_Signal(self, signal);
-
-  if (signal->active)
-    signal->active = GYRO_WATCHER_POST_FORK;
-
-  return self;
-}
-
 void Init_Gyro_Signal() {
   cGyro_Signal = rb_define_class_under(mGyro, "Signal", rb_cData);
   rb_define_alloc_func(cGyro_Signal, Gyro_Signal_allocate);
 
   rb_define_method(cGyro_Signal, "initialize", Gyro_Signal_initialize, 1);
   rb_define_method(cGyro_Signal, "await", Gyro_Signal_await, 0);
-  rb_define_method(cGyro_Signal, "deactivate_post_fork", Gyro_Signal_deactivate_post_fork, 0);
 }

data/ext/gyro/socket.c

@@ -72,7 +72,7 @@ static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE sock) {
   rb_blocking_function_t *func;
   const char *funcname;
   VALUE write_watcher = Qnil;
-  
+
   rb_scan_args(argc, argv, "21", &arg.mesg, &flags, &to);
 
   StringValue(arg.mesg);
@@ -196,14 +196,17 @@ static VALUE Socket_accept(VALUE sock) {
 }
 
 void Init_Socket() {
+  VALUE cBasicSocket;
+  VALUE cSocket;
+  
   rb_require("socket");
-  VALUE cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+  cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
 
   rb_define_method(cBasicSocket, "send", BasicSocket_send, -1);
   rb_define_method(cBasicSocket, "recv", BasicSocket_recv, -1);
 
-  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
-  
+  cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+
   rb_define_method(cSocket, "accept", Socket_accept, 0);
 
   cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));

data/ext/gyro/thread.c

@@ -40,11 +40,14 @@ static VALUE Thread_create_event_selector(VALUE self, VALUE thread) {
 }
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
+  VALUE queue;
+  VALUE selector;
+  
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
   rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
-  VALUE queue = rb_ary_new();
+  queue = rb_ary_new();
   rb_ivar_set(self, ID_run_queue, queue);
-  VALUE selector = rb_funcall(rb_cThread, ID_create_event_selector, 1, self);
+  selector = rb_funcall(rb_cThread, ID_create_event_selector, 1, self);
   rb_ivar_set(self, ID_ivar_event_selector, selector);
 
   return self;
@@ -101,20 +104,21 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   VALUE stats = rb_hash_new();
   VALUE queue = rb_ivar_get(self, ID_run_queue);
   VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  
+  long pending_count;
+
   long scheduled_count = RARRAY_LEN(queue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  long pending_count = Gyro_Selector_pending_count(selector);
+  pending_count = Gyro_Selector_pending_count(selector);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
 }
 
 VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
-  if (rb_fiber_alive_p(fiber) != Qtrue) {
-    return self;
-  }
+  VALUE queue;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
 
   FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
   // if fiber is already scheduled, just set the scheduled value, then return
@@ -123,7 +127,7 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
     return self;
   }
 
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  queue = rb_ivar_get(self, ID_run_queue);
   rb_ary_push(queue, fiber);
   rb_ivar_set(fiber, ID_runnable, Qtrue);
 
@@ -142,13 +146,14 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
 }
 
 VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
-  if (rb_fiber_alive_p(fiber) != Qtrue) {
-    return self;
-  }
+  VALUE queue;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
+
   FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
   rb_ivar_set(fiber, ID_runnable_value, value);
 
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  queue = rb_ivar_get(self, ID_run_queue);
 
   // if fiber is already scheduled, remove it from the run queue
   if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
@@ -176,22 +181,25 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 
 VALUE Thread_switch_fiber(VALUE self) {
   VALUE current_fiber = rb_fiber_current();
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  VALUE next_fiber;
+  VALUE value;
+  int ref_count;
+
   if (__tracing_enabled__) {
     if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
       rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_switchpoint, current_fiber);
     }
   }
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
 
-  VALUE next_fiber;
 
   while (1) {
     next_fiber = rb_ary_shift(queue);
     // if (break_flag != 0) {
     //   return Qnil;
     // }
-    int ref_count = Thread_fiber_ref_count(self);
+    ref_count = Thread_fiber_ref_count(self);
     if (next_fiber != Qnil) {
       if (ref_count > 0) {
         // this mechanism prevents event starvation in case the run queue never
@@ -212,7 +220,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   }
 
   // run next fiber
-  VALUE value = rb_ivar_get(next_fiber, ID_runnable_value);
+  value = rb_ivar_get(next_fiber, ID_runnable_value);
   FIBER_TRACE(3, SYM_fiber_run, next_fiber, value);
 
   rb_ivar_set(next_fiber, ID_runnable, Qnil);
@@ -236,9 +244,10 @@ VALUE Thread_post_fork(VALUE self) {
 }
 
 VALUE Gyro_switchpoint() {
+  VALUE ret;
   VALUE thread = rb_thread_current();
   Thread_ref(thread);
-  VALUE ret = Thread_switch_fiber(thread);
+  ret = Thread_switch_fiber(thread);
   Thread_unref(thread);
   RB_GC_GUARD(ret);
   return ret;

data/ext/gyro/timer.c

@@ -1,39 +1,21 @@
 #include "gyro.h"
 
 struct Gyro_Timer {
-  struct  ev_timer ev_timer;
-  struct  ev_loop *ev_loop;
-  int     active;
+  GYRO_WATCHER_DECL(ev_timer);
   double  after;
   double  repeat;
-  VALUE   self;
-  VALUE   fiber;
-  VALUE   selector;
 };
 
 VALUE cGyro_Timer = Qnil;
 
 static void Gyro_Timer_mark(void *ptr) {
   struct Gyro_Timer *timer = ptr;
-  if (timer->fiber != Qnil) {
-    rb_gc_mark(timer->fiber);
-  }
-  if (timer->selector != Qnil) {
-    rb_gc_mark(timer->selector);
-  }
+  GYRO_WATCHER_MARK(timer);
 }
 
 static void Gyro_Timer_free(void *ptr) {
   struct Gyro_Timer *timer = ptr;
-  switch (timer->active) {
-    case GYRO_WATCHER_POST_FORK:
-      return;
-    case 1:
-      ev_clear_pending(timer->ev_loop, &timer->ev_timer);
-      ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    default:
-      xfree(timer);
-  }
+  GYRO_WATCHER_FREE(timer);
 }
 
 static size_t Gyro_Timer_size(const void *ptr) {
@@ -66,28 +48,26 @@ inline void timer_activate(struct Gyro_Timer *timer) {
   ev_timer_start(timer->ev_loop, &timer->ev_timer);
 }
 
-inline void timer_deactivate(struct Gyro_Timer *timer, int force_deactivate) {
+inline void timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
   if (!timer->active) return;
 
-  timer->fiber = Qnil;
-
-  // timer should not be deactivated if 
-  if (timer->repeat && !force_deactivate) return;
-
-  ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-  if (RTEST(timer->selector)) {
-    Gyro_Selector_remove_active_watcher(timer->selector, timer->self);
-    timer->selector = Qnil;
+  if (!timer->repeat || !non_recurring_only) {
+    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+    if (RTEST(timer->selector)) {
+      Gyro_Selector_remove_active_watcher(timer->selector, timer->self);
+      timer->selector = Qnil;
+    }
+    timer->ev_loop = 0;
+    timer->active = 0;
   }
-  timer->ev_loop = 0;
-  timer->active = 0;
+
+  timer->fiber = Qnil;
 }
 
 void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
   struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
 
-  if (timer->fiber != Qnil)
-    Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
+  Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
   timer_deactivate(timer, 1);
 }
 
@@ -95,15 +75,9 @@ static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
   struct Gyro_Timer *timer;
 
   GetGyro_Timer(self, timer);
-
-  timer->self       = self;
-  timer->fiber      = Qnil;
-  timer->selector   = Qnil;
+  GYRO_WATCHER_INITIALIZE(timer, self);
   timer->after      = NUM2DBL(after);
   timer->repeat     = NUM2DBL(repeat);
-  timer->active     = 0;
-  timer->ev_loop    = 0;
-
   ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
 
   return Qnil;
@@ -119,10 +93,11 @@ VALUE Gyro_Timer_stop(VALUE self) {
 
 VALUE Gyro_Timer_await(VALUE self) {
   struct Gyro_Timer *timer;
+  VALUE ret;
   GetGyro_Timer(self, timer);
 
   timer_activate(timer);
-  VALUE ret = Gyro_switchpoint();
+  ret = Gyro_switchpoint();
   timer_deactivate(timer, 1);
 
   TEST_RESUME_EXCEPTION(ret);
@@ -130,22 +105,11 @@ VALUE Gyro_Timer_await(VALUE self) {
   return ret;
 }
 
-VALUE Gyro_Timer_deactivate_post_fork(VALUE self) {
-  struct Gyro_Timer *timer;
-  GetGyro_Timer(self, timer);
-
-  if (timer->active)
-    timer->active = GYRO_WATCHER_POST_FORK;
-
-  return self;
-}
-
 void Init_Gyro_Timer() {
   cGyro_Timer = rb_define_class_under(mGyro, "Timer", rb_cData);
   rb_define_alloc_func(cGyro_Timer, Gyro_Timer_allocate);
 
   rb_define_method(cGyro_Timer, "initialize", Gyro_Timer_initialize, 2);
   rb_define_method(cGyro_Timer, "await", Gyro_Timer_await, 0);
-  rb_define_method(cGyro_Timer, "deactivate_post_fork", Gyro_Timer_deactivate_post_fork, 0);
   rb_define_method(cGyro_Timer, "stop", Gyro_Timer_stop, 0);
 }

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.39'
+  VERSION = '0.40'
 end

data/lib/polyphony.rb

@@ -14,7 +14,6 @@ require_relative './polyphony/extensions/io'
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/net'
-
 require_relative './polyphony/adapters/process'
 
 # Main Polyphony API
@@ -32,9 +31,8 @@ module Polyphony
     end
 
     def fork(&block)
-      old_threads = Thread.list - [Thread.current]
       Kernel.fork do
-        old_threads.each(&:deactivate_all_watchers_post_fork)
+        Gyro.incr_generation
 
         # Since the fiber doing the fork will become the main fiber of the
         # forked process, we leave it behind by transferring to a new fiber

data/polyphony.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'minitest-reporters',   '1.4.2'
   s.add_development_dependency  'simplecov',            '0.17.1'
   s.add_development_dependency  'rubocop',              '0.80.0'
-  s.add_development_dependency  'pg',                   '1.1.3'
+  s.add_development_dependency  'pg',                   '1.1.4'
   s.add_development_dependency  'rake-compiler',        '1.0.5'
   s.add_development_dependency  'redis',                '4.1.0'
   s.add_development_dependency  'hiredis',              '0.6.3'

data/test/helper.rb

@@ -18,17 +18,9 @@ Minitest::Reporters.use! [
   Minitest::Reporters::SpecReporter.new
 ]
 
-module MiniTest::Assertions
-  def assert_in_range(range, act)
-    msg = message(msg) {
-      "Expected #{act.inspect} to be in range #{range.inspect}"
-    }
-    assert range.include?(act), msg
-  end
-end
-
 class MiniTest::Test
   def setup
+    # puts "* setup #{self.name}"
     if Fiber.current.children.size > 0
       puts "Children left: #{Fiber.current.children.inspect}"
       exit!
@@ -38,6 +30,7 @@ class MiniTest::Test
   end
 
   def teardown
+    #puts "* teardown #{self.name}"
     Fiber.current.terminate_all_children
     Fiber.current.await_all_children
   end
@@ -49,4 +42,4 @@ module Kernel
   rescue Exception => e
     e
   end
-end
+end

data/test/test_async.rb

@@ -22,6 +22,7 @@ class AsyncTest < MiniTest::Test
   def test_that_async_watcher_coalesces_signals
     count = 0
     a = Gyro::Async.new
+   
     coproc = spin {
       loop {
         a.await
@@ -34,6 +35,7 @@ class AsyncTest < MiniTest::Test
       orig_sleep 0.001
       3.times { a.signal }
     end
+
     coproc.await
     assert_equal 1, count
   end