em_remote_call 0.0.3 → 0.0.4

data/lib/em_remote_call/client.rb

@@ -10,35 +10,32 @@ module EM::RemoteCall
     define_method name do |*method_opts, &callb|
       return unless self.class.remote_connection
       
-      if !block_given? && method_opts.last.is_a?(Proc)
-        callb = method_opts.pop
-      end
-      if method_opts.last.is_a? Proc
-        return_block = method_opts.pop
-      end
-      argument = method_opts.shift
+      callback = EM::RemoteCall::Deferrable.new
+      callback.callback(&callb) if callb
       
-      remote_method = opts[:calls] || name
-      klass         = opts[:class_name] || self.class.to_s
-      id            = opts[:find_by] && send(opts[:find_by]) # when it's nil, it's considered a class method.
+      call = {
+        :argument => method_opts.first,                     # evt. other args will get dropped
+        :instance => {
+          :class => opts[:class_name] || self.class.to_s,   # own class name by default
+          :id => opts[:find_by] && send(opts[:find_by])     # when it's nil, it's considered a class method.
+        },
+        :method => opts[:calls] || name,                    # same method name by default
+        :deferrable_id => callback.object_id                  # store the callbacks object_id to retrieve it later
+      }
       
-      call = {:argument => argument, :instance => {:class => klass, :id => id}, :method => remote_method}
-      self.class.remote_connection.call(call, callb, return_block)
+      self.class.remote_connection.call call
+      return callback
     end
   end
 end
 
-class EM::RemoteCall::Callback
+class EM::RemoteCall::Deferrable
+  include EventMachine::Deferrable
   is_a_collection :object_id
   
-  def initialize(&callb)
-    @callback = callb
-    super
-  end
-  
-  def call(arg)
-    @callback.call arg
+  def set_deferred_status status, *args
     remove_from_collection
+    super
   end
 end
 
@@ -46,22 +43,13 @@ module EM::RemoteCall::Client
   include EM::JsonConnection::Client
   
   def json_parsed(hash)
-    if id = hash[:callback_id]
-      if callb = EM::RemoteCall::Callback.find(id)
-        callb.call hash[:argument]
-      end
-    end
+    id = hash[:deferrable_id]
+    deffr = EM::RemoteCall::Deferrable.find(id)
+    deffr.succeed hash[:success] if hash.has_key? :success
+    deffr.fail    hash[:error]   if hash.has_key? :error
   end
   
-  def call(call, callb, return_block)
-    if callb
-      callb = EM::RemoteCall::Callback.new(&callb)
-      call.merge!({ :callback_id => callb.object_id })
-    end
-    if return_block
-      return_block = EM::RemoteCall::Callback.new(&return_block)
-      call.merge!({ :return_block_id => return_block.object_id })
-    end
+  def call(call)
     send_data call
   end
 end

data/lib/em_remote_call/server.rb

@@ -1,30 +1,28 @@
 module EM::RemoteCall; end
 
 class EM::RemoteCall::Call
+  class Error < StandardError; end
+  class NoInstanceError         < Error ; end
+  class NoMethodGivenError      < Error; end
+  class NoMethodOfInstanceError < Error; end
+  
   def initialize(instance_opts, method, argument)
-    klass = instance_opts[:class] or return false
-    
-    @method, @argument = method, argument
-    
-    if indentifier = instance_opts[:id]
-      klass = EM::RemoteCall::Utils.constantize(klass) or return false
-      @instance = klass.find(indentifier)
-    else
-      @instance = EM::RemoteCall::Utils.constantize(klass) or return false
-    end
-    
+    @argument = argument
+    @method   = method                       or raise NoMethodError.new method
+    @instance = find_instance(instance_opts) or raise NoInstanceError.new instance_opts
+    @instance.respond_to?(@method)           or raise NoMethodOfInstanceError.new "#{@instance}##{method}"
   end
   
-  def valid?
-    @instance && @method && @instance.respond_to?(@method)
+  def find_instance(args)
+    if args[:id]
+      klass = EM::RemoteCall::Utils.constantize(args[:class])      or return false
+      @instance = klass.find(args[:id])                            or return false
+    else
+      @instance = EM::RemoteCall::Utils.constantize(args[:class])  or return false
+    end
   end
   
   def call(&callb)
-    unless valid?
-      puts "invalid remote call: :instance => #{@instance}, :method => #{@method}, :argument => #{@argument}"
-      return false
-    end
-    
     if @argument
       @instance.__send__ @method, @argument, &callb
     else
@@ -38,10 +36,13 @@ module EM::RemoteCall::Server
   
   def json_parsed(hash)
     remote_call = EM::RemoteCall::Call.new hash[:instance], hash[:method].to_sym, hash[:argument]
-    return_value = remote_call.call do |blk_value|
-      send_data({:callback_id => hash[:callback_id], :argument => blk_value}) if hash[:callback_id]
+    
+    remote_call.call do |blk_value|
+      send_data({:deferrable_id => hash[:deferrable_id], :success => blk_value})
     end
-    send_data({:callback_id => hash[:return_block_id], :argument => return_value}) if hash[:return_block_id]
     
+  rescue => e
+    puts "#{e}: #{e.message}"
+    send_data( { :deferrable_id => hash[:deferrable_id], :error => {:class => e.class.name, :message => e.message} } )
   end
 end

data/lib/em_remote_call/version.rb

@@ -1,3 +1,3 @@
 module EmRemoteCall
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/integration_spec.rb

@@ -5,7 +5,7 @@ require 'em_remote_call'
 class Track
   attr_reader :title, :artist
   
-  def initialize(opts)
+  def initialize(opts={})
     @title, @artist = opts[:title], opts[:artist]
     super
   end
@@ -27,12 +27,16 @@ class ServerTrack < Track
     callb.call "finished #{id}"
     "started #{id}"
   end
+  def raise_hell
+    EM.next_tick{raise 'foobar'}
+  end
 end
 
 class ClientTrack < Track
   extend EM::RemoteCall
   remote_method :init_track_on_server, :class_name => 'ServerTrack', :calls => :new
   remote_method :play,                 :class_name => 'ServerTrack', :find_by => :id
+  remote_method :raise_hell,           :class_name => 'ServerTrack', :find_by => :id
 end
 
 class EMController
@@ -63,7 +67,7 @@ describe EM::RemoteCall do
       test_on_client do
         callb = mock(:callb)
         callb.should_receive(:foo)
-        ClientTrack.new({}).init_track_on_server({}){callb.foo}
+        ClientTrack.new.init_track_on_server({}){callb.foo}
       end
     end
   end
@@ -78,16 +82,16 @@ describe EM::RemoteCall do
       end
     end
   end
-  describe "return values" do
-    it "should be passed to the second proc" do
+  describe "errbacks" do
+    it "should take an errback method" do
       test_on_client do
         callb = mock(:callb)
-        callb.should_receive(:bar).with('started a - b')
+        callb.should_receive(:foo).with({:class=>"RuntimeError", :message=>"foobar"})
         c = ClientTrack.new(:title => 'a', :artist => 'b')
         c.init_track_on_server(:title => 'a', :artist => 'b')
-        c.play proc{|a| callb.bar a}, proc{}
+        play_call = c.raise_hell
+        play_call.errback{|a| callb.foo a}
       end
     end
   end
 end
-

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Niko Dittmann
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-01 00:00:00 +01:00
+date: 2010-12-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency