Brian Kotek: Inversion of Control - Swiz

Swiz 2.0 Beta, Now with AOP!

Tue, 06 Sep 2011 13:11:00 -0700

In case you missed it, the Swiz team has made Swiz 2.0 Beta available. It includes the much-anticipated Aspect-Oriented Programming (AOP) features that have been in the works for a long time. AOP is incredibly powerful, and having done a lot of work with Spring, ColdSpring, and Spring.NET, it is hard to overstate the potential impact of AOP for Flash. I also want to give a shout out to Maxim Porges, who spearheaded the effort to bring true bytecode generation to Flash with his Loom project. Without his effort this just wouldn't be happening. For now, you can find full details on the new AOP features in the Swiz blog! As things get more stable, you can expect the Swiz documentation to incorporate this as well.

Swiz Console 1.2, and an introduction to AOP in ActionScript

Wed, 06 Jul 2011 10:35:00 -0700

First just a quick note that I have updated the Swiz Console to version 1.2, which maintains parity with Swiz version 1.2. This update adds a tab to show views that have been processed with ViewAdded and ViewRemoved. As always, you can grab the swc or the source at my GitHub repository. In other news, Chris Scott put up a blog entry on the Swiz site with an overview of aspect-oriented programming in AS3. One might speculate that this is a lead-in to some very cool stuff coming in the Swiz framework, if one were so inclined...;-)

Swiz 1.2 Is Out!

Tue, 14 Jun 2011 14:11:00 -0700

Just a very quick entry to say that the Swiz Team has pushed version 1.2.0 out the door! This has a few small tweaks and bug fixes, but also adds the ViewAdded and ViewRemoved metadata tags to support the use of the View Mediator pattern. We also did a bit of consolidation related to conditional compilation. We still have two versions, but one is now just for the Flex 4.x SDK (including the 4.5 Mobile SDK), and the other just for the Flex 3.x SDK. Get it while it's hot!

Swiz Screencast, with Swiz Console and Sourcemate 3.0 Integration

Mon, 13 Jun 2011 08:27:00 -0700

I put together a 30 minute screencast on creating a simple Flex application using the Swiz framework. This also shows off some of the great Swiz integration that comes with Sourcemate 3.0, as well as using the Swiz Console for debugging and runtime introspection. If folks find this helpful, I'll try to do some more. So please let me know what you think! Thanks.

Swiz 1.1.0 Released

Thu, 05 May 2011 08:12:00 -0700

This is a few days late but maybe that is a good thing since several folks blogged and tweeted about it on Monday in case anyone missed it. The Swiz team has released version 1.1.0 of the framework. This is mainly a bug fix release, but we've also added a version of the swc that works with the Flex 4.5 Mobile SDK. The release notes have full details. So give Swiz a try with your new mobile apps and ask any questions or provide some feedback on the mailing list!

Swiz Debugging Console

Mon, 28 Feb 2011 08:51:00 -0700

I've created a Swiz Debugging Console based on the Kap Lab libraries. It's meant to provide helpful information while building Swiz-based Flex and AIR applications. The source code, compiled swc, and basic documentation is available at the above GitHub link. [More]

Swiz 1.0 Is Ready, and Updated Module and Chaining Demos

Wed, 15 Dec 2010 09:37:00 -0700

Today marks a big milestone in development of the Swiz framework for Flex and ActionScript: the team is proud to announce that version 1.0 has been released. This has been coming for a while, but we wanted to be sure we weren't rushing things and that the framework was really solid and ready for the 1.0 designation. Download the final Swiz 1.0 distribution, which contains the swc, API docs, and source code. If you like, check out the release notes to see what's new since RC2. Finally, the wiki documentation has been updated to reflect the new changes. To go along with the final 1.0 release, I've pushed some updated demo apps to the swiz-examples Github repository to show more of the chaining API and the inter-module communication options that Swiz brings to the table. If you'd rather see running code, I've got the Chaining Demo and Module Communication Demo applications live on my site. The view source option is enabled, so feel free to browse the code to see what's going on. That's all for now. I hope folks find the examples helpful!

Swiz Example Application Demonstrating Module Support

Mon, 16 Aug 2010 13:12:00 -0700

I just pushed a new sample application called SwizModuleExample-Flex4 to GitHub. This example is meant to demonstrate the various ways that Swiz supports the use of modules. The key ideas demonstrated are:

Loading a Module
Detecting full creation of a Module (not just the ModuleEvent.READY event)
Dispatching events from a root Swiz instance that are mediated by all Modules
Dispatching events from a root Swiz instance to a specific Module
Dispatching events from a Module that are mediated in the root Swiz instance
Dispatching events from a Module that are mediated by other Modules.
Injecting Beans that are defined in a root Swiz instance into a child Swiz instance.

