rocket-js 0.0.1 → 0.0.2

data/.gitignore

@@ -1,24 +1,13 @@
-## MAC OS
 .DS_Store
-
-## TEXTMATE
 *.tmproj
 tmtags
-
-## EMACS
 *~
 \#*
 .\#*
-
-## VIM
 *.swp
-
-## PROJECT::GENERAL
 coverage
 rdoc
 pkg
-
-## PROJECT::SPECIFIC
 *.rdb
 test/public/testing
 config/config.yml

data/Rakefile

@@ -1,45 +1,49 @@
 # -*- ruby -*-
-
 $:.unshift(File.expand_path('../lib', __FILE__))
 $:.unshift(File.expand_path('../../rocket/lib/', __FILE__))
-
 require 'rspec/core/rake_task'
 require 'rake/rdoctask'
-require 'rocket/js/version'
+require 'rocket/version'
 
-SUMMARY = %Q{JavaScript client library for Rocket server.}
-DESCRIPTION = %Q{
-This library is client that allows JavaScript clients to connect to the 
-Rocket web socket server.
-}
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/ruby/**/*_spec.rb'
+  t.rspec_opts = %q[-I../rocket-core/lib -I../rocket/lib -Ilib -c -b]
+end
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |g|
-    g.version = Rocket::JS.version
-    g.name = "rocket-js"
-    g.email = "chris@nu7hat.ch"
-    g.homepage = "http://github.com/araneo/rocket"
-    g.authors = ["Araneo", "Chris Kowalik"]
-    g.summary = SUMMARY
-    g.description = DESCRIPTION
-    #g.add_dependency "rocket", "0.0.1"
-    g.add_dependency "json", "~> 1.4"
-    g.add_dependency "yui-compressor", "~> 0.9"
-    g.add_development_dependency "rspec", "~> 2.0"
-    g.add_development_dependency "mocha", "~> 0.9"
-    g.add_development_dependency "jasmine", "~> 1.0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue
-  puts 'Jeweler is not available here'
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rspec_opts = %q[-I../rocket-core/lib -I../rocket/lib -Ilib -c -b]
+  t.rcov_opts = %q[-I../rocket-core/lib -I../rocket/lib -Ilib -T -x "spec"]
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.title = "Rocket JavaScript Tools #{Rocket.version}"
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Build current version as a rubygem"
+task :build do
+  sh "gem build rocket-js.gemspec"
+  sh "mkdir -p pkg"
+  sh "mv rocket-js-*.gem pkg/"
+end
+
+desc "Relase current version to rubygems.org"
+task :release => :build do
+  sh "gem push pkg/rocket-js-#{Rocket.version}.gem"
+end
+
+desc "Perform installation via rubygems"
+task :install => :build do
+  sh "gem install pkg/rocket-js-#{Rocket.version}.gem"
 end
 
 namespace :js do
   desc 'Bundle and minify source files.'
   task :build do
     require 'rocket-js'
-    require 'rocket/js/builder'
     Rocket::JS::Builder.new(File.dirname(__FILE__), true).generate_script
   end
 
@@ -49,22 +53,4 @@ namespace :js do
   end
 end
 
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = 'spec/ruby/**/*_spec.rb'
-  t.rspec_opts = %q[-Ilib -c -b]
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |t|
-  t.rcov = true
-  t.rspec_opts = %q[-Ilib -c -b]
-  t.rcov_opts = %q[-Ilib -T -x "spec"]
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc.title = "Rocket JavaScript Tools #{Rocket::JS.version}"
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 task :default => :spec

data/lib/rocket/js.rb

@@ -4,5 +4,3 @@ module Rocket
     autoload :CLI,     'rocket/js/cli'
   end # JS
 end # Rocket
-
-require 'rocket/js/version'

data/lib/rocket/js/builder.rb

@@ -59,11 +59,11 @@ module Rocket
       end
       
       def save_script(source)
-        scriptname = "rocket-#{Rocket::JS.version}#{'.min' if minified}.js"
+        scriptname = "rocket-#{Rocket.version}#{'.min' if minified}.js"
         File.open(File.expand_path(scriptname, dest), 'w+') {|f|
           contents = CONTENTS.map {|content|
             File.read(File.expand_path("../../../../src/#{content}", __FILE__))
-          }.join("\n\n").sub(/<%= VERSION %>/, Rocket::JS.version)
+          }.join("\n\n").sub(/<%= VERSION %>/, Rocket.version)
 
           f.write(contents)
           f.write("\n\n")

data/lib/rocket/js/cli.rb

