Code Cookbook

hexMVC

MVC implementation for writing individual modules with the classical Model-View-Controller structural pattern. Lightweight experimental MVP is provided as well.

Module example with service locator

private class MModule extends Module
{
    public function new( serviceLocator : IStatefulConfig )
    {
        super();
        this._addStatefulConfigs( [serviceLocator] );
        this._addStatelessConfigClasses( [MStatelessCommandConfig, MStatelessModelConfig] );
    }
    
    override private function _getRuntimeDependencies() : IRuntimeDependencies
    {
        var rt = new RuntimeDependencies();
        rt.addServiceDependencies( [IGitService] );
        return rt;
    }
    
    override public function _onInitialisation() : Void 
    {
        this._dispatchPrivateMessage( MessageTypeList.TEST, new Request( [new ExecutionPayload( something, ISomething )] ) );
    }
}

Model config

private class MStatelessModelConfig extends StatelessModelConfig
{
    override public function configure() : Void 
    {
        this.mapModel( IMModel, MModel  );
    }
}

Stateful command config

private class MStatefulCommandConfig extends StatefulCommandConfig
{
    public function new()
    {
        super();
    }
    
    override public function configure( injector : IDependencyInjector ) : Void
    {
        super.configure( injector );
        this.map( MessageTypeList.TEST, TestCommand ).once().withGuards( MyGuardClass ).withCompleteHandlers([ function( e : AsyncCommandEvent ){ trace( e ); } ]);
    }
}

Asynchronous command example with injections

private class TestCommand extends AsyncCommand implements IHTTPServiceListener<GitServiceConfiguration> implements IInjectorContainer
{
    @Inject
    public var model : IMModel;
    
    @Inject
    public var service : IGitService;
    
    override public function execute( ?request : Request ) : Void
    {
        this.service.addHTTPServiceListener( this );
        this.service.call();
    }
    
    public function onServiceTimeout( service : IHTTPService<GitServiceConfiguration> ) : Void 
    {
        this._handleFail();
    }
    
    public function onServiceComplete( service : IHTTPService<GitServiceConfiguration> ) : Void 
    {
        this.model.setValue( service.getResult() );
        this._handleComplete();
    }
    
    public function onServiceFail( service : IHTTPService<GitServiceConfiguration> ) : Void 
    {
        this._handleFail();
    }
    
    public function onServiceCancel( service : IHTTPService<GitServiceConfiguration> ) : Void 
    {
        this._handleCancel();
    }
}

hexIoC

Inversion of Control system to make multi-modular applications. You can have an extremely powerful DSL layer (Domain Specific Language), where you can connect togethet any modules, components and describe any dependency, behavior between them.

Parsing DSL at compile-time

var applicationAssembler = XmlCompiler.readXmlFile( "example.xml" );

Parsing DSL at runtime

var applicationAssembler = XmlReader.readXmlFile( "example.xml" );

Simple example

<root name="applicationContext">
    <test id="s" value="hello"/>
</root>

Building dynamic object

<root name="applicationContext">
    <test id="obj" type="Object">
        <property name="name" value="Francis"/>
        <property name="age" type="Int" value="44"/>
        <property name="height" type="Float" value="1.75"/>
        <property name="isWorking" type="Bool" value="true"/>
    </test>
</root>

Passing arguments to constructor

<root name="applicationContext">
    <bean id="size" type="hex.structures.Size">
        <argument type="Int" value="10"/>
        <argument type="Int" value="20"/>
    </bean>
</root>

Injection by using references

<root name="applicationContext">
    <rectangle id="rect" type="hex.ioc.parser.xml.mock.MockRectangle">
        <argument ref="rectPosition.x"/>
        <argument ref="rectPosition.y"/>
        <property name="size" ref="rectSize" />
    </rectangle>
    
    <size id="rectSize" type="hex.structures.Point">
        <argument type="Int" value="30"/>
        <argument type="Int" value="40"/>
    </size>
    
    <position id="rectPosition" type="hex.structures.Point">
        <property type="Int" name="x" value="10"/>
        <property type="Int" name="y" value="20"/>
    </position>
