appjam 0.1.0.pre4

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/command/MacroCommand.h

@@ -0,0 +1,50 @@
+//
+//  MacroCommand.h
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "INotification.h"
+#import "Notifier.h"
+#import "ICommand.h"
+
+/**
+ * A base <code>ICommand</code> implementation that executes other <code>ICommand</code>s.
+ *  
+ * <P>
+ * A <code>MacroCommand</code> maintains an list of
+ * <code>ICommand</code> Class references called <i>SubCommands</i>.</P>
+ * 
+ * <P>
+ * When <code>execute</code> is called, the <code>MacroCommand</code> 
+ * instantiates and calls <code>execute</code> on each of its <i>SubCommands</i> turn.
+ * Each <i>SubCommand</i> will be passed a reference to the original
+ * <code>INotification</code> that was passed to the <code>MacroCommand</code>'s 
+ * <code>execute</code> method.</P>
+ * 
+ * <P>
+ * Unlike <code>SimpleCommand</code>, your subclass
+ * should not override <code>execute</code>, but instead, should 
+ * override the <code>initializeMacroCommand</code> method, 
+ * calling <code>addSubCommand</code> once for each <i>SubCommand</i>
+ * to be executed.</P>
+ * 
+ * <P>
+ * 
+ * @see Controller, Notification, SimpleCommand
+ */
+@interface MacroCommand : Notifier <ICommand> {
+	NSMutableArray *subCommands;
+}
+
+@property(nonatomic, retain) NSMutableArray *subCommands;
+
+-(id)init;
+-(void)initializeMacroCommand;
+-(void)addSubCommand:(Class)commandClassRef;
++(id)command;
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/command/MacroCommand.m

@@ -0,0 +1,101 @@
+//
+//  MacroCommand.m
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import "MacroCommand.h"
+
+
+@implementation MacroCommand
+
+@synthesize subCommands;
+
+/**
+ * Static Convenience Constructor. 
+ */
++(id)command {
+	return [[[self alloc] init] autorelease];
+}
+
+/**
+ * Constructor. 
+ * 
+ * <P>
+ * You should not need to define a constructor, 
+ * instead, override the <code>initializeMacroCommand</code>
+ * method.</P>
+ * 
+ * <P>
+ * If your subclass does define a constructor, be 
+ * sure to call <code>[super init]</code>.</P>
+ */
+-(id)init {
+	if (self = [super init]) {
+		self.subCommands = [NSMutableArray array];
+		[self initializeMacroCommand];
+	}
+	return self;
+}
+
+/**
+ * Initialize the <code>MacroCommand</code>.
+ * 
+ * <P>
+ * In your subclass, override this method to 
+ * initialize the <code>MacroCommand</code>'s <i>SubCommand</i>  
+ * list with <code>ICommand</code> class references like 
+ * this:</P>
+ * 
+ * @code
+ *		// Initialize MyMacroCommand
+ *		-(void)initializeMacroCommand {
+ *			[self addSubCommand:[FirstCommand class]];
+ *			[self addSubCommand:[SecondCommand class]];
+ *			[self addSubCommand:[ThirdCommand class]];
+ *		}
+ * @endcode
+ * 
+ * <P>
+ * Note that <i>SubCommand</i>s may be any <code>ICommand</code> implementor,
+ * <code>MacroCommand</code>s or <code>SimpleCommands</code> are both acceptable.
+ */
+-(void)initializeMacroCommand {
+}
+
+/**
+ * Add a <i>SubCommand</i>.
+ * 
+ * <P>
+ * The <i>SubCommands</i> will be called in First In/First Out (FIFO)
+ * order.</P>
+ * 
+ * @param commandClassRef a reference to the <code>Class</code> of the <code>ICommand</code>.
+ */
+-(void)addSubCommand:(Class)commandClassRef {
+	[subCommands addObject:commandClassRef];
+}
+
+/** 
+ * Execute this <code>MacroCommand</code>'s <i>SubCommands</i>.
+ * 
+ * <P>
+ * The <i>SubCommands</i> will be called in First In/First Out (FIFO)
+ * order. 
+ * 
+ * @param notification the <code>INotification</code> object to be passsed to each <i>SubCommand</i>.
+ */
+-(void)execute:(id<INotification>)notification {
+	for (Class commandClassRef in subCommands) {
+		[[[[commandClassRef alloc] init] autorelease] execute:notification];
+	}
+}
+
+-(void)dealloc {
+	self.subCommands = nil;
+	[super dealloc];
+}
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/command/SimpleCommand.h

