hessian2 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3e89025e74e937f051cc7c5532bd58d003dd3cc
-  data.tar.gz: 127b7703579d72674763c1f64c6aea4ef72ef051
+  metadata.gz: 3b9a89d291633b69257f589b65f232b5dcc38466
+  data.tar.gz: 69d82afa46069344e29a162c978ec3c095b9a0de
 SHA512:
-  metadata.gz: 229b79558ab04006522bc54ed2fb139ae305621ba0b174da4d4007fff713c74435c4864d3d33075490e28381ef209ab44fc71f70d515df1702f32bf27ce0525b
-  data.tar.gz: b1ce0ce88dfe6696ea2a3741ebdb43bf1db8500f4f5d9f79fe602e85ee2446ad42db2c1795bd05385cfe3953069fa3b9ac985f8d694e971ebcdf4ad6a25bdc4c
+  metadata.gz: 336224add2f6534f56e6c1357567f6e165550c9a24f9e466b4530966c6d9a821844d1c7c8190aa69de8bffb979704e0fa791a95d61c7e9ad70cd9478f26a092e
+  data.tar.gz: 26a9830f996c2a9bd0a4b3e2ea342bbd9ff532c2dc2b6fee33abf9fbdca6d0c0b1151b7e114e14ef9ad545e0db3b83b75de8aef563a61e8cb029bc7e2240ce34

data/.gitignore

