redom 0.0.1 → 0.1.0

data/README.md

@@ -1,126 +1,216 @@
-DJS Tutorial
-
-  DJS is a distributed object library for Server-WebBrowser communication. This tutorial shows how to create a web application using DJS.
+Redom
+=====
+Redom is a distributed object based server-centric user-friendly web application framework. Redom enables developers to write all application logics in Ruby at server side easily using both browser-side and server-side libraries. Redom provides distributed objects published by browser in natural Ruby syntax so that developers can access browser-side objects directly.
 
-===============
+Redom requires Ruby 1.9 or higher.
+ 
 Getting started
-===============
+---------------
+### Installation ###
+#### `$ gem install redom`
 
-- Creating a DJS connection class
+### Usage ###
+1. __Create a Redom connection class__  
+    A Redom connection class is where you write the scripts to manipulate the browser-side objects from server. The Redom connection class must include module **Redom::Connection**. An instance of Redom connection class will be created when the connection between browser and Redom server is established. There are three methods in **Redom::Connection** that can be overridden to tell Redom what to do.  
+  * __on_open__       - Called when the connection is established.  
+  * __on_close__       - Called when the connection is closed.  
+  * __on_error(err)__ - Called when an error occurs.  
+   
 
-  A DJS connection class is where you write the scripts to manipulate the browser-side objects from server. The DJS connection class must be subclass of 'DJS::DJSConnection'. An instance of DJS connection class will be created when the connection between browser and DJS server is established. There are four methods in 'DJS::DJSConnection' that can be overridden to tell DJS what to do.
+2. __Access to browser-side objects__  
+    Every browser-side object is published as a ditributed object. Therefore, method invocation and property reference of these objects can be done as if they are Ruby objects.  
+    Example: document.getElementById('text').value
 
-  on_open()       - Called when the connection is established.
-  on_error(err)   - Called when an browser-side error occurs.
-  on_message(msg) - Called when an message is received from browser.(not implemented)
-  on_close()      - Called when the connection is shutdown.(not implemented)
+3. __Start Redom server__  
+    Assuming you have created a Redom connection class and saved it into a file `app.rb`, you can start Redom server using command `redom app.rb`.  
+    Redom uses WebSocket as the server/browser communication protocol. [EM-WebSocket] is used as the default WebSocket server in Redom.
 
-  Here is an example:
-#
-  class MyConnection < DJS::Connection
-    def on_open
-      window.alert "Hello world!"
-    end
-    def on_error(error)
-      p error
-    end
-  end
-#
+4. __Connect to Redom server from a web page__  
+    Once you have added Redom JavaScript runtime into the web page, you can use `Redom("ws://localhost:8080").open("RedomConnectionClassName")` to connect to a Redom server. The operations written in the specified Redom connection class will be processed.
 
-- Starting DJS server
+[EM-WebSocket]:https://github.com/igrigorik/em-websocket
 
-  After a DJS connection class is defined, you can start DJS server using 'DJS::start(klass)' method. Your DJS connection class must be passed as the argument.
-#
-  DJS.start(MyConnection, {:host => 127.0.0.1, :port => 8080})
-#
+### Example: Hello World! ###
+hello.rb
 
-- Adding DJS library to HTML
+    require 'redom'
+    
+    class HelloConnection
+      inlcude Redom::Connection
+      
+      def on_open
+        alert "Hello World!"
+      end
+      
+      def on_close
+        puts "Browser is closed."
+      end
+    end
 
-  Add DJS JavaScript library 'djs.js' in your HTML. And call 'djs.start(host)' to connect to a DJS server.
-#
-  <script type="text/javascript" src="djs.js"></script>
-  <script type="text/javascript">
-    window.onload = function() {
-      djs.start("ws://127.0.0.1:8080");
-    }
-  </script>
-#
+hello.html
 
-- Stopping DJS server
+    <html>
+      <head>
+        <title>Hello World!</title>
+        <script type="text/javascript" src="redom.js"></script>
+        <script type="text/javascript">
+          window.onload = function() {
+            Redom("ws://localhost:8080").open("HelloConnection");
+          }
+        </script>
+      </head>
+    </html>
 
-  Use 'DJS.stop' to stop a DJS server.
-#
-  DJS.stop
-#
+See more examples in `example`
 
-========
 API Docs
-========
+--------
+
+#### (Module) Redom
+
+- __Redom.start(opts = {})__
+  
+  Start Redom server.
+
+  Parameter:
+    opts (Hash) - Options. Default values are as below:
+      :log       => STDOUT  - Log file
+      :log_level => 'error' - Log level. [fatal|error|warn|info|debug]
+      :worker    => 5       - Number of worker threads.
+      :buff_size => 200     - Size of bluk messages before synchronization with browser.
+
+- __Redom.stop__
+
+  Stop Redom server.
+
+#### (Module) Redom::Connection
+
+- __connections__
+
+  Return all Redom connection instances in an array that the Redom server is holding currently.
+
+  Return:  
+    (Array) - An array of Redom::Connection instances
+
+  Example:  
+
+        connections.each { |conn|
+          conn.do_something
+        }
 
-* Module: DJS
+- __sync{}__
 
-  - DJS.start(klass, opts = {})
+  Synchronize with browser immediately. Notice that a null block is required.
+
+  Return:  
+    nil
+
+  Example:  
+
+        a = document.getElementById("a").value
+        b = document.getElementById("b").value
+        sync{}
+        puts a + b
+
+- __sync__
+
+  Return a synchronous method caller of this connection. Any method of this connection can be called through this  method caller. Current process will be blocked until the method invocation is done.
+
+  Return:  
+    (Redom::Connection::Sender) - A synchronous method caller
     
-    Start DJS server.
+  Example:  
 
-    Parameters:
-      klass (Class) - A class that extends DJS::Connection
-      opts (Hash) - Options. Default values are as below:
-        :buff_size => 200 - Messages stored before synchronization with browser.
+        def foo
+          sleep 5
+          "bar"
+        end
+        p sync.foo # will print "bar" after 5 seconds
 
-  - DJS.stop
+- __async { ... }__
 
-    Stop DJS server.
+  Evaluate the code inside the block asynchronously which means current process will not be blocked.
 
-  - DJS.connections
+  Return:  
+    nil
+    
+  Example:  
 
-    Return all DJS connection instances that the DJS server is holding currently.
+        def foo
+          sleep 5
+          "bar"
+        end
+        p async {
+          p foo
+        } # print "nil" immediately and will print "bar" after 5 seconds
 
-    Returns:
-      (DJS::Connections) - An DJS::Connections instance that contains all DJS::Connection instances the DJS server is holding currently.
+- __async__
 
-    Examples:
-      DJS.connections.do_something
-  
+  Return a asynchronous method caller of this connection. Any method of this connection can be called through this  method caller and current process will not be blocked. The return value of the method invocation can not be retrieved.
 
-* Class: DJS::Connection
+  Return:  
+    (Redom::Connection::Sender) - A asynchronous method caller
 
-  - sync
+  Example:  
 
-    Synchronize with browser immediately.
+        def foo
+          sleep 5
+          "bar"
+        end
+        p async.foo # print "nil" immediately and will print "bar" after 5 seconds
 
-  - window
+- __window, document__
 
-    A reference for browser-side object 'window'.
+  A reference for browser-side object 'window' and 'document'.
 
-   Returns:
-     (DJS::ProxyObject) - A DJS::ProxyObject that references to browser-side object 'window'.
+ Returns:  
+   (Redom::Proxy) - A Redom::Proxy that references to browser-side object 'window' and 'document'.
 
-   Examples:
-     window.alert "Hello world."
+ Examples:  
+   `window.alert "Hello world."`
+   `alert "Hello World." (window can be omitted)`
 
-* Class: DJS:ProxyObject
+- __parse(src)__
 
-  - sync, to_s, to_f, to_i, to_a, to_h, to_b
+  Parse Ruby code into JavaScript code.
 
-    Synchronize with browser immediately and return the true value of the referenced object.
+  Parameter:  
+    src (String) - Ruby code
 
-    Returns:
-      (Object) - Primitive type if the referenced object is primitive, otherwise the DJS::ProxyObject itself.
+  Return:  
+    (String) - JavaScript code.
 