@@ -6,7 +6,7 @@ module Rocket
       
       desc "Show version of used javascript library"
       def version
-        puts "Rocket javascript library v#{Rocket::JS.version}"
+        puts "Rocket javascript library v#{Rocket.version}"
       end
       
       desc "Generate Rocket's javascript toolkit in given directory"

data/rocket-js.gemspec

@@ -1,84 +1,27 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+# -*- ruby -*-
+$:.unshift(File.expand_path('../lib', __FILE__))
+$:.unshift(File.expand_path('../../rocket/lib', __FILE__))
+require 'rocket/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{rocket-js}
-  s.version = "0.0.1"
+  s.name               = 'rocket-js'
+  s.version            = Rocket.version
+  s.homepage           = 'http://github.com/araneo/rocket'
+  s.email              = ['chris@nu7hat.ch']
+  s.authors            = ['Araneo Ltd.', 'Chris Kowalik']
+  s.summary            = %q{JavaScript client library for Rocket server.}
+  s.description        = %q{This library is client that allows JavaScript clients to connect to the Rocket web socket server.}
+  s.files              = `git ls-files`.split("\n") + Dir["src/vendor/web-socket-js/**/*"]
+  s.test_files         = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths      = %w[lib]
+  s.extra_rdoc_files   = %w[LICENSE README.md]
+  s.executables        = %w[rocket-js]
+  s.default_executable = 'rocket-js'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Araneo", "Chris Kowalik"]
-  s.date = %q{2010-11-03}
-  s.description = %q{
-This library is client that allows JavaScript clients to connect to the 
-Rocket web socket server.
-}
-  s.email = %q{chris@nu7hat.ch}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    ".gitignore",
-     "LICENSE",
-     "README.md",
-     "Rakefile",
-     "bin/rocket-js",
-     "lib/rocket-js.rb",
-     "lib/rocket/js.rb",
-     "lib/rocket/js/builder.rb",
-     "lib/rocket/js/cli.rb",
-     "lib/rocket/js/version.rb",
-     "rocket-0.0.1.min.js",
-     "rocket-js.gemspec",
-     "spec/js/app.rb",
-     "spec/js/public/WebSocketMain.swf",
-     "spec/js/public/favicon.ico",
-     "spec/js/public/jquery-1.4.2.min.js",
-     "spec/js/public/qunit.css",
-     "spec/js/public/qunit.js",
-     "spec/js/public/test.js",
-     "spec/js/public/testing/WebSocketMain.swf",
-     "spec/js/public/testing/WebSocketMainInsecure.zip",
-     "spec/js/public/testing/rocket-0.0.1.js",
-     "spec/js/views/index.erb",
-     "spec/ruby/spec_helper.rb",
-     "src/rocket.channels.js",
-     "src/rocket.core.js",
-     "src/rocket.defaults.js",
-     "src/rocket.license.js",
-     "src/vendor/json/json2.js"
-  ]
-  s.homepage = %q{http://github.com/araneo/rocket}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{JavaScript client library for Rocket server.}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<json>, ["~> 1.4"])
-      s.add_runtime_dependency(%q<yui-compressor>, ["~> 0.9"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.0"])
-      s.add_development_dependency(%q<mocha>, ["~> 0.9"])
-      s.add_development_dependency(%q<jasmine>, ["~> 1.0"])
-    else
-      s.add_dependency(%q<json>, ["~> 1.4"])
-      s.add_dependency(%q<yui-compressor>, ["~> 0.9"])
-      s.add_dependency(%q<rspec>, ["~> 2.0"])
-      s.add_dependency(%q<mocha>, ["~> 0.9"])
-      s.add_dependency(%q<jasmine>, ["~> 1.0"])
-    end
-  else
-    s.add_dependency(%q<json>, ["~> 1.4"])
-    s.add_dependency(%q<yui-compressor>, ["~> 0.9"])
-    s.add_dependency(%q<rspec>, ["~> 2.0"])
-    s.add_dependency(%q<mocha>, ["~> 0.9"])
-    s.add_dependency(%q<jasmine>, ["~> 1.0"])
-  end
+  s.add_runtime_dependency     'rocket-core',    [Rocket.version]
+  s.add_runtime_dependency     'json',           ['>= 1.4']
+  s.add_runtime_dependency     'yui-compressor', ['~> 0.9'] 
+  s.add_development_dependency 'rspec',          ["~> 2.0"]
+  s.add_development_dependency 'mocha',          [">= 0.9"]
+  s.add_development_dependency 'jasmine',        ["~> 1.0"]
 end
-

data/src/vendor/web-socket-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)
+    {
+        var 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);
+    }
+};