polyphony 0.27 → 0.28

data/ext/gyro/gyro.c

@@ -6,12 +6,13 @@ ID ID_call;
 ID ID_caller;
 ID ID_clear;
 ID ID_each;
+ID ID_fiber_trace;
 ID ID_inspect;
 ID ID_new;
 ID ID_raise;
 ID ID_ivar_running;
-ID ID_scheduled;
-ID ID_scheduled_value;
+ID ID_runnable;
+ID ID_runnable_value;
 ID ID_size;
 ID ID_signal_bang;
 ID ID_switch_fiber;
@@ -20,14 +21,30 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
+ID ID_trace_ev_loop_enter;
+ID ID_trace_ev_loop_leave;
+ID ID_trace_run;
+ID ID_trace_runnable;
+ID ID_trace_terminate;
+ID ID_trace_wait;
+
 ID ID_empty;
 ID ID_pop;
 ID ID_push;
 
 VALUE SYM_dead;
 VALUE SYM_running;
-VALUE SYM_scheduled;
-VALUE SYM_suspended;
+VALUE SYM_runnable;
+VALUE SYM_waiting;
+
+VALUE SYM_fiber_create;
+VALUE SYM_fiber_ev_loop_enter;
+VALUE SYM_fiber_ev_loop_leave;
+VALUE SYM_fiber_run;
+VALUE SYM_fiber_schedule;
+VALUE SYM_fiber_switchpoint;
+VALUE SYM_fiber_terminate;
+
 
 // static VALUE Gyro_break_set(VALUE self) {
 //   break_flag = 1;
@@ -64,7 +81,7 @@ static VALUE Gyro_unref(VALUE self) {
 }
 
 static VALUE Gyro_suspend(VALUE self) {
-  rb_ivar_set(self, ID_scheduled_value, Qnil);
+  rb_ivar_set(self, ID_runnable_value, Qnil);
   VALUE ret = Thread_switch_fiber(rb_thread_current());
   
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
@@ -94,19 +111,21 @@ static VALUE Fiber_state(VALUE self) {
   if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
     return SYM_dead;
   if (rb_fiber_current() == self) return SYM_running;
-  if (rb_ivar_get(self, ID_scheduled) != Qnil) return SYM_scheduled;
+  if (rb_ivar_get(self, ID_runnable) != Qnil) return SYM_runnable;
   
-  return SYM_suspended;
+  return SYM_waiting;
 }
 
 inline void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
-  rb_ivar_set(fiber, ID_scheduled_value, value);
-  // if fiber is already scheduled, we just set the scheduled value, then return
-  if (rb_ivar_get(fiber, ID_scheduled) != Qnil)
-    return;
+  if (__tracing_enabled__) {
+    rb_funcall(rb_cObject, ID_fiber_trace, 3, SYM_fiber_schedule, fiber, value);
+  }
+  Thread_schedule_fiber(rb_thread_current(), fiber, value);
+}
 