While this example is really meant to be looked through at the code level, I have a running version with View Source enabled that you can look at as well. I hope folks find this example helpful!

CFUnited Clean Code and Swiz Presentations Now Online

Wed, 04 Aug 2010 15:33:00 -0700

Just a quick note that, as promised, my presentations from CFUnited are now online! Clean Code The Swiz Framework for Flex and ActionScript Thanks to all who attended!

Using the Swiz AutowiredTestCase

Tue, 15 Jun 2010 09:27:00 -0700

One of the utility classes that is part of the Swiz library is AutowiredTestCase. As the name implies, you can use this class to help test your Swiz applications. In this case, code will show what's going on much better than doing a lot of typing, so here is a sample FlexUnit 4 test case. First, the class under test:

js|
package com.briankotek.flex4swiztests.control
{
	import com.briankotek.flex4swiztests.event.MyEvent;
	import flash.events.IEventDispatcher;

	public class MyController
	{
		
		[Dispatcher]
		public var dispatcher : IEventDispatcher;
		
		public var didSomething : Boolean = false;
		
		[Mediate( event="MyEvent.CONTROLLER_ACTION_REQUESTED" )]
		public function handleAction() : void
		{
			didSomething = true;
			actionComplete();
		}
		
		private function actionComplete() : void
		{
			dispatcher.dispatchEvent( new MyEvent( MyEvent.CONTROLLER_ACTION_COMPLETE ) );
		}
		
	}
}

You can see this is a simple controller, which responds to the CONTROLLER_ACTION_REQUESTED event, updates a property, and then dispatches CONTROLLER_ACTION_COMPLETE. We want to test that the controller is responding to the correct event, property updating the property, and finally dispatching the completion event. The event itself is a simple event class:

js|
package com.briankotek.flex4swiztests.event
{
	import flash.events.Event;
	
	public class MyEvent extends Event
	{
		public static const CONTROLLER_ACTION_REQUESTED : String = "controllerActionRequested";
		public static const CONTROLLER_ACTION_COMPLETE : String = "controllerActionComplete";
		
		public function MyEvent(type:String)
		{
			super(type, true, false);
		}
	}
}

Finally, the test case itself:

js|
package com.briankotek.flex4swiztests.control
{
	import com.briankotek.flex4swiztests.control.MyController;
	import com.briankotek.flex4swiztests.event.MyEvent;
	import org.flexunit.Assert;
	import org.flexunit.async.Async;
	import org.swizframework.core.*;
	import org.swizframework.utils.test.AutowiredTestCase;

	public class MyControllerTestCase extends AutowiredTestCase
	{	
		private var myController : MyController;
		
		[Before]
		public function setUp():void
		{
			myController = new MyController();
			
			swizConfig = new SwizConfig();
			swizConfig.eventPackages = "com.briankotek.flex4swiztests.event.*";
			
			beanProviders = [new BeanProvider( [myController] )];
		}
		
		[After]
		public function tearDown():void
		{
			myController = null;
		}
		
		[Test(async)]
		public function testControllerActionRequested() : void
		{
			Assert.assertTrue( "Controller property is already true.", myController.didSomething == false );	
			Async.handleEvent( this, swiz.dispatcher, MyEvent.CONTROLLER_ACTION_COMPLETE, checkEvent ); 
			swiz.dispatcher.dispatchEvent( new MyEvent( MyEvent.CONTROLLER_ACTION_REQUESTED ) );
		}
		
		private function checkEvent( event : Event, passThroughData : Object ) : void
		{
			Assert.assertTrue( "Controller property was not updated.", myController.didSomething == true );	
		}
		
	}
}

I start off setting up an instance of Swiz that my test can use. AutowiredTestCase has a method marked with [Before] metadata, so that FlexUnit runs it before each test. I create an instance of the class under test (MyController), then set the event packages on the SwizConfig. Finally, I place the MyController instance into a BeanProvider, so that Swiz will process it as a bean. This way, any Swiz metadata in MyController is processed. The test method dispatches a CONTROLLER_ACTION_REQUESTED event. If all goes well, the mediated event in the controller should run, update the property, and then the controller will dispatch the completion event. Running the test produces a passing result, so everything is working as expected! Note that because Swiz actually processes your test case itself as a bean, you can use Swiz metadata in your test if you want or need to. So injecting a dispatcher, mediating an event, or testing custom metadata processors are all possible as well.

Swiz 1.0RC Released! So here's an updated example, custom ViewMediator, and more

Wed, 19 May 2010 09:56:00 -0700