-    Examples:
-      value = document.getElementById("text").value.sync
+  Example:  
+    `window.eval parse("alert 'Hello World.'")`
+
+#### (Class) Redom:Proxy
+
+- __sync__
+
+  Synchronize with browser immediately and return the true value of the referenced object.
+
+  Returns:  
+    (Object) - Primitive type if the referenced object is primitive, otherwise the Redom::Proxy itself.
+
+  Examples:  
+    `value = document.getElementById("text").value.sync`
 
-=====
 Hints
-=====
+-----
+
+#### * Define a event handler as 'object.event_name = :event_handler_name'  
+  Examples:  
 
-- Define a event handler as 'object.event_name = :event_handler_name'
-  Examples:
     def button_click_handler(event)
       button = event.srcElement
     end
     document.getElementById("button").onclick = :button_click_handler
 
+License
+----------
+The [MIT] License - Copyright &copy; 2012 Yi Hu
+[MIT]: http://www.opensource.org/licenses/mit-license.php
 
-
+Contact
+-------
+Email: future.azure@gmail.com

data/bin/redom

@@ -42,7 +42,7 @@ parser = OptionParser.new { |opts|
   opts.separator "Common options:"
 
   opts.on(      "--worker NUM",            "number of worker thread (default: 5)") { |num| options[:worker] = num.to_i }
-  opts.on(      "--buff-size NUM",         "size of packed RPC message before sync") { |num| options[:buff_size] = num.to_i }
+  opts.on(      "--buff-size NUM",         "size of packed RPC message before sync (default: 200)") { |num| options[:buff_size] = num.to_i }
   opts.on(      "--log FILE",              "path to log (default: STDOUT)") { |path| options[:log] = path }
   opts.on(      "--log-level fatal|error|warn|info|debug", "log level (default: error)") { |lv| options[:log_level] = lv }
   opts.on_tail( "--help",                  "show this message") { puts opts; exit }

data/lib/redom.rb

@@ -5,7 +5,7 @@ require 'thread'
 
 $LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
 %w[
-  utils connection dispatcher proxy task worker thread_pool runtime version
+  utils connection dispatcher proxy task worker thread_pool runtime version parser
 ].each { |file|
   require "redom/#{file}"
 }
@@ -26,8 +26,9 @@ module Redom
   # REQ_HANDSHAKE
   IDX_CONNECTION_CLASS = 1
   # REQ_METHOD_INVOCATION
-  IDX_METHOD_NAME      = 1
-  IDX_ARGUMENTS        = 2
+  IDX_CONNECTION_ID    = 1
+  IDX_METHOD_NAME      = 2
+  IDX_ARGUMENTS        = 3
   # REQ_PROXY_RESULT
   IDX_TASK_ID          = 1
   IDX_PROXY_RESULT     = 2

data/lib/redom/connection.rb

@@ -2,6 +2,24 @@ module Redom
   module Connection
     include Utils
 
+    class Sender
+      def initialize(conn, async = false)
+        @conn = conn
+        @async = async
+      end
+
+      def method_missing(name, *args, &blck)
+        if @async
+          @conn._dispatcher.run_task(@conn, name, args, blck)
+          nil
+        else
+          result = @conn.send(name, *args, &blck)
+          @conn.sync{}
+          result
+        end
+      end
+    end
+
     # Default event handlers
     def on_open; end
     def on_close; end
@@ -28,6 +46,8 @@ module Redom
       @ws = ws
       @proxies = Hash.new
       @buff_size = opts[:buff_size]
+      @sync = Sender.new(self, false)
+      @async = Sender.new(self, true)
       self
     end
 
@@ -40,14 +60,10 @@ module Redom
       end
     end
 
-    def sync(obj = nil)
-      obj = _fid if obj == self
-      if Connection === obj
-        _dispatcher.run_task(obj, :sync, [_fid], nil)
-        return
-      end
+    def sync(&blck)
+      return @sync unless blck
 
-      fid = obj ? obj : _fid
+      fid = _fid
       stack = @proxies[fid]
       return if !stack || stack.empty?
 
@@ -56,7 +72,7 @@ module Redom
         msg << v._info
       }
 