-  rb_ivar_set(fiber, ID_scheduled, Qtrue);
-  Thread_schedule_fiber(rb_thread_current(), fiber);
+VALUE Gyro_trace(VALUE self, VALUE enabled) {
+  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
+  return Qnil;
 }
 
 void Init_Gyro() {
@@ -115,6 +134,7 @@ void Init_Gyro() {
   rb_define_singleton_method(mGyro, "post_fork", Gyro_post_fork, 0);
   rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
   rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
+  rb_define_singleton_method(mGyro, "trace", Gyro_trace, 1);
 
   // rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
   // rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 0);
@@ -127,34 +147,53 @@ void Init_Gyro() {
   rb_define_method(cFiber, "schedule", Fiber_schedule, -1);
   rb_define_method(cFiber, "state", Fiber_state, 0);
 
-  ID_call             = rb_intern("call");
-  ID_caller           = rb_intern("caller");
-  ID_clear            = rb_intern("clear");
-  ID_each             = rb_intern("each");
-  ID_inspect          = rb_intern("inspect");
-  ID_new              = rb_intern("new");
-  ID_raise            = rb_intern("raise");
-  ID_ivar_running          = rb_intern("@running");
-  ID_scheduled        = rb_intern("scheduled");
-  ID_scheduled_value  = rb_intern("scheduled_value");
-  ID_size             = rb_intern("size");
-  ID_signal_bang      = rb_intern("signal!");
-  ID_switch_fiber     = rb_intern("switch_fiber");
-  ID_transfer         = rb_intern("transfer");
-  ID_R                = rb_intern("r");
-  ID_W                = rb_intern("w");
-  ID_RW               = rb_intern("rw");
-
-  ID_empty            = rb_intern("empty?");
-  ID_pop              = rb_intern("pop");
-  ID_push             = rb_intern("push");
+  ID_call           = rb_intern("call");
+  ID_caller         = rb_intern("caller");
+  ID_clear          = rb_intern("clear");
+  ID_each           = rb_intern("each");
+  ID_empty          = rb_intern("empty?");
+  ID_inspect        = rb_intern("inspect");
+  ID_ivar_running   = rb_intern("@running");
+  ID_new            = rb_intern("new");
+  ID_pop            = rb_intern("pop");
+  ID_push           = rb_intern("push");
+  ID_raise          = rb_intern("raise");
+  ID_runnable       = rb_intern("runnable");
+  ID_runnable_value = rb_intern("runnable_value");
+  ID_signal_bang    = rb_intern("signal!");
+  ID_size           = rb_intern("size");
+  ID_switch_fiber   = rb_intern("switch_fiber");
+  ID_transfer       = rb_intern("transfer");
+
+  ID_R              = rb_intern("r");
+  ID_RW             = rb_intern("rw");
+  ID_W              = rb_intern("w");
+
+  ID_fiber_trace          = rb_intern("__fiber_trace__");
+
+  #define GLOBAL_SYM(sym) var = ID2SYM(rb_intern(sym)); rb_global_variable(sym)
 
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));
-  SYM_scheduled = ID2SYM(rb_intern("scheduled"));
-  SYM_suspended = ID2SYM(rb_intern("suspended"));
+  SYM_runnable = ID2SYM(rb_intern("runnable"));
+  SYM_waiting = ID2SYM(rb_intern("waiting"));
   rb_global_variable(&SYM_dead);
   rb_global_variable(&SYM_running);
-  rb_global_variable(&SYM_scheduled);
-  rb_global_variable(&SYM_suspended);
+  rb_global_variable(&SYM_runnable);
+  rb_global_variable(&SYM_waiting);
+
+  SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));
+  SYM_fiber_ev_loop_enter = ID2SYM(rb_intern("fiber_ev_loop_enter"));
+  SYM_fiber_ev_loop_leave = ID2SYM(rb_intern("fiber_ev_loop_leave"));
+  SYM_fiber_run           = ID2SYM(rb_intern("fiber_run"));
+  SYM_fiber_schedule      = ID2SYM(rb_intern("fiber_schedule"));
+  SYM_fiber_switchpoint   = ID2SYM(rb_intern("fiber_switchpoint"));
+  SYM_fiber_terminate     = ID2SYM(rb_intern("fiber_terminate"));
+  rb_global_variable(&SYM_fiber_create);
+  rb_global_variable(&SYM_fiber_ev_loop_enter);
+  rb_global_variable(&SYM_fiber_ev_loop_leave);
+  rb_global_variable(&SYM_fiber_run);
+  rb_global_variable(&SYM_fiber_schedule);
+  rb_global_variable(&SYM_fiber_switchpoint);
+  rb_global_variable(&SYM_fiber_terminate);
 }

data/ext/gyro/gyro.h

@@ -44,7 +44,7 @@ VALUE Thread_ref(VALUE thread);
 VALUE Thread_unref(VALUE thread);
 VALUE Thread_switch_fiber(VALUE thread);
 VALUE Fiber_await();
-VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber);
+VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_post_fork(VALUE thread);
 
 
@@ -58,17 +58,17 @@ extern VALUE cGyro_Queue;
 extern VALUE cGyro_Selector;
 extern VALUE cGyro_Timer;
 
-extern VALUE Gyro_reactor_fiber;
-extern VALUE Gyro_root_fiber;
-
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
+extern ID ID_fiber_trace;
 extern ID ID_inspect;
+extern ID ID_ivar_running;
 extern ID ID_new;
 extern ID ID_raise;
-extern ID ID_scheduled_value;
+extern ID ID_runnable;
+extern ID ID_runnable_value;
 extern ID ID_signal_bang;
 extern ID ID_size;
 extern ID ID_switch_fiber;
@@ -77,4 +77,14 @@ extern ID ID_R;
 extern ID ID_W;
 extern ID ID_RW;
 
+extern VALUE SYM_fiber_create;
+extern VALUE SYM_fiber_ev_loop_enter;
+extern VALUE SYM_fiber_ev_loop_leave;
+extern VALUE SYM_fiber_run;
+extern VALUE SYM_fiber_schedule;
+extern VALUE SYM_fiber_switchpoint;
+extern VALUE SYM_fiber_terminate;
+
+extern int __tracing_enabled__;
+
 #endif /* RUBY_EV_H */