@@ -0,0 +1,28 @@
+//
+//  SimpleCommand.h
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "INotification.h"
+#import "Notifier.h"
+#import "ICommand.h"
+
+/**
+ * A base <code>ICommand</code> implementation.
+ * 
+ * <P>
+ * Your subclass should override the <code>execute</code> 
+ * method where your business logic will handle the <code>INotification</code>. </P>
+ * 
+ * @see Controller, Notification, MacroCommand
+ */
+@interface SimpleCommand : Notifier <ICommand> {
+}
+
++(id)command;
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/command/SimpleCommand.m

@@ -0,0 +1,34 @@
+//
+//  SimpleCommand.m
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import "SimpleCommand.h"
+
+
+@implementation SimpleCommand
+
+/**
+ * Static Convenience Constructor. 
+ */
++(id)command {
+	return [[[self alloc] init] autorelease];
+}
+
+/**
+ * Fulfill the use-case initiated by the given <code>INotification</code>.
+ * 
+ * <P>
+ * In the Command Pattern, an application use-case typically
+ * begins with some user action, which results in an <code>INotification</code> being broadcast, which 
+ * is handled by business logic in the <code>execute</code> method of an
+ * <code>ICommand</code>.</P>
+ * 
+ * @param notification the <code>INotification</code> to handle.
+ */
+-(void)execute:(id<INotification>)notification {}
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/facade/Facade.h

@@ -0,0 +1,52 @@
+//
+//  Facade.h
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "IFacade.h"
+#import "IController.h"
+#import "IModel.h"
+#import "IView.h"
+
+/**
+ * A base Singleton <code>IFacade</code> implementation.
+ * 
+ * <P>
+ * In PureMVC, the <code>Facade</code> class assumes these 
+ * responsibilities:
+ * <UL>
+ * <LI>Initializing the <code>Model</code>, <code>View</code>
+ * and <code>Controller</code> Singletons.</LI> 
+ * <LI>Providing all the methods defined by the <code>IModel, 
+ * IView, & IController</code> interfaces.</LI>
+ * <LI>Providing the ability to override the specific <code>Model</code>,
+ * <code>View</code> and <code>Controller</code> Singletons created.</LI> 
+ * <LI>Providing a single point of contact to the application for 
+ * registering <code>Commands</code> and notifying <code>Observers</code></LI>
+ * </UL>
+ * <P>
+ * 
+ * @see Model, View, Controller, Notification, Mediator, Proxy, SimpleCommand, MacroCommand
+ */
+@interface Facade : NSObject <IFacade> {
+	id<IController> controller;
+	id<IModel> model;
+	id<IView> view;
+}
+
+@property(nonatomic, retain) id<IController> controller;
+@property(nonatomic, retain) id<IModel> model;
+@property(nonatomic, retain) id<IView> view;
+
+-(id)init;
+-(void)initializeFacade;
++(id<IFacade>)getInstance;
+-(void)initializeController;
+-(void)initializeView;
+-(void)initializeModel;
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/patterns/facade/Facade.m