-      rsp = Fiber.yield(msg)
+      rsp = Fiber.yield([self, msg])
 
       error = nil
       while result = rsp.shift
@@ -75,13 +91,46 @@ module Redom
         end
       end
 
+      vars = (eval('local_variables', blck.binding) - [:_]).map { |v|
+        "#{v} = map[#{v}.__id__].origin if Redom::Proxy === #{v} && map.key?(#{v}.__id__)"
+      }.join("\n")
+      set_var = eval %Q{
+        lambda { |map|
+          #{vars}
+        }
+      }, blck.binding
+      set_var.call stack
+
       stack.clear
 
       on_error(error) if error
+
+      nil
+    end
+
+    def async(block = nil, &blck)
+      return @async unless block || blck
+
+      if block
+        block.call
+      else
+        _dispatcher.run_task(self, :async, blck)
+      end
+
+      nil
+    end
+
+    def parse(str, file='(file)')
+      Parser.new(self).parse str, file
+    end
+
+    def _on_open
+      _bulk Proxy.new(self, [nil, nil, nil, _cid])
+      on_open
     end
 
     def _cid
-      @ws.__id__
+      "#{@ws.__id__}@#{__id__}"
     end
 
     def _fid

data/lib/redom/dispatcher.rb

@@ -18,7 +18,7 @@ module Redom
       @pool.stop
     end
 
-    def run_task(conn, name, args, blck)
+    def run_task(conn, name, args = [], blck = nil)
       task = Task.new(conn, @pool.worker, [name, args, blck])
       @tasks[task._id] = task
       task.run
@@ -35,15 +35,13 @@ module Redom
       when REQ_HANDSHAKE
         if cls = @conn_cls[req[IDX_CONNECTION_CLASS]]
           conn = cls.new._init(ws, @opts)
-          @conns[ws.__id__] = conn
-          task = Task.new(conn, @pool.worker, [:on_open, []])
-          @tasks[task._id] = task
-          task.run
+          @conns["#{ws.__id__}@#{conn.__id__}"] = conn
+          run_task(conn, :_on_open)
         else
           _logger.error "Undefined Redom::Connection class '#{req[IDX_CONNECTION_CLASS]}'."
         end
       when REQ_METHOD_INVOCATION
-        if conn = @conns[ws.__id__]
+        if conn = @conns[req[IDX_CONNECTION_ID]]
           req[IDX_ARGUMENTS].map! { |arg|
             if Array === arg
               case arg[0]
@@ -55,11 +53,9 @@ module Redom
             end
             arg
           }
-          task = Task.new(conn, @pool.worker, req[IDX_METHOD_NAME..-1])
-          @tasks[task._id] = task
-          task.run
+          run_task(conn, req[IDX_METHOD_NAME], req[IDX_ARGUMENTS])
         else
-          _logger.error "Connection missing. ID='#{ws.__id__}'"
+          _logger.error "Connection missing. ID='#{req[IDX_CONNECTION_ID]}'"
         end
       when REQ_PROXY_RESULT
         if task = @tasks[req[IDX_TASK_ID]]
@@ -75,9 +71,7 @@ module Redom
     def on_close(ws)
       _logger.debug "Connection closed. ID='#{ws.__id__}'"
       if conn = @conns[ws.__id__]
-        task = Task.new(conn, @pool.worker, [:on_close, []])
-        @tasks[task._id] = task
-        task.run
+        run_task(conn, :on_close)
         @conns.delete ws.__id__
       end
     end

data/lib/redom/parser.rb

