appjam 0.1.0.pre4

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Eiffel Q
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,27 @@
+= appjam
+
+appjam is iphone app generator, generate iphone app skeleton based on pure mvc framework.
+
+== Usage
+
+run command below in your favorite shell, appjam will generate your iphone app skeleton.
+
+$ gem install appjam 
+
+$ appjam User # Model name(like User)
+
+== Contributing to appjam
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Eiffel Q. See LICENSE.txt for
+further details.
+

data/bin/appjam

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rubygems' unless defined?(Gem) 
+
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+unless $LOAD_PATH.include?(lib_dir)
+  $LOAD_PATH << lib_dir
+end
+
+require 'appjam'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/appjam/generators/app')
+
+begin
+  Appjam::Generators::App.start(ARGV)
+rescue => e
+  STDERR.puts "Error: #{e}\n"
+  exit -1
+end

data/lib/appjam.rb

@@ -0,0 +1,50 @@
+require 'appjam/version.rb'
+require 'active_support' 
+
+module Appjam
+  ##
+  # This method return the correct location of mvc-gen bin or
+  # exec it using Kernel#system with the given args
+  #
+  def self.bin_gen(*args)
+    @_mvc_gen_bin ||= [IphoneMvc.ruby_command, File.expand_path("../bin/appjam", __FILE__)]
+    args.empty? ? @_mvc_gen_bin : system(args.unshift(@_mvc_gen_bin).join(" "))
+  end
+
+  ##
+  # This module it's used for register generators
+  #
+  module Generators
+
+    DEV_PATH = File.expand_path("../../", File.dirname(__FILE__))
+
+    class << self
+
+      ##
+      # Here we store our generators paths
+      #
+      def load_paths
+        @_files ||= []
+      end
+
+      ##
+      # Return a ordered list of task with their class
+      #
+      def mappings
+        @_mappings ||= ActiveSupport::OrderedHash.new
+      end
+
+      ##
+      # Gloabl add a new generator class
+      #
+      def add_generator(name, klass)
+        mappings[name] = klass
+      end
+    end
+  end # Generators
+end # IphoneMvc
+
+##
+# We add our generators to Appjam::Genererator
+#
+Appjam::Generators.load_paths << Dir[File.dirname(__FILE__) + '/appjam/generators/app.rb']

data/lib/appjam/generators/Classes/ContactsAppDelegate.h.tt

@@ -0,0 +1,18 @@
+//
+//  ContactsAppDelegate.h
+//  Contacts
+//
+//  Created by eiffel on 11-2-16.
+//  Copyright 2011 Redsafi. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface ContactsAppDelegate : NSObject <UIApplicationDelegate> {
+    UIWindow *window;
+}
+
+@property (nonatomic, retain) IBOutlet UIWindow *window;
+
+@end
+

data/lib/appjam/generators/Classes/ContactsAppDelegate.m.tt

@@ -0,0 +1,88 @@
+//
+//  ContactsAppDelegate.m
+//  Contacts
+//
+//  Created by eiffel on 11-2-16.
+//  Copyright 2011 Redsafi. All rights reserved.
+//
+
+#import "ContactsAppDelegate.h"
+#import "ApplicationFacade.h"
+#import "Contacts.h"
+
+@implementation ContactsAppDelegate
+
+@synthesize window;
+
+
+#pragma mark -
+#pragma mark Application lifecycle
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {    
+    
+    // Override point for customization after application launch.
+    window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+    Contacts *contacts = [[[Contacts alloc] initWithFrame:[window frame]] autorelease];
+	[[ApplicationFacade getInstance] startup:contacts];
+	[window addSubview:contacts];
+    [window makeKeyAndVisible];
+    
+    return YES;
+}
+
+
+- (void)applicationWillResignActive:(UIApplication *)application {
+    /*
+     Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
+     Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
+     */
+}
+
+
+- (void)applicationDidEnterBackground:(UIApplication *)application {
+    /*
+     Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. 
+     If your application supports background execution, called instead of applicationWillTerminate: when the user quits.
+     */
+}
+
+
+- (void)applicationWillEnterForeground:(UIApplication *)application {
+    /*
+     Called as part of  transition from the background to the inactive state: here you can undo many of the changes made on entering the background.
+     */
+}
+
+
+- (void)applicationDidBecomeActive:(UIApplication *)application {
+    /*
+     Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
+     */
+}
+
+
+- (void)applicationWillTerminate:(UIApplication *)application {
+    /*
+     Called when the application is about to terminate.
+     See also applicationDidEnterBackground:.
+     */
+}
+
+
+#pragma mark -
+#pragma mark Memory management
+
+- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application {
+    /*
+     Free up as much memory as possible by purging cached data objects that can be recreated (or reloaded from disk) later.
+     */
+}
+
+
+- (void)dealloc {
+    [window release];
+    [super dealloc];
+}
+
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/core/Controller.h

