mojombo-bertrpc 0.1.2 → 0.2.0

data/README.md

@@ -26,7 +26,7 @@ Example
     require 'bertrpc'
     
     svc = BERTRPC::Service.new('localhost', 9999)
-    svc.calc.add.call(1, 2)
+    svc.call.calc.add(1, 2)
     # => 3
 
 This generates a BERT-RPC request like so:

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/bertrpc.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bertrpc}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tom Preston-Werner"]
-  s.date = %q{2009-05-27}
+  s.date = %q{2009-08-13}
   s.email = %q{tom@mojombo.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -21,23 +21,28 @@ Gem::Specification.new do |s|
      "VERSION",
      "bertrpc.gemspec",
      "lib/bertrpc.rb",
+     "lib/bertrpc/call.rb",
+     "lib/bertrpc/call_proxy.rb",
+     "lib/bertrpc/encodes.rb",
      "lib/bertrpc/errors.rb",
-     "lib/bertrpc/fun.rb",
      "lib/bertrpc/mod.rb",
      "lib/bertrpc/service.rb",
-     "test/fun_test.rb",
+     "test/call_proxy_test.rb",
+     "test/call_test.rb",
+     "test/encodes_test.rb",
      "test/mod_test.rb",
      "test/service_test.rb",
      "test/test_helper.rb"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/mojombo/bertrpc}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.0}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{BERTRPC is a Ruby BERT-RPC client library.}
   s.test_files = [
-    "test/fun_test.rb",
+    "test/call_proxy_test.rb",
+     "test/call_test.rb",
+     "test/encodes_test.rb",
      "test/mod_test.rb",
      "test/service_test.rb",
      "test/test_helper.rb"
@@ -45,7 +50,7 @@ Gem::Specification.new do |s|
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<erlectricity>, [">= 1.0.1"])

data/lib/bertrpc/call.rb

@@ -0,0 +1,33 @@
+module BERTRPC
+  class Call
+    include Encodes
+    
+    def initialize(svc, mod, fun, args)
+      @svc = svc
+      @mod = mod
+      @fun = fun
+      @args = args
+    end
+
+    def execute
+      bert_request = encode_ruby_request([:call, @mod, @fun, @args])
+      bert_response = sync_request(bert_request)
+      decode_bert_response(bert_response)
+    end
+
+    #private
+
+    def sync_request(bert_request)
+      sock = TCPSocket.new(@svc.host, @svc.port)
+      sock.write([bert_request.length].pack("N"))
+      sock.write(bert_request)
+      lenheader = sock.read(4)
+      raise ProtocolError.new("Unable to read length header from server.") unless lenheader
+      len = lenheader.unpack('N').first
+      bert_response = sock.read(len)
+      raise ProtocolError.new("Unable to read data from server.") unless bert_response
+      sock.close
+      bert_response
+    end
+  end
+end

data/lib/bertrpc/call_proxy.rb

@@ -0,0 +1,11 @@
+module BERTRPC
+  class CallProxy
+    def initialize(svc)
+      @svc = svc
+    end
+
+    def method_missing(cmd, *args)
+      Mod.new(@svc, Call, cmd)
+    end
+  end
+end

data/lib/bertrpc/{fun.rb → encodes.rb}

@@ -1,33 +1,5 @@
 module BERTRPC
-  class Fun
-    def initialize(svc, mod, fun)
-      @svc = svc
-      @mod = mod
-      @fun = fun
-    end
-
-    def call(*args)
-      args = [*args]
-      bert_request = encode_ruby_request([:call, @mod, @fun, args])
-      bert_response = sync_request(bert_request)
-      decode_bert_response(bert_response)
-    end
-
-    # private
-
-    def sync_request(bert_request)
-      sock = TCPSocket.new(@svc.host, @svc.port)
-      sock.write([bert_request.length].pack("N"))
-      sock.write(bert_request)
-      lenheader = sock.read(4)
-      raise ProtocolError.new("Unable to read length header from server.") unless lenheader
-      len = lenheader.unpack('N').first
-      bert_response = sock.read(len)
-      raise ProtocolError.new("Unable to read data from server.") unless bert_response
-      sock.close
-      bert_response
-    end
-
+  module Encodes
     def encode_ruby_request(ruby_request)
       ruby_payload = convert(ruby_request)
       Erlectricity::Encoder.encode(ruby_payload)

data/lib/bertrpc/mod.rb

@@ -1,12 +1,14 @@
 module BERTRPC
   class Mod
-    def initialize(svc, mod)
+    def initialize(svc, type, mod)
       @svc = svc
+      @type = type
       @mod = mod
     end
 
     def method_missing(cmd, *args)
-      Fun.new(@svc, @mod, cmd)
+      args = [*args]
+      @type.new(@svc, @mod, cmd, args).execute
     end
   end
 end

data/lib/bertrpc/service.rb

@@ -7,8 +7,8 @@ module BERTRPC
       @port = port
     end
 
-    def method_missing(cmd, *args)
-      Mod.new(self, cmd)
+    def call
+      CallProxy.new(self)
     end
   end
 end

data/lib/bertrpc.rb

@@ -2,6 +2,8 @@ require 'erlectricity'
 require 'socket'
 
 require 'bertrpc/service'
+require 'bertrpc/call_proxy'
 require 'bertrpc/mod'
-require 'bertrpc/fun'
+require 'bertrpc/encodes'
+require 'bertrpc/call'
 require 'bertrpc/errors'

data/test/call_proxy_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CallProxyTest < Test::Unit::TestCase
+  context "A CallProxy" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+    end
+
+    should "be created with a Service" do
+      assert BERTRPC::CallProxy.new(@svc).is_a?(BERTRPC::CallProxy)
+    end
+  end
+
+  context "A CallProxy instance" do
+    setup do
+      svc = BERTRPC::Service.new('localhost', 9941)
+      @cp = BERTRPC::CallProxy.new(@svc)
+    end
+
+    should "return a Mod instance" do
+      assert @cp.myfun.is_a?(BERTRPC::Mod)
+    end
+  end
+end

data/test/call_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class CallTest < Test::Unit::TestCase
+  context "A Call" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+    end
+
+    should "be created with a Service, module name, fun name, and args" do
+      assert BERTRPC::Call.new(@svc, :mymod, :myfun, [1, 2]).is_a?(BERTRPC::Call)
+    end
+  end
+
+  context "A Call instance" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @enc = Enc.new
+    end
+
+    should "call with single-arity" do
+      req = @enc.encode_ruby_request([:call, :mymod, :myfun, [1]])
+      res = @enc.encode_ruby_request([:reply, 2])
+      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [1])
+      call.expects(:sync_request).with(req).returns(res)
+      assert_equal 2, call.execute
+    end
+
+    should "call with single-arity array" do
+      req = @enc.encode_ruby_request([:call, :mymod, :myfun, [[1, 2, 3]]])
+      res = @enc.encode_ruby_request([:reply, [4, 5, 6]])
+      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [[1, 2, 3]])
+      call.expects(:sync_request).with(req).returns(res)
+      assert_equal [4, 5, 6], call.execute
+    end
+
+    should "call with multi-arity" do
+      req = @enc.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
+      res = @enc.encode_ruby_request([:reply, [4, 5, 6]])
+      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [1, 2, 3])
+      call.expects(:sync_request).with(req).returns(res)
+      assert_equal [4, 5, 6], call.execute
+    end
+
+    context "sync_request" do
+      setup do
+        @svc = BERTRPC::Service.new('localhost', 9941)
+        @call = BERTRPC::Call.new(@svc, :mymod, :myfun, [])
+      end
+    
+      should "read and write BERT-Ps from the socket" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        io.expects(:read).with(4).returns("\000\000\000\003")
+        io.expects(:read).with(3).returns("bar")
+        io.expects(:close)
+        TCPSocket.expects(:new).returns(io)
+        assert_equal "bar", @call.sync_request("foo")
+      end
+
+      should "raise a ProtocolError when the length is invalid" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        io.expects(:read).with(4).returns(nil)
+        TCPSocket.expects(:new).returns(io)
+        assert_raises(BERTRPC::ProtocolError) do
+          @call.sync_request("foo")
+        end
+      end
+      
+      should "raise a ProtocolError when the data is invalid" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        io.expects(:read).with(4).returns("\000\000\000\003")
+        io.expects(:read).with(3).returns(nil)
+        TCPSocket.expects(:new).returns(io)
+        assert_raises(BERTRPC::ProtocolError) do
+          @call.sync_request("foo")
+        end
+      end
+    end
+  end
+end