@@ -0,0 +1,235 @@
+require 'opal'
+
+module Redom
+  class Parser < Opal::Parser
+    include Utils
+
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # s(:lit, 1)
+    # s(:lit, :foo)
+    def process_lit(sexp, level)
+      val = sexp.shift
+      case val
+      when Numeric
+        level == :recv ? "(#{val.inspect})" : val.inspect
+      when Symbol
+        "Opal.$method(#{@conn._cid.inspect}, #{val.to_s.inspect})"
+      when Regexp
+        val == // ? /^/.inspect : val.inspect
+      when Range
+        @helpers[:range] = true
+        "__range(#{val.begin}, #{val.end}, #{val.exclude_end?})"
+      else
+        raise "Bad lit: #{val.inspect}"
+      end
+    end
+
+    # Converts a ruby method name into its javascript equivalent for
+    # a method/function call. All ruby method names get prefixed with
+    # a '$', and if the name is a valid javascript identifier, it will
+    # have a '.' prefix (for dot-calling), otherwise it will be
+    # wrapped in brackets to use reference notation calling.
+    #
+    #     mid_to_jsid('foo')      # => ".$foo"
+    #     mid_to_jsid('class')    # => ".$class"
+    #     mid_to_jsid('==')       # => "['$==']"
+    #     mid_to_jsid('name=')    # => "['$name=']"
+    #
+    # @param [String] mid ruby method id
+    # @return [String]
+    def mid_to_jsid(mid, djs_call = true)
+      if /^([a-zA-Z0-9$_]+)=$/ =~ mid.to_s
+        ".$djsAssign('#{$1}')"
+      elsif '[]' == mid.to_s
+        ".$djsCall('')"
+      elsif /\=|\+|\-|\*|\/|\!|\?|\<|\>|\&|\||\^|\%|\~|\[/ =~ mid.to_s
+        "['$#{mid}']"
+      else
+        if djs_call
+          ".$djsCall('$#{mid}')"
+        else
+          ".$#{mid}"
+        end
+      end
+    end
+
+    def js_def(recvr, mid, args, stmts, line, end_line)
+      jsid = mid_to_jsid(mid.to_s, false)
+
+      if recvr
+        @scope.defines_defs = true
+        smethod = true if @scope.class_scope? && recvr.first == :self
+        recv = process(recvr, :expr)
+      else
+        @scope.defines_defn = true
+        recv = current_self
+      end
+
+      code = ''
+      params = nil
+      scope_name = nil
+      uses_super = nil
+
+      # opt args if last arg is sexp
+      opt = args.pop if Array === args.last
+
+      # block name &block
+      if args.last.to_s.start_with? '&'
+        block_name = args.pop.to_s[1..-1].to_sym
+      end
+
+      # splat args *splat
+      if args.last.to_s.start_with? '*'
+        if args.last == :*
+          args.pop
+        else
+          splat = args[-1].to_s[1..-1].to_sym
+          args[-1] = splat
+          len = args.length - 2
+        end
+      end
+
+      indent do
+        in_scope(:def) do
+          @scope.mid  = mid
+          @scope.defs = true if recvr
+
+          if block_name
+            @scope.uses_block!
+          end
+
+          yielder = block_name || '__yield'
+          @scope.block_name = yielder
+
+          params = process args, :expr
+
+          opt[1..-1].each do |o|
+            next if o[2][2] == :undefined
+            id = process s(:lvar, o[1]), :expr
+            code += ("if (%s == null) {\n%s%s\n%s}" %
+                      [id, @indent + INDENT, process(o, :expre), @indent])
+          end if opt
+
+          code += "#{splat} = __slice.call(arguments, #{len});" if splat
+          code += "\n#@indent" + process(stmts, :stmt)
+
+          # Returns the identity name if identified, nil otherwise
+          scope_name = @scope.identity
+
+          if @scope.uses_block?
+            @scope.add_temp '__context'
+            @scope.add_temp yielder
+
+            blk = "\n%s%s = %s._p || nil, __context = %s._s, %s._p = null;\n%s" %
+              [@indent, yielder, scope_name, yielder, scope_name, @indent]
+
+            code = blk + code
+          end
+
+          uses_super = @scope.uses_super
+
+          code = "#@indent#{@scope.to_vars}" + code
+        end
+      end
+
+      defcode = "#{"#{scope_name} = " if scope_name}function(#{params}) {\n#{code}\n#@indent}"
+
+      if recvr
+        if smethod
+          @scope.smethods << "$#{mid}"
+          "#{ @scope.name }#{jsid} = #{defcode}"
+        else
+          "#{ recv }#{ jsid } = #{ defcode }"
+        end
+      elsif @scope.class_scope?
+        @scope.methods << "$#{mid}"
+        if uses_super
+          @scope.add_temp uses_super
+          uses_super = "#{uses_super} = #{@scope.proto}#{jsid};\n#@indent"
+        end
+        "#{uses_super}#{ @scope.proto }#{jsid} = #{defcode}"
+      elsif @scope.type == :iter
+        "def#{jsid} = #{defcode}"
+      elsif @scope.type == :top
+        "#{ current_self }#{ jsid } = #{ defcode }"
+      else
+        "def#{jsid} = #{defcode}"
+      end
+    end
+
+    # s(:const, :const)
+    def process_const(sexp, level)
+      "__scope.$djsCall('#{sexp.shift}')()"
+    end
+
+    # s(:call, recv, :mid, s(:arglist))
+    # s(:call, nil, :mid, s(:arglist))
+    def process_call(sexp, level)
+      recv, meth, arglist, iter = sexp
+      mid = mid_to_jsid meth.to_s
+
+      case meth
+      when :attr_reader, :attr_writer, :attr_accessor
+        return handle_attr_optimize(meth, arglist[1..-1])
+      when :block_given?
+        return js_block_given(sexp, level)
+      when :alias_native
+        return handle_alias_native(sexp) if @scope.class_scope?
+      when :require
+        path = arglist[1]
+
+        if path and path[0] == :str
+          @requires << path[1]
+        end
+
+        return "//= require #{path[1]}"
+      when :respond_to?
+        return handle_respond_to(sexp, level)
+      end
+
+      splat = arglist[1..-1].any? { |a| a.first == :splat }
+
+      if Array === arglist.last and arglist.last.first == :block_pass
+        block   = process s(:js_tmp, process(arglist.pop, :expr)), :expr
+      elsif iter
+        block   = iter
+      end
+
+      recv ||= s(:self)
+
+      if block
+        tmprecv = @scope.new_temp
+      elsif splat and recv != [:self] and recv[0] != :lvar
+        tmprecv = @scope.new_temp
+      end
+
+      args      = ""
+
+      recv_code = process recv, :recv
+
+      args = process arglist, :expr
+
+      result = if block
+        dispatch = "(%s = %s, %s%s._p = %s, %s%s" %
+          [tmprecv, recv_code, tmprecv, mid_to_jsid(meth.to_s, false), block, tmprecv, mid]
+
+        if splat
+          "%s.apply(null, %s))" % [dispatch, args]
+        else
+          "%s(%s))" % [dispatch, args]
+        end
+      else
+        # m_missing = " || __mm(#{meth.to_s.inspect})"
+        # dispatch = "((#{tmprecv} = #{recv_code}).$m#{mid}#{ m_missing })"
+        # splat ? "#{dispatch}.apply(null, #{args})" : "#{dispatch}(#{args})"
+        dispatch = tmprecv ? "(#{tmprecv} = #{recv_code})#{mid}" : "#{recv_code}#{mid}"
+        splat ? "#{dispatch}.apply(#{tmprecv || recv_code}, #{args})" : "#{dispatch}(#{args})"
+      end
+
+      result
+    end
+  end
+end

data/lib/redom/proxy.rb

@@ -25,7 +25,7 @@ module Redom
 
     def sync
       unless @solved
-        @conn.sync
+        @conn.sync{}
       end
       @origin
     end
@@ -56,9 +56,9 @@ module Redom
         }
         arg
       when Method
