RubyGems - nyny - Versions diffs - 1.0.0.pre1 - Mend

nyny 1.0.0.pre1

Files changed (49) hide show

checksums.yaml +7 -0
data/.gitignore +17 -0
data/.rspec +2 -0
data/.ruby-gemset +1 -0
data/.ruby-version +1 -0
data/Gemfile +5 -0
data/LICENSE.txt +22 -0
data/Performance.md +65 -0
data/README.md +167 -0
data/Rakefile +1 -0
data/benchmarks/filters/frankie.rb +18 -0
data/benchmarks/filters/sinatra.rb +17 -0
data/benchmarks/helpers/frankie.rb +19 -0
data/benchmarks/helpers/sinatra.rb +18 -0
data/benchmarks/simple/frankie.rb +10 -0
data/benchmarks/simple/sinatra.rb +9 -0
data/benchmarks/url_pattern/frankie.rb +10 -0
data/benchmarks/url_pattern/sinatra.rb +8 -0
data/examples/active_record/.gitignore +1 -0
data/examples/active_record/Gemfile +14 -0
data/examples/active_record/Rakefile +51 -0
data/examples/active_record/config/database.yml +0 -0
data/examples/active_record/database.rb +12 -0
data/examples/active_record/db/migrate/20130606133756_add_shouts.rb +12 -0
data/examples/active_record/models/shout.rb +3 -0
data/examples/active_record/server.rb +43 -0
data/examples/json_api.rb +21 -0
data/examples/templates/server.rb +27 -0
data/examples/templates/views/index.haml +1 -0
data/examples/web_sockets/public/FABridge.js +604 -0
data/examples/web_sockets/public/WebSocketMain.swf +0 -0
data/examples/web_sockets/public/index.html +76 -0
data/examples/web_sockets/public/swfobject.js +4 -0
data/examples/web_sockets/public/web_socket.js +388 -0
data/examples/web_sockets/server.rb +60 -0
data/lib/nyny.rb +9 -0
data/lib/nyny/app.rb +66 -0
data/lib/nyny/class_level_api.rb +40 -0
data/lib/nyny/primitives.rb +25 -0
data/lib/nyny/request_scope.rb +60 -0
data/lib/nyny/route_signature.rb +44 -0
data/lib/nyny/version.rb +3 -0
data/nyny.gemspec +24 -0
data/spec/app_spec.rb +144 -0
data/spec/class_level_api_spec.rb +39 -0
data/spec/primitives_spec.rb +26 -0
data/spec/request_scope_spec.rb +71 -0
data/spec/spec_helper.rb +42 -0
metadata +138 -0

data/examples/active_record/Rakefile ADDED Viewed

@@ -0,0 +1,51 @@
+require 'yaml'
+require 'logger'
+MIGRATIONS_DIR = 'db/migrate'
+namespace :db do
+  task :env do
+    ENV['RACK_ENV'] ||= 'development'
+    DATABASE_ENV = ENV['RACK_ENV']
+    require_relative 'database'
+  end
+  task :migrate => :env do
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migrator.migrate MIGRATIONS_DIR, ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+  end
+  task :rollback => :env do
+    init_connection
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.rollback MIGRATIONS_DIR, step
+  end
+  task :version => :env do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+  task :create_migration do
+    name = ENV['NAME']
+    abort("no NAME specified. use `rake db:create_migration NAME=create_users`") if !name
+    migrations_dir = File.join("db", "migrate")
+    version = ENV["VERSION"] || Time.now.utc.strftime("%Y%m%d%H%M%S")
+    filename = "#{version}_#{name}.rb"
+    migration_name = name.gsub(/_(.)/) { $1.upcase }.gsub(/^(.)/) { $1.upcase }
+    FileUtils.mkdir_p(migrations_dir)
+    open(File.join(migrations_dir, filename), 'w') do |f|
+      f << (<<-EOS).gsub("      ", "")
+      class #{migration_name} < ActiveRecord::Migration
+        def self.up
+        end
+        def self.down
+        end
+      end
+      EOS
+    end
+  end
+end

data/examples/active_record/config/database.yml ADDED Viewed

File without changes

data/examples/active_record/database.rb ADDED Viewed

@@ -0,0 +1,12 @@
+require 'active_record'
+ENV['RACK_ENV'] ||= 'development'
+def sqlite_db name
+  File.join(File.dirname(__FILE__), "./db/#{name}.sqlite3")
+end
+ActiveRecord::Base.establish_connection(
+    :adapter => "sqlite3",
+    :database  => sqlite_db(ENV['RACK_ENV'].to_sym)
+)

data/examples/active_record/db/migrate/20130606133756_add_shouts.rb ADDED Viewed

@@ -0,0 +1,12 @@
+class AddShouts < ActiveRecord::Migration
+  def self.up
+    create_table :shouts do |t|
+      t.string :body
+      t.timestamps
+    end
+  end
+  def self.down
+    drop_table :shouts
+  end
+end

data/examples/active_record/models/shout.rb ADDED Viewed

@@ -0,0 +1,3 @@
+class Shout < ActiveRecord::Base
+  attr_accessible :body
+end

data/examples/active_record/server.rb ADDED Viewed

@@ -0,0 +1,43 @@
+#!ruby -I ../../lib -I lib
+ENV['RACK_ENV'] ||= 'development'
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, ENV['RACK_ENV'].to_sym)
+require 'frankie'
+require_relative 'database'
+#Require all models
+Dir[File.dirname(__FILE__) + "/models/*.rb"].each {|file| require file }
+TEMPLATE = DATA.read.freeze
+class App < Frankie::App
+  get '/' do
+    shouts = Shout.all.reverse
+    ERB.new(TEMPLATE).result(binding)
+  end
+  post '/shouts' do
+    Shout.create :body => params[:body]
+    redirect_to '/'
+  end
+end
+App.run! 9000
+__END__
+<html>
+<body>
+  <form action="/shouts" method="post">
+    <input type="text" name="body"></input>
+    <input type="submit" value="SHOUT"></input>
+  </form>
+  <ul>
+    <% shouts.each do |shout| %>
+      <li><%= shout.body %>
+    <% end %>
+  </ul>
+</body>
+</html>

data/examples/json_api.rb ADDED Viewed

@@ -0,0 +1,21 @@
+#!ruby -I ../lib -I lib
+require 'frankie'
+require 'json'
+#
+# Every response of this app will be automatically converted to json
+#
+class App < Frankie::App
+  before { headers 'Content-Type' => 'application/json' }
+  after do
+    body = response.raw_body
+    response.body = body.to_json if body.respond_to? :to_json
+  end
+  get '/' do
+    {:some => [:json, :mate!]}
+  end
+end
+App.run! 9000

data/examples/templates/server.rb ADDED Viewed

@@ -0,0 +1,27 @@
+#!ruby -I ../lib -I lib
+require 'frankie'
+require 'sinatra'
+require 'ostruct'
+module Views
+  include ::Sinatra::Templates
+  def settings
+    @settings ||= OpenStruct.new :templates => {}
+  end
+  def template_cache
+    @template_cache = Tilt::Cache.new
+  end
+end
+class App < Frankie::App
+  helpers Views
+  get '/' do
+    haml :index
+  end
+end
+App.run!

data/examples/templates/views/index.haml ADDED Viewed

	@@ -0,0 +1 @@
1	+ %h1 Dat HAML!

data/examples/web_sockets/public/FABridge.js ADDED Viewed

@@ -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);
+    }
+};