data/ext/gyro/gyro_ext.c

@@ -10,6 +10,7 @@ void Init_Gyro_Signal();
 void Init_Gyro_Timer();
 void Init_Socket();
 void Init_Thread();
+void Init_Tracing();
 
 void Init_gyro_ext() {
   ev_set_allocator(xrealloc);
@@ -25,4 +26,6 @@ void Init_gyro_ext() {
 
   Init_Socket();
   Init_Thread();
+
+  Init_Tracing();
 }

data/ext/gyro/thread.c

@@ -3,18 +3,18 @@
 static VALUE cQueue;
 
 static ID ID_create_event_selector;
-static ID ID_ivar_event_selector;
-static ID ID_ivar_event_selector_proc;
+static ID ID_empty;
 static ID ID_fiber_ref_count;
-static ID ID_run_queue;
+static ID ID_ivar_event_selector_proc;
+static ID ID_ivar_event_selector;
 static ID ID_ivar_main_fiber;
-static ID ID_stop;
-
-static ID ID_scheduled;
-
-static ID ID_empty;
 static ID ID_pop;
 static ID ID_push;
+static ID ID_run_queue;
+// static ID ID_run_queue_head;
+// static ID ID_run_queue_tail;
+static ID ID_runnable_next;
+static ID ID_stop;
 
 VALUE event_selector_factory_proc(RB_BLOCK_CALL_FUNC_ARGLIST(args, klass)) {
   return rb_funcall(klass, ID_new, 1, rb_ary_entry(args, 0));
@@ -97,44 +97,59 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   return stats;
 }
 
-inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber) {
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_push(queue, fiber);
+inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  // if fiber is already scheduled, just set the scheduled value, then return
+  rb_ivar_set(fiber, ID_runnable_value, value);
+  if (rb_ivar_get(fiber, ID_runnable) == Qnil) {
+    VALUE queue = rb_ivar_get(self, ID_run_queue);
+    rb_ary_push(queue, fiber);
+    rb_ivar_set(fiber, ID_runnable, Qtrue);
+  }
   return self;
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
+  VALUE current_fiber;
+  if (__tracing_enabled__) {
+    current_fiber = rb_fiber_current();
+    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);
-  long scheduled_count;
+  VALUE next_fiber;
 
   while (1) {
-    scheduled_count = RARRAY_LEN(queue);
+    next_fiber = rb_ary_shift(queue);
     // if (break_flag != 0) {
     //   return Qnil;
     // }
-    if ((scheduled_count > 0) || (Thread_fiber_ref_count(self) == 0)) {
+    if ((next_fiber != Qnil) || (Thread_fiber_ref_count(self) == 0)) {
       break;
     }
 
+    if (__tracing_enabled__) {
+      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_ev_loop_enter, current_fiber);
+    }
     Gyro_Selector_run(selector);
+    if (__tracing_enabled__) {
+      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_ev_loop_leave, current_fiber);
+    }
   }
 
-  VALUE next_fiber;
-  // while (1) {
-    if (scheduled_count == 0) {
-      return Qnil;
-    }
-    next_fiber = rb_ary_shift(queue);
-    // break;
-    // if (rb_fiber_alive_p(next_fiber) == Qtrue) {
-    //   break;
-    // }
-  // }
+  if (next_fiber == Qnil) {
+    return Qnil;
+  }
 
   // run next fiber
-  VALUE value = rb_ivar_get(next_fiber, ID_scheduled_value);
-  rb_ivar_set(next_fiber, ID_scheduled, Qnil);
+  VALUE value = rb_ivar_get(next_fiber, ID_runnable_value);
+
+  if (__tracing_enabled__) {
+    rb_funcall(rb_cObject, ID_fiber_trace, 3, SYM_fiber_run, next_fiber, value);
+  }
+
+  rb_ivar_set(next_fiber, ID_runnable, Qnil);
   RB_GC_GUARD(next_fiber);
   RB_GC_GUARD(value);
   return rb_funcall(next_fiber, ID_transfer, 1, value);
@@ -180,20 +195,20 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
 
-  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 1);
+  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
 
 
   ID_create_event_selector    = rb_intern("create_event_selector");
+  ID_empty                    = rb_intern("empty?");
+  ID_fiber_ref_count          = rb_intern("fiber_ref_count");
   ID_ivar_event_selector      = rb_intern("@event_selector");
   ID_ivar_event_selector_proc = rb_intern("@event_selector_proc");
   ID_ivar_main_fiber          = rb_intern("@main_fiber");
