em_remote_call 0.0.6 → 0.1.0

data/lib/em_remote_call/client.rb

@@ -1,35 +1,47 @@
-module EM::RemoteCall
-  def remote_method(name, opts={})
-    unless respond_to? :remote_connection
-      class << self
-        define_method(:remote_connection=){ |conn| @remote_connection = conn }
-        define_method(:remote_connection) {        @remote_connection        }
-      end
+class Class
+  def has_em_remote_class(remote_class_name, opts)
+    extend EM::RemoteCall
+    class << self
+      attr_accessor :remote_connection
+      extend EM::RemoteCall
     end
     
-    define_method name do |*method_opts, &callb|
-      remote_connection =
-        (self.class.respond_to?(:remote_connection) && self.class.remote_connection) ||
-        (self.respond_to?(:remote_connection)       && self.remote_connection)
-      return unless remote_connection
+    opts[:name] ||= :default
+    opts[:remote_class_name] = remote_class_name
+    self.remote_connection = EM::RemoteCall::Client.find(opts[:name]) || EM::RemoteCall::Client.new(opts)
+  end
+end
+
+module EM::RemoteCall
+  def remote_method(method_name, opts={})
+    define_method method_name do |*method_args, &callb|
+      return unless remote_connection =                                                                                                                                                     
+        (self.class.respond_to?(:remote_connection) && self.class.remote_connection) ||                                                                                       
+        (self.respond_to?(:remote_connection)       && self.remote_connection)                                                                                                
       
       callback = EM::RemoteCall::Deferrable.new
       callback.callback(&callb) if callb
       
       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
-      }
+        :deferrable_id => callback.object_id,          # store the callbacks object_id to retrieve it later
+        :debug         => opts[:debug],                # debugging on client and server
+        :method        => opts[:calls] || method_name, # same method name by default
+        :arguments     => [*method_args],              # all the args
+        :instance      => {
+          :class => remote_connection.remote_class_name || self.class.to_s,                # own class name by default
+          :id    => !opts[:server_class_method] && send(remote_connection.instance_finder) # when it's nil, it's considered a class method.
+      }}
       
+      puts "On Client: #{call}" if opts[:debug]
       remote_connection.call call
       return callback
     end
   end
+  
+  # a convinience wrapper for class methods:
+  def remote_class_method(method_name, opts={})
+    (class << self; self; end).remote_method method_name, opts.merge({:server_class_method => true})
+  end
 end
 
 class EM::RemoteCall::Deferrable
@@ -42,17 +54,36 @@ class EM::RemoteCall::Deferrable
   end
 end
 
-module EM::RemoteCall::Client
+module EM::RemoteCall::ClientConnection
   include EM::JsonConnection::Client
   
   def json_parsed(hash)
-    id = hash[:deferrable_id]
-    deffr = EM::RemoteCall::Deferrable.find(id)
+    puts "From server: #{hash}" if hash[:debug]
+    
+    deffr = EM::RemoteCall::Deferrable.find hash[:deferrable_id]
     deffr.succeed hash[:success] if hash.has_key? :success
     deffr.fail    hash[:error]   if hash.has_key? :error
   end
+end
+
+class EM::RemoteCall::Client
+  attr_reader :name, :remote_class_name, :instance_finder
+  is_a_collection :name
+  
+  def initialize(opts)
+    @name               = opts[:name] ||= :default
+    @remote_class_name  = opts[:remote_class_name]
+    @socket             = opts[:socket]
+    @port               = opts[:port]
+    @instance_finder    = opts[:instance_finder] ||= :id
+  end
   
   def call(call)
-    send_data call
+    unless @connection && @connection.connected?
+      @connection = EM::RemoteCall::ClientConnection.connect_to *[@socket, @port].compact
+    end
+    
+    @connection.send_data call
   end
+  
 end

data/lib/em_remote_call/server.rb

@@ -2,15 +2,15 @@ module EM::RemoteCall; end
 
 class EM::RemoteCall::Call
   class Error < StandardError; end
