gwt_rpc 0.0.0

data/lib/gwt_rpc/gxt/paginated_resultset.rb

@@ -0,0 +1,16 @@
+class GwtRpc::Gxt::PaginatedResultset
+  attr_reader :offset, :total_count, :results
+  
+  def initialize(offset, total_count, results)
+    @offset = offset
+    @total_count = total_count
+    @results = results
+  end
+  
+  def self.gwt_deserialize(reader)
+    offset = reader.read_int
+    total_count = reader.read_int
+    results = reader.read_object
+    new(offset, total_count, results)
+  end
+end

data/lib/gwt_rpc/gxt/sort_dir.rb

@@ -0,0 +1,15 @@
+class GwtRpc::Gxt::SortDir
+  attr_reader :direction
+  
+  def initialize(direction)
+    @direction = direction
+  end
+  
+  def self.gwt_deserialize(reader)
+    new(reader.read_int)
+  end
+  
+  def eql?(o)
+    o.direction == direction
+  end
+end

data/lib/gwt_rpc/gxt/sort_info.rb

@@ -0,0 +1,15 @@
+class GwtRpc::Gxt::SortInfo
+  attr_reader :field, :direction
+  
+  def initialize(field, direction)
+    @direction = direction
+    @field = field
+  end
+  
+  def self.gwt_deserialize(reader)
+    direction = reader.read_object
+    reader.read_int
+    reader.read_int
+    new(nil,direction)
+  end
+end

data/lib/gwt_rpc/procedure.rb

@@ -0,0 +1,26 @@
+class GwtRpc::Procedure
+  attr_reader :path, :namespace, :method, :identifier
+  def initialize(options, &block)
+    options.symbolize_keys!
+    @path = options[:path] or raise ":path must be provided"
+    if block
+      @block = block
+    else
+      @namespace = options[:namespace] or raise ":namespace must be provided"
+      @method = options[:method] or raise ":method must be provided"
+      @identifier = options[:identifier] or raise ":identifier must be provided"
+    end
+  end
+  
+  def call(client, *parameters)
+    response = request(client, *parameters).call
+  end
+  
+  def request(client, *parameters)
+    if @block
+      GwtRpc::Request.new(client, :procedure => self, :body => @block.call(*parameters))
+    else
+      GwtRpc::Request.new(client, :procedure => self, :parameters => parameters)
+    end
+  end
+end

data/lib/gwt_rpc/request.rb

@@ -0,0 +1,72 @@
+class GwtRpc::Request
+  def initialize(client, options = {})
+    @client = client
+    @procedure = options[:procedure]
+    @parameters = options[:parameters]
+    @body = options[:body]
+  end
+  
+  def call
+    10.times do
+      begin
+        response = Typhoeus::Request.post(url,
+              :body          => body,
+              :headers       => {'Content-Type' => "text/x-gwt-rpc; charset=utf-8"},
+              :timeout       => 1000,
+              :cache_timeout => 60)
+        return GwtRpc::Response.new(@client, response).content
+      rescue GwtRpc::Error::NoResponse
+        # prevent random hiccups
+      end
+    end
+  end
+  
+  def url
+    'http://' + @client.domain + @procedure.path
+  end
+  
+  def header
+    [5,0]
+  end
+  
+  def body
+    if @body
+      body = @body
+    else
+      string_table, payload = stringtablize(data)
+      body = (header + [string_table.size] + string_table + payload).join("|")  + "|"
+    end
+  end
+  
+  def data
+    [
+      @client.js_url,
+      @procedure.identifier,
+      @procedure.namespace,
+      @procedure.method,
+      @parameters.size,
+      parameter_classes,
+      parameter_values.flatten
+    ].flatten
+  end
+  
+  def parameter_classes
+    @parameters.map{|p| @client.class.ruby_class_to_java(p.class)}
+  end
+  
+  def parameter_values
+    @parameters.map{|p| p.gwt_serialize }.flatten
+  end
+  
+  def stringtablize(data)
+    string_table = data.select{|v| v.class == String }.uniq
+    vals = data.map do |v|
+      if v.class == String
+        string_table.index(v) + 1
+      else
+        v
+      end
+    end
+    return string_table, vals
+  end
+end