-  ID_fiber_ref_count          = rb_intern("fiber_ref_count");
-  ID_run_queue                = rb_intern("run_queue");
-  ID_scheduled                = rb_intern("scheduled");
-  ID_empty                    = rb_intern("empty?");
   ID_pop                      = rb_intern("pop");
   ID_push                     = rb_intern("push");
+  ID_run_queue                = rb_intern("run_queue");
+  ID_runnable_next            = rb_intern("runnable_next");
   ID_stop                     = rb_intern("stop");
 
   SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));

data/ext/gyro/tracing.c

@@ -0,0 +1,11 @@
+#include "gyro.h"
+
+int __tracing_enabled__ = 0;
+
+VALUE __fiber_trace__(int argc, VALUE *argv, VALUE self) {
+  return rb_ary_new4(argc, argv);
+}
+
+void Init_Tracing() {
+  rb_define_global_function("__fiber_trace__", __fiber_trace__, -1);
+}

data/lib/polyphony/core/global_api.rb

@@ -29,8 +29,8 @@ module API
     canceller.stop
   end
 
-  def spin(&block)
-    Fiber.spin(caller, &block)
+  def spin(tag = nil, &block)
+    Fiber.spin(tag, caller, &block)
   end
   alias_method :defer, :spin
 
@@ -66,17 +66,24 @@ module API
   end
 
   def sleep(duration = nil)
-    return suspend unless duration
+    return sleep_forever unless duration
 
     timer = Gyro::Timer.new(duration, 0)
     timer.await
   end
 
+  def sleep_forever
+    Thread.current.fiber_ref
+    suspend
+  ensure
+    Thread.current.fiber_unref
+  end
+
   def supervise(&block)
     Supervisor.new.await(&block)
   end
 
-  def throttled_loop(rarote, count: nil, &block)
+  def throttled_loop(rate, count: nil, &block)
     throttler = Throttler.new(rate)
     if count
       count.times { throttler.(&block) }

data/lib/polyphony/core/supervisor.rb

@@ -10,6 +10,7 @@ class Supervisor
   def initialize
     @fibers = []
     @pending = {}
+    yield(self) if block_given?
   end
 
   def await(&block)

data/lib/polyphony/core/thread_pool.rb

@@ -1,38 +1,47 @@
 # frozen_string_literal: true
 
-export :process, :setup, :size=, :busy?
-
-@size = 10
-
-def process(&block)
-  setup unless @task_queue
-
-  watcher = Gyro::Async.new
-  @task_queue << [block, watcher]
-  watcher.await
-end
-
-def size=(size)
-  @size = size
-end
-
-def busy?
-  !@queue.empty?
-end
-
-def setup
-  @task_queue = ::Queue.new
-  @threads = (1..@size).map { Thread.new { thread_loop } }
-end
-
-def thread_loop
-  loop { run_queued_task }
-end
-
-def run_queued_task
-  (block, watcher) = @task_queue.pop
-  result = block.()
-  watcher.signal!(result)
-rescue Exception => e
-  watcher.signal!(e)
+export_default :ThreadPool
+
+require 'etc'
+
+# Implements a pool of threads
+class ThreadPool
+  attr_reader :size
+
+  def initialize(size = Etc.nprocessors)
+    @size = size
+    @task_queue = ::Queue.new
+    @threads = (1..@size).map { Thread.new { thread_loop } }
+  end
+
+  def process(&block)
+    setup unless @task_queue
+
+    watcher = Gyro::Async.new
+    @task_queue << [block, watcher]
+    watcher.await
+  end
+
+  def cast(&block)
+    setup unless @task_queue
+
+    @task_queue << [block, nil]
+    self
+  end
+
+  def busy?
+    !@task_queue.empty?
+  end
+
+  def thread_loop
+    loop { run_queued_task }
+  end
+
+  def run_queued_task
+    (block, watcher) = @task_queue.pop
+    result = block.()
+    watcher&.signal!(result)
+  rescue Exception => e
+    watcher ? watcher.signal!(e) : raise(e)
+  end
 end

data/lib/polyphony/extensions/fiber.rb

@@ -104,13 +104,18 @@ class ::Fiber
     @running_fibers_map.size
   end
 
-  def self.spin(orig_caller = caller, &block)
+  def self.spin(tag = nil, orig_caller = caller, &block)
     f = new { |v| f.run(v) }
-    f.setup(block, orig_caller)
+    f.setup(tag, block, orig_caller)
     f
   end
 
