hexMachina - a powerful multi-modular MVC framework written in Haxe

Haxe Summit 2018 - Consuming injections with minimal dependencies

Sat, 05 May 2018 00:00:00 +0000

Find below the video and slide for Francis’s talk about hexInject at Haxe Summit 2018 in Seattle.

Consuming injections with minimal dependencies

Managing dependencies is a big topic in application engineering. Francis in this talk will showcase some maintanable and performant solutions he’s using with haxe.

Haxe Summit 2018 - A deep dive into hexUnit

Thu, 03 May 2018 00:00:00 +0000

Find below the video for Laurent’s talk about hexUnit at Haxe Summit 2018 in Seattle.

A deep dive into hexUnit

During this presentation, we will see in detail all the possibilities offered by hexUnit. How to play with metadata, asserts, notifiers and asynchronous testing. hexUnit is the hexMachina’s Unit Test library.

Haxe Summit 2017 - A deep dive into hexInject

Fri, 15 Sep 2017 00:00:00 +0000

Find below the video for Stepan’s workshop about hexInject at Haxe Summit 2017 in Amsterdam.

A deep dive into hexInject

Have you ever struggled to maintain a highly coupled monolithic application? Worry no more and discover all possibilities of dependency mappings and injections with Injector from hexInject and see how to wire everything together in unique “flow” flavor of hexDSL. Basic Haxe knowledge necessary, familiarity with Rick and Morty optional.

Workshop sources: DoclerLabs/hexWorkshop/hexInject

Haxe Summit 2017 - A deep dive into hexDSL

Fri, 15 Sep 2017 00:00:00 +0000

Find below the video for Laurent’s workshop about hexDSL at Haxe Summit 2017 in Amsterdam.

A deep dive into hexDSL

Workshop sources: DoclerLabs/hexWorkshop/hexDSL

Haxe Summit 2017 - DSL, mon amour!

Wed, 13 Sep 2017 00:00:00 +0000

Find below the video for Francis’s talk at Haxe Summit 2017 in Amsterdam.

DSL, mon amour!

DSLs are small languages, focused on a particular aspect of your software system. You can’t build a whole program with a DSL, but you often use multiple DSLs in a system mainly written in a general purpose language.

This presentation is split in 3 parts presenting:

Advantages to use internal/external DSLs instead of traditional libraries to improve programmer productivity and communication between team members.
Case study of a real world DSL able to be parsed/executed at runtime and compile time.
How to use Haxe language features to develop powerful DSL toolchain with different grammars and code generation.

Who is this presentation for:

It’s targeted to every developer who wants to have a nice introduction about DSL power in the application world, and have a first taste of Haxe macros black magic.

0.28.0 - @parser and code.clone()

Tue, 08 Aug 2017 00:00:00 +0000

Let’s highlight some new feature on this new release.

Custom parser can be declared in flow DSL with `@parser` metadata

Added in 0.24.0, custom parser can now be directly added in DSL file with @parser flow keyword. Few custom parser examples in hexDSL.

@context( name = 'applicationContext' )
@parser( hex.compiletime.flow.parser.custom.AddParser )
{
	s = add( "hello", space, "world", space, "!" );
	space =  " ";
	
	i = add( 6, five );
	five = 5;
	
	p = add( p1, new hex.structures.Point( 3, 4 ), p2 );
	p1 = new hex.structures.Point( 5, 5 );
	p2 = new hex.structures.Point( 3, 4 );
}

Code compilation can be cloned with unique assembler reference

Requested for a long time, we can now run the same application few times in the same place without scope problems. ApplicationAssembler is now used as a unique key. More than that, we can manually duplicate DSL with the new clone method.

var code = StaticFlowCompiler.compile( assembler, "context/flow/dsl.flow" );
code.execute();
		
var clonedCode = code.clone( new ApplicationAssembler() );
clonedCode.execute();

Assert.isInstanceOf( code.locator.instance, MockClassWithoutArgument );
Assert.isInstanceOf( clonedCode .locator.instance, MockClassWithoutArgument );
		
Assert.notEquals( code.locator.instance, clonedCode .locator.instance );

To go further

flow - @type and @lazy

Sun, 02 Jul 2017 00:00:00 +0000

Let’s highlight two new features in flow arrived with hexMachina 0.27.0.

Force typing in flow DSL with new `@type`

By default, every object instancied in DSL use his own type as property type. With the new @type flow keyword is possible to apply another type to the property. Not to be confused with @map_type use to map object in ApplicationContext injector.

@context()
{
    @type( 'hex.log.ILogger' )
    logger = new hex.log.Logger( loggerContext, "myLogger");

    loggerContext = hex.log.LoggerContext.getContext();
}

Is equal to that in haxe :

class hex.context.applicationContext implements hex.context.IapplicationContext_0 {

	public var loggerContext:hex.log.LoggerContext;
	public var logger:hex.log.ILogger;

	public function m_dcea6fa1359cfeff3f1f1e4264791aa7() {
		var loggerContext = hex.log.LoggerContext.getContext();
		this.loggerContext = loggerContext;
		var logger = new hex.log.Logger(loggerContext, "myLogger");
		this.logger = logger;
	}
}

Define lazy instanciation in flow DSL with `@lazy`

Declaration with @lazy metadata will not be executed until is used somewhere. context/flow/primitives/lazyInt.flow - link

@context( name = 'applicationContext' )
{
	@lazy
	i = hex.mock.LazyProvider.provide( -3 );
	
	@lazy
	o = new hex.mock.LazyClass( 'test' );
}

test/hex/mock/LazyClass.hx - link

class LazyClass 
{
	public static var value : Any;
	
	public function new( o : Any ) 
	{
		LazyClass.value = o;
	}
}

test/hex/mock/LazyProvider.hx - link

class LazyProvider 
{
	public static var value : Any;
	
	public function new() {}
	
	public static function provide<T>( o : T ) : T
	{
		LazyProvider.value = o;
		return o;
	}
}

@Test( “test building lazy primitive” ) - link

@Test( "test building lazy primitive" )
public function testBuildingLazyInt() : Void
{
	var code = BasicStaticFlowCompiler.compile( this._myApplicationAssembler, "context/flow/primitives/lazyInt.flow", "BasicStaticFlowCompiler_testBuildingLazyInt" );
	LazyProvider.value = null;
	LazyClass.value = null;
	code.execute();
	
	Assert.isNull( LazyProvider.value );
	Assert.equals( -3, code.locator.i );
	Assert.equals( -3, LazyProvider.value );
	
	Assert.isNull( LazyClass.value );
	Assert.isNotNull( code.locator.o );
	Assert.equals( 'test', LazyClass.value );
}

To go further

IDependencyOwner, check dependency injection at compiletime

Tue, 30 May 2017 00:00:00 +0000

Let’s highlight one new feature arrived with hexMachina 0.22.0.

hex.di.mapping.IDependencyOwner

With this new feature is possible to check injector dependencies at compiletime. With @Dependency metadata is possible to declare mapping dependencies on classes that implements hex.di.mapping.IDependencyOwner,

@Dependency( var _:String )
@Dependency( var name:InterfaceWithGeneric<String> )
@Dependency( var _:Void->Void, hex.di.mock.MockConstants.NAME_ONE )
class DependencyOwner implements hex.di.mapping.IDependencyOwner
{
	var _injector = new Injector();
	
	public function new() {}
	
	public function getInjector() : IDependencyInjector return this._injector;
}

In this example, DependencyOwner request mapping of :

`fromType`	`withName`
`String`	no name
`InterfaceWithGeneric<String>`	“name”
`Void->Void`	the value of `hex.di.mock.MockConstants.NAME_ONE`

Mapping Could be provided by code with static Extension hex.di.util.MappingDefinitionUtil.addDefinition:

var f2 = function() {};
var mapping : MappingDefinition = { fromType: "String", toValue: "test" };
var mappings : Array<MappingDefinition> = [
	{ fromType: "hex.di.mock.types.InterfaceWithGeneric<String>", toClass: ClazzWithGeneric, withName: "name" },
	{ fromType: "Void->Void", toValue: f2, withName:hex.di.mock.MockConstants.NAME_ONE }
];

var dependencyOwner = new DependencyOwner();
dependencyOwner.addDefinition( [mapping].concat( mappings ) );

var injector = dependencyOwner.getInjector();

Or in DSL through the constructor like :

@Dependency( var _			:String )
@Dependency( var id			:Interface )
@Dependency( var anotherID	:Interface )
class AnotherDependenciesOwner implements IDependencyOwner
{
	var _injector = new Injector();
	
	public function new( mapping : MappingDefinition, mappings : Array<MappingDefinition> ) {}
	
	public function getInjector() : IDependencyInjector return this._injector;
}

@context( name = 'applicationContext' )
{
	s = "test";
	mapping1 = mapping({fromType: "String", toValue: s});
	mapping2 = mapping( {fromType: "hex.mock.Interface", toValue: new hex.mock.Clazz(), withName: "anotherID"} );
	
	mappings = new Array<hex.di.mapping.MappingDefinition>
	(
		mapping2,
		mapping( {fromType: "hex.mock.Interface", toClass: hex.mock.Clazz, withName: "id", asSingleton:true} )
	);

	owner = new AnotherDependenciesOwner( mapping1, mappings );
}

To go further

IAnnotationReplace - use constant in annotation

Tue, 16 May 2017 00:00:00 +0000

Let’s highlight one new feature on release 0.21.0.

IAnnotationReplace

Utility interface that allows you to replace expressions in annotation with their values. It’s especially handy for keeping injection names in classes with constants.

Build macro attached to IAnnotationReplace will cause following change:

@Inject(MyConstants.NAME_ONE)
public var injectedOne:String;

becomes

@Inject("one")
public var injectedOne:String;

Expressions that are already constants will remain untouched so @Inject("one") will stay the same. That also applies to combinations of expressions so @Inject(MyConstants.NAME_ONE, "two") changes to @Inject("one", "two")

Currently supported values of expressions:

String
Bool
Int

Currently supported expressions that will be replaced:

Constant in current class
- @Meta(TEST)
Constant in different class
- @Meta(MyClass.TEST)
Constant in different class (with reference using FQCN)
- @Meta(my.pack.MyClass.TEST)

Note that the only expressions that are replaced are [public] static var. Non-static variables are not being searched so they won’t be found.

Important: If used with IInjectorContainer the order matters:

Only this order of implementation will work because of the macro execution order - fix will come soon:

class MyClass implements IInjectorContainer implements IAnnotationReplace

To go further

Drop haxe 3.2.1 support

Tue, 21 Mar 2017 00:00:00 +0000

It’s time to say thank you and goodbye to Haxe 3.2.1, hexMachina minimal haxe support is now 3.4.0!

hexMachina - a powerful multi-modular MVC framework written in Haxe

Haxe Summit 2018 - Consuming injections with minimal dependencies

Consuming injections with minimal dependencies

Haxe Summit 2018 - A deep dive into hexUnit

A deep dive into hexUnit

Haxe Summit 2017 - A deep dive into hexInject

A deep dive into hexInject

Haxe Summit 2017 - A deep dive into hexDSL

A deep dive into hexDSL

Haxe Summit 2017 - DSL, mon amour!

DSL, mon amour!

0.28.0 - @parser and code.clone()

Custom parser can be declared in flow DSL with @parser metadata

Code compilation can be cloned with unique assembler reference

To go further

flow - @type and @lazy

Force typing in flow DSL with new @type

Define lazy instanciation in flow DSL with @lazy

To go further

IDependencyOwner, check dependency injection at compiletime

hex.di.mapping.IDependencyOwner

To go further

IAnnotationReplace - use constant in annotation

IAnnotationReplace

To go further

Drop haxe 3.2.1 support

To go further

Custom parser can be declared in flow DSL with `@parser` metadata

Force typing in flow DSL with new `@type`

Define lazy instanciation in flow DSL with `@lazy`