asyncengine 0.0.1.testing → 0.0.1.testing1

data/lib/asyncengine/errors.rb

@@ -0,0 +1,5 @@
+module AsyncEngine
+
+  class Error < ::StandardError ; end
+
+end

data/lib/asyncengine/next_tick.rb

@@ -0,0 +1,24 @@
+module AsyncEngine
+
+  def self.next_tick block1=nil, &block2
+    @_next_ticks << (block1 || block2)
+    _c_next_tick
+  end
+
+  def self.execute_next_ticks
+    ticks, @_next_ticks = @_next_ticks, []
+    ticks.each do |cb|
+      begin
+        cb.call
+      rescue => e
+        AsyncEngine.send :manage_exception, e
+      end
+    end
+  end
+
+  class << self
+    private :_c_next_tick
+    private :execute_next_ticks
+  end
+
+end

data/lib/asyncengine/timer.rb

@@ -0,0 +1,46 @@
+module AsyncEngine
+
+  def self.add_timer delay, block1=nil, &block2
+    _c_add_timer((delay*1000).to_i, nil, block1 || block2, nil)
+    true
+  end
+
+  def self.add_periodic_timer interval, delay=nil, block1=nil, &block2
+    if delay
+      _c_add_timer((delay*1000).to_i, (interval*1000).to_i, block1 || block2, nil)
+    else
+      interval = (interval*1000).to_i
+      _c_add_timer(interval, interval, block1 || block2, nil)
+    end
+    true
+  end
+
+  class << self
+    private :_c_add_timer
+  end
+
+
+  class Timer
+    def initialize delay, block1=nil, &block2
+      @_cdata = AsyncEngine.send(:_c_add_timer, (delay*1000).to_i, nil, block1 || block2, self)
+    end
+  end
+
+
+  class PeriodicTimer < Timer
+    def initialize interval, delay=nil, block1=nil, &block2
+      if delay
+        @_cdata = AsyncEngine.send(:_c_add_timer, (delay*1000).to_i, (interval*1000).to_i, block1 || block2, self)
+      else
+        interval = (interval*1000).to_i
+        @_cdata = AsyncEngine.send(:_c_add_timer, interval, interval, block1 || block2, self)
+      end
+    end
+
+    def set_interval interval
+      _c_set_interval (interval*1000).to_i
+    end
+    alias :interval= :set_interval
+  end
+
+end

data/lib/asyncengine/udp.rb

@@ -0,0 +1,5 @@
+module AsyncEngine
+
+
+
+end

data/lib/asyncengine/version.rb

@@ -1,3 +1,3 @@
 module AsyncEngine
-  VERSION = "0.0.1.testing"
+  VERSION = "0.0.1.testing1"
 end

data/lib/asyncengine.rb

@@ -1,41 +1,65 @@
-# Native C extension.
-require "asyncengine_ext.so"
+# AsyncEngine native C extension.
+require "asyncengine/asyncengine_ext.so"
 
-# Library files.
+# AsyncEngine Ruby library files.
 require "asyncengine/version.rb"
-
+require "asyncengine/errors.rb"
+require "asyncengine/timer.rb"
+require "asyncengine/next_tick.rb"
+require "asyncengine/udp.rb"
 
 
 module AsyncEngine
 
-  # Must be run before AsyncEngine.start (TODO: check it).
-  # TODO: Si mando una signal al proceso que no ha sido declarada con on_signal,
-  # entonces obviamente no pasa nada, pero cuando mando luego una signal declarada
-  # con on_signal entonces resulta que el proceso Ruby actúa como si se hubiese
-  # recibido la primera signal.
-  # TODO: Esto no va a funcionar creo, ya que cuando esté todo funcionando con callbacks
-  # de Ruby, me temo que al enviar una signal puede que sea Ruby el que la capture (no se).
-  def self.on_signal signal, &callback
-    @trapped_signals ||= {}
-
-    # Normalize the signal name.
-    signal_name = signal.to_s.upcase.sub(/^SIG/, "")
-
-    raise "invalid signal name `#{signal}'" unless (signal_number = ::Signal.list[signal_name])
-    raise "no callback provided"  unless callback
-
-    if self.trap_signal signal_number
-      @trapped_signals[signal_number] = callback
-      true
+  @_is_running = false
+  @_exception_manager = nil
+  @_blocks = {}
+  @_next_ticks = []
+
+  def self.run
+    #raise AsyncEngine::Error, "AsyncEngine already running"  if @_is_running
+    @_is_running = true
+
+    yield  if block_given?
+
+    if _c_run
+      # _c_run does not terminate (it blocks) until all the handles end.
+      # If so, let's set again @_is_running to false and return true.
+      @_is_running = false
+      return true
     else
-      raise "AsyncEngine.trap_signal returns false when setting signal `#{signal_name}' (number #{signal_number})"
+      raise AsyncEngine::Error, "AsyncEngine failed to run"
     end
   end
 
-  def self.timer_cb
-    puts "TIMER CB !!!"
+  def self.running?
+    @_is_running
+  end
+
+  def self.exception_manager block1=nil, &block2
+    if (block = block1 || block2)
+      raise AsyncEngine::Error, "no block provided"  unless block.respond_to? :call
+      @_exception_manager = block
+    else
+      @_exception_manager = nil
+    end
   end
+
+  def self.manage_exception e
+    if @_exception_manager
+      @_exception_manager.call e
+    else
+      raise e
+    end
+  end
+
+  class << self
+    private :_c_run
+    private :manage_exception
+  end
+
 end
 
 
+# Let's allow AE.xxxxx usage.
 AE = AsyncEngine