</root>

Injection and method call

<root name="applicationContext">
    <rectangle id="rect" type="hex.ioc.parser.xml.mock.MockRectangle">
        <property name="size" ref="rectSize" />
        <method-call name="offsetPoint">
            <argument ref="rectPosition"/>
        </method-call></rectangle>
    
    <size id="rectSize" type="hex.structures.Point">
        <argument type="Int" value="30"/>
        <argument type="Int" value="40"/>
    </size>
    
    <position id="rectPosition" type="hex.structures.Point">
        <property type="Int" name="x" value="10"/>
        <property type="Int" name="y" value="20"/>
    </position>
    
    <rectangle id="anotherRect" type="hex.ioc.parser.xml.mock.MockRectangle">
        <property name="size" ref="rectSize" />
        <method-call name="reset"/>
    </rectangle>
</root>

Singleton instantiation

<root name="applicationContext">
    <gateway id="gateway" value="http://localhost/amfphp/gateway.php"/>
    
    <service id="service" type="hex.ioc.parser.xml.mock.MockServiceProvider" singleton-access="getInstance">
        <method-call name="setGateway">
            <argument ref="gateway" />
        </method-call>
    </service>
</root>

Factory instantiation

<root name="applicationContext">
    <rectangle id="rect" type="hex.ioc.parser.xml.mock.MockRectangleFactory" factory="getRectangle">
        <argument type="Int" value="10"/><argument type="Int" value="20"/>
        <argument type="Int" value="30"/><argument type="Int" value="40"/>
    </rectangle>
</root>

Factory instantiation using singleton

<root name="applicationContext">
    <point id="point" type="hex.ioc.parser.xml.mock.MockPointFactory" singleton-access="getInstance" factory="getPoint">
        <argument type="Int" value="10"/>
        <argument type="Int" value="20"/>
    </point>
</root>

XML type parsed

<root name="applicationContext">
    <data id="fruits" type="XML" parser-class="hex.ioc.parser.xml.mock.MockXMLParser">
        <root>
            <node>orange</node>
            <node>apple</node>
            <node>banana</node>
        </root>
    </data>
</root>

Array containing references

<root name="applicationContext">
    <collection id="fruits" type="Array">
        <argument ref="fruit0" />
        <argument ref="fruit1" />
        <argument ref="fruit2" />
    </collection>
    
    <fruit id="fruit0" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="orange"/></fruit>
    <fruit id="fruit1" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="apple"/></fruit>
    <fruit id="fruit2" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="banana"/></fruit>
</root>

Building an HashMap

<root name="applicationContext">
    <collection id="fruits" type="hex.core.HashMap">
        <item> <key value="0"/> <value ref="fruit0"/></item>
        <item> <key type="Int" value="1"/> <value ref="fruit1"/></item>
        <item> <key ref="stubKey"/> <value ref="fruit2"/></item>
    </collection>
    
    <fruit id="fruit0" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="orange"/></fruit>
    <fruit id="fruit1" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="apple"/></fruit>
    <fruit id="fruit2" type="hex.ioc.parser.xml.mock.MockFruitVO"><argument value="banana"/></fruit>
    
    <point id="stubKey" type="hex.structures.Point"/>
</root>

Module listening another module

<root name="applicationContext">
    <chat id="chat" type="hex.ioc.parser.xml.mock.MockChatModule">
        <listen ref="translation"/>
    </chat>
    
    <translation id="translation" type="hex.ioc.parser.xml.mock.MockTranslationModule">
        <listen ref="chat">
            <event static-ref="hex.ioc.parser.xml.mock.MockChatModule.TEXT_INPUT" method="onSomethingToTranslate"/>
        </listen>
    </translation>
</root>

Module listening another module with adapter strategy

<root name="applicationContext">
    <chat id="chat" type="hex.ioc.parser.xml.mock.MockChatModule">
        <listen ref="translation"/>
    </chat>
    
    <translation id="translation" type="hex.ioc.parser.xml.mock.MockTranslationModule">
        <listen ref="chat">
            <event static-ref="hex.ioc.parser.xml.mock.MockChatModule.TEXT_INPUT" method="onTranslateWithTime" strategy="hex.ioc.parser.xml.mock.MockChatAdapterStrategy"/>
        </listen>
    </translation>
</root>

Class reference

<root name="applicationContext">
    <RectangleClass id="RectangleClass" type="Class" value="hex.ioc.parser.xml.mock.MockRectangle"/>
    
    <test id="classContainer" type="Object">
        <property name="AnotherRectangleClass" ref="RectangleClass"/>
    </test>
</root>

Building a service locator

<root name="applicationContext">
    <serviceLocator id="serviceLocator" type="hex.config.stateful.ServiceLocator">
        <item> <key type="Class" value="hex.ioc.parser.xml.mock.IMockFacebookService"/> <value ref="facebookService"/></item>
    </serviceLocator>
</root>

Building a mapping configuration with mapped service classes

<root name="applicationContext">
    <config id="config" type="hex.ioc.di.MappingConfiguration">
        <item map-name="amazon0"> <key type="Class" value="hex.ioc.parser.xml.mock.IMockAmazonService"/> <value type="Class" value="hex.ioc.parser.xml.mock.MockAmazonService"/></item>
        <item map-name="amazon1"> <key type="Class" value="hex.ioc.parser.xml.mock.IMockAmazonService"/> <value type="Class" value="hex.ioc.parser.xml.mock.AnotherMockAmazonService"/></item>
    </config>
</root>

Module listening a service

<root name="applicationContext">
    <service id="myService" type="hex.ioc.parser.xml.mock.MockStubStatefulService"/>
    
    <module id="myModule" type="hex.ioc.parser.xml.mock.MockModuleWithServiceCallback">
        <listen ref="myService">
            <event static-ref="hex.ioc.parser.xml.mock.MockStubStatefulService.BOOLEAN_VO_UPDATE" method="onBooleanServiceCallback"/>
        </listen>
    </module>
</root>

State machine configuration

<root name="applicationContext">
    <initialState id="initialState" static-ref="hex.ioc.parser.xml.state.mock.MockStateEnum.INITIAL_STATE">
        <method-call name="addTransition">
            <argument static-ref="hex.ioc.parser.xml.state.mock.MockStateMessage.TRIGGER_NEXT_STATE"/>
            <argument static-ref="hex.ioc.parser.xml.state.mock.MockStateEnum.NEXT_STATE"/>
        </method-call>
        
        <method-call name="addExitCommand">
            <argument type="Class" value="hex.ioc.parser.xml.state.mock.MockExitStateCommand"/>
            <argument ref="myModule"/>
        </method-call>
        
    </initialState>
    
    <stateConfig id="stateConfig" type="hex.state.config.stateful.StatefulStateMachineConfig">
        <argument ref="initialState"/>
    </stateConfig>
    
    <module id="myModule" type="hex.ioc.parser.xml.state.mock.MockModuleWorkingWithStates">
        <argument ref="stateConfig"/>
    </module>
</root>

Module listening service with adapter strategy and module injections

<root name="applicationContext">
    <service id="myService" type="hex.ioc.parser.xml.mock.MockStubStatefulService"/>
    
    <module id="myModule" type="hex.ioc.parser.xml.mock.MockModuleWithServiceCallback">
        <listen ref="myService">
            <event static-ref="hex.ioc.parser.xml.mock.MockStubStatefulService.INT_VO_UPDATE"
                   method="onFloatServiceCallback"
                   strategy="hex.ioc.parser.xml.mock.MockIntDividerEventAdapterStrategy"
                   injectedInModule="true"/>
        </listen>
    </module>
</root>

Redefining application context class

<root name="applicationContext" type="hex.ioc.parser.xml.context.mock.MockApplicationContext">
    <test id="test" value="Hola Mundo"/>
</root>

Listening application context states changes

<root name="applicationContext">
    <state id="assemblingStart" ref="applicationContext.state.ASSEMBLING_START">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommand"/>
    </state>
    
    <state id="objectsBuilt" ref="applicationContext.state.OBJECTS_BUILT">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommandWithModule" fire-once="true" context-owner="module"/>
    </state>
    
    <state id="domainListenersAssigned" ref="applicationContext.state.DOMAIN_LISTENERS_ASSIGNED">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommand"/>
    </state>
    
    <state id="methodsCalled" ref="applicationContext.state.METHODS_CALLED">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommand"/>
    </state>
    
    <state id="modulesInitialized" ref="applicationContext.state.MODULES_INITIALIZED">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommand"/>
    </state>
    
    <state id="assemblingEnd" ref="applicationContext.state.ASSEMBLING_END">
        <enter command-class="hex.ioc.parser.xml.assembler.mock.MockStateCommandWithModule" fire-once="true" context-owner="anotherModule"/>
    </state>
    
    <module id="module" type="hex.ioc.parser.xml.assembler.mock.MockModule" map-type="hex.module.IModule"/>
    <module id="anotherModule" type="hex.ioc.parser.xml.assembler.mock.MockModule" map-type="hex.module.IModule"/>
</root>

Conditional parsing

<root name="applicationContext">
    <msg id="message" value="hello debug" if="debug,release"/>
    <msg id="message" value="hello production" if="production"/>
</root>

applicationAssembler.addConditionalProperty ( ["production" => true, "debug" => false, "release" => false] );

Preprocessing

<root ${context}>
    ${node}
</root>

var preprocessor = new Preprocessor();
preprocessor.addProperty( "hello", "bonjour" );
preprocessor.addProperty( "contextName", 'applicationContext' );
preprocessor.addProperty( "context", 'name="$${contextName}"' );
preprocessor.addProperty( "node", '<msg id="message" value="$${hello}"/>' );

var preprocessor = new Preprocessor();
preprocessor.addProperty( "hello", "bonjour" );
preprocessor.addProperty( "contextName", 'applicationContext' );
preprocessor.addProperty( "context", 'name="$${contextName}"' );
preprocessor.addProperty( "node", '<msg id="message" value="$${hello}"/>' );

Include

<?xml version="1.0" encoding="utf-8" ?>
<root name="applicationContext">
    <include file="../bin/otherContext.xml"/>
    <include file="lib/anotherContext.xml"/>
</root>

Read xml at compile time with preprocessing

var assembler = XmlCompiler.readXmlFile( "../context/preprocessor.xml", 
[   
    "hello"         => "bonjour",
    "contextName"   => 'applicationContext',
    "context"       => 'name="${contextName}"',
    "node"          => '<msg id="message" value="${hello}"/>' 
] );

hexDSL

DSL toolkit

hexInject

Powerful and easy-to-use Dependency Injection system based on @annotations. It supports property, method and constructor injections predefined in injector mappings.

Simple example

var injector = new Injector;

//create a basic mapping:
injector.map( Model ).toType( Model );

//map to another class:
injector.map( Model ).toType( BetterModel );

//map an interface to a value:
injector.map( IEventDispatcher ).toValue( new EventDispatcher() );

//map an interface to a singleton:
injector.map( IEventDispatcher ).toSingleton( EventDispatcher );

Properties injection

class MockClass implements IInjectorContainer
{
    @Inject
    public var property1 : Interface;
    
    @Inject( "name" )
    public var property2 : Interface;
    
    public function new()
    {
        
    }
}

Constructor injections with one named and optional

class MockClass implements IInjectorContainer
{
    var m_dependency    : IModel;
    var m_dependency2   : String;
    
    @Inject( null, "name" )
    @Optional( false, true )
    public function new( dependency : IModel, dependency2 : String = "hello world" )
    {
        this.m_dependency   = dependency;
        this.m_dependency2  = dependency2;
    }
}

Method injections with named dependencies

class MockClass implements IInjectorContainer
{
    var m_dependency    : IModel;
    var m_dependency2   : String;
    
    public function new()
    {
        
    }
    
    @Inject( "name1", "name2" ) : Void
    public function setDependencies( dependency : IModel, dependency2 : String )
    {
        this.m_dependency   = dependency;
        this.m_dependency2  = dependency2;
    }
}

Postconstruct methods

class MockClass implements IInjectorContainer
{
    public function new()
    {
        
    }
    
    @PostConstruct( 0 )
    public function doSomething() : Void
    {
        //this method will be called after constructor
    }
    
    @PostConstruct( 1)
    public function doSomethingMore() : Void
    {
        //this method will be called after 'doSomething' call
    }
}

Predestroy methods

class MockClass implements IInjectorContainer
{
    public function new()
    {
        
    }
    
    @PreDestroy( 0 )
    public function doSomething() : Void
    {
        //this method will be called when this instance will be destroyed
    }
    
    @PreDestroy( 1)
    public function doSomethingMore() : Void
    {
        //this method will be called after 'doSomething' call
    }
}

hexUnit

Extendable UnitTest runner with the basic assertions. It works well together with any mocking and assertion system. FlexUnit and JUnit like syntax.

How to run framework tests inside the browser

var emu = new ExMachinaUnitCore();
emu.addListener( new BrowserUnitTestNotifier( "console" ) );
emu.addTest( HexMVCSuite );
emu.addTest( HexCoreSuite );
emu.addTest( HexInjectSuite );
emu.addTest( HexMachinaSuite );
emu.addTest( HexUnitSuite );
emu.run();

How to run tests with NodeJS (you can mix tests classes with suites)

var emu = new ExMachinaUnitCore();
emu.addListener( new ConsoleNotifier(false) );
emu.addTest( InjectorTest );
emu.addTest( HexCoreSuite );
emu.run();

How to test only one method

var emu = new ExMachinaUnitCore();
emu.addListener( new BrowserUnitTestNotifier( "console" ) );
emu.addTestMethod( InjectorTest, "get_instance_errors_for_unmapped_class" );
emu.run();

Suite example (you can mix tests classes with suites)

class AsyncSuite
{
    @Suite("Async suite")
    public var list : Array<Class<Dynamic>> = [AsyncCommandSuite, AsyncCommandTest];
}

Test example

class DomainTest
{
    @Test( "Test 'name' property passed to constructor" )
    public function testConstructor() : Void
    {
        var domain = new Domain( "testConstructor" );
        Assert.equals( "testConstructor", domain.getName(), "'name' property should be the same passed to constructor" );
    }
    
    @Test( "Test null 'name' value passed to constructor" )
    public function testConstructorNullException() : Void
    {
        Assert.constructorCallThrows( NullPointerException, Domain, [], "" );
    }
    
    @Test( "Test using twice the same 'name' value" )
    public function testConstructorWithNameValues() : Void
    {
        var domain = new Domain( "testConstructorWithNameValues" );
        Assert.constructorCallThrows( IllegalArgumentException, Domain, ["testConstructorWithNameValues"], "" );
    }
}

Asynchronous test example

@Async( "Test every command was executed" )
public function testHasRunEveryCommand() : Void
{
    this._macroExecutor.add( MockAsyncCommand );
    Assert.failTrue( this._macroExecutor.hasRunEveryCommand, "'hasRunEveryCommand' should return false" );
    this._macroExecutor.executeNextCommand();
    Timer.delay( MethodRunner.asyncHandler( this._onTestHasRunEveryCommand ), 100 );
}

private function _onTestHasRunEveryCommand() : Void
{
    Assert.isTrue( this._macroExecutor.hasRunEveryCommand, "'hasRunEveryCommand' should return true" );
}

hexService

Service layer extension for hexMVC to separate service communications. It has all typical predefined service behaviors like: configuration, success, fail, cancel, timeout, etc.

hexAnnotation

Easy-to-use utilities for reading and writing @annotation data.

hexReflection

Fast class description builder to output lightweight reflection data and replace rtti (class description parsing at compile time)

hexState

Powerful easy-to-use StateMachina system based on Martin Dowler’s implementation. It saves you from a lot of issue with invalid states of your application.

Docs Code Cookbook

Code Cookbook

hexMVC

hexIoC

hexDSL

hexInject

hexUnit

hexService

hexAnnotation

hexReflection

hexState

hexCore

Copyright © 2018 hexMachina

Sitemap

Docs

Contacts