@@ -1,10 +1,10 @@
-*.gem
-.bundle
-Gemfile.lock
-doc/*
-pkg/*
-spec/*.yml
-spec/*.jpg
-test/*.data
-test/*.txt
-test/*.yml
+*.gem
+.bundle
+Gemfile.lock
+doc/*
+pkg/*
+spec/*.yml
+spec/*.jpg
+test/*.data
+test/*.txt
+test/*.yml

data/README.md

@@ -1,197 +1,197 @@
-# hessian2
-
-like json, additionally, 麻绳2 parse your object as a struct.
-
-hessian2 implements hessian 2.0 protocol. look [web services protocol](http://hessian.caucho.com/doc/hessian-ws.html) and [serialization protocol](http://hessian.caucho.com/doc/hessian-serialization.html).
-
-## comparing
-
-yajl-ruby: json, fast.
-
-msgpack: binary, faster.
-
-protobuf: encoding your object with schema.
-
-marshal: powerful, fast, but ruby only.
-
-hessian2: powerful as marshal but parse object to struct, clean api, smaller.
-
-## install
-
-```
-gem install hessian2
-```
-
-## serializing
-
-```
-require 'hessian2'
-```
-
-``` ruby
-attributes = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-monkey = Monkey.new(attributes)
-#=> #<Monkey id: nil, born_at: "2009-05-08 00:00:00", name: "\u5927\u9E21", price: #<BigDecimal:2b7c568,'0.9998999999 999999E2',27(45)>>
-
-bin = Hessian2.write(monkey)
-```
-
-## deserializing 
-
-``` ruby
-monkey = Hessian2.parse(bin)
-#=> #<struct id=nil, born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21", price=99.99>
-```
-
-## struct wrapper 
-
-for hash and object, only send values that specified.
-
-``` ruby
-MonkeyStruct = Struct.new(:born_at, :name)
-
-wrapped_monkey = Hessian2::StructWrapper.new(MonkeyStruct, monkey)
-bin = Hessian2.write(wrapped_monkey)
-```
-
-parsing values-binary to a monkey struct
-
-``` ruby
-monkey = Hessian2.parse(bin, MonkeyStruct)
-#=> #<struct born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21">
-```
-
-monkeys
-
-``` ruby
-wrapped_monkeys = Hessian2::StructWrapper.new([MonkeyStruct], monkeys)
-bin = Hessian2.write(wrapped_monkeys)
-
-monkeys = Hessian2.parse(bin, [MonkeyStruct])
-```
-
-struct wrapper supports: hash, object, [hash, [object
-
-## class wrapper
-
-for statically typed languages.
-
-``` ruby
-wrapped_monkey = Hessian2::ClassWrapper.new('com.sun.java.Monkey', monkey)
-```
-
-monkeys
-
-``` ruby
-wrapped_monkeys = Hessian2::ClassWrapper.new('[com.sun.java.Monkey', monkeys)
-```
-
-class wrapper supports: hash, object, [hash, [object
-
-## type wrapper
-
-wrap a string to long
-
-``` ruby
-str = '-0x8_000_000_000_000_000'
-heslong = Hessian2::TypeWrapper.new(:long, str)
-```
-
-wrap a file to binary
-
-``` ruby
-binstr = IO.binread(File.expand_path("../Lighthouse.jpg", __FILE__))
-hesbin = Hessian2::TypeWrapper.new(:bin, binstr)
-```
-
-there are types: 'L', 'I', 'B', '[L', '[I', '[B', :long, :int, :bin, [:long], [:int], [:bin]
-
-## :symbolize_keys parser option
-
-``` ruby
-bin = Hessian2.write(attributes)
-hash = Hessian2.parse(bin, nil, symbolize_keys: true)
-#=> {:born_at=>2009-05-08 00:00:00 +0800, :name=>"\u5927\u9E21", :price=>99.99}
-```
-
-## client
-
-``` ruby
-url = 'http://127.0.0.1:9292/monkey'
-client = Hessian2::Client.new(url)
-```
-
-call remote method, send a monkey
-
-``` ruby
-client.send_monkey(monkey)
-```
-
-## service
-
-extend hessian handler
-
-``` ruby
-class MonkeyService
-  extend Hessian2::Handler
-
-  def self.send_monkey(monkey)
-  # ...
-end
-```
-
-handle request
-
-``` ruby
-post '/monkey' do
-  MonkeyService.handle(request.body.read)
-end
-```
-
-## fiber_aware
-
-fibered service, fiber aware client. use em-synchrony/em-http post.
-
-``` ruby
-client = Hessian2::Client.new(url, fiber_aware: true)
-concurrency = 2
-
-EM.synchrony do
-  EM::Synchrony::FiberIterator.new(0...10, concurrency).each do |i|
-    puts client.asleep
-  end
-
-  EM.stop
-end
-```
-
-## async
-
-evented service, asynchronous callbacks. use em-synchrony/em-http apost.
-
-``` ruby
-client = Hessian2::Client.new(url, async: true)
-
-EM.run do
-  http = client.asleep
-  http.callback do |r|
-    puts Hessian2.parse_rpc(r.response)
-    EM.stop
-  end
-
-  http.errback do |r|
-    puts r.error
-    EM.stop
-  end
-
-  puts "posted."
-end
-```
-
-## todo
-
-supports packet and envelope
-
-## authors
-
-[takafan](http://hululuu.com)
+# hessian2
+
+like json, additionally, 麻绳2 parse your object as a struct.
+
+hessian2 implements hessian 2.0 protocol. look [web services protocol](http://hessian.caucho.com/doc/hessian-ws.html) and [serialization protocol](http://hessian.caucho.com/doc/hessian-serialization.html).
+
+## comparing
+
+yajl-ruby: json, fast.
+
+msgpack: binary, faster.
+
+protobuf: encoding your object with schema.
+
+marshal: powerful, fast, but ruby only.
+
+hessian2: powerful as marshal but parse object to struct, clean api, smaller.
+
+## install
+
+```
+gem install hessian2
+```
+
+## serializing
+
+```
+require 'hessian2'
+```
+
+``` ruby
+attributes = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+monkey = Monkey.new(attributes)
+#=> #<Monkey id: nil, born_at: "2009-05-08 00:00:00", name: "\u5927\u9E21", price: #<BigDecimal:2b7c568,'0.9998999999 999999E2',27(45)>>
+
+bin = Hessian2.write(monkey)
+```
+
+## deserializing 
+
+``` ruby
+monkey = Hessian2.parse(bin)
+#=> #<struct id=nil, born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21", price=99.99>
+```
+
+## struct wrapper 
+
+for hash and object, only send values that specified.
+
+``` ruby
+MonkeyStruct = Struct.new(:born_at, :name)
+
+wrapped_monkey = Hessian2::StructWrapper.new(MonkeyStruct, monkey)
+bin = Hessian2.write(wrapped_monkey)
+```
+
+parsing values-binary to a monkey struct
+
+``` ruby
+monkey = Hessian2.parse(bin, MonkeyStruct)
+#=> #<struct born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21">
+```
+
+monkeys
+
+``` ruby
+wrapped_monkeys = Hessian2::StructWrapper.new([MonkeyStruct], monkeys)
+bin = Hessian2.write(wrapped_monkeys)
+
+monkeys = Hessian2.parse(bin, [MonkeyStruct])
+```
+
+struct wrapper supports: hash, object, [hash, [object
+
+## class wrapper
+
+for statically typed languages.
+
+``` ruby
+wrapped_monkey = Hessian2::ClassWrapper.new('com.sun.java.Monkey', monkey)
+```
+
+monkeys
+
+``` ruby
+wrapped_monkeys = Hessian2::ClassWrapper.new('[com.sun.java.Monkey', monkeys)
+```
+
+class wrapper supports: hash, object, [hash, [object
+
+## type wrapper
+
+wrap a string to long
+
+``` ruby
+str = '-0x8_000_000_000_000_000'
+heslong = Hessian2::TypeWrapper.new(:long, str)
+```
+
+wrap a file to binary
+
+``` ruby
+binstr = IO.binread(File.expand_path("../Lighthouse.jpg", __FILE__))
+hesbin = Hessian2::TypeWrapper.new(:bin, binstr)
+```
+
+there are types: 'L', 'I', 'B', '[L', '[I', '[B', :long, :int, :bin, [:long], [:int], [:bin]
+
+## :symbolize_keys parser option
+
+``` ruby
+bin = Hessian2.write(attributes)
+hash = Hessian2.parse(bin, nil, symbolize_keys: true)
+#=> {:born_at=>2009-05-08 00:00:00 +0800, :name=>"\u5927\u9E21", :price=>99.99}
+```
+
+## client
+
+``` ruby
+url = 'http://127.0.0.1:9292/monkey'
+client = Hessian2::Client.new(url)
+```
+
+call remote method, send a monkey
+
+``` ruby
+client.send_monkey(monkey)
+```
+
+## service
+
+extend hessian handler
+
+``` ruby
+class MonkeyService
+  extend Hessian2::Handler
+
+  def self.send_monkey(monkey)
+  # ...
+end
+```
+
+handle request
+
+``` ruby
+post '/monkey' do
+  MonkeyService.handle(request.body.read)
+end
+```
+
+## fiber_aware
+
+fibered service, fiber aware client. use em-synchrony/em-http post.
+
+``` ruby
+client = Hessian2::Client.new(url, fiber_aware: true)
+concurrency = 2
+
+EM.synchrony do
+  EM::Synchrony::FiberIterator.new(0...10, concurrency).each do |i|
+    puts client.asleep
+  end
+
+  EM.stop
+end
+```
+
+## async
+
+evented service, asynchronous callbacks. use em-synchrony/em-http apost.
+
+``` ruby
+client = Hessian2::Client.new(url, async: true)
+
+EM.run do
+  http = client.asleep
+  http.callback do |r|
+    puts Hessian2.parse_rpc(r.response)
+    EM.stop
+  end
+
+  http.errback do |r|
+    puts r.error
+    EM.stop
+  end
+
+  puts "posted."
+end
+```
+
+## todo
+
+supports packet and envelope
+
+## authors
+
+[takafan](http://hululuu.com)

data/hessian2.gemspec

@@ -22,6 +22,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec'
   s.add_runtime_dependency 'activerecord'
   s.add_runtime_dependency 'bigdecimal'
-  s.add_runtime_dependency 'em-http-request'
-  s.add_runtime_dependency 'em-synchrony'
 end

data/lib/hessian2/client.rb

@@ -1,50 +1,57 @@
-require 'uri'
-require 'net/http'
-require 'em-synchrony/em-http'
-require 'hessian2'
-
-module Hessian2
-  class Client
-    attr_accessor :user, :password
-    attr_reader :scheme, :host, :port, :path, :proxy
-
-    def initialize(url, options = {})
-      uri = URI.parse(url)
-      @scheme, @host, @port, @path = uri.scheme, uri.host, uri.port, uri.path.empty? ? '/' : uri.path
-      @path += "?#{uri.query}" if uri.query
-      raise "Unsupported Hessian protocol: #{@scheme}" unless %w(http https).include?(@scheme)
-      @async = options.delete(:async)
-      @fiber_aware = options.delete(:fiber_aware)
-      @proxy = options
-    end
-
-
-    def method_missing(id, *args)
-      return invoke(id.id2name, args)
-    end
-
-    private
-    
-    def invoke(method, args)
-      req_head = { 'Content-Type' => 'application/binary' }
-      req_body = Hessian2.call(method, args)
-
-      if @async
-        EM::HttpRequest.new("#{@scheme}://#{@host}:#{@port}#{@path}").apost(body: req_body, head: req_head)
-      elsif @fiber_aware
-        http = EM::HttpRequest.new("#{@scheme}://#{@host}:#{@port}#{@path}").post(body: req_body, head: req_head)
-        Hessian2.parse_rpc(http.response)
-      else
-        req = Net::HTTP::Post.new(@path, req_head)
-        req.basic_auth @user, @password if @user
-        conn = Net::HTTP.new(@host, @port, *@proxy.values_at(:host, :port, :user, :password))
-        conn.use_ssl = true and conn.verify_mode = OpenSSL::SSL::VERIFY_NONE if @scheme == 'https'
-        conn.start do |http|
-          res = http.request(req, req_body)
-          Hessian2.parse_rpc(res.body)
-        end
-      end
-    end
-
-  end
-end
+require 'uri'
+require 'hessian2'
+
+module Hessian2
+  class Client
+    attr_accessor :user, :password
+    attr_reader :scheme, :host, :port, :path, :proxy
+
+    def initialize(url, options = {})
+      uri = URI.parse(url)
+      @scheme, @host, @port, @path = uri.scheme, uri.host, uri.port, uri.path.empty? ? '/' : uri.path
+      @path += "?#{uri.query}" if uri.query
+      raise "Unsupported Hessian protocol: #{@scheme}" unless %w(http https).include?(@scheme)
+      @async = options.delete(:async)
+      @fiber_aware = options.delete(:fiber_aware)
+      if @async || @fiber_aware
+        begin
+          require 'em-synchrony/em-http'
+        rescue LoadError => error
+          raise "Missing EM-Synchrony dependency: gem install em-synchrony em-http-request"
+        end
+      else
+        require 'net/http'
+      end
+      @proxy = options
+    end
+
+
+    def method_missing(id, *args)
+      return invoke(id.id2name, args)
+    end
+
+    private
+    
+    def invoke(method, args)
+      req_head = { 'Content-Type' => 'application/binary' }
+      req_body = Hessian2.call(method, args)
+
+      if @async
+        EM::HttpRequest.new("#{@scheme}://#{@host}:#{@port}#{@path}").apost(body: req_body, head: req_head)
+      elsif @fiber_aware
+        http = EM::HttpRequest.new("#{@scheme}://#{@host}:#{@port}#{@path}").post(body: req_body, head: req_head)
+        Hessian2.parse_rpc(http.response)
+      else
+        req = Net::HTTP::Post.new(@path, req_head)
+        req.basic_auth @user, @password if @user
+        conn = Net::HTTP.new(@host, @port, *@proxy.values_at(:host, :port, :user, :password))
+        conn.use_ssl = true and conn.verify_mode = OpenSSL::SSL::VERIFY_NONE if @scheme == 'https'
+        conn.start do |http|
+          res = http.request(req, req_body)
+          Hessian2.parse_rpc(res.body)
+        end
+      end
+    end
+
+  end
+end