simple ActionScript DSL :)

DSL.as

package
{
	import flash.display.Sprite;
	import flash.events.Event;

	[SWF(frameRate="1")]
	public class DSL extends Sprite
	{
		private var myModel : MyModel = new MyModel();

		public function DSL()
		{
			when( myModel, "state" ).changes().execute( traceCurrentState );
			when( myModel, "state" ).changes().execute( updateColor );
			when( myModel, "state" ).becomes( MyModelStates.START ).execute( traceData );
			when( myModel, "state" ).becomes( MyModelStates.END ).execute( trace ).withParams( "------------------------------------" );

			when( myModel, "worksCount" ).becomesGreaterThan( 2 ).executeOnce( trace ).withParams( "We have do work 3 times" );

			this.addEventListener( Event.ENTER_FRAME, function ( e : Event ) : void
			{
				myModel.nextState();
			} );
		}

		private function updateColor() : void
		{
			with ( graphics )
			{
				clear();
				beginFill( myModel.state == MyModelStates.START ? 0x00FF00 : myModel.state == MyModelStates.PROCESSING ? 0xFFFF00 : 0xFF0000 );
				drawRect( 0, 0, 1000, 600 );
				endFill();
			}
		}

		private function traceCurrentState() : void
		{
			trace( myModel.state );
		}

		private function traceData() : void
		{
			trace( "Work started at " + new Date().toLocaleDateString() );
		}
	}
}

import flash.events.EventDispatcher;

import mx.binding.utils.BindingUtils;
import mx.binding.utils.ChangeWatcher;

class MyModel extends EventDispatcher
{
	[Bindable]
	public var state : String;

	[Bindable]
	public var worksCount : int = 0;

	public function nextState() : void
	{
		switch ( state )
		{
			case MyModelStates.START:
			{
				state = MyModelStates.PROCESSING;
			}
				break;

			case MyModelStates.PROCESSING:
			{
				worksCount++;
				state = MyModelStates.END;
			}
				break;

			case MyModelStates.END:
			{
				state = MyModelStates.START;
			}
				break;

			default:
			{
				state = MyModelStates.START;
			}
				break;
		}
	}
}

class MyModelStates
{
	public static const START : String = "start";
	public static const PROCESSING : String = "processing";
	public static const END : String = "end";
}


function when( obj : Object, prop : String ) : DSLObject
{
	return new DSLObject( obj, prop );
}

class DSLObject
{
	private var obj : Object;
	private var prop : String;
	private var handler : Function;
	private var params : Array;
	private var onValueChangedHandler : Function;
	private var oldValue : *;
	private var changeWatcher : ChangeWatcher;

	public function DSLObject( obj : Object, prop : String )
	{
		this.obj = obj;
		this.prop = prop;
	}

	public function becomes( value : * ) : DSLObject
	{
		onValueChangedHandler = function ( newValue : * ) : void
		{
			if ( newValue == value )
			{
				handler.apply( null, params );
			}
		}
		return this;
	}

	public function becomesGreaterThan( value : * ) : DSLObject
	{
		onValueChangedHandler = function ( newValue : * ) : void
		{
			if ( newValue > value )
			{
				handler.apply( null, params );
			}
		}
		return this;
	}

	public function changes() : DSLObject
	{
		onValueChangedHandler = function ( newValue : * ) : void
		{
			if ( newValue != oldValue )
			{
				handler.apply( null, params );
			}

			oldValue = newValue
		}
		return this;
	}

	public function execute( handler : Function ) : DSLObject
	{
		this.handler = handler;
		changeWatcher = BindingUtils.bindSetter( onValueChangedHandler, obj, prop );
		return this;
	}

	public function executeOnce( oneTimeHandler : Function ) : DSLObject
	{
		this.handler = function ( ...args ) : void
		{
			oneTimeHandler.apply( null, params );
			changeWatcher.unwatch();
			changeWatcher = null;
			this.handler = null;
			this.onValueChangedHandler = null;
		};

		changeWatcher = BindingUtils.bindSetter( onValueChangedHandler, obj, prop );
		return this;
	}

	public function withParams( ...args ) : void
	{
		this.params = args;
	}
}