@@ -0,0 +1,304 @@
+//
+//  Facade.m
+//  PureMVC_ObjectiveC
+//
+//  PureMVC Port to ObjectiveC by Brian Knorr <brian.knorr@puremvc.org>
+//  PureMVC - Copyright(c) 2006-2008 Futurescale, Inc., Some rights reserved.
+//
+
+#import "Facade.h"
+#import "Model.h"
+#import "View.h"
+#import "Controller.h"
+#import "Notification.h"
+
+static id<IFacade> instance;
+
+@implementation Facade
+
+@synthesize model, controller, view;
+
+/**
+ * Constructor. 
+ * 
+ * <P>
+ * This <code>IFacade</code> implementation is a Singleton, 
+ * so you should not call the constructor 
+ * directly, but instead call the static Singleton 
+ * Factory method <code>[Facade getInstance]</code>
+ * 
+ * @throws NSException if Singleton instance has already been constructed
+ * 
+ */
+-(id)init {
+	if (instance != nil) {
+		[NSException raise:@"Facade Singleton already constructed! Use getInstance instead." format:@""];
+	} else if (self = [super init]) {
+		[self initializeFacade];
+	}
+	return self;
+}
+
+/**
+ * Initialize the Singleton <code>Facade</code> instance.
+ * 
+ * <P>
+ * Called automatically by the constructor. Override in your
+ * subclass to do any subclass specific initializations. Be
+ * sure to call <code>[super initializeFacade]</code>, though.</P>
+ */
+-(void)initializeFacade {
+	[self initializeModel];
+	[self initializeController];
+	[self initializeView];
+}
+
+/**
+ * Facade Singleton Factory method
+ * 
+ * @return the Singleton instance of the Facade
+ */
++(id<IFacade>)getInstance {
+	if (instance == nil) {
+		instance = [[self alloc] init];
+	}
+	return instance;
+}
+
+/**
+ * Initialize the <code>Model</code>.
+ * 
+ * <P>
+ * Called by the <code>initializeFacade</code> method.
+ * Override this method in your subclass of <code>Facade</code> 
+ * if one or both of the following are true:
+ * <UL>
+ * <LI> You wish to initialize a different <code>IModel</code>.</LI>
+ * <LI> You have <code>Proxy</code>s to register with the Model that do not 
+ * retrieve a reference to the Facade at construction time.</code></LI> 
+ * </UL>
+ * If you don't want to initialize a different <code>IModel</code>, 
+ * call <code>[super initializeModel]</code> at the beginning of your
+ * method, then register <code>Proxy</code>s.
+ * <P>
+ * Note: This method is <i>rarely</i> overridden; in practice you are more
+ * likely to use a <code>Command</code> to create and register <code>Proxy</code>s
+ * with the <code>Model</code>, since <code>Proxy</code>s with mutable data will likely
+ * need to send <code>INotification</code>s and thus will likely want to fetch a reference to 
+ * the <code>Facade</code> during their construction. 
+ * </P>
+ */
+-(void)initializeModel {
+	if (model != nil) return;
+	self.model = [Model getInstance];
+}
+
+/**
+ * Initialize the <code>Controller</code>.
+ * 
+ * <P>
+ * Called by the <code>initializeFacade</code> method.
+ * Override this method in your subclass of <code>Facade</code> 
+ * if one or both of the following are true:
+ * <UL>
+ * <LI> You wish to initialize a different <code>IController</code>.</LI>
+ * <LI> You have <code>Commands</code> to register with the <code>Controller</code> at startup.</code>. </LI>		  
+ * </UL>
+ * If you don't want to initialize a different <code>IController</code>, 
+ * call <code>[super initializeController]</code> at the beginning of your
+ * method, then register <code>Command</code>s.
+ * </P>
+ */
+-(void)initializeController {
+	if (controller != nil) return;
+	self.controller = [Controller getInstance];
+}
+
+/**
+ * Initialize the <code>View</code>.
+ * 
+ * <P>
+ * Called by the <code>initializeFacade</code> method.
+ * Override this method in your subclass of <code>Facade</code> 
+ * if one or both of the following are true:
+ * <UL>
+ * <LI> You wish to initialize a different <code>IView</code>.</LI>
+ * <LI> You have <code>Observers</code> to register with the <code>View</code></LI>
+ * </UL>
+ * If you don't want to initialize a different <code>IView</code>, 
+ * call <code>[super initializeView]</code> at the beginning of your
+ * method, then register <code>IMediator</code> instances.
+ * <P>
+ * Note: This method is <i>rarely</i> overridden; in practice you are more
+ * likely to use a <code>Command</code> to create and register <code>Mediator</code>s
+ * with the <code>View</code>, since <code>IMediator</code> instances will need to send 
+ * <code>INotification</code>s and thus will likely want to fetch a reference 
+ * to the <code>Facade</code> during their construction. 
+ * </P>
+ */
+-(void)initializeView {
+	if (view != nil) return;
+	self.view = [View getInstance];
+}
+
+
+/**
+ * Create and send an <code>INotification</code>.
+ * 
+ * <P>
+ * Keeps us from having to construct new notification 
+ * instances in our implementation code.
+ * @param notificationName the name of the notiification to send
+ * @param body the body of the notification
+ * @param type the type of the notification
+ */ 
+-(void)sendNotification:(NSString *)notificationName body:(id)body type:(NSString *)type {
+	[self notifyObservers:[Notification withName:notificationName body:body type:type]];
+}
+
+-(void)sendNotification:(NSString *)notificationName {
+	[self sendNotification:notificationName body:nil type:nil];
+}
+
+-(void)sendNotification:(NSString *)notificationName body:(id)body {
+	[self sendNotification:notificationName body:body type:nil];
+}
+
+-(void)sendNotification:(NSString *)notificationName type:(NSString *)type {
+	[self sendNotification:notificationName body:nil type:type];
+}
+
+/**
+ * Check if a Command is registered for a given Notification 
+ * 
+ * @param notificationName
+ * @return whether a Command is currently registered for the given <code>notificationName</code>.
+ */
+-(BOOL)hasCommand:(NSString *)notificationName {
+	return [controller hasCommand:notificationName];
+}
+
+/**
+ * Check if a Mediator is registered or not
+ * 
+ * @param mediatorName
+ * @return whether a Mediator is registered with the given <code>mediatorName</code>.
+ */
+-(BOOL)hasMediator:(NSString *)mediatorName {
+	return [view hasMediator:mediatorName];
+}
+
+/**
+ * Check if a Proxy is registered
+ * 
+ * @param proxyName
+ * @return whether a Proxy is currently registered with the given <code>proxyName</code>.
+ */
+-(BOOL)hasProxy:(NSString *)proxyName {
+	return [model hasProxy:proxyName];
+}
+
+/**
+ * Notify <code>Observer</code>s.
+ * <P>
+ * This method is left public mostly for backward 
+ * compatibility, and to allow you to send custom 
+ * notification classes using the facade.</P>
+ *<P> 
+ * Usually you should just call sendNotification
+ * and pass the parameters, never having to 
+ * construct the notification yourself.</P>
+ * 
+ * @param notification the <code>INotification</code> to have the <code>View</code> notify <code>Observers</code> of.
+ */
+-(void)notifyObservers:(id<INotification>)notification {
+	[view notifyObservers:notification];
+}
+
+/**
+ * Register an <code>ICommand</code> with the <code>Controller</code> by Notification name.
+ * 
+ * @param notificationName the name of the <code>INotification</code> to associate the <code>ICommand</code> with
+ * @param commandClassRef a reference to the Class of the <code>ICommand</code>
+ */
+-(void)registerCommand:(NSString *)notificationName commandClassRef:(Class)commandClassRef {
+	[controller registerCommand:notificationName commandClassRef:commandClassRef];
+}
+
+/**
+ * Register a <code>IMediator</code> with the <code>View</code>.
+ * 
+ * @param mediator a reference to the <code>IMediator</code>
+ */
+-(void)registerMediator:(id<IMediator>)mediator {
+	[view registerMediator:mediator];
+}
+
+/**
+ * Register an <code>IProxy</code> with the <code>Model</code> by name.
+ * 
+ * @param proxy the <code>IProxy</code> instance to be registered with the <code>Model</code>.
+ */
+-(void)registerProxy:(id<IProxy>)proxy {
+	[model registerProxy:proxy];
+}
+
+/**
+ * Remove a previously registered <code>ICommand</code> to <code>INotification</code> mapping from the Controller.
+ * 
+ * @param notificationName the name of the <code>INotification</code> to remove the <code>ICommand</code> mapping for
+ */
+-(void)removeCommand:(NSString *)notificationName {
+	[controller removeCommand:notificationName];
+}
+
+/**
+ * Remove an <code>IMediator</code> from the <code>View</code>.
+ * 
+ * @param mediatorName name of the <code>IMediator</code> to be removed.
+ * @return the <code>IMediator</code> that was removed from the <code>View</code>
+ */
+-(id<IMediator>)removeMediator:(NSString *)mediatorName {
+	return [view removeMediator:mediatorName];
+}
+
+/**
+ * Remove an <code>IProxy</code> from the <code>Model</code> by name.
+ *
+ * @param proxyName the <code>IProxy</code> to remove from the <code>Model</code>.
+ * @return the <code>IProxy</code> that was removed from the <code>Model</code>
+ */
+-(id<IProxy>)removeProxy:(NSString *)proxyName {
+	return [model removeProxy:proxyName];
+}
+
+/**
+ * Retrieve an <code>IMediator</code> from the <code>View</code>.
+ * 
+ * @param mediatorName
+ * @return the <code>IMediator</code> previously registered with the given <code>mediatorName</code>.
+ */
+-(id<IMediator>)retrieveMediator:(NSString *)mediatorName {
+	return [view retrieveMediator:mediatorName];
+}
+
+/**
+ * Retrieve an <code>IProxy</code> from the <code>Model</code> by name.
+ * 
+ * @param proxyName the name of the proxy to be retrieved.
+ * @return the <code>IProxy</code> instance previously registered with the given <code>proxyName</code>.
+ */
+-(id<IProxy>)retrieveProxy:(NSString *)proxyName {
+	return [model retrieveProxy:proxyName];
+}
+
+-(void)dealloc {
+	self.model = nil;
+	self.controller = nil;
+	self.view = nil;
+	[(id)instance release];
+	instance = nil;
+	[super dealloc];
+}
+
+@end