em_remote_call 0.0.1

data/lib/em_remote_call/client.rb

@@ -0,0 +1,68 @@
+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
+    end
+    
+    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
+      
+      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 => argument, :instance => {:class => klass, :id => id}, :method => remote_method}
+      self.class.remote_connection.call(call, callb, return_block)
+    end
+  end
+end
+
+class EM::RemoteCall::Callback
+  is_a_collection :object_id
+  
+  def initialize(&callb)
+    @callback = callb
+    super
+  end
+  
+  def call(arg)
+    @callback.call arg
+    remove_from_collection
+  end
+end
+
+module EM::RemoteCall::Client
+  include EM::JsonConnection::Client
+  
+  def json_parsed(hash)
+    p hash
+    if id = hash[:callback_id]
+      if callb = EM::RemoteCall::Callback.find(id)
+        callb.call hash[:argument]
+      end
+    end
+  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
+    send_data call
+  end
+end

data/lib/em_remote_call/server.rb

@@ -0,0 +1,48 @@
+module EM::RemoteCall; end
+
+class EM::RemoteCall::Call
+  def initialize(instance_opts, method, argument)
+    klass = instance_opts[:class] or return false
+    
+    @method, @argument = method, argument
+    
+    if indentifier = instance_opts[:id]
+      klass = Object.const_defined?(klass) && Object.const_get(klass) or return false
+      @instance = klass.find(indentifier)
+    else
+      @instance = Object.const_defined?(klass) && Object.const_get(klass) or return false
+    end
+    
+  end
+  
+  def valid?
+    @instance && @method && @instance.respond_to?(@method)
+  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
+      @instance.__send__ @method, &callb
+    end
+  end
+end
+
+module EM::RemoteCall::Server
+  include EM::JsonConnection::Server
+  
+  def json_parsed(hash)
+    p 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]
+    end
+    send_data({:callback_id => hash[:return_block_id], :argument => return_value}) if hash[:return_block_id]
+    
+  end
+end

data/lib/em_remote_call/version.rb

@@ -0,0 +1,3 @@
+module EmRemoteCall
+  VERSION = "0.0.1"
+end

data/lib/em_remote_call.rb

@@ -0,0 +1,9 @@
+require 'eventmachine'
+require 'fiber'
+
+require 'em_json_connection'
+require 'is_a_collection'
+
+require 'em_remote_call/client'
+require 'em_remote_call/server'
+

data/spec/integration_spec.rb

@@ -0,0 +1,93 @@
+$LOAD_PATH << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
+
+require 'em_remote_call'
+
+class Track
+  attr_reader :title, :artist
+  
+  def initialize(opts)
+    @title, @artist = opts[:title], opts[:artist]
+    super
+  end
+  
+  def id
+    "#{title} - #{artist}"
+  end
+end
+
+class ServerTrack < Track
+  is_a_collection
+  
+  def initialize(opts, &callb)
+    callb.call
+    super
+  end
+  
+  def play(&callb)
+    callb.call "finished #{id}"
+    "started #{id}"
+  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
+end
+
+class EMController
+  extend EM::RemoteCall
+  remote_method :stop, :class_name => 'EM', :calls => :stop
+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
+  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
+      EM.stop
+    end
+  end
+end
+
+describe EM::RemoteCall do
+  describe "class method callbacks" do
+    it "should be called" do
+      test_on_client do
+        callb = mock(:callb)
+        callb.should_receive(:foo)
+        ClientTrack.new({}).init_track_on_server({}){callb.foo}
+      end
+    end
+  end
+  describe "instance method callbacks" do
+    it "should be called" 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}
+      end
+    end
+  end
+  describe "return values" do
+    it "should be passed to the second proc" do
+      test_on_client do
+        callb = mock(:callb)
+        callb.should_receive(:bar).with('started a - b')
+        c = ClientTrack.new(:title => 'a', :artist => 'b')
+        c.init_track_on_server(:title => 'a', :artist => 'b')
+        c.play proc{|a| callb.bar a}, proc{}
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: em_remote_call
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Niko Dittmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-15 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: is_a_collection
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: em_json_connection
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Provides an Eventmachine server/client couple which allows the client to call methods within the server process, including local client-callbacks.
+email: mail+git@niko-dittmann.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/em_remote_call/client.rb
+- lib/em_remote_call/server.rb
+- lib/em_remote_call/version.rb
+- lib/em_remote_call.rb
+- spec/integration_spec.rb
+has_rdoc: true
+homepage: http://github.com/niko/em_remote_call
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides an Eventmachine server/client couple which allows the client to call methods within the server process, including local client-callbacks.
+test_files: 
+- spec/integration_spec.rb