elrpc 0.0.1

data/lib/elrpc/version.rb

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

data/sample/echo-client.el

@@ -0,0 +1,28 @@
+(require 'epc)
+
+(let (epc)
+  ;; start a child process
+  ;; bundle exec
+  (setq epc (epc:start-epc "bundle" '("exec" "ruby" "echo.rb")))
+
+  ;; system ruby
+  ;;(setq epc (epc:start-epc "ruby" '("_echo.rb")))
+
+  ;; debug process (manual connection)
+  ;;(setq epc (epc:start-epc-debug 8888))
+
+
+  ;; asynchronous calling
+  (deferred:$
+    (epc:call-deferred epc 'echo '("hello"))
+    (deferred:nextc it 
+      (lambda (x) (message "Return : %S" x))))
+
+  ;; synchronous calling (debug purpose)
+  (message "%S" (epc:call-sync epc 'echo '(world)))
+
+  ;; 
+  (epc:stop-epc epc)
+  )
+
+;; just `eval-last-sexp' here

data/sample/echo-client.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+# start a child process
+cl = Elrpc.start_process(["ruby","echo.rb"])
+
+# synchronous calling
+puts cl.call_method("echo", "1 hello")
+
+# asynchronous calling
+cl.call_method_async("echo", "3 world") do |err, value|
+  puts value
+end
+
+puts "2 wait"
+sleep 0.2
+
+puts "4 ok"
+
+# kill the child process
+cl.stop

data/sample/echo.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+# start server
+server = Elrpc.start_server()
+
+# define a method
+server.def_method "echo" do |arg|
+  # just return the given argument value
+  arg
+end
+
+# sleep the main thread and wait for closing connection
+server.wait 

data/test/_add.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+server = Elrpc.start_server([],8888)
+server.def_method "add" do |a,b|
+  a+b
+end
+server.wait

data/test/_call_echo.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+cl = Elrpc.start_client(8888)
+ret = cl.call_method("echo", 1)
+puts ret
+cl.stop
+
+

data/test/_echo.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+server = Elrpc.start_server([], 8888)
+server.def_method "echo" do |*arg|
+  arg
+end
+server.wait

data/test/_errors.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+server = Elrpc.start_server([],8888)
+server.def_method "num_error" do |arg|
+  1/0
+end
+server.def_method "raise_error" do |arg|
+  raise "Raise!"
+end
+server.def_method "echo" do |*arg|
+  arg
+end
+server.wait

data/test/_methods.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+methods = [
+   Elrpc::Method.new("method1", "args", "", &->(a) { 1 }),
+   Elrpc::Method.new("test2", "a,b,c", "docstring here...", &->(a,b,c) { 2 }),
+]
+
+server = Elrpc.start_server(methods, 8888)
+server.wait

data/test/_process.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+
+server = Elrpc.start_server()
+server.wait

data/test/echo-bench.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+require 'elrpc'
+require 'benchmark'
+require 'monitor'
+
+cl = Elrpc.start_process(["ruby","#{__dir__}/_echo.rb"])
+
+rnd = Random.new 1000
+array = (1..100).map {|i| rnd.rand*10000 }
+hash  = array.inject({}) {|h, i| h[i] = rnd.rand*10000; h }
+str   = array.join("")
+
+n = 2000
+Benchmark.bm(10) do |x|
+  tint = x.report("int")    { n.times { cl.call_method("echo", 1) } }
+  tinta = x.report("int_a") do
+    wait_lock = Mutex.new
+    wait_cv = ConditionVariable.new
+    count = 0
+    n.times do
+      cl.call_method_async("echo", 1) do |val|
+        count += 1
+        wait_lock.synchronize do
+          wait_cv.signal if count == n
+        end
+      end
+    end
+    wait_lock.synchronize do
+      wait_cv.wait(wait_lock)
+    end
+  end
+  tstr = x.report("string") { n.times { cl.call_method("echo", str) } }
+  tarr = x.report("array")  { n.times { cl.call_method("echo", array) } }
+  thsh = x.report("hash")   { n.times { cl.call_method("echo", hash) } }
+  puts sprintf("(call/sec) int: %.1f  int_async: %.1f  string: %.1f  array: %.1f  hash: %.1f", 
+               n/tint.total, n/tinta.total, n/tstr.total, n/tarr.total, n/thsh.total)
+end
+
+cl.stop

data/test/test-epc.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/ruby
+
+require 'test/unit'
+require 'elrpc'
+
+def base(file)
+  "#{__dir__}/#{file}"
+end
+
+STDOUT.sync = true
+
+class TestEPC < Test::Unit::TestCase
+  
+  sub_test_case "01 Process" do
+    test "Start with port num and Getting it" do
+      port = nil
+      IO.popen(["ruby", base("_echo.rb")]) do |io|
+        port = io.readline.strip
+        Process.kill("TERM",io.pid)
+      end
+      assert_equal("8888", port)
+    end
+
+    test "Start without port num and getting the port num" do
+      port = nil
+      IO.popen(["ruby", base("_process.rb")]) do |io|
+        port = io.readline
+        Process.kill("TERM",io.pid)
+      end
+      assert_true(port.to_i > 0)
+    end
+  end
+
+
+
+  def with_epc(progname)
+    IO.popen(["ruby", base(progname)]) do |io|
+      port = io.readline.to_i
+      thread = Thread.start { loop { puts io.readline } }
+      client = Elrpc.start_client(port)
+      client.logger.level = Logger::ERROR
+      begin
+        yield client
+      rescue => e
+        Process.kill("TERM",io.pid)
+        raise e
+      ensure
+        client.stop
+        thread.kill
+      end
+    end
+  end
+
+
+  sub_test_case "02 Echo" do
+
+    test "Echo sync" do
+      with_epc "_echo.rb" do |client|
+        ret = client.call_method("echo", "hello")
+        assert_equal "hello", ret[0]
+        ret = client.call_method("echo", 12345)
+        assert_equal 12345, ret[0]
+      end
+    end
+
+    test "Echo async" do
+      with_epc "_echo.rb" do |client|
+        client.call_method_async("echo", "hello") do |err, ret|
+          assert_equal "hello", ret[0]
+        end
+        client.call_method_async("echo", -12.345) do |err, ret|
+          assert_equal -12.345, ret[0]
+          client.stop
+        end
+        client.wait
+      end
+    end
+  end
+
+
+  sub_test_case "03 Add" do
+    
+    test "Add sync" do 
+      with_epc "_add.rb" do |client|
+        ret = client.call_method("add", 1, 2)
+        assert_equal 3, ret
+        ret = client.call_method("add", "A", "B")
+        assert_equal "AB", ret
+      end
+    end
+    
+    test "Add async" do
+      with_epc "_add.rb" do |client|
+        client.call_method_async("add", 3, 4) do |err, ret|
+          assert_equal 7, ret
+        end
+        client.call_method_async("add", "C","D") do |err, ret|
+          assert_equal "CD", ret
+          client.stop
+        end
+        client.wait
+      end
+    end
+  end
+
+  sub_test_case "04 Errors" do
+
+    test "Error sync" do
+      with_epc "_errors.rb" do |client|
+        assert_raise_message /divided by 0/ do
+          ret = client.call_method("num_error")
+        end
+        assert_raise_message /Raise!/ do
+          ret = client.call_method("raise_error")
+        end
+        ret = client.call_method("echo", "recover!!")
+        assert_equal "recover!!", ret[0]
+      end
+    end
+
+    test "Error async" do
+      with_epc "_errors.rb" do |client|
+        client.call_method_async("num_error") do |err, ret|
+          assert_equal "divided by 0", err.remote_message
+        end
+        client.call_method_async("raise_error") do |err, ret|
+          assert_equal "Raise!", err.remote_message
+          client.stop
+        end
+        client.wait
+      end
+    end
+
+    test "EPC Error" do
+      with_epc "_echo.rb" do |client|
+        assert_raise_kind_of Elrpc::EPCStackError do
+          client.call_method("echo", Elparser::Parser.new )
+        end
+        assert_raise_kind_of Elrpc::EPCStackError do
+          client.call_method("echo??", 1 )
+        end
+        ret = client.call_method("echo", "recover!!")
+        assert_equal "recover!!", ret[0]
+      end
+    end
+
+  end
+
+  sub_test_case "05 Query" do
+    test "Query sync" do
+      with_epc "_methods.rb" do |client|
+        ret = client.query_methods
+        assert_equal 2, ret.size
+        assert_equal :method1, ret[0][0]
+        assert_equal "args", ret[0][1]
+        assert_equal "", ret[0][2]
+        assert_equal :test2, ret[1][0]
+        assert_equal "a,b,c", ret[1][1]
+        assert_equal "docstring here...", ret[1][2]
+      end
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: elrpc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- SAKURAI Masashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: EPC (RPC stack for the Emacs Lisp) for Ruby.
+email:
+- m.sakurai@kiwanami.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elrpc.gemspec
+- lib/elrpc.rb
+- lib/elrpc/version.rb
+- sample/echo-client.el
+- sample/echo-client.rb
+- sample/echo.rb
+- test/_add.rb
+- test/_call_echo.rb
+- test/_echo.rb
+- test/_errors.rb
+- test/_methods.rb
+- test/_process.rb
+- test/echo-bench.rb
+- test/test-epc.rb
+homepage: https://github.com/kiwanami/ruby-elrpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: EPC (RPC stack for the Emacs Lisp) for Ruby.
+test_files:
+- test/_add.rb
+- test/_call_echo.rb
+- test/_echo.rb
+- test/_errors.rb
+- test/_methods.rb
+- test/_process.rb
+- test/echo-bench.rb
+- test/test-epc.rb