-  def setup(block, caller)
+  attr_accessor :tag
+  Fiber.current.tag = :main
+
+  def setup(tag, block, caller)
+    __fiber_trace__(:fiber_create, self)
+    @tag = tag
     @calling_fiber = Fiber.current
     @caller = caller
     @block = block
@@ -120,19 +125,24 @@ class ::Fiber
   def run(first_value)
     Kernel.raise first_value if first_value.is_a?(Exception)
 
-    @running = true
-    self.class.map[self] = true
-    result = @block.(first_value)
-    finish_execution(result)
-  rescue Exceptions::MoveOn => e
-    finish_execution(e.value)
+    start_execution(first_value)
   rescue ::Interrupt, ::SystemExit => e
     Thread.current.main_fiber.transfer e.class.new
+  rescue Exceptions::MoveOn => e
+    finish_execution(e.value)
   rescue Exception => e
     finish_execution(e, true)
   end
 
+  def start_execution(first_value)
+    @running = true
+    self.class.map[self] = true
+    result = @block.(first_value)
+    finish_execution(result)
+  end
+
   def finish_execution(result, uncaught_exception = false)
+    __fiber_trace__(:fiber_terminate, self, result)
     @result = result
     @running = false
     self.class.map.delete(self)

data/lib/polyphony/extensions/io.rb

@@ -23,20 +23,20 @@ class ::IO
 
     EMPTY_HASH = {}.freeze
 
-    alias_method :orig_foreach, :foreach
-    def foreach(_name, _sep = $/, _limit = nil, _getline_args = EMPTY_HASH,
-                &_block)
-      # IO.orig_read(name).each_line(&block)
-      raise NotImplementedError
-
-      # if sep.is_a?(Integer)
-      #   sep = $/
-      #   limit = sep
-      # end
-      # File.open(name, 'r') do |f|
-      #   f.each_line(sep, limit, getline_args, &block)
-      # end
-    end
+    # alias_method :orig_foreach, :foreach
+    # def foreach(_name, _sep = $/, _limit = nil, _getline_args = EMPTY_HASH,
+    #             &_block)
+    #   # IO.orig_read(name).each_line(&block)
+    #   raise NotImplementedError
+
+    #   # if sep.is_a?(Integer)
+    #   #   sep = $/
+    #   #   limit = sep
+    #   # end
+    #   # File.open(name, 'r') do |f|
+    #   #   f.each_line(sep, limit, getline_args, &block)
+    #   # end
+    # end
 
     alias_method :orig_read, :read
     def read(name, length = nil, offset = nil, opt = EMPTY_HASH)

data/lib/polyphony/extensions/socket.rb

@@ -10,7 +10,7 @@ class ::Socket
 
   def connect(remotesockaddr)
     loop do
-      result = connect_nonblock(remotesockaddr, NO_EXCEPTION)
+      result = connect_nonblock(remotesockaddr, **NO_EXCEPTION)
       return if result == 0
 
       result == :wait_writable ? write_watcher.await : (raise IOError)
@@ -20,7 +20,7 @@ class ::Socket
   def recv(maxlen, flags = 0, outbuf = nil)
     outbuf ||= +''
     loop do
-      result = recv_nonblock(maxlen, flags, outbuf, NO_EXCEPTION)
+      result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
       raise IOError unless result
 
       result == :wait_readable ? read_watcher.await : (return result)
@@ -30,7 +30,7 @@ class ::Socket
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     loop do
-      result = recvfrom_nonblock(maxlen, flags, @read_buffer, NO_EXCEPTION)
+      result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
       raise IOError unless result
 
       result == :wait_readable ? read_watcher.await : (return result)

data/lib/polyphony/irb.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'polyphony'
+
+# readline blocks the current thread, so we offload it to the blocking-ops
+# thread pool. That way, the reactor loop can keep running while waiting for
+# readline to return
+module ::Readline
+  alias_method :orig_readline, :readline
+  def readline(*args)
+    Polyphony::ThreadPool.process { orig_readline(*args) }
+  end
+end

data/lib/polyphony/postgres.rb

@@ -91,4 +91,19 @@ class ::PG::Connection
   end
 
   self.async_api = true
+
+  def wait_for_notify(timeout = nil, &block)
+    return move_on_after(timeout) { wait_for_notify(&block) } if timeout
+
+    loop do
+      socket_io.read_watcher.await
+      consume_input
+      notice = notifies
+      next unless notice
+
+      values = notice.values
+      block&.(*values)
+      return values.first
+    end
+  end
 end