data/lib/gwt_rpc/response.rb

@@ -0,0 +1,19 @@
+class GwtRpc::Error < Exception; end
+class GwtRpc::Error::ServerError < GwtRpc::Error; end
+class GwtRpc::Error::NoResponse < GwtRpc::Error; end
+
+class GwtRpc::Response
+  def initialize(client, raw_response)
+    @client       = client
+    @raw_response = raw_response
+    
+    raise GwtRpc::Error::NoResponse.new("Error: no response to request") if @raw_response.code == 0
+    raise GwtRpc::Error::ServerError.new("Error: status code #{@raw_response.code} not 200") if @raw_response.code != 200
+    raise GwtRpc::Error::ServerError.new("Error: #{@raw_response.body}") if @raw_response.body !~ /^\/\/OK/
+  end
+  
+  def content
+    json_body = @raw_response.body.sub(/^\/\/OK/,'')
+    GwtRpc::Response::Reader.new(@client, json_body).read_object
+  end
+end

data/lib/gwt_rpc/response/reader.rb

@@ -0,0 +1,75 @@
+class GwtRpc::Response::Reader
+  DEBUG = false
+  
+  attr_reader :version, :string_table, :data, :objects
+  def initialize(client, json_body)
+    @client = client
+    (@version, placeholder, @string_table, *@data) = JSON.parse(json_body).reverse
+    @max_prior_string_location = 0
+    @objects = []
+  end
+  
+  def read_int
+    int = @data.shift
+    puts "read int #{int}" if DEBUG
+    int
+  end
+  
+  def read_string(position=read_int)
+    if position > (@max_prior_string_location + 1)
+      raise "trying to read #{position}, which is too far ahead; max seen thus far is #{@max_prior_string_location}!"
+    end
+    
+    if position > @max_prior_string_location
+      @max_prior_string_location += 1
+    end
+    
+    val = @string_table[position-1]
+    puts "read str #{val} (@#{position})" if DEBUG
+    
+    val
+  end
+  
+  def read_object
+    int = read_int
+    
+    if int < 0
+      obj = @objects[-1 - int]
+      # if int == -11
+      #   puts obj.inspect
+      #   @objects.each_with_index do |doc, i|
+      #     puts "#{i} => #{doc.inspect}"
+      #   end
+      #   exit
+      # end
+    elsif int > 0
+      java_class = read_string(int)
+      java_class.sub!(/\/\d+$/,'')
+      puts "reading obj #{java_class}" if DEBUG
+      ruby_class = @client.class.java_class_to_ruby(java_class)
+      
+      if ruby_class
+        placeholder_position = @objects.count
+        @objects << "PLACEHOLDER of type #{java_class}"
+        
+        obj = ruby_class.constantize.gwt_deserialize(self)
+        @objects[placeholder_position] = obj
+      else
+        raise "unknown java class '#{java_class}'"
+      end
+    elsif int == 0
+      obj = nil
+    end
+    obj
+  end
+  
+  def debug
+    html = "<table>\n"
+    html << @data.map{|i| [i, @string_table[i-1]].map{|val| "<td>#{val}</td>"}}.map{|row| "<tr>#{row}</tr>"}.join("\n")
+    html << "</table><table>\n"
+    @string_table.each_with_index{|str,i| html << "<tr><td>#{i+1}</td><td>#{str}</td></tr>\n"}
+    html << "</table>"
+    
+    html
+  end
+end