-        [TYPE_METHOD, arg.name]
+        [TYPE_METHOD, @conn._cid, arg.name]
       when Symbol
-        [TYPE_METHOD, arg.to_s]
+        [TYPE_METHOD, @conn._cid, arg.to_s]
       else
         arg
       end

data/lib/redom/runtime.rb

@@ -19,9 +19,88 @@ module Redom
   P_INFO_NAME = 2,
   P_INFO_ARGS = 3;
 
+  if (window.Opal) {
+    Object.prototype.$djsCall = function(name) {
+        if (name == '') {
+          return (function(obj) {
+            return function(key) {
+              return obj[key];
+             };
+        })(this);
+      }
+
+      if (name == '$method') {
+        return function(methodName) {
+          if (Opal.top['$' + methodName]) {
+            return Opal.top['$' + methodName];
+          } else {
+            return function(e) {
+              window.djs.invoke(methodName, [e]);
+            };
+          }
+        };
+      }
+
+      if (Opal.top[name]) {
+        if (typeof Opal.top[name] == 'function') {
+          return function() {
+            return Opal.top[name].apply(Opal.top, arguments);
+          };
+        } else {
+          return function() {
+            return Opal.top[name];
+          };
+        }
+      }
+      if (name[0] == "$" && this[name] == null) {
+        name = name.substring(1);
+      };
+
+      if (this[name] != null) {
+        if (typeof this[name] == 'function') {
+          return (function(obj) {
+            return function() {
+              return obj[name].apply(obj, arguments);
+            };
+          })(this);
+        } else {
+          return (function(obj) {
+            return function() {
+              return obj[name];
+            };
+          })(this);
+        }
+      } else if (window[name]) {
+        if (typeof window[name] == 'function') {
+          return function() {
+            return window[name].apply(window, arguments);
+          };
+        } else {
+          return function() {
+            return window[name];
+          };
+        }
+      }
+
+      return function() {
+        return null;
+      };
+    };
+    Object.prototype.$djsAssign = function(name) {
+      return (function(obj) {
+        return function(value) {
+          return obj[name] = value;
+        };
+      })(this);
+    };
+    Opal.top.$window = window;
+    Opal.top.$document = window.document;
+    Opal.top.$navigator = window.navigator;
+    Opal.top.$location = window.location;
+  }
+
   var Redom = function(server) {
-    var ws = new WebSocket(server);
-      conn = "Connection",
+    var ws = new WebSocket(server),
       refs = {
         seq: 0,
         hash: {},
@@ -54,8 +133,7 @@ module Redom
     // Initialize WebSocket event handlers
     function open(connectionClassName) {
       ws.onopen = function() {
-        conn = connectionClassName;
-        ws.send(serialize([REQ_HANDSHAKE, conn]));
+        ws.send(serialize([REQ_HANDSHAKE, connectionClassName]));
         console.log("WebSocket opened.");
       };
       ws.onclose = function() {
@@ -230,10 +308,6 @@ module Redom
         return server;
       },
 
-      getConnection: function() {
-        return conn;
-      },
-
       open: function(connectionClassName) {
         open(connectionClassName);
       },

data/lib/redom/task.rb

@@ -32,14 +32,14 @@ module Redom
             _logger.error "Method '#{@info[T_INFO_METHOD_NAME]}' is not defined in class '#{@conn.class}'."
             @conn.method(:on_error).call("No such method '#{@info[T_INFO_METHOD_NAME]}'.")
           end
-          @conn.sync
+          @conn.sync{}
           nil
         end
         result = @fiber.resume
       end
 
       if result
-        @conn._send [_id, result].to_json
+        result[0]._send [_id, result[1]].to_json
       else
         _dispatcher.delete_task _id
       end

data/lib/redom/version.rb

@@ -1,3 +1,3 @@
 module Redom
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/redom.gemspec

@@ -17,4 +17,5 @@ Gem::Specification.new do |s|
   s.executables   = ['redom']
 
   s.add_dependency 'em-websocket', '>= 0.3.5'
+  s.add_dependency 'opal', '>= 0.3.27'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redom
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000Z
+date: 2012-12-21 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-websocket
-  requirement: &70124221424660 !ruby/object:Gem::Requirement
+  requirement: &70180056191480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,7 +22,18 @@ dependencies:
         version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *70124221424660
+  version_requirements: *70180056191480
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: &70180056190760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.27
+  type: :runtime
+  prerelease: false
+  version_requirements: *70180056190760
 description: A distributed object based server-centric web framework.
 email: future.azure@gmail.com
 executables:
@@ -36,6 +47,7 @@ files:
 - lib/redom.rb
 - lib/redom/connection.rb
 - lib/redom/dispatcher.rb
+- lib/redom/parser.rb
 - lib/redom/proxy.rb
 - lib/redom/runtime.rb
 - lib/redom/task.rb