hessian 0.5.0

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2006, Christer Sandberg (chrsan@gmail.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * The names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.verbose = true
+  t.warning = true
+end
+
+PKG_VERSION = "0.5.0"
+PKG_FILES = FileList[
+  'LICENSE',
+  'Rakefile',
+  'lib/**/*.rb',
+  'test/**/test_*.rb'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = "hessian"
+  s.version = PKG_VERSION
+  s.author = "Christer Sandberg"
+  s.email = "chrsan@gmail.com"
+  s.homepage = "http://www.baanii.se/"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A Ruby Hessian client."
+  s.files = PKG_FILES.to_a
+  s.require_path = "lib"
+end
+
+package_task = Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar_gz = true
+end

data/lib/hessian.rb

@@ -0,0 +1,176 @@
+require 'uri'
+require 'net/http'
+
+module Hessian
+  class Binary
+    attr :data
+    def initialize(data)
+      @data = data.to_s
+    end
+  end
+
+  class HessianException < RuntimeError
+    attr_reader :code
+    def initialize(code)
+      @code = code
+    end
+  end
+
+  class HessianClient
+    attr_reader :host, :port, :path
+    def initialize(url)
+      uri = URI.parse(url)
+      @host, @port, @path = uri.host, uri.port, uri.path
+      raise "Unsupported Hessian protocol: #{uri.scheme}" unless uri.scheme == "http"
+    end
+
+    def method_missing(id, *args)
+      return invoke(id.id2name, args)
+    end
+
+    private
+    def invoke(method, args)
+      req = HessianWriter.new.write_call method, args
+      header = { 'Content-Type' => 'application/binary' }
+      Net::HTTP.start(@host, @port) do |http|
+        res = http.send_request('POST', @path, req, header)
+        HessianParser.new.parse_response res.body
+      end
+    end
+
+    class HessianWriter
+      def write_call(method, args)
+        @refs = {}
+        out = [ 'c', '0', '1', 'm', method.length ].pack('ahhan') << method
+        args.each { |arg| out << write_object(arg) }
+        out << 'z'
+      end
+
+      private
+      def write_object(val)
+        return 'N' if val.nil?
+        case val
+        when Binary: [ 'B', val.data.length ].pack('an') << val.data
+        when String: [ 'S', val.length ].pack('an') << val.unpack('C*').pack('U*')
+        when Integer
+          # Max and min values for integers in Java.
+          if val >= -0x80000000 && val <= 0x7fffffff
+            [ 'I', val ].pack('aN')
+          else
+            "L%s" % to_long(val)
+          end
+        when Float: [ 'D', val ].pack('aG')
+        when Time: "d%s" % to_long(val.to_i * 1000)
+        when TrueClass: 'T'
+        when FalseClass: 'F'
+        when Array
+          ref = write_ref val; return ref if ref
+          str = [ 'V', 't', '0', '0', 'l', val.length ].pack('aahhaN')
+          val.each { |v| str << write_object(v) }
+          str << 'z'
+        when Hash
+          ref = write_ref val; return ref if ref
+          str = [ 'M', 't', '0', '0' ].pack('aahh')
+          val.each { |k, v| str << write_object(k); str << write_object(v) }
+          str << 'z'
+        else
+          raise "Not implemented for #{val.class}"
+        end
+      end
+      
+      def to_long(val)
+        str, pos = " " * 8, 0
+        56.step(0, -8) { |o| str[pos] = val >> o & 0x00000000000000ff; pos += 1 }
+        str
+      end
+
+      def write_ref(val)
+        id = @refs[val.object_id]
+        if id
+          [ 'R', id ].pack('aN')
+        else
+          @refs[val.object_id] = @refs.length
+          nil
+        end
+      end
+    end
+
+    class HessianParser
+      def parse_response(res)
+        raise "Invalid response, expected 'r', received '#{res[0,1]}'" unless res[0,1] == 'r'
+        @chunks = []
+        @refs = []
+        @data = res[3..-1]
+        parse_object
+      end
+
+      private
+      def parse_object
+        t = @data.slice!(0, 1)
+        case t
+        when 'f': raise_exception
+        when 's', 'S', 'x', 'X'
+          v = from_utf8(@data.slice!(0, 2).unpack('n')[0])
+          @data.slice!(0, v[1])
+          @chunks << v[0]
+          if 'sx'.include? t
+            parse_object
+          else
+            str = @chunks.join; @chunks.clear; str
+          end
+        when 'b', 'B'
+          v = @data.slice!(0, @data.slice!(0, 2).unpack('n')[0])
+          @chunks << v
+          if t == 'b'
+            parse_object
+          else
+            bytes = @chunks.join; @chunks.clear; Binary.new bytes
+          end
+        when 'I': @data.slice!(0, 4).unpack('N')[0]
+        when 'L': parse_long
+        when 'd': l = parse_long; Time.at(l / 1000, l % 1000 * 1000)
+        when 'D': @data.slice!(0, 8).unpack('G')[0]
+        when 'T': true
+        when 'F': false
+        when 'N': nil
+        when 'R': @refs[@data.slice!(0, 4).unpack('N')[0]]
+        when 'V'
+          # Skip type + type length (2 bytes) if specified.
+          @data.slice!(0, 3 + @data.unpack('an')[1]) if @data[0,1] == 't'
+          # Skip the list length if specified.
+          @data.slice!(0, 5) if @data[0,1] == 'l'
+          @refs << (list = [])
+          list << parse_object while @data[0,1] != 'z'; list
+        when 'M'
+          # Skip type + type length (2 bytes) if specified.
+          @data.slice!(0, 3 + @data.unpack('an')[1]) if @data[0,1] == 't'
+          @refs << (map = {})
+          map[parse_object()] = parse_object while @data[0,1] != 'z'; map
+        else
+          raise "Invalid type: '#{t}'"
+        end
+      end
+      
+      def from_utf8(len = '*')
+        s = @data.unpack("U#{len}").pack('C*')
+        [ s, s.unpack('C*').pack('U*').length ]
+      end
+
+      def parse_long
+        val, o = 0, 56
+        @data.slice!(0, 8).each_byte { |b| val += (b & 0xff) << o; o -= 8 }
+        val
+      end
+
+      def raise_exception
+        # Skip code description.
+        parse_object
+        code = parse_object
+        # Skip message description
+        parse_object
+        msg = parse_object
+        raise HessianException.new(code), msg
+      end
+    end
+  end
+end

data/test/test_hessian_parser.rb

@@ -0,0 +1,54 @@
+require 'hessian'
+require 'test/unit'
+
+class HessianParserTest < Test::Unit::TestCase
+  def parse res
+    Hessian::HessianClient::HessianParser.new.parse_response res
+  end
+  
+  def test_integer
+    assert_equal 4711, parse("r\001\000I\000\000\022gz")
+  end
+  def test_long
+    assert_equal 2, parse("r\001\000L\000\000\000\000\000\000\000\002z")
+  end  
+  def test_double
+    assert_equal 3.4, parse("r\001\000D@\v333333z")
+  end
+  def test_false
+    assert_equal false, parse("r\001\000Fz")
+  end
+  def test_true
+    assert_equal true, parse("r\001\000Tz")
+  end
+  def test_string
+    assert_equal "string", parse("r\001\000S\000\006stringz")
+  end
+  def test_null
+    assert_equal nil, parse("r\001\000Nz")
+  end
+  def test_date
+    time = parse("r\001\000d\000\000\001\010\344\036\332\360z")
+    assert_instance_of Time, time
+    assert_equal '2006-01-19 20:23:13', time.strftime("%Y-%m-%d %H:%M:%S")
+  end
+  def test_integer_array
+    assert_equal [ 1, 2, 3 ], parse([ "r\001\000Vt\000\004[intl\000\000\000\003",
+      "I\000\000\000\001I\000\000\000\002I\000\000\000\003zz" ].join)
+  end
+  def test_array
+    assert_equal [ 'sillen', 32 ], parse([ "r\001\000Vt\000\a[objectl\000\000\000\002",
+      "S\000\006sillenI\000\000\000 zz" ].join)
+  end
+  def test_array_in_array
+    assert_equal [ 'A list', [ 9, 3 ] ], parse([ "r\001\000Vl\000\000\000\002S\000\006",
+      "A listVt\000\022[java.lang.Integerl\000\000\000\002I\000\000\000\t",
+      "I\000\000\000\003zzz" ].join)
+  end
+  def test_map
+    map = { 'numbers' => [ 1.1, 1.2, 1.3 ] }
+    assert_equal map, parse([ "r\001\000Mt\000\000S\000\anumbersVt\000\a[double",
+      "l\000\000\000\003D?\361\231\231\231\231\231\232D?\363333333D?",
+      "\364\314\314\314\314\314\315zS\000\006sillenI\000\000\000 zz" ].join)
+    end
+end

metadata

@@ -0,0 +1,42 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: hessian
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+date: 2006-01-19 00:00:00 +01:00
+summary: A Ruby Hessian client.
+require_paths: 
+  - lib
+email: chrsan@gmail.com
+homepage: http://www.baanii.se/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Christer Sandberg
+files: 
+  - LICENSE
+  - Rakefile
+  - lib/hessian.rb
+  - test/test_hessian_parser.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []