dnode 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT/X11 license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/examples/moo/client.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'dnode'
+
+DNode.new({:name => 'Bertrand' }).connect(5050) do |remote|
+    remote.moo(proc do |cow|
+        puts cow.msg
+        cow.ooo(10) { |moo| puts moo }
+    end)
+    
+    remote.range(5) { |n| puts "range: #{n}" }
+end

data/examples/moo/server.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'dnode'
+
+class Moo
+    def initialize name
+        @name = name
+    end
+    
+    def moo; yield({
+        :msg => "Moo! Greetings #{name}.",
+        :ooo => proc { |n,&b| b.call('M' + 'o' * n + '!') },
+    }); end
+    
+    def range n
+        0.upto(n - 1).each { |x| yield x }
+    end
+end
+
+DNode.new(proc { |client|
+    Moo.new(client.name)
+}).listen(5050)

data/examples/simple/client.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'dnode'
+
+DNode.new({}).connect(5050) do |remote|
+    remote.f(30000) { |x| puts "x=<#{x}>" }
+end

data/examples/simple/server.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'dnode'
+
+DNode.new({
+    :f => proc { |x| yield x + 1337 }
+}).listen(5050)

data/lib/dnode.rb

@@ -0,0 +1,50 @@
+require 'eventmachine'
+require 'dnode/conn'
+require 'json'
+require 'socket'
+
+class DNode
+    def initialize obj={}
+        @instance = obj
+    end
+    
+    def from_args *args, &block
+        types = args.inject({}) { |acc,x| acc.merge(x.class.to_s => x) }
+        kw = types['Hash'] || {}
+        {
+            :host => kw['host'] || kw[:host] || types['String'] || 'localhost',
+            :port => kw['port'] || kw[:port] || types['Fixnum'],
+            :block => block || kw['block'] || kw[:block] || types['Proc'],
+        }
+    end
+    private :from_args
+    
+    def handle_conn c, conn
+        c.extend EM::P::LineText2
+        (class << c; self; end).send(:define_method, 'receive_line') do |line|
+            conn.handle(JSON(line))
+        end
+    end
+    private :handle_conn
+    
+    def connect *args, &block
+        params = from_args(*args, &block).merge(:instance => @instance)
+        EM.run do EM.connect(params[:host], params[:port]) do |c|
+            conn = Conn.new(params.merge :conn => c)
+            handle_conn(c, conn)
+        end end
+    end
+    
+    class Listener < EM::Connection
+    end
+    
+    def listen *args, &block
+        params = from_args(*args, &block).merge(:instance => @instance)
+        EM.run do
+            EM.start_server(params[:host], params[:port], Listener) do |c|
+                conn = Conn.new(params.merge :conn => c)
+                handle_conn(c, conn)
+            end
+        end
+    end
+end

data/lib/dnode/conn.rb

@@ -0,0 +1,57 @@
+require 'eventmachine'
+require 'events'
+require 'json'
+require 'dnode/scrub'
+require 'dnode/jsobject'
+
+class Conn
+    include Events::Emitter
+    
+    def initialize params
+        @block = params[:block] || lambda {}
+        @instance = params[:instance] || {}
+        @conn = params[:conn]
+        @scrub = Scrub.new
+        @remote = {}
+        
+        request('methods',
+            if @instance.is_a? Proc
+                then @instance.call(*[@remote,self][0..@instance.arity-1])
+                else @instance
+            end
+        )
+    end
+    
+    def handle req
+        args = @scrub.unscrub(req) do |id|
+            lambda { |*argv| self.request(id, *argv) }
+        end
+        
+        if req['method'].is_a? Integer then
+            id = req['method']
+            @scrub.callbacks[id].call(*JSObject.create(args))
+        elsif req['method'] == 'methods' then
+            @remote.update(args[0])
+            js = JSObject.create(@remote)
+            
+            @block.call(*[ js, self ][ 0 .. @block.arity - 1 ])
+            self.emit('remote', js)
+            self.emit('ready')
+        end
+    end
+    
+    def request method, *args
+        scrubbed = @scrub.scrub(args)
+        @conn.send_data(JSON(
+            {
+                :method => (
+                    if method.respond_to? :match and method.match(/^\d+$/)
+                        then method.to_i
+                        else method
+                    end
+                ),
+                :links => [],
+            }.merge(scrubbed)
+        ) + "\n")
+    end
+end

data/lib/dnode/jsobject.rb

@@ -0,0 +1,38 @@
+require 'dnode/walk'
+
+class JSObject
+    class JSHash < Hash
+        def [] key; super key.to_s; end
+        def []= key, value; super key.to_s, value; end
+        
+        @@names = []
+        def self.create hash
+            @@names.each { |name| remove_method(name) }
+            @@names = hash.keys
+            
+            hash.each do |name,value|
+                define_method(name) do |*args,&block|
+                    if value.is_a? Proc then
+                        if block.nil? then
+                            value.call(*args)
+                        else 
+                            value.call(*args) { |*iargs| block.call(*iargs) }
+                        end
+                    else
+                        value
+                    end
+                end
+            end
+            
+            self.new.update(hash)
+        end
+    end
+    
+    def self.create obj={}
+        Walk.new(obj).walk do |node|
+            if node.value.is_a? Hash and not node.value.is_a? JSHash then
+                node.value = JSHash.create(node.value)
+            end
+        end
+    end
+end

data/lib/dnode/scrub.rb

@@ -0,0 +1,35 @@
+require 'dnode/walk'
+
+class Scrub
+    def initialize
+        @callbacks = {}
+        @last_id = 0
+    end
+    
+    attr_accessor :callbacks
+    
+    def scrub args
+        callbacks = {}
+        walked = Walk.new(args).walk do |node|
+            if node.value.is_a? Proc then
+                id = @last_id
+                @last_id += 1
+                @callbacks[id] = node.value
+                callbacks[id] = node.path.clone
+                node.value = '[Function]'
+            end
+        end
+        { :arguments => walked, :callbacks => callbacks }
+    end
+    
+    def unscrub req, &block
+        args = Walk.new(req['arguments']).walk do |node|
+            path = node.path.map(&:to_s)
+            pair = req['callbacks'].detect{ |_,p| p.map(&:to_s) == path }
+            unless pair.nil? then
+                id = pair.first
+                node.value = block.call(id)
+            end
+        end
+    end
+end

data/lib/dnode/walk.rb

@@ -0,0 +1,63 @@
+class Walk
+    def initialize obj
+        @path = []
+        @object = obj
+    end
+    
+    def clone obj
+        _walk(obj, proc do |node|
+            unless @object.is_a? Array or @object.is_a? Hash then
+                node.value = node.value.clone
+            end
+        end)
+    end
+    
+    def walk &block
+        _walk(clone(@object), block)
+    end
+    
+    def _walk obj, cb
+        node = Node.new(:value => obj, :path => @path)
+        cb.call(node)
+        value = node.value
+        
+        if value.is_a? Hash then
+            copy = value.class.new
+            value.each do |key,v|
+                @path.push key
+                copy[key] = _walk(v, cb)
+                @path.pop
+            end
+            return copy
+        elsif value.is_a? Array then
+            copy = value.class.new
+            value.each_with_index do |v,i|
+                @path.push i
+                copy.push(_walk(v, cb))
+                @path.pop
+            end
+            return copy
+        elsif [ Numeric, String, Proc ].select{ |x| value.is_a? x }.any?
+            return value
+        else
+            # only serve up the object's "own" methods
+            return value.methods.select { |name|
+                value.method(name).owner == value.class
+            }.inject({}) { |acc,name|
+                acc.merge(name => value.method(name).to_proc)
+            }
+        end
+    end
+    private :_walk
+end
+
+class Node
+    def initialize params
+        @value = params[:value]
+        @path = params[:path]
+    end
+    
+    attr_accessor :value
+    alias :update :value=
+    attr_reader :path
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: dnode
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Halliday
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-12 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: "\n        With DNode you can tie together servers written in ruby, node.js, and\n        perl.\n        \n        DNode is similar to DRb, but is asynchronous and transforms callbacks\n        embedded in deeply nested structures.\n    "
+email: mail@substack.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- LICENSE
+- lib/dnode.rb
+- lib/dnode/conn.rb
+- lib/dnode/scrub.rb
+- lib/dnode/walk.rb
+- lib/dnode/jsobject.rb
+- examples/simple/client.rb
+- examples/simple/server.rb
+- examples/moo/client.rb
+- examples/moo/server.rb
+has_rdoc: true
+homepage: http://github.com/substack/dnode-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Asynchronous remote method calls with transparently wrapped callbacks
+test_files: []
+