cool.io-websocket 0.1.4

data/ChangeLog

@@ -0,0 +1,23 @@
+
+2011-1-15 version 0.1.4:
+
+** change all references to Rev to Cool.io
+
+2010-07-22 version 0.1.3:
+
+  * rescue all StandardErrors on_readable
+  * adds 'RPC push' example
+
+2010-07-17 version 0.1.2:
+
+  * sends <cross-domain-policy> on <policy-file-request> to accept Flash-based clients
+  * adds examples
+
+2010-07-13 version 0.1.1:
+
+  * fixes compatibility with Chrome 6 (draft-76)
+
+2010-07-13 version 0.1.0:
+
+  * first release
+

data/README.rdoc

@@ -0,0 +1,144 @@
+= Cool.io-WebSocket
+
+Cool.io-WebSocket is a WebSocket server implementation based on Cool.io,
+a high performance event-driven I/O library for Ruby.
+
+This library conforms to WebSocket draft-75 and draft-76.
+
+- http://github.com/maxjustus/cool.io-websocket
+
+
+== Installation
+
+    gem install cool.io-websocket
+
+
+== Examples
+
+- examples/echo.rb - receives a message from clients and just echos.
+- examples/shoutchat.rb - simple chat application.
+- examples/rpc.rb - pushes messages to browsers from programs separated from the web socket server.
+
+See examples/README.md[http://github.com/maxjustus/cool.io-websocket/tree/master/examples/] for details.
+
+=== Simple echo server
+
+    require 'rubygems'
+    require 'cool.io-websocket'
+    
+    class MyConnection < Cool.io::WebSocket
+      def on_open
+        puts "WebSocket opened"
+        send_message("Hello, world!")
+      end
+    
+      def on_message(data)
+        puts "WebSocket data received: '#{data}'"
+        send_message("echo: #{data}")
+      end
+    
+      def on_close
+        puts "WebSocket closed"
+      end
+    end
+    
+    host = '0.0.0.0'
+    port = '8080'
+    
+    server = Cool.io::WebSocketServer.new(host, port, MyConnection)
+    server.attach(Cool.io::Loop.default)
+    
+    Cool.io::Loop.default.run
+
+
+=== Publisher/Subscriber-style message routing
+    require 'rubygems'
+    require 'cool.io-websocket'
+    
+    class PubSub
+      def initialize
+        @subscriber = {}
+        @seqid = 0
+      end
+    
+      def subscribe(&block)
+        sid = @seqid += 1
+        @subscriber[sid] = block
+        return sid
+      end
+    
+      def unsubscribe(key)
+        @subscriber.delete(key)
+      end
+    
+      def publish(data)
+        @subscriber.each_value {|block|
+          block.call(data)
+        }
+      end
+    end
+    
+    $pubsub = PubSub.new
+    
+    class MyConnection < Cool.io::WebSocket
+      def on_open
+        puts "WebSocket opened"
+        @sid = $pubsub.subscribe {|data|
+          send_message data
+        }
+      end
+    
+      def on_message(data)
+        puts "WebSocket data received, broadcasting: '#{data}'"
+        $pubsub.publish(data)
+      end
+    
+      def on_close
+        puts "WebSocket closed"
+        $pubsub.unsubscribe(@sid)
+      end
+    end
+    
+    host = '0.0.0.0'
+    port = ARGV[0] || 8080
+    
+    server = Cool.io::WebSocketServer.new(host, port, MyConnection)
+    server.attach(Cool.io::Loop.default)
+    
+    puts "start on #{host}:#{port}"
+    
+    Cool.io::Loop.default.run
+
+
+== Learn more
+
+- [Cool.io API reference] http://rev.rubyforge.org/rdoc/
+- [JSON for object serialization] http://github.com/brianmario/yajl-ruby
+- [MessagePack for object serialization] http://msgpack.org/
+- [The WebSocket protocol draft-76] http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+- [EventMachine based WebSocket server] http://github.com/igrigorik/em-websocket
+
+
+== License
+
+Copyright (c) 2010 FURUHASHI Sadayuki
+
+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/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+
+begin
+	require 'jeweler'
+	Jeweler::Tasks.new do |gemspec|
+		gemspec.name = "cool.io-websocket"
+		gemspec.summary = "WebSocket server based on Coolio"
+		gemspec.description = "Cool.io-WebSocket is a WebSocket server implementation based on Cool.io, a high performance event-driven I/O library for Ruby. This library conforms to WebSocket draft-75 and draft-76."
+		gemspec.email = "frsyuki@users.sourceforge.jp"
+		gemspec.homepage = "http://github.com/maxjustus/cool.io-websocket"
+		gemspec.authors = ["FURUHASHI Sadayuki", "Max Justus Spransy"]
+		gemspec.files.include "lib/**/*"
+		gemspec.files.include "examples/**/*"
+		gemspec.files.exclude ".gitignore"
+		gemspec.add_dependency("cool.io", ">= 0.3.2")
+		gemspec.add_dependency("thin", '>= 1.2.7')
+	end
+	Jeweler::GemcutterTasks.new
+rescue LoadError
+	puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+task :default => :build
+

data/VERSION

@@ -0,0 +1 @@
+0.1.4

data/examples/README.md

@@ -0,0 +1,41 @@
+Rev-WebSocket Examlpes
+======================
+
+Documents for *rev-websocket* is available at [frsyuki's rev-websocket repository](http://github.com/frsyuki/rev-websocket).
+
+
+## Echo server
+
+    $ gem install rev-websocket
+    $ ruby ./echo
+
+A HTTP server runs on localhost:8080 and WebSocket server runs on localhost:8081.
+
+Then access to [htt://localhost:8080/echo.html](http://localhost:8080/echo.html).
+
+
+## RPC push
+
+With RPC (Remote Procedure Call), you can push messages to browsers from programs separated from the WebSocket server.
+
+In this example, a Sinatra based web appliction pushes messages using MessagePack-RPC, a simple cross-language RPC library.
+
+    $ gem install msgpack-rpc
+    $ gem install rev-websocket
+    $ gem install sinatra
+    $ gem install json
+    $ ruby ./rpc
+
+Then access to [htt://localhost:8080/](http://localhost:8080/).
+
+
+## ShoutChat
+
+ShoutChat is a simple browser-based chat application.
+
+    $ gem install rev-websocket
+    $ gem install json
+    $ ruby ./shoutchat
+
+Then access to [htt://localhost:8080/shoutchat.html](http://localhost:8080/shoutchat.html).
+

data/examples/echo

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+fork {
+	load 'echo.rb'
+	exit 0
+}
+
+require 'webrick'
+
+server = WEBrick::HTTPServer.new({
+	:Port => 8080,
+	:BindAddress => '127.0.0.1',
+	:DocumentRoot => File.dirname(__FILE__)+'/public'})
+
+trap('INT') { server.shutdown }
+
+server.start
+

data/examples/echo.rb

@@ -0,0 +1,31 @@
+# WebSocket echo server
+
+require 'rubygems'
+require 'cool.io-websocket'
+
+class EchoConnection < Cool.io::WebSocket
+	def on_open
+		puts "WebSocket opened from '#{peeraddr[2]}': request=#{request.inspect}"
+		send_message("server: Hello, world!")
+	end
+
+	def on_message(data)
+		puts "WebSocket data received: '#{data}'"
+		send_message(data)
+	end
+
+	def on_close
+		puts "WebSocket closed"
+	end
+end
+
+host = '0.0.0.0'
+port = ARGV[0] || 8081
+
+server = Cool.io::WebSocketServer.new(host, port, EchoConnection)
+server.attach(Cool.io::Loop.default)
+
+puts "start on #{host}:#{port}"
+
+Cool.io::Loop.default.run
+

data/examples/public/echo.css

@@ -0,0 +1,11 @@
+
+.time {
+	color: #007010;
+	margin-right: 0.2em;
+	padding-right: 0.2em;
+}
+
+.time:after {
+	content: ":";
+}
+

data/examples/public/echo.html

@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="UTF-8" />
+	<meta content="text/css" http-equiv="content-style-type" />
+	<meta content="text/javascript" http-equiv="content-script-type" />
+
+	<script type="text/javascript" src='js/jquery.min.js'></script>
+	<script type="text/javascript" src='js/swfobject.js'></script>
+	<script type="text/javascript" src='js/FABridge.js'></script>
+	<script type="text/javascript" src='js/web_socket.js'></script>
+	<script type="text/javascript" src='js/json2.js'></script>
+	<link rel="stylesheet" type="text/css" href="echo.css" />
+
+	<title>Cool.io-WebSocket Demo: Echo server</title>
+
+	<script>
+	WS_URL = "ws://localhost:8081";
+	WEB_SOCKET_SWF_LOCATION = "js/WebSocketMain.swf";
+
+	var global = this;
+
+	$(document).ready(function(){
+
+		function debug(message) {
+			html = "<p><span class='time'>"+new Date()+"</span>"+message+"</p>"
+			$("#debug").append(html);
+		}
+
+		debug("connecting to "+WS_URL+"...");
+		ws = new WebSocket(WS_URL);
+
+		ws.onopen = function() {
+			debug("connected.");
+
+			text = "client: hello";
+			ws.send(text);
+
+			debug("message sent: "+text);
+		}
+
+		ws.onclose = function() {
+			debug("disconnected...");
+		}
+
+		ws.onerror = function(msg) {
+			debug("failed to connect："+msg);
+		}
+
+		ws.onmessage = function(event) {
+			debug("message received: "+event.data);
+			$("#message").append("<p>"+event.data+"</p>");
+		}
+
+    setTimeout(function(){ws.send('YOYOYOYOYO')}, 5000);
+	});
+	</script>
+</head>
+<body>
+	<div id="message"></div>
+	<div id="debug"></div>
+</body>

data/examples/public/js/FABridge.js

@@ -0,0 +1,604 @@
+/*
+/*
+Copyright 2006 Adobe Systems Incorporated
+
+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.
+
+*/
+
+
+/*
+ * The Bridge class, responsible for navigating AS instances
+ */
+function FABridge(target,bridgeName)
+{
+    this.target = target;
+    this.remoteTypeCache = {};
+    this.remoteInstanceCache = {};
+    this.remoteFunctionCache = {};
+    this.localFunctionCache = {};
+    this.bridgeID = FABridge.nextBridgeID++;
+    this.name = bridgeName;
+    this.nextLocalFuncID = 0;
+    FABridge.instances[this.name] = this;
+    FABridge.idMap[this.bridgeID] = this;
+
+    return this;
+}
+
+// type codes for packed values
+FABridge.TYPE_ASINSTANCE =  1;
+FABridge.TYPE_ASFUNCTION =  2;
+
+FABridge.TYPE_JSFUNCTION =  3;
+FABridge.TYPE_ANONYMOUS =   4;
+
+FABridge.initCallbacks = {};
+FABridge.userTypes = {};
+
+FABridge.addToUserTypes = function()
+{
+	for (var i = 0; i < arguments.length; i++)
+	{
+		FABridge.userTypes[arguments[i]] = {
+			'typeName': arguments[i], 
+			'enriched': false
+		};
+	}
+}
+
+FABridge.argsToArray = function(args)
+{
+    var result = [];
+    for (var i = 0; i < args.length; i++)
+    {
+        result[i] = args[i];
+    }
+    return result;
+}
+
+function instanceFactory(objID)
+{
+    this.fb_instance_id = objID;
+    return this;
+}
+
+function FABridge__invokeJSFunction(args)
+{  
+    var funcID = args[0];
+    var throughArgs = args.concat();//FABridge.argsToArray(arguments);
+    throughArgs.shift();
+   
+    var bridge = FABridge.extractBridgeFromID(funcID);
+    return bridge.invokeLocalFunction(funcID, throughArgs);
+}
+
+FABridge.addInitializationCallback = function(bridgeName, callback)
+{
+    var inst = FABridge.instances[bridgeName];
+    if (inst != undefined)
+    {
+        callback.call(inst);
+        return;
+    }
+
+    var callbackList = FABridge.initCallbacks[bridgeName];
+    if(callbackList == null)
+    {
+        FABridge.initCallbacks[bridgeName] = callbackList = [];
+    }
+
+    callbackList.push(callback);
+}
+
+// updated for changes to SWFObject2
+function FABridge__bridgeInitialized(bridgeName) {
+    var objects = document.getElementsByTagName("object");
+    var ol = objects.length;
+    var activeObjects = [];
+    if (ol > 0) {
+		for (var i = 0; i < ol; i++) {
+			if (typeof objects[i].SetVariable != "undefined") {
+				activeObjects[activeObjects.length] = objects[i];
+			}
+		}
+	}
+    var embeds = document.getElementsByTagName("embed");
+    var el = embeds.length;
+    var activeEmbeds = [];
+    if (el > 0) {
+		for (var j = 0; j < el; j++) {
+			if (typeof embeds[j].SetVariable != "undefined") {
+            	activeEmbeds[activeEmbeds.length] = embeds[j];
+            }
+        }
+    }
+    var aol = activeObjects.length;
+    var ael = activeEmbeds.length;
+    var searchStr = "bridgeName="+ bridgeName;
+    if ((aol == 1 && !ael) || (aol == 1 && ael == 1)) {
+    	FABridge.attachBridge(activeObjects[0], bridgeName);	 
+    }
+    else if (ael == 1 && !aol) {
+    	FABridge.attachBridge(activeEmbeds[0], bridgeName);
+        }
+    else {
+                var flash_found = false;
+		if (aol > 1) {
+			for (var k = 0; k < aol; k++) {
+				 var params = activeObjects[k].childNodes;
+				 for (var l = 0; l < params.length; l++) {
+					var param = params[l];
+					if (param.nodeType == 1 && param.tagName.toLowerCase() == "param" && param["name"].toLowerCase() == "flashvars" && param["value"].indexOf(searchStr) >= 0) {
+						FABridge.attachBridge(activeObjects[k], bridgeName);
+                            flash_found = true;
+                            break;
+                        }
+                    }
+                if (flash_found) {
+                    break;
+                }
+            }
+        }
+		if (!flash_found && ael > 1) {
+			for (var m = 0; m < ael; m++) {
+				var flashVars = activeEmbeds[m].attributes.getNamedItem("flashVars").nodeValue;
+				if (flashVars.indexOf(searchStr) >= 0) {
+					FABridge.attachBridge(activeEmbeds[m], bridgeName);
+					break;
+    }
+            }
+        }
+    }
+    return true;
+}
+
+// used to track multiple bridge instances, since callbacks from AS are global across the page.
+
+FABridge.nextBridgeID = 0;
+FABridge.instances = {};
+FABridge.idMap = {};
+FABridge.refCount = 0;
+
+FABridge.extractBridgeFromID = function(id)
+{
+    var bridgeID = (id >> 16);
+    return FABridge.idMap[bridgeID];
+}
+
+FABridge.attachBridge = function(instance, bridgeName)
+{
+    var newBridgeInstance = new FABridge(instance, bridgeName);
+
+    FABridge[bridgeName] = newBridgeInstance;
+
+/*  FABridge[bridgeName] = function() {
+        return newBridgeInstance.root();
+    }
+*/
+    var callbacks = FABridge.initCallbacks[bridgeName];
+    if (callbacks == null)
+    {
+        return;
+    }
+    for (var i = 0; i < callbacks.length; i++)
+    {
+        callbacks[i].call(newBridgeInstance);
+    }
+    delete FABridge.initCallbacks[bridgeName]
+}
+
+// some methods can't be proxied.  You can use the explicit get,set, and call methods if necessary.
+
+FABridge.blockedMethods =
+{
+    toString: true,
+    get: true,
+    set: true,
+    call: true
+};
+
+FABridge.prototype =
+{
+
+
+// bootstrapping
+
+    root: function()
+    {
+        return this.deserialize(this.target.getRoot());
+    },
+//clears all of the AS objects in the cache maps
+    releaseASObjects: function()
+    {
+        return this.target.releaseASObjects();
+    },
+//clears a specific object in AS from the type maps
+    releaseNamedASObject: function(value)
+    {
+        if(typeof(value) != "object")
+        {
+            return false;
+        }
+        else
+        {
+            var ret =  this.target.releaseNamedASObject(value.fb_instance_id);
+            return ret;
+        }
+    },
+//create a new AS Object
+    create: function(className)
+    {
+        return this.deserialize(this.target.create(className));
+    },
+
+
+    // utilities
+
+    makeID: function(token)
+    {
+        return (this.bridgeID << 16) + token;
+    },
+
+
+    // low level access to the flash object
+
+//get a named property from an AS object
+    getPropertyFromAS: function(objRef, propName)
+    {
+        if (FABridge.refCount > 0)
+        {
+            throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+        }
+        else
+        {
+            FABridge.refCount++;
+            retVal = this.target.getPropFromAS(objRef, propName);
+            retVal = this.handleError(retVal);
+            FABridge.refCount--;
+            return retVal;
+        }
+    },
+//set a named property on an AS object
+    setPropertyInAS: function(objRef,propName, value)
+    {
+        if (FABridge.refCount > 0)
+        {
+            throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+        }
+        else
+        {
+            FABridge.refCount++;
+            retVal = this.target.setPropInAS(objRef,propName, this.serialize(value));
+            retVal = this.handleError(retVal);
+            FABridge.refCount--;
+            return retVal;
+        }
+    },
+
+//call an AS function
+    callASFunction: function(funcID, args)
+    {
+        if (FABridge.refCount > 0)
+        {
+            throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+        }
+        else
+        {
+            FABridge.refCount++;
+            retVal = this.target.invokeASFunction(funcID, this.serialize(args));
+            retVal = this.handleError(retVal);
+            FABridge.refCount--;
+            return retVal;
+        }
+    },
+//call a method on an AS object
+    callASMethod: function(objID, funcName, args)
+    {
+        if (FABridge.refCount > 0)
+        {
+            throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+        }
+        else
+        {
+            FABridge.refCount++;
+            args = this.serialize(args);
+            retVal = this.target.invokeASMethod(objID, funcName, args);
+            retVal = this.handleError(retVal);
+            FABridge.refCount--;
+            return retVal;
+        }
+    },
+
+    // responders to remote calls from flash
+
+    //callback from flash that executes a local JS function
+    //used mostly when setting js functions as callbacks on events
+    invokeLocalFunction: function(funcID, args)
+    {
+        var result;
+        var func = this.localFunctionCache[funcID];
+
+        if(func != undefined)
+        {
+            result = this.serialize(func.apply(null, this.deserialize(args)));
+        }
+
+        return result;
+    },
+
+    // Object Types and Proxies
+	
+    // accepts an object reference, returns a type object matching the obj reference.
+    getTypeFromName: function(objTypeName)
+    {
+        return this.remoteTypeCache[objTypeName];
+    },
+    //create an AS proxy for the given object ID and type
+    createProxy: function(objID, typeName)
+    {
+        var objType = this.getTypeFromName(typeName);
+	        instanceFactory.prototype = objType;
+	        var instance = new instanceFactory(objID);
+        this.remoteInstanceCache[objID] = instance;
+        return instance;
+    },
+    //return the proxy associated with the given object ID
+    getProxy: function(objID)
+    {
+        return this.remoteInstanceCache[objID];
+    },
+
+    // accepts a type structure, returns a constructed type
+    addTypeDataToCache: function(typeData)
+    {
+        newType = new ASProxy(this, typeData.name);
+        var accessors = typeData.accessors;
+        for (var i = 0; i < accessors.length; i++)
+        {
+            this.addPropertyToType(newType, accessors[i]);
+        }
+
+        var methods = typeData.methods;
+        for (var i = 0; i < methods.length; i++)
+        {
+            if (FABridge.blockedMethods[methods[i]] == undefined)
+            {
+                this.addMethodToType(newType, methods[i]);
+            }
+        }
+
+
+        this.remoteTypeCache[newType.typeName] = newType;
+        return newType;
+    },
+
+    //add a property to a typename; used to define the properties that can be called on an AS proxied object
+    addPropertyToType: function(ty, propName)
+    {
+        var c = propName.charAt(0);
+        var setterName;
+        var getterName;
+        if(c >= "a" && c <= "z")
+        {
+            getterName = "get" + c.toUpperCase() + propName.substr(1);
+            setterName = "set" + c.toUpperCase() + propName.substr(1);
+        }
+        else
+        {
+            getterName = "get" + propName;
+            setterName = "set" + propName;
+        }
+        ty[setterName] = function(val)
+        {
+            this.bridge.setPropertyInAS(this.fb_instance_id, propName, val);
+        }
+        ty[getterName] = function()
+        {
+            return this.bridge.deserialize(this.bridge.getPropertyFromAS(this.fb_instance_id, propName));
+        }
+    },
+
+    //add a method to a typename; used to define the methods that can be callefd on an AS proxied object
+    addMethodToType: function(ty, methodName)
+    {
+        ty[methodName] = function()
+        {
+            return this.bridge.deserialize(this.bridge.callASMethod(this.fb_instance_id, methodName, FABridge.argsToArray(arguments)));
+        }
+    },
+
+    // Function Proxies
+
+    //returns the AS proxy for the specified function ID
+    getFunctionProxy: function(funcID)
+    {
+        var bridge = this;
+        if (this.remoteFunctionCache[funcID] == null)
+        {
+            this.remoteFunctionCache[funcID] = function()
+            {
+                bridge.callASFunction(funcID, FABridge.argsToArray(arguments));
+            }
+        }
+        return this.remoteFunctionCache[funcID];
+    },
+    
+    //reutrns the ID of the given function; if it doesnt exist it is created and added to the local cache
+    getFunctionID: function(func)
+    {
+        if (func.__bridge_id__ == undefined)
+        {
+            func.__bridge_id__ = this.makeID(this.nextLocalFuncID++);
+            this.localFunctionCache[func.__bridge_id__] = func;
+        }
+        return func.__bridge_id__;
+    },
+
+    // serialization / deserialization
+
+    serialize: function(value)
+    {
+        var result = {};
+
+        var t = typeof(value);
+        //primitives are kept as such
+        if (t == "number" || t == "string" || t == "boolean" || t == null || t == undefined)
+        {
+            result = value;
+        }
+        else if (value instanceof Array)
+        {
+            //arrays are serializesd recursively
+            result = [];
+            for (var i = 0; i < value.length; i++)
+            {
+                result[i] = this.serialize(value[i]);
+            }
+        }
+        else if (t == "function")
+        {
+            //js functions are assigned an ID and stored in the local cache 
+            result.type = FABridge.TYPE_JSFUNCTION;
+            result.value = this.getFunctionID(value);
+        }
+        else if (value instanceof ASProxy)
+        {
+            result.type = FABridge.TYPE_ASINSTANCE;
+            result.value = value.fb_instance_id;
+        }
+        else
+        {
+            result.type = FABridge.TYPE_ANONYMOUS;
+            result.value = value;
+        }
+
+        return result;
+    },
+
+    //on deserialization we always check the return for the specific error code that is used to marshall NPE's into JS errors
+    // the unpacking is done by returning the value on each pachet for objects/arrays 
+    deserialize: function(packedValue)
+    {
+
+        var result;
+
+        var t = typeof(packedValue);
+        if (t == "number" || t == "string" || t == "boolean" || packedValue == null || packedValue == undefined)
+        {
+            result = this.handleError(packedValue);
+        }
+        else if (packedValue instanceof Array)
+        {
+            result = [];
+            for (var i = 0; i < packedValue.length; i++)
+            {
+                result[i] = this.deserialize(packedValue[i]);
+            }
+        }
+        else if (t == "object")
+        {
+            for(var i = 0; i < packedValue.newTypes.length; i++)
+            {
+                this.addTypeDataToCache(packedValue.newTypes[i]);
+            }
+            for (var aRefID in packedValue.newRefs)
+            {
+                this.createProxy(aRefID, packedValue.newRefs[aRefID]);
+            }
+            if (packedValue.type == FABridge.TYPE_PRIMITIVE)
+            {
+                result = packedValue.value;
+            }
+            else if (packedValue.type == FABridge.TYPE_ASFUNCTION)
+            {
+                result = this.getFunctionProxy(packedValue.value);
+            }
+            else if (packedValue.type == FABridge.TYPE_ASINSTANCE)
+            {
+                result = this.getProxy(packedValue.value);
+            }
+            else if (packedValue.type == FABridge.TYPE_ANONYMOUS)
+            {
+                result = packedValue.value;
+            }
+        }
+        return result;
+    },
+    //increases the reference count for the given object
+    addRef: function(obj)
+    {
+        this.target.incRef(obj.fb_instance_id);
+    },
+    //decrease the reference count for the given object and release it if needed
+    release:function(obj)
+    {
+        this.target.releaseRef(obj.fb_instance_id);
+    },
+
+    // check the given value for the components of the hard-coded error code : __FLASHERROR
+    // used to marshall NPE's into flash
+    
+    handleError: function(value)
+    {
+        if (typeof(value)=="string" && value.indexOf("__FLASHERROR")==0)
+        {
+            var myErrorMessage = value.split("||");
+            if(FABridge.refCount > 0 )
+            {
+                FABridge.refCount--;
+            }
+            throw new Error(myErrorMessage[1]);
+            return value;
+        }
+        else
+        {
+            return value;
+        }   
+    }
+};
+
+// The root ASProxy class that facades a flash object
+
+ASProxy = function(bridge, typeName)
+{
+    this.bridge = bridge;
+    this.typeName = typeName;
+    return this;
+};
+//methods available on each ASProxy object
+ASProxy.prototype =
+{
+    get: function(propName)
+    {
+        return this.bridge.deserialize(this.bridge.getPropertyFromAS(this.fb_instance_id, propName));
+    },
+
+    set: function(propName, value)
+    {
+        this.bridge.setPropertyInAS(this.fb_instance_id, propName, value);
+    },
+
+    call: function(funcName, args)
+    {
+        this.bridge.callASMethod(this.fb_instance_id, funcName, args);
+    }, 
+    
+    addRef: function() {
+        this.bridge.addRef(this);
+    }, 
+    
+    release: function() {
+        this.bridge.release(this);
+    }
+};