data/test/encodes_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class EncodesTest < Test::Unit::TestCase
+  context "An Encodes includer" do
+    setup do
+      @enc = Enc.new
+    end
+
+    context "converter" do
+      should "convert top level hashes to BERT-RPC dict form" do
+        assert_equal([:dict, [:foo, 1], [:bar, 2]], @enc.convert({:foo => 1, :bar => 2}))
+      end
+
+      should "convert nested hashes in the same way" do
+        assert_equal([1, 2, [:dict, [:foo, 1]]], @enc.convert([1, 2, {:foo => 1}]))
+      end
+
+      should "keep everything else the same" do
+        assert_equal [1, 2, "foo", :bar, 3.14], @enc.convert([1, 2, "foo", :bar, 3.14])
+      end
+    end
+
+    context "deconverter" do
+      should "convert top level BERT-RPC dict forms to hashes" do
+        assert_equal({:foo => 1, :bar => 2}, @enc.deconvert([:dict, [:foo, 1], [:bar, 2]]))
+      end
+
+      should "convert nested dicts in the same way" do
+        assert_equal([1, 2, {:foo => 1}], @enc.deconvert([1, 2, [:dict, [:foo, 1]]]))
+      end
+
+      should "keep everything else the same" do
+        assert_equal [1, 2, "foo", :bar, 3.14], @enc.deconvert([1, 2, "foo", :bar, 3.14])
+      end
+    end
+    
+    context "ruby request encoder" do
+      should "return BERT-RPC encoded request" do
+        bert = "\203h\004d\000\004calld\000\005mymodd\000\005myfunh\003a\001a\002a\003"
+        assert_equal bert, @enc.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
+      end
+    end
+    
+    context "bert response decoder" do
+      should "return response when successful" do
+        req = @enc.encode_ruby_request([:reply, [1, 2, 3]])
+        res = @enc.decode_bert_response(req)
+        assert_equal [1, 2, 3], res
+      end
+
+      should "raise a ProtocolError error when protocol level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:protocol, 1, "invalid"]])
+        assert_raises(BERTRPC::ProtocolError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a ServerError error when server level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:server, 1, "invalid"]])
+        assert_raises(BERTRPC::ServerError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a UserError error when user level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:user, 1, "invalid"]])
+        assert_raises(BERTRPC::UserError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a ProxyError error when proxy level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:proxy, 1, "invalid"]])
+        assert_raises(BERTRPC::ProxyError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+    end
+  end
+end

data/test/mod_test.rb

@@ -6,19 +6,25 @@ class ModTest < Test::Unit::TestCase
       @svc = BERTRPC::Service.new('localhost', 9941)
     end
 
-    should "be created with a Service and module name" do
-      assert BERTRPC::Mod.new(@svc, :mymod).is_a?(BERTRPC::Mod)
+    should "be created with a Service and type and module name" do
+      assert BERTRPC::Mod.new(@svc, BERTRPC::Call, :mymod).is_a?(BERTRPC::Mod)
     end
   end
 
   context "A Mod instance" do
     setup do
-      svc = BERTRPC::Service.new('localhost', 9941)
-      @mod = BERTRPC::Mod.new(@svc, :mymod)
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @mod = BERTRPC::Mod.new(@svc, BERTRPC::Call, :mymod)
     end
 
-    should "return a Fun instance" do
-      assert @mod.myfun.is_a?(BERTRPC::Fun)
+    should "call execute on the type" do
+      m = mock(:execute => nil)
+      BERTRPC::Call.expects(:new).with(@svc, :mymod, :myfun, [1, 2, 3]).returns(m)
+      @mod.myfun(1, 2, 3)
+      
+      m = mock(:execute => nil)
+      BERTRPC::Call.expects(:new).with(@svc, :mymod, :myfun, [1]).returns(m)
+      @mod.myfun(1)
     end
   end
 end

data/test/service_test.rb

@@ -21,8 +21,8 @@ class ServiceTest < Test::Unit::TestCase
       assert_equal 9941, @svc.port
     end
 
-    should "return a Mod instance" do
-      assert @svc.mymod.is_a?(BERTRPC::Mod)
+    should "return a Call instance" do
+      assert @svc.call.is_a?(BERTRPC::CallProxy)
     end
   end
 end

data/test/test_helper.rb

@@ -7,5 +7,6 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'bertrpc'
 
-class Test::Unit::TestCase
-end
+class Enc
+  include BERTRPC::Encodes
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mojombo-bertrpc
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-27 00:00:00 -07:00
+date: 2009-08-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,16 +40,21 @@ files:
 - VERSION
 - bertrpc.gemspec
 - lib/bertrpc.rb
+- lib/bertrpc/call.rb
+- lib/bertrpc/call_proxy.rb
+- lib/bertrpc/encodes.rb
 - lib/bertrpc/errors.rb
-- lib/bertrpc/fun.rb
 - lib/bertrpc/mod.rb
 - lib/bertrpc/service.rb
-- test/fun_test.rb
+- test/call_proxy_test.rb
+- test/call_test.rb
+- test/encodes_test.rb
 - test/mod_test.rb
 - test/service_test.rb
 - test/test_helper.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/mojombo/bertrpc
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -70,12 +75,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: BERTRPC is a Ruby BERT-RPC client library.
 test_files: 
-- test/fun_test.rb
+- test/call_proxy_test.rb
+- test/call_test.rb
+- test/encodes_test.rb
 - test/mod_test.rb
 - test/service_test.rb
 - test/test_helper.rb

data/test/fun_test.rb

@@ -1,148 +0,0 @@
-require 'test_helper'
-
-class FunTest < Test::Unit::TestCase
-  context "A Fun" do
-    setup do
-      @svc = BERTRPC::Service.new('localhost', 9941)
-    end
-
-    should "be created with a Service, module name, and fun name" do
-      assert BERTRPC::Fun.new(@svc, :mymod, :myfun).is_a?(BERTRPC::Fun)
-    end
-  end
-
-  context "A Fun instance" do
-    setup do
-      svc = BERTRPC::Service.new('localhost', 9941)
-      @fun = BERTRPC::Fun.new(svc, :mymod, :myfun)
-    end
-
-    should "call with single-arity" do
-      req = @fun.encode_ruby_request([:call, :mymod, :myfun, [1]])
-      res = @fun.encode_ruby_request([:reply, 2])
-      @fun.expects(:sync_request).with(req).returns(res)
-      assert_equal 2, @fun.call(1)
-    end
-
-    should "call with single-arity array" do
-      req = @fun.encode_ruby_request([:call, :mymod, :myfun, [[1, 2, 3]]])
-      res = @fun.encode_ruby_request([:reply, [4, 5, 6]])
-      @fun.expects(:sync_request).with(req).returns(res)
-      assert_equal [4, 5, 6], @fun.call([1, 2, 3])
-    end
-
-    should "call with multi-arity" do
-      req = @fun.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
-      res = @fun.encode_ruby_request([:reply, [4, 5, 6]])
-      @fun.expects(:sync_request).with(req).returns(res)
-      assert_equal [4, 5, 6], @fun.call(1, 2, 3)
-    end
-
-    context "converter" do
-      should "convert top level hashes to BERT-RPC dict form" do
-        assert_equal([:dict, [:foo, 1], [:bar, 2]], @fun.convert({:foo => 1, :bar => 2}))
-      end
-
-      should "convert nested hashes in the same way" do
-        assert_equal([1, 2, [:dict, [:foo, 1]]], @fun.convert([1, 2, {:foo => 1}]))
-      end
-
-      should "keep everything else the same" do
-        assert_equal [1, 2, "foo", :bar, 3.14], @fun.convert([1, 2, "foo", :bar, 3.14])
-      end
-    end
-
-    context "deconverter" do
-      should "convert top level BERT-RPC dict forms to hashes" do
-        assert_equal({:foo => 1, :bar => 2}, @fun.deconvert([:dict, [:foo, 1], [:bar, 2]]))
-      end
-
-      should "convert nested dicts in the same way" do
-        assert_equal([1, 2, {:foo => 1}], @fun.deconvert([1, 2, [:dict, [:foo, 1]]]))
-      end
-
-      should "keep everything else the same" do
-        assert_equal [1, 2, "foo", :bar, 3.14], @fun.deconvert([1, 2, "foo", :bar, 3.14])
-      end
-    end
-
-    context "sync_request" do
-      should "read and write BERT-Ps from the socket" do
-        io = stub()
-        io.expects(:write).with("\000\000\000\003")
-        io.expects(:write).with("foo")
-        io.expects(:read).with(4).returns("\000\000\000\003")
-        io.expects(:read).with(3).returns("bar")
-        io.expects(:close)
-        TCPSocket.expects(:new).returns(io)
-        assert_equal "bar", @fun.sync_request("foo")
-      end
-
-      should "raise a ProxyError when the length is invalid" do
-        io = stub()
-        io.expects(:write).with("\000\000\000\003")
-        io.expects(:write).with("foo")
-        io.expects(:read).with(4).returns(nil)
-        TCPSocket.expects(:new).returns(io)
-        assert_raises(BERTRPC::ProtocolError) do
-          @fun.sync_request("foo")
-        end
-      end
-
-      should "raise a ProxyError when the data is invalid" do
-        io = stub()
-        io.expects(:write).with("\000\000\000\003")
-        io.expects(:write).with("foo")
-        io.expects(:read).with(4).returns("\000\000\000\003")
-        io.expects(:read).with(3).returns(nil)
-        TCPSocket.expects(:new).returns(io)
-        assert_raises(BERTRPC::ProtocolError) do
-          @fun.sync_request("foo")
-        end
-      end
-    end
-
-    context "ruby request encoder" do
-      should "return BERT-RPC encoded request" do
-        bert = "\203h\004d\000\004calld\000\005mymodd\000\005myfunh\003a\001a\002a\003"
-        assert_equal bert, @fun.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
-      end
-    end
-
-    context "bert response decoder" do
-      should "return response when successful" do
-        req = @fun.encode_ruby_request([:reply, [1, 2, 3]])
-        res = @fun.decode_bert_response(req)
-        assert_equal [1, 2, 3], res
-      end
-
-      should "raise a ProtocolError error when protocol level error is returned" do
-        req = @fun.encode_ruby_request([:error, [:protocol, 1, "invalid"]])
-        assert_raises(BERTRPC::ProtocolError) do
-          @fun.decode_bert_response(req)
-        end
-      end
-
-      should "raise a ServerError error when server level error is returned" do
-        req = @fun.encode_ruby_request([:error, [:server, 1, "invalid"]])
-        assert_raises(BERTRPC::ServerError) do
-          @fun.decode_bert_response(req)
-        end
-      end
-
-      should "raise a UserError error when user level error is returned" do
-        req = @fun.encode_ruby_request([:error, [:user, 1, "invalid"]])
-        assert_raises(BERTRPC::UserError) do
-          @fun.decode_bert_response(req)
-        end
-      end
-
-      should "raise a ProxyError error when proxy level error is returned" do
-        req = @fun.encode_ruby_request([:error, [:proxy, 1, "invalid"]])
-        assert_raises(BERTRPC::ProxyError) do
-          @fun.decode_bert_response(req)
-        end
-      end
-    end
-  end
-end