package loom.template
{
  public class BaseClass
  {    
    public function BaseClass(constructorArg1 : String, constructorArg2 : String)
    {
      trace("BaseClass::constructor()");
    }
 
    public function methodCallOne(arg1 : String, arg2 : Number) : int
    {
      trace("BaseClass::methodCallOne()");
      return 100;
    }
 
    public function methodCallTwo(arg1 : String, arg2 : Number, arg3 : Object) : void
    {
      trace("BaseClass::methodCallTwo()");
    } 
 
    public function methodCallThree(arg1 : String, arg2 : Number) : String
    {
      trace("BaseClass::methodCallThree()");
      return "stringValue";
    }
  }
}

package loom.util
{
  import flash.events.Event;
  import flash.utils.describeType;
  import flash.utils.getDefinitionByName;
 
  import loom.TestConstants;
  import loom.abc.AbcFile;
  import loom.loom_namespace;
  import loom.swf.AbcClassLoader;
  import loom.template.BaseClass;
  import loom.template.MethodInvocation;
 
  import net.digitalprimates.fluint.tests.TestCase;
 
  public class DynamicProxyFactoryTest extends TestCase
  {
    public function testCreateProxy() : void
    {
      var fixture : DynamicProxyFactory = new DynamicProxyFactory();
      var proxyFile : AbcFile = new AbcDeserializer(TestConstants.getBaseClassTemplate()).deserialize();
 
      // We enhance the loaded ABC file to save the work the compiler already did, and just add to/replace it
      fixture.createProxy(proxyFile);
 
      var classLoader : AbcClassLoader = new AbcClassLoader();
      classLoader.addEventListener(
        Event.COMPLETE,
        function (event : Event) : void
        {
          var classRef : * = getDefinitionByName("loom.template::DynamicSubClass");
          trace(describeType(classRef));
 
          // This would blow up if the types are not compatible
          var instance : BaseClass = new classRef(null, null);
          assertTrue(instance is BaseClass); // redundant, yet satisfying :)
 
          // Run original method invocation
          trace(">>> Original method invocation");
          trace(instance.methodCallOne("Hello Original Method Invocation!", -1));
 
          // Set up a handler
          instance.loom_namespace::setHandler(
            "methodCallOne",
            function (invocation : MethodInvocation) : *
            {
              trace("Before advice for: " + invocation);
 
              try
              {
                return invocation.proceed();
              }
              catch (e : Error)
              {
                trace("Throws advice for: " + e);
              }
              finally
              {
                trace("After advice for: " + invocation);
              }
            }
          );
          trace(">>> AOP method invocation");
          trace(instance.methodCallOne("Hello Dynamic Method Invocation!", 1234));
        }
      );
 
      // Load in the proxied class definition
      classLoader.loadClassDefinitionsFromBytecode([
       new AbcSerializer().serializeAbcFile(proxyFile)
      ]);
    }
  }
}

<type name="loom.template::DynamicSubClass" base="Class" isDynamic="true" isFinal="true" isStatic="true">
  <extendsClass type="Class"/>
  <extendsClass type="Object"/>
  <accessor name="prototype" access="readonly" type="*" declaredBy="Class"/>
  <factory type="loom.template::DynamicSubClass">
    <extendsClass type="loom.template::BaseClass"/>
    <extendsClass type="Object"/>
    <constructor>
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="String" optional="false"/>
    </constructor>
    <method name="methodCallThree" declaredBy="loom.template::DynamicSubClass" returnType="String">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Number" optional="false"/>
    </method>
    <variable name="handlerMappings" type="flash.utils::Dictionary" uri="http://loom.ninjitsoft.com"/>
    <method name="setHandler" declaredBy="loom.template::DynamicSubClass" returnType="void" uri="http://loom.ninjitsoft.com">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Function" optional="false"/>
    </method>
    <method name="methodCallOne" declaredBy="loom.template::DynamicSubClass" returnType="int">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Number" optional="false"/>
    </method>
    <method name="methodCallTwo" declaredBy="loom.template::DynamicSubClass" returnType="void">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Number" optional="false"/>
      <parameter index="3" type="Object" optional="false"/>
    </method>
    <method name="proxyInvocation" declaredBy="loom.template::DynamicSubClass" returnType="*" uri="http://loom.ninjitsoft.com">
      <parameter index="1" type="loom.template::MethodInvocation" optional="false"/>
    </method>
  </factory>
</type>
BaseClass::constructor()
>>> Original method invocation
BaseClass::methodCallOne()
100
>>> AOP method invocation
Before advice for: methodCallOne(Hello Dynamic Method Invocation!, 1234)
BaseClass::methodCallOne()
After advice for: methodCallOne(Hello Dynamic Method Invocation!, 1234)
100