data/spec/gwt_rpc/base_extensions/array_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::BaseExtensions::Array do
+  describe ".gwt_deserialize" do
+    before :each do
+      @client = GwtRpc::Client.new
+      @reader = GwtRpc::Response::Reader.new(@client, '[3,1,2,1,2,["java.lang.String/2004016611","Hello","World"],0,5]')
+    end
+    
+    it "should determine it size and call read_object that many times" do
+      Array.gwt_deserialize(@reader).should == ['Hello', 'World']
+    end
+  end
+end

data/spec/gwt_rpc/base_extensions/boolean_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::BaseExtensions::Boolean do
+  describe ".gwt_deserialize" do
+    it "0 should be false" do
+      client = GwtRpc::Client.new
+      reader = GwtRpc::Response::Reader.new(client, '[0,[],0,5]')
+      GwtRpc::BaseExtensions::Boolean.gwt_deserialize(reader).should == false
+    end
+    it "1 should be true" do
+      client = GwtRpc::Client.new
+      reader = GwtRpc::Response::Reader.new(client, '[0,[],0,5]')
+      GwtRpc::BaseExtensions::Boolean.gwt_deserialize(reader).should == false
+    end
+  end
+end

data/spec/gwt_rpc/base_extensions/hash_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::BaseExtensions::Hash do
+  describe ".gwt_deserialize" do
+    before :each do
+      @client = GwtRpc::Client.new
+      @reader = GwtRpc::Response::Reader.new(@client, '[5,1,4,1,3,1,2,1,2,["java.lang.String/2004016611","Hello","Hola","Goodbye","Adios"],0,5]')
+    end
+    
+    it "should determine it size and call read_object that many times" do
+      Hash.gwt_deserialize(@reader).should == {'Hello' => 'Hola', 'Goodbye' => 'Adios'}
+    end
+  end
+end

data/spec/gwt_rpc/base_extensions/multipart_string_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::BaseExtensions::MultipartString do
+  describe ".gwt_deserialize" do
+    it "should combine multiple strings" do
+      client = GwtRpc::Client.new
+      reader = GwtRpc::Response::Reader.new(client, '[3,2,1,3,["a","b","c"],0,5]')
+      GwtRpc::BaseExtensions::MultipartString.gwt_deserialize(reader).should == ["a","b","c"]
+    end
+  end
+end

data/spec/gwt_rpc/base_extensions/string_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::BaseExtensions::String do
+  describe ".gwt_serialize" do
+    it "should return itself" do
+      "foo".gwt_serialize.should == ["foo"]
+    end
+  end
+  
+  describe ".gwt_deserialize" do
+    it "should simply read a string from the string table" do
+      client = GwtRpc::Client.new
+      reader = GwtRpc::Response::Reader.new(client, '[1,["foo"],0,5]')
+      
+      String.gwt_deserialize(reader).should == "foo"
+    end
+  end
+end

data/spec/gwt_rpc/client_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe GwtRpc::Client do
+  before :each do
+    @subclass = Class.new(GwtRpc::Client)
+  end
+  describe ".domain" do
+    it "should set the domain when passed a value" do
+      @subclass.domain "example.com"
+      @subclass.domain.should == "example.com"
+    end
+  end
+  
+  describe ".js_url" do
+    it "should set the js_url when passed a value" do
+      @subclass.js_url "http://www.example.com/foo/bar/"
+      @subclass.js_url.should == "http://www.example.com/foo/bar/"
+    end
+  end
+  
+  describe "default class mapping" do
+    it "should define string" do
+      @subclass.java_class_to_ruby("java.lang.String").should == "String"
+      @subclass.java_class_to_ruby("java.util.ArrayList").should == "Array"
+      @subclass.java_class_to_ruby("java.util.HashMap").should == "Hash"
+      @subclass.java_class_to_ruby("java.lang.Boolean").should == "GwtRpc::BaseExtensions::Boolean"
+      @subclass.java_class_to_ruby("[Ljava.lang.String;").should == "GwtRpc::BaseExtensions::MultipartString"
+      @subclass.java_class_to_ruby("com.extjs.gxt.ui.client.data.RpcMap").should == "GwtRpc::Gxt::Hash"
+      @subclass.java_class_to_ruby("com.extjs.gxt.ui.client.Style$SortDir").should == "GwtRpc::Gxt::SortDir"
+      @subclass.java_class_to_ruby("com.extjs.gxt.ui.client.data.SortInfo").should == "GwtRpc::Gxt::SortInfo"
+      @subclass.java_class_to_ruby("com.extjs.gxt.ui.client.data.BasePagingLoadResult").should == "GwtRpc::Gxt::PaginatedResultset"
+    end
+  end
+  
+  describe ".map_classes" do
+    it "should store the class mapping" do
+      @subclass.map_classes "java.lang.Foo" => "Foo", "java.lang.Bar" => "Bar"
+      @subclass.java_class_to_ruby("java.lang.Foo").should == "Foo"
+      @subclass.java_class_to_ruby("java.lang.Bar").should == "Bar"
+    end
+  end
+  
+  describe ".ruby_class_to_java" do
+    it "should return the reverse mapping" do
+      @subclass.map_classes "java.lang.Foo" => "Foo", "java.lang.Bar" => "Bar"
+      @subclass.ruby_class_to_java("Foo").should == "java.lang.Foo"
+    end
+  end
+  
+  describe ".add_procedure" do
+    it "should add a procedure object to the set" do
+      @subclass.procedures.should == {}
+      @subclass.add_procedure :hello_world, :path => '/hello/world', :method => "foo", :namespace => "bar", :identifier => "abc"
+      @subclass.procedures[:hello_world].should be_a(GwtRpc::Procedure)
+    end
+    
+    it "should define a method of the same name that calls that procedure" do
+      instance = @subclass.new
+      instance.should_not respond_to(:test)
+      @subclass.add_procedure :test, :path => '/test', :method => "foo", :namespace => "bar", :identifier => "abc"
+      
+      instance.should respond_to(:test)
+      
+      @subclass.procedures[:test].should_receive(:call).with do |client, *params|
+        client.should == instance
+        params.should == [1,2]
+      end
+      
+      instance.test(1,2)
+    end
+  end
+  
+  describe "instance" do
+    describe ".domain" do
+      it "should read from the class's .domain" do
+        @subclass.domain "example.com"
+        @subclass.new.domain.should == 'example.com'
+      end
+    end
+  end
+end

data/spec/gwt_rpc/gxt/hash_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::Gxt::Hash do
+  describe ".new" do
+    it "should be a subclass of Hash" do
+      GwtRpc::Gxt::Hash.new should be_a(Hash)
+    end
+  end
+  describe ".gwt_deserialize" do
+    before :each do
+      @client = GwtRpc::Client.new
+      @reader = GwtRpc::Response::Reader.new(@client, '[5,2,4,3,2,1,2,["Hello","java.lang.String/2004016611","Hola","Goodbye","Adios"],0,5]')
+    end
+    
+    it "should determine it size and call read_object that many times" do
+      GwtRpc::Gxt::Hash.gwt_deserialize(@reader).should == GwtRpc::Gxt::Hash['Hello' => 'Hola', 'Goodbye' => 'Adios']
+    end
+  end
+end

data/spec/gwt_rpc/gxt/paginated_resultset_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GwtRpc::Gxt::PaginatedResultset do
+  describe ".gwt_deserialize" do
+    it "should parse correctly" do
+      @client = GwtRpc::Client.new
+      @reader = GwtRpc::Response::Reader.new(@client, '[3,2,1,1,1,0,["java.util.ArrayList","java.lang.String","Hi"],0,5]')
+      results = GwtRpc::Gxt::PaginatedResultset.gwt_deserialize(@reader)
+      results.offset.should == 0
+      results.total_count.should == 1
+      results.results.should == ['Hi']
+    end
+  end
+end