-  class NoInstanceError         < Error ; end
+  class NoInstanceError         < Error; end
   class NoMethodGivenError      < Error; end
   class NoMethodOfInstanceError < Error; end
   
-  def initialize(instance_opts, method, argument)
-    @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}"
+  def initialize(instance_opts, method, arguments)
+    @arguments = arguments
+    @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 find_instance(args)
@@ -22,8 +22,15 @@ class EM::RemoteCall::Call
     end
   end
   
+  def takes_block?
+    method = @instance.method(@method)
+    return unless method.respond_to?(:parameters)
+    params = method.parameters
+    params.last && params.last.first == :block
+  end
+  
   def call(&callb)
-    @argument ? @instance.__send__(@method, @argument, &callb) : @instance.__send__(@method, &callb)
+    @arguments.empty? ? @instance.__send__(@method, &callb) : @instance.__send__(@method, *@arguments, &callb)
   end
 end
 
@@ -31,23 +38,24 @@ module EM::RemoteCall::Server
   include EM::JsonConnection::Server
   
   def json_parsed(hash)
-    remote_call = EM::RemoteCall::Call.new hash[:instance], hash[:method].to_sym, hash[:argument]
+    remote_call = EM::RemoteCall::Call.new hash[:instance], hash[:method].to_sym, hash[:arguments]
+    puts "On Server: #{remote_call}: #{hash}" if hash[:debug]
     
-    ret = remote_call.call do |result|
-      send_data({:deferrable_id => hash[:deferrable_id], :success => result})
+    if remote_call.takes_block?
+      remote_call.call{ |result| send_data :deferrable_id => hash[:deferrable_id], :method_type => :block, :success => result }
+      return
     end
     
+    ret = remote_call.call
     if ret.is_a? EM::Deferrable
-      ret.callback do |result|
-        send_data({:deferrable_id => hash[:deferrable_id], :success => result})
-      end
-      ret.errback do |result|
-        send_data({:deferrable_id => hash[:deferrable_id], :error => result})
-      end
+      ret.callback{ |result| send_data :deferrable_id => hash[:deferrable_id], :debug => hash[:debug], :method_type => :deferrable, :success => result }
+      ret.errback { |result| send_data :deferrable_id => hash[:deferrable_id], :debug => hash[:debug], :method_type => :deferrable, :error => result }
+    else
+      send_data :deferrable_id => hash[:deferrable_id], :success => ret, :method_type => :returned, :debug => hash[:debug]
     end
     
   rescue => e
     puts "#{e}: #{e.message}"
-    send_data( { :deferrable_id => hash[:deferrable_id], :error => {:class => e.class.name, :message => e.message} } )
+    send_data :deferrable_id => hash[:deferrable_id], :error => {:class => e.class.name, :message => e.message}, :method_type => :rescue, :debug => hash[:debug]
   end
 end

data/lib/em_remote_call/version.rb

@@ -1,3 +1,3 @@
 module EmRemoteCall
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/spec/integration_spec.rb

@@ -15,43 +15,54 @@ class Track
   end
 end
 
+TEST_SOCKET = File.join( File.expand_path(File.dirname(__FILE__)), 'test_socket' )
+
 class ServerTrack < Track
   is_a_collection
   
-  def initialize(opts, &callb)
-    callb.call
+  def initialize(opts={}, &callb)
+    callb.call if callb
     super
   end
   
+  # takes a block:
   def play(&callb)
     callb.call "finished #{id}"
     "started #{id}"
   end
+  
+  # raises:
   def raise_hell
     raise 'foobar'
   end
+  
+  # returns a deferrable:
   def with_deferrable(outcome = 'succeed') # does not take a block
     d = EventMachine::DefaultDeferrable.new
     d.send outcome
     return d
   end
   
-  def self.some_class_meth
-    yield
+  # doesn't take a block, just returns a hash:
+  def as_hash
+    {:title => title, :artist => artist}
+  end
+  
+  # a class method:
+  def self.some_class_meth(&blk)
+    blk.call
   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
-  remote_method :with_deferrable,      :class_name => 'ServerTrack', :find_by => :id
+  has_em_remote_class 'ServerTrack', :socket => TEST_SOCKET
   
-  class << self
-    extend EM::RemoteCall
-    remote_method :some_class_meth, :class_name => 'ServerTrack'
-  end
+  remote_method :init_track_on_server, :calls => :new, :server_class_method => true
+  remote_method :play
+  remote_method :raise_hell
+  remote_method :with_deferrable
+  remote_method :as_hash
+  remote_class_method :some_class_meth
 end
 
 class EMController
@@ -60,14 +71,11 @@ class EMController
 end
 
 def test_on_client
-  socket = File.join( File.expand_path(File.dirname(__FILE__)), 'test_socket' )
-  
   server_pid = EM.fork_reactor do
-    EM::RemoteCall::Server.start_at socket
+    EM::RemoteCall::Server.start_at TEST_SOCKET
   end
   sleep 0.1
   EM.run do
-    ClientTrack.remote_connection = EM::RemoteCall::Client.connect_to socket
     yield
     EM.add_timer 0.1 do
       Process.kill 'HUP', server_pid
@@ -82,39 +90,39 @@ 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
-  describe "instance method callbacks" do
-    it "should be called" do
+  describe "class method callbacks too" do
+    it "should work twice" do
       test_on_client do
         callb = mock(:callb)
-        callb.should_receive(:foo).with('finished a - b')
-        c = ClientTrack.new(:title => 'a', :artist => 'b')
-        c.init_track_on_server(:title => 'a', :artist => 'b')
-        c.play{|a| callb.foo a}
+        callb.should_receive(:foo).twice
+        ClientTrack.new.init_track_on_server{callb.foo}
+        ClientTrack.new.init_track_on_server{callb.foo}
       end
     end
   end
-  describe "errbacks" do
-    it "should take an errback method" do
+  describe "client side class method" do
+    it "should work :)" do
       test_on_client do
         callb = mock(:callb)
-        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')
-        play_call = c.raise_hell
-        play_call.errback{|a| callb.foo a}
+        callb.should_receive(:foo)
+        ClientTrack.some_class_meth{callb.foo}
       end
     end
   end
-  describe "client side class method" do
-    it "should work :)" do
+  describe "without block or deferrable" do
+    it "should return just the return value" do
       test_on_client do
         callb = mock(:callb)
-        callb.should_receive(:foo)
-        ClientTrack.some_class_meth{callb.foo}
+        properties = {:artist => 'a', :title => 't'}
+        callb.should_receive(:foo).with(properties)
+        c = ClientTrack.new properties
+        c.init_track_on_server properties do
+          c.as_hash{|r| callb.foo(r)}
+        end
       end
     end
   end
@@ -124,9 +132,9 @@ describe EM::RemoteCall do
         it "should use the block as callback" do
           test_on_client do
             callb = mock(:callb)
-            callb.should_receive(:foo).with()
+            callb.should_receive(:foo)
             c = ClientTrack.new
-            c.init_track_on_server({})
+            c.init_track_on_server
             c.with_deferrable(:succeed){ callb.foo }
           end
         end
@@ -135,9 +143,9 @@ describe EM::RemoteCall do
         it "should use callback" do
           test_on_client do
             callb = mock(:callb)
-            callb.should_receive(:foo).with()
+            callb.should_receive(:foo)
             c = ClientTrack.new
-            c.init_track_on_server({})
+            c.init_track_on_server
             play_call = c.with_deferrable(:succeed)
             play_call.callback{ callb.foo }
           end
@@ -148,9 +156,9 @@ describe EM::RemoteCall do
       it "should use errback" do
         test_on_client do
           callb = mock(:callb)
-          callb.should_receive(:foo).with()
+          callb.should_receive(:foo)
           c = ClientTrack.new
-          c.init_track_on_server({})
+          c.init_track_on_server
           play_call = c.with_deferrable(:fail)
           play_call.errback{ callb.foo }
         end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 6
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors: 
 - Niko Dittmann
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-23 00:00:00 +01:00
+date: 2010-12-27 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency