Reflexive Notification Interests allow you to implement the act of indicating notification interests and reacting to them in handleNotification in a single step via respondToNote syntax. Instead of writing a long switch case statements, individual respondTo methods are used. Similarly, the reactTo syntax does the same thing for events. Thanks Marcel, Nice to see an indepth and objective look at Fabrication.

Interceptors allow means to alter the normal flow of PureMVC notifications. You can drop notification, change their payload, or send completely different notification in its place, all before they reach the rest of the PureMVC actors, Mediators and Commands. See the wiki page for Interceptors for more details.

Reactions bring a respondTo like convention to mediators for handling component events automatically. A reactToMyComponentFooEvent indicates interest in the FooEvent of the MyComponent and its handler function at the same time. See the wiki page for Reactions for more details.

ChangeLog of what has changed in this release.
Download Fabrication 0.6.

Happy New Year Everyone!

Grab it here
http://code.google.com/p/fabrication/downloads/list

You can check out the test runner below,
Fabrication Test Runner

The unit tests have proved to be very useful so far. I have been able to identify some really hard to find issues that had gone unnoticed until now. Fabrication is now updated to 0.5. Here is a list of what got changed,

1. Fixed memory leaks within the framework. The simple_routing example is updated to show this in action.
2. Fixed incorrect component route caching.
3. Refactored ComponentRouteMapper object to be cached at the facade level instead of globally.
4. Fixed incorrect notification caching in the FabricationMediator.
5. Refactored message routing internals to use an explicit TransportNotification instead of the earlier dynamic implementation.
6. Added FabricationModel to improve garbage collection of proxies.
7. Added FabricationView to improve garbage collections of mediators(Thanks Jason).
8. Added HashMap object to implement consistent cache management throughout the framework.
9. Implemented IDisposable in nearly all classes in the framework.
10. routeNotification now supports typed notifications with the syntax, routeNotification(new CustomNotification(“foo”))
11. Fixed invalid auto description regular expression in SimpleUndoableCommand.
12. FabricationFacade now provides a standard caching api to store objects within the scope of a facade instance.
13. Added platform specific swcs for flex and air.
14. Moved the build system into the framework and updated example builds.

Grab the swcs and sources from Google code.
http://code.google.com/p/fabrication/downloads/list

Download 0.4.3 swc

Download 0.4.3 source zip

Thanks Jason for the fix.

1. routeNotification now supports dynamic to arguments. The to parameter can now take moduleAddress objects as well as string routes.
2. Added expansion property to FabricationProxy to allow turning off of the default notification expansion of for custom named proxies.

Check it out here

private function loadModule(moduleDescriptor:ModuleDescriptor):void {
	var module:IModuleInfo = ModuleManager.getModule(moduleDescriptor.url);

	module.data = moduleDescriptor;
	module.addEventListener(ModuleEvent.READY, moduleReadyListener);

	pendingModules.push(module);
	module.load(ApplicationDomain.currentDomain);
}

private function moduleReadyListener(event:ModuleEvent):void {
	var module:IModuleInfo = event.module;
	var moduleDescriptor:ModuleDescriptor = event.module.data as ModuleDescriptor;
	var moduleInstance:Object = event.module.factory.create();

	moduleInstance.router = applicationRouter;
	moduleInstance.defaultRouteAddress = applicationAddress;
	moduleInstance.id = moduleDescriptor.getElementID();

	moduleInstance.addEventListener(FabricatorEvent.FABRICATION_CREATED, moduleCreated);
	moduleInstance.addEventListener(FabricatorEvent.FABRICATION_REMOVED, moduleRemoved);

	modulesContainer.addChild(moduleInstance as DisplayObject);
}

Thanks to Ruben from the PureMVC forums for reporting this issue. You can download Fabrication 0.4.1 from here.

I am going to focus on 2 specific pieces of the Slacker Demo. The MainDisplayMediator.as class and the corresponding MainDisplay.mxml component. The main work of the demo happens in these classes. The rest of code deals with triggering notifications to change the selected child view, and is unchanged.

The MainDisplay component contains the child components, GalleryView, EditorView, and ProfileView inside a ViewStack. The view stack is set to use deferred instantiation with the creationPolicy, auto. Each of the children of the ViewStack send a custom event via a sendEvent method. This event is bubbled so that the event can be handled by a listener of the MainDisplay component. This code looks like,

The MainDisplayMediator listens for this event and registers a mediator when the child view is created. Checks are performed to ensure that the mediator registration happens only once. The MainDisplayMediator also changes the selected mediator in the ViewStack using typical PureMVC listNotificationInterests and handleNotification methods. The code for the MainDisplayMediator is,

package org.puremvc.as3.demos.flex.slacker.view
{
    import flash.events.Event;

    import org.puremvc.as3.demos.flex.slacker.ApplicationFacade;
    import org.puremvc.as3.demos.flex.slacker.view.components.MainDisplay;
    import org.puremvc.as3.interfaces.INotification;
    import org.puremvc.as3.patterns.mediator.Mediator;

    public class MainDisplayMediator extends Mediator
    {
        public static const NAME:String = 'MainDisplayMediator';

        public function MainDisplayMediator( viewComponent:Object )
        {
            super( NAME, viewComponent );
        }

        override public function onRegister():void
        {
            mainDisplay.addEventListener( MainDisplay.GALLERY_CREATED, onGalleryCreated );
            mainDisplay.addEventListener( MainDisplay.EDITOR_CREATED, onEditorCreated  );
            mainDisplay.addEventListener( MainDisplay.PROFILE_CREATED, onProfileCreated );
        }

		override public function listNotificationInterests():Array
		{
			return [ApplicationFacade.EDITOR_MODE,
					ApplicationFacade.GALLERY_MODE,
					ApplicationFacade.PROFILE_MODE]
		}

       	override public function handleNotification(note:INotification):void
       	{
       		switch (note.getName())
       		{
       			case ApplicationFacade.EDITOR_MODE:
       				mainDisplay.currentViewSelector = MainDisplay.EDITOR;
       				break;
				case ApplicationFacade.GALLERY_MODE:
       				mainDisplay.currentViewSelector = MainDisplay.GALLERY
       				break;
				case ApplicationFacade.PROFILE_MODE:
       				mainDisplay.currentViewSelector = MainDisplay.PROFILE;
       				break;
       		}
       	}

        protected function onEditorCreated( event:Event ):void
        {
			checkForMediator( MainDisplay.EDITOR, mainDisplay.activeView );
        }

        protected function onGalleryCreated( event:Event ):void
        {
			checkForMediator( MainDisplay.GALLERY, mainDisplay.activeView );
        }

        protected function onProfileCreated( event:Event ):void
        {
			checkForMediator( MainDisplay.PROFILE, mainDisplay.activeView );
        }

        protected function checkForMediator( childSelector:Number, child:Object ):void
        {
            switch (childSelector)
            {
				 case MainDisplay.PROFILE:
				      if ( ! facade.hasMediator( ProfileViewMediator.NAME ) )
				         facade.registerMediator(new ProfileViewMediator( child ));
				      break;
				 case MainDisplay.GALLERY:
				      if ( ! facade.hasMediator( GalleryViewMediator.NAME ) )
				         facade.registerMediator(new GalleryViewMediator( child ));
				      break;
				 case MainDisplay.EDITOR:
				      if ( ! facade.hasMediator( EditorViewMediator.NAME ) )
				         facade.registerMediator(new EditorViewMediator( child ));
				      break;
              }
        }

        protected function get mainDisplay():MainDisplay
        {
            return viewComponent as MainDisplay;
        }

    }
}

After Using Fabrication

The above code is significantly reduced with Fabrication while preserving the same functionality. With the 0.4 release Fabrication now supports Reflexive Mediator registration. This feature allows you to register a mediator with a component that was created with deferred instantiation without the overhead.

In the MainDisplay we only need to give id’s to the child view components of the ViewStack. This allows us to identify the components once they are instantiated. Further you no longer need the custom event dispatch. The MainDisplay is now reduced to,

The MainDisplayMediator shows even greater impact. Using Reflexive Mediator Registration we can access the child profileView/galleryView/editorView with the descendant operator(..) like, resolve(mainDisplay)..childComponent. And using Fabrication 0.4’s support for Reflexive Notification Interests, we can indicate interest in a notification and listen to it, all in one step. The code for the MainDisplayMediator is now reduced to,

package org.puremvc.as3.demos.flex.slacker.view {
	import org.puremvc.as3.demos.flex.slacker.view.components.MainDisplay;
	import org.puremvc.as3.multicore.interfaces.INotification;
	import org.puremvc.as3.multicore.utilities.fabrication.patterns.mediator.FlexMediator;

	public class MainDisplayMediator extends FlexMediator {
		public static const NAME:String = 'MainDisplayMediator';

		public function MainDisplayMediator( viewComponent:Object ) {
			super(NAME, viewComponent);
		}

		override public function onRegister():void {
			registerMediator(new ProfileViewMediator(resolve(mainDisplay)..profileView));
			registerMediator(new GalleryViewMediator(resolve(mainDisplay)..galleryView));
			registerMediator(new EditorViewMediator(resolve(mainDisplay)..editorView));
		}

		public function respondToEditorMode(note:INotification):void {
			mainDisplay.currentViewSelector = MainDisplay.EDITOR;
		}

		public function respondToGalleryMode(note:INotification):void {
			mainDisplay.currentViewSelector = MainDisplay.GALLERY;
		}

		public function respondToProfileMode(note:INotification):void {
			mainDisplay.currentViewSelector = MainDisplay.PROFILE;
		}

		protected function get mainDisplay():MainDisplay {
			return viewComponent as MainDisplay;
		}
	}
}

This examples illustrated the benefits of using Reflexive Mediator Registration and Reflexive Notification Interests to reduce code complexity. I have added it to the SVN of the Fabrication Google Code project. You can check it out here.