There's a lot of good news from the Swiz world today. First, we just released the Swiz 1.0 Release Candidate, which fixes a number of small bugs in the beta and adds numerous new features. This version should be pretty much feature-complete, so at this point we'll be focused on fixing any issues that come up. A final 1.0 should be out in the next few weeks. I did my best to help out with this release by working hard on updated documentation. You can see the fruits of this labor on the new Swiz documentation wiki we've created through JIRA Studio. You can also sign up to enter feature requests or bugs, vote on issues, and all the other good stuff that JIRA provides. If you have any feedback on the documentation, feel free to leave a wiki comment and we'll do our best to address it. I've also created a Swiz 1.0RC version of my example application. If you like, you can view or download the source code. Since 1.0RC removes the option for "view injection" into a bean, folks have asked about ways to handle providing a view to a Swiz bean. I created a MediateView custom metadata extension that should handle most of these needs. I'll do my best to keep it up to date as I get feedback about it. And finally, in the "better late than never" department, I've uploaded the Swiz presentation I gave at cf.Objective() 2010 to SlideSix. I'll also be speaking on Swiz at this year's CFUnited conference. If you're planning on going, I'm happy to talk about Swiz into the wee hours of the morning!

Swiz Example Application Updated to Support Swiz 1.0 Beta

Fri, 05 Mar 2010 08:59:00 -0700

Update on 8/16/10: With the release of Swiz RC1, I released an updated version of this example application. With the release of the 1.0 Beta of the Swiz framework, I've updated my Swiz example application to the latest version. You can also view the source code if you like. I'd like to point out a few things that I had to change from the example based on version 0.6.4:

The instantiation of the framework has changed in order to support multiple instances of Swiz, primarily for Flex module support:
xml|
The static methods on the Swiz class have been removed, due to the fact that there can now be multiple instances of Swiz. This means that instead of doing something like Swiz.dispatchEvent( event ), you now want to inject a dispatcher object into your non-view objects and dispatch events through it instead. The two main ways to do this are to inject the dispatcher in your BeanLoader/BeanProvider, or by having your class implement the IDispatcherAware interface, which will instruct Swiz to inject the dispatcher automatically.
The [Autowire] metadata tag has been deprecated in favor of the more industry-standard [Inject]. [Autowire] will still work for now, but be aware that this may be removed in a future release.
The use of the earlier CommandChain has changed to support more robust and extensible chains, as well as supporting internal Flex event-based chains on top of the existing support for chains that make server calls. For example:
js| var chain : CommandChain = new CommandChain(); chain.addMember( new AsyncChainStepCommand( delegate.deleteUser, [user], userDeleteHandler ) ); chain.addMember( new AsyncChainStepCommand( delegate.deleteUserProfileImage, [user], userProfileImageDeleteHandler ) ); chain.addEventListener( "chainComplete", userDeleteCompleteHandler, false, 0, true ); chain.start();

Anyway, that's all for now, but I'll be posting more about the Swiz updates soon. If you're interested in seeing more about 1.0, have a look at Sam Ahn's demo of Swiz using AS3Signals. A very cool use of the brand new custom metadata support now available in Swiz!

Swiz 1.0 Beta is Live!

Mon, 01 Mar 2010 11:29:00 -0700

This morning, the Swiz team released the 1.0 Beta of the Swiz Framework. You can view the extensive list of updates at the Swiz web site. Have a look and try out the new features. We'll be doing a full update of the documentation as we prepare for the final release. I also have an updated version of my sample application about ready, and I will upload it and highlight the differences between 0.6.4 and 1.0. Stay tuned!

My CFinNC Presentations at SlideSix

Thu, 22 Oct 2009 12:02:00 -0700

I've uploaded my CFinNC presentations to SlideSix for anyone who's interested: Object-Oriented Design Principles Introduction to Swiz Overall, CFinNC was great. I actually had to work for a large chunk of the weekend so aside from presenting and mingling with folks later in the evening, I didn't get to attend many other sessions. That said, everything looked top-notch while I was there. The conference unfolded very smoothly and all of the attendees seemed very engaged. Hats off to Dan Wilson and the entire volunteer team for pulling this off! This conference definitely held its own against the other CF conferences I've attended. It was very difficult to tell that it was completely free. Hopefully we can do it again next year!

I'm Speaking at the CFinNC Conference...See You There?

Fri, 04 Sep 2009 12:00:00 -0700

Just a quick note that I'll be speaking at the CFinNC conference on October 17-18th here in Raleigh, NC. My topics are Object-oriented Design Principles and The Swiz Framework for Flex. The conference is FREE and the lineup is very impressive, so if you can attend, please register! And if you register, please actually show up! The danger with a free conference is that it's easy for folks to back out at the last minute, since they lose nothing. But for the organizers, it makes estimating actual attendance difficult. So if you sign up, please do your best to make it. :-) I'm looking forward to seeing some folks that I normally have to wait until MAX or next year's CFObjective or CFUnited conferences to see. And I hope to meet a lot of new people as well. See you in Raleigh!