@@ -0,0 +1,54 @@
+//
+//  Controller.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 "IController.h"
+#import "IView.h"
+
+/**
+ * A Singleton <code>IController</code> implementation.
+ * 
+ * <P>
+ * In PureMVC, the <code>Controller</code> class follows the
+ * 'Command and Controller' strategy, and assumes these 
+ * responsibilities:
+ * <UL>
+ * <LI> Remembering which <code>ICommand</code>s 
+ * are intended to handle which <code>INotifications</code>.</LI>
+ * <LI> Registering itself as an <code>IObserver</code> with
+ * the <code>View</code> for each <code>INotification</code> 
+ * that it has an <code>ICommand</code> mapping for.</LI>
+ * <LI> Creating a new instance of the proper <code>ICommand</code>
+ * to handle a given <code>INotification</code> when notified by the <code>View</code>.</LI>
+ * <LI> Calling the <code>ICommand</code>'s <code>execute</code>
+ * method, passing in the <code>INotification</code>.</LI> 
+ * </UL>
+ * 
+ * <P>
+ * Your application must register <code>ICommands</code> with the 
+ * Controller.
+ * <P>
+ * The simplest way is to subclass </code>Facade</code>, 
+ * and use its <code>initializeController</code> method to add your 
+ * registrations.
+ *
+ * @see View, Observer, Notification, SimpleCommand, MacroCommand
+ */
+@interface Controller : NSObject <IController> {
+	NSMutableDictionary *commandMap;
+	id<IView> view;
+}
+
+@property(nonatomic, retain) NSMutableDictionary *commandMap;
+@property(nonatomic, retain) id<IView> view;
+
+-(id)init;
+-(void)initializeController;
++(id<IController>)getInstance;
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/core/Controller.m

@@ -0,0 +1,145 @@
+//
+//  Controller.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 "Controller.h"
+#import "View.h"
+#import "IObserver.h"
+#import "Observer.h"
+#import "ICommand.h"
+
+static id<IController> instance;
+
+@implementation Controller
+
+@synthesize commandMap, view;
+
+/**
+ * Constructor. 
+ * 
+ * <P>
+ * This <code>IController</code> implementation is a Singleton, 
+ * so you should not call the constructor 
+ * directly, but instead call the static Singleton 
+ * Factory method <code>[Controller getInstance]</code>
+ * 
+ * @throws NSException if Singleton instance has already been constructed
+ * 
+ */
+-(id)init {
+	if (instance != nil) {
+		[NSException raise:@"Controller Singleton already constructed! Use getInstance instead." format:@""];
+	} else if (self = [super init]) {
+		self.commandMap = [NSMutableDictionary dictionary];
+		[self initializeController];
+	}
+	return self;
+}
+
+/**
+ * Initialize the Singleton <code>Controller</code> instance.
+ * 
+ * <P>Called automatically by the constructor.</P> 
+ * 
+ * <P>Note that if you are using a subclass of <code>View</code>
+ * in your application, you should <i>also</i> subclass <code>Controller</code>
+ * and override the <code>initializeController</code> method in the 
+ * following way:</P>
+ * 
+ * @code
+ *		// ensure that the Controller is talking to my IView implementation
+ *		-(void)initializeController {
+ *			self.view = [MyView getInstance];
+ *		}
+ * @endcode
+ * 
+ * @return void
+ */
+-(void)initializeController {
+	self.view = [View getInstance];
+}
+
+/**
+ * <code>Controller</code> Singleton Factory method.
+ * 
+ * @return the Singleton instance of <code>Controller</code>
+ */
++(id<IController>)getInstance {
+	if (instance == nil) {
+		instance = [[self alloc] init];
+	}
+	return instance;
+}
+
+/**
+ * If an <code>ICommand</code> has previously been registered 
+ * to handle a the given <code>INotification</code>, then it is executed.
+ * 
+ * @param notification an <code>INotification</code>
+ */
+-(void)executeCommand:(id<INotification>)notification {
+	Class commandClassRef = [commandMap objectForKey:[notification name]];
+	if (commandClassRef == nil) {
+		return;
+	}
+	[[[[commandClassRef alloc] init] autorelease] execute:notification];
+}
+
+/**
+ * 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 [commandMap objectForKey:notificationName] != nil;
+}
+
+/**
+ * Register a particular <code>ICommand</code> class as the handler 
+ * for a particular <code>INotification</code>.
+ * 
+ * <P>
+ * If an <code>ICommand</code> has already been registered to 
+ * handle <code>INotification</code>s with this name, it is no longer
+ * used, the new <code>ICommand</code> is used instead.</P>
+ * 
+ * The Observer for the new ICommand is only created if this the 
+ * first time an ICommand has been regisered for this Notification name.
+ * 
+ * @param notificationName the name of the <code>INotification</code>
+ * @param commandClassRef the <code>Class</code> of the <code>ICommand</code>
+ */
+-(void)registerCommand:(NSString *)notificationName commandClassRef:(Class)commandClassRef {
+	if ([commandMap objectForKey:notificationName] == nil) {
+		id<IObserver> observer = [Observer withNotifyMethod:@selector(executeCommand:) notifyContext:self];
+		[view registerObserver:notificationName observer:observer];
+	}
+	[commandMap setObject:commandClassRef forKey:notificationName];
+}
+
+/**
+ * Remove a previously registered <code>ICommand</code> to <code>INotification</code> mapping.
+ * 
+ * @param notificationName the name of the <code>INotification</code> to remove the <code>ICommand</code> mapping for
+ */
+-(void)removeCommand:(NSString *)notificationName {
+	if ([self hasCommand:notificationName]) {
+		[view removeObserver:notificationName notifyContext:self];
+		[commandMap removeObjectForKey:notificationName];
+	}
+}
+
+-(void)dealloc {
+	self.commandMap = nil;
+	self.view = nil;
+	[(id)instance release];
+	instance = nil;
+	[super dealloc];
+}
+
+@end

data/lib/appjam/generators/Classes/org/puremvc/objectivec/core/Model.h

@@ -0,0 +1,47 @@
+//
+//  Model.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 "IModel.h"
+
+/**
+ * A Singleton <code>IModel</code> implementation.
+ * 
+ * <P>
+ * In PureMVC, the <code>Model</code> class provides
+ * access to model objects (Proxies) by named lookup. 
+ * 
+ * <P>
+ * The <code>Model</code> assumes these responsibilities:</P>
+ * 
+ * <UL>
+ * <LI>Maintain a cache of <code>IProxy</code> instances.</LI>
+ * <LI>Provide methods for registering, retrieving, and removing 
+ * <code>IProxy</code> instances.</LI>
+ * </UL>
+ * 
+ * <P>
+ * Your application must register <code>IProxy</code> instances 
+ * with the <code>Model</code>. Typically, you use an 
+ * <code>ICommand</code> to create and register <code>IProxy</code> 
+ * instances once the <code>Facade</code> has initialized the Core 
+ * actors.</p>
+ *
+ * @see Proxy, IProxy
+ */
+@interface Model : NSObject <IModel> {
+	NSMutableDictionary *proxyMap;
+}
+
+@property(nonatomic, retain) NSMutableDictionary *proxyMap;
+
+-(id)init;
+-(void)initializeModel;
++(id<IModel>)getInstance;
+
+@end