javascriptmvc 3.0.0.pre15

data/lib/javascriptmvc/jquery/view/view.js

@@ -0,0 +1,296 @@
+if ( window.jQuery && jQuery.Controller ) {
+	steal.plugins("jquery/controller/view")
+}
+steal.plugins("jquery").then(function( $ ) {
+
+	// converts to an ok dom id
+	var toId = function( src ) {
+		return src.replace(/^\/\//, "").replace(/[\/\.]/g, "_")
+	},
+		// used for hookup ids
+		id = 1;
+
+	/**
+	 * @constructor jQuery.View
+	 * @tag core
+	 * View provides a uniform interface for using templates in JavaScriptMVC.  When templates 
+	 * [jQuery.View.static.register register] themselves, you are able to:
+	 * <ul>
+	 * 	
+	 *  <li>Use views with jQuery extensions [jQuery.fn.after after], [jQuery.fn.append append],
+	 *  	[jQuery.fn.before before], [jQuery.fn.html html], [jQuery.fn.prepend prepend],
+	 *      [jQuery.fn.replace replace], [jQuery.fn.text text] like:
+	 * @codestart
+	 * $('.foo').html("//path/to/view.ejs",{})
+	 * @codeend
+	 *  </li>
+	 *  <li>Compress your views with [steal.static.views].</li>
+	 *  <li>Use the [jQuery.Controller.prototype.view controller/view] plugin to auto-magically
+	 *  lookup views.</li>
+	 *  <li>Hookup Controllers and other code on elements after render.</li>
+	 *  
+	 * </ul>
+	 * 
+	 * <h2>Supported Templates</h2>
+	 * <ul>
+	 * 	<li>[jQuery.View.EJS EJS] - provides an ERB like syntax: <code>&lt;%= %&gt;</code></li>
+	 *  <li>[Jaml] - A functional approach to JS templates.</li>
+	 *  <li>[Micro] - A very lightweight template similar to EJS.</li>
+	 * </ul>
+	 * @iframe jquery/view/view.html 700
+	 *
+	 * 
+	 * <h2>Compress Views with Steal</h2>
+	 * Steal can package processed views in the production file. Because 'stolen' views are already
+	 * processed, they don't rely on eval.  Here's how to steal them:
+	 * @codestart
+	 * steal.views('//views/tasks/show.ejs');
+	 * @codeend
+	 * Read more about [steal.static.views steal.views].
+	 * <h2>Hooking up controllers</h2>
+	 * After drawing some html, you often want to add other widgets and plugins inside that html.
+	 * View makes this easy.  You just have to return the Contoller class you want to be hooked up.
+	 * @codestart
+	 * &lt;ul &lt;%= Phui.Tabs%>>...&lt;ul>
+	 * @codeend
+	 * You can even hook up multiple controllers:
+	 * @codestart
+	 * &lt;ul &lt;%= [Phui.Tabs, Phui.Filler]%>>...&lt;ul>
+	 * @codeend
+	 * @init Looks up a template, processes it, caches it, then renders the template
+	 * with data and optional helpers.
+	 * @codestart
+	 * $.View("//myplugin/views/init.ejs",{message: "Hello World"})
+	 * @codeend
+	 * @param {String} url The url or id of an element to use as the template's source.
+	 * @param {Object} data The data to be passed to the view.
+	 * @param {Object} [helpers] Optional helper functions the view might use.
+	 * @return {String} The rendered result of the view.
+	 */
+	$.View = function( url, data, helpers ) {
+		var suffix = url.match(/\.[\w\d]+$/),
+			type, el, url, id, renderer;
+
+		//if there is no suffix, add one
+		if (!suffix ) {
+			suffix = $.View.ext;
+			url = url + $.View.ext
+		}
+
+		//convert to a unique and valid id
+		id = toId(url);
+
+		//if a absolute path, use steal to get it
+		if ( url.match(/^\/\//) ) {
+			url = steal.root.join(url.substr(2)); //can steal be removed?
+		}
+
+		//get the template engine
+		type = $.View.types[suffix];
+
+		//get the renderer function
+		var renderer =
+		$.View.cached[id] ? // is it cached?
+		$.View.cached[id] : // use the cached version
+		((el = document.getElementById(id)) ? //is it in the document?
+		type.renderer(id, el.innerHTML) : //use the innerHTML of the elemnt
+		type.get(id, url) //do an ajax request for it
+		);
+
+		//if we should cache templates
+		if ( $.View.cache ) {
+			$.View.cached[id] = renderer;
+		}
+		return renderer.call(type, data, helpers)
+	};
+
+	/* @Static */
+	$.extend($.View, {
+		/**
+		 * @attribute hookups
+		 * @hide
+		 * A list of pending 'hookups'
+		 */
+		hookups: {},
+		/**
+		 * @function hookup
+		 * Registers a hookup function to be called back after the html is put on the page
+		 * @param {Function} cb a callback function to be called with the element
+		 * @param {Number} the hookup number
+		 */
+		hookup: function( cb ) {
+			var myid = ++id;
+			jQuery.View.hookups[myid] = cb;
+			return myid;
+		},
+		/**
+		 * @attribute cached
+		 * @hide
+		 * Cached are put in this object
+		 */
+		cached: {},
+		/**
+		 * @attribute cache
+		 * Should the views be cached or reloaded from the server. Defaults to true.
+		 */
+		cache: true,
+		/**
+		 * @function register
+		 * Registers a template engine to be used with view helpers and compression.  
+		 * @param {Object} info a object of method and properties that enable template integration:
+		 * <ul>
+		 * 		<li>suffix - the view extension.  EX: 'ejs'</li>
+		 * 		<li>get(id, url) - a function that returns the 'render' function of processed template.  <b>get</b>
+		 * 			function is called with an id for the template and the url where the view can be loaded.
+		 * 			The returned function's signiture should look like:
+		 * 			<pre>renderer(data, helpers)</pre>
+		 * 		</li>
+		 * 		<li>script(id, src) - a function that returns a string that when evaluated returns a function that can be 
+		 * 			used as the render (i.e. have func.call(data, data, helpers) called on it).</li>
+		 * 		<li>renderer(id, text) - a function that takes the id of the template and the text of the template and
+		 * 			returns a render function.</li>
+		 * </ul>
+		 */
+		register: function( info ) {
+			this.types["." + info.suffix] = info;
+		},
+		types: {},
+		/**
+		 * @attribute ext
+		 * The default suffix to use if none is provided in the view's url.  
+		 * This is set to .ejs by default.
+		 */
+		ext: ".ejs",
+		/**
+		 * @hide 
+		 * @param {Object} type
+		 * @param {Object} id
+		 * @param {Object} src
+		 */
+		registerScript: function( type, id, src ) {
+			return "$.View.preload('" + id + "'," + $.View.types["." + type].script(id, src) + ");";
+		},
+		/**
+		 * @hide
+		 * Called by a production script to pre-load a renderer function
+		 * into the view cache.
+		 * @param {String} id
+		 * @param {Function} renderer
+		 */
+		preload: function( id, renderer ) {
+			$.View.cached[id] = function( data, helpers ) {
+				return renderer.call(data, data, helpers)
+			}
+		}
+
+	})
+
+
+	//---- ADD jQUERY HELPERS -----
+	var
+	//converts jquery functions to use views	
+	convert = function( func_name ) {
+		var old = jQuery.fn[func_name];
+
+		jQuery.fn[func_name] = function() {
+			var args = arguments,
+				res, hasHookup, secArgType = typeof arguments[1];
+
+			//check if a template
+			if ( typeof arguments[0] == "string" && (secArgType == 'object' || secArgType == 'function') && !arguments[1].nodeType && !arguments[1].jquery ) {
+				args = [$.View.apply($.View, $.makeArray(arguments))];
+			}
+
+			//check if there are new hookups
+			for ( var hasHookups in jQuery.View.hookups ) {};
+
+			//if there are hookups, get jQuery object
+			if ( hasHookups ) {
+				args[0] = $(args[0])
+			}
+			res = old.apply(this, args)
+
+			//now hookup hookups
+			if ( hasHookups ) {
+				hookupView(args[0])
+			}
+			return res;
+		}
+	},
+		hookupView = function( els ) {
+			//remove all hookups
+			var hooks = jQuery.View.hookups,
+				hookupEls, len, i = 0,
+				id, func;
+			jQuery.View.hookups = {};
+			hookupEls = els.add("[data-view-id]", els);
+			len = hookupEls.length;
+			for (; i < len; i++ ) {
+				if ( hookupEls[i].getAttribute && (id = hookupEls[i].getAttribute('data-view-id')) && (func = hooks[id]) ) {
+					func(hookupEls[i], id);
+					delete hooks[id];
+					hookupEls[i].removeAttribute('data-view-id')
+				}
+			}
+			//copy remaining hooks back
+			$.extend(jQuery.View.hookups, hooks);
+		},
+		/**
+		 *  @add jQuery.fn
+		 */
+		funcs = [
+		/**
+		 *  @function prepend
+		 *  @tag view
+		 *  abc
+		 */
+		"prepend",
+		/**
+		 *  @function append
+		 *  @tag view
+		 *  abc
+		 */
+		"append",
+		/**
+		 *  @function after
+		 *  @tag view
+		 *  abc
+		 */
+		"after",
+		/**
+		 *  @function before
+		 *  @tag view
+		 *  abc
+		 */
+		"before",
+		/**
+		 *  @function replace
+		 *  @tag view
+		 *  abc
+		 */
+		"replace",
+		/**
+		 *  @function text
+		 *  @tag view
+		 *  abc
+		 */
+		"text",
+		/**
+		 *  @function html
+		 *  @tag view
+		 *  abc
+		 */
+		"html",
+		/**
+		 *  @function replaceWith
+		 *  @tag view
+		 *  abc
+		 */
+		"replaceWith"];
+
+	//go through helper funcs and convert
+	for ( var i = 0; i < funcs.length; i++ ) {
+		convert(funcs[i]);
+	}
+
+})

data/lib/javascriptmvc/js

@@ -0,0 +1,56 @@
+#!/bin/sh
+# This script checks for arguments, if they don't exist it opens the Rhino dialog
+# if arguments do exist, it loads the script in the first argument and passes the other arguments to the script
+# ie: ./js steal/script/controller Todo
+
+if [ $# -eq 0 ]
+then
+  java -cp steal/rhino/js.jar:funcunit/dist/selenium/selenium/selenium-java-client-driver.jar org.mozilla.javascript.tools.shell.Main
+  exit 127
+fi
+if [ $1 = "-selenium" ]
+then
+  java -jar funcunit/dist/selenium/selenium/selenium-server.jar
+  exit 127
+fi
+CP=funcunit/dist/selenium/selenium/selenium-java-client-driver.jar:steal/rhino/js.jar
+if [ $1 = "-mail" ]
+then
+	CP=steal/rhino/mail.jar:funcunit/dist/selenium/selenium/selenium-java-client-driver.jar:steal/rhino/js.jar
+	shift
+fi
+
+if [ $1 = "-h" -o $1 = "-?" -o $1 = "--help" ]
+then
+echo Load a command line Rhino JavaScript environment or run JavaScript script files in Rhino.
+echo Available commands:
+echo -e "./js\t\t\t\tOpens a command line JavaScript environment"
+echo -e "./js -d\t\t\t\tOpens the Rhino debugger"
+echo -e "./js [FILE]\t\t\tRuns FILE in the Rhino environment"
+echo -e ""
+echo  -e "JavaScriptMVC script usage:"
+echo  -e "./js steal/generate/app [NAME]\t\tCreates a new JavaScriptMVC application"
+echo  -e "./js steal/generate/page [APP] [PAGE]\tGenerates a page for the application"
+echo  -e "./js steal/generate/controller [NAME]\tGenerates a Controller file"
+echo  -e "./js steal/generate/model [TYPE] [NAME]\tGenerates a Model file"
+echo  -e "./js apps/[NAME]/compress.js\t\tCompress your application and generate documentation"
+  exit 127
+fi
+
+
+if [ $1 = "-d" ]
+then
+        java -classpath steal/rhino/js.jar:steal/rhino/selenium-java-client-driver.jar org.mozilla.javascript.tools.debugger.Main
+        exit 127
+fi
+
+ARGS=[
+for arg
+do
+  if [ $arg != $1 ]
+  then
+    ARGS=$ARGS"'$arg'",
+  fi
+done
+ARGS=$ARGS]
+java -Xss1024k -cp $CP org.mozilla.javascript.tools.shell.Main -e _args=$ARGS -opt -1 -e 'load('"'"$1"'"')'

data/lib/javascriptmvc/js.bat

@@ -0,0 +1,57 @@
+:: This script checks for arguments, if they don't exist it opens the Rhino dialog
+:: if arguments do exist, it loads the script in the first argument and passes the other arguments to the script
+:: ie: js jmvc\script\controller Todo
+@echo off
+SETLOCAL ENABLEDELAYEDEXPANSION
+if "%1"=="" (
+	java -cp steal\rhino\js.jar org.mozilla.javascript.tools.shell.Main
+	GOTO END
+)
+if "%1"=="-h" GOTO PRINT_HELP
+if "%1"=="-?" GOTO PRINT_HELP
+if "%1"=="--help" GOTO PRINT_HELP
+
+if "%1"=="-d" (
+	java -classpath funcunit/dist/selenium/selenium/selenium-java-client-driver.jar;steal/rhino/js.jar org.mozilla.javascript.tools.debugger.Main
+	GOTO END
+)
+if "%1"=="-selenium" (
+	java -jar funcunit\java\selenium-server.jar
+	GOTO END
+)
+SET CP=funcunit/dist/selenium/selenium/selenium-java-client-driver.jar;steal\rhino\js.jar
+if "%1"=="-mail" (
+	SET CP=steal/rhino/mail.jar;funcunit/dist/selenium/selenium/selenium-java-client-driver.jar;steal\rhino\js.jar
+	SHIFT /0
+)
+SET ARGS=[
+SET FILENAME=%1
+SET FILENAME=%FILENAME:\=/%
+::haven't seen any way to loop through all args yet, so for now this goes through arg 2-7
+for /f "tokens=2,3,4,5,6,7 delims= " %%a in ("%*") do SET ARGS=!ARGS!'%%a','%%b','%%c','%%d','%%e','%%f'
+::remove the commas
+for %%a in (",''=") do ( call set ARGS=%%ARGS:%%~a%% )
+::remove the spaces
+for /f "tokens=1*" %%A in ("%ARGS%") do SET ARGS=%%A
+SET ARGS=%ARGS%]
+set ARGS=%ARGS:\=/%
+java -Xss1024k -cp %CP% org.mozilla.javascript.tools.shell.Main -opt -1 -e _args=%ARGS% -e load('%FILENAME%')
+
+GOTO END
+
+:PRINT_HELP
+echo Load a command line Rhino JavaScript environment or run JavaScript script files in Rhino.
+echo Available commands:
+echo js				Opens a command line JavaScript environment
+echo js	-d			Opens the Rhino debugger
+echo js -selenium   Starts selenium server
+echo js [FILE]			Runs FILE in the Rhino environment
+
+echo JavaScriptMVC script usage:
+echo js steal/generate/app [NAME]	Creates a new JavaScriptMVC application
+echo js steal/generate/page [APP] [PAGE]	Generates a page for the application
+echo js steal/generate/controller [NAME]	Generates a Controller file
+echo js steal/generate/model [TYPE] [NAME]	Generates a Model file
+echo js apps/[NAME]/compress.js	Compress your application and generate documentation
+
+:END

data/lib/javascriptmvc/steal/README

@@ -0,0 +1,26 @@
+TOC:
+  A.  How to get (and contribute) to JMVC
+
+
+A.  How to get (and contribute) JMVC
+
+  1.  Start a new project in git.
+  
+  2.  Fork ....
+           http://github.com/jupiterjs/steal     and 
+           http://github.com/jupiterjs/javascriptmvc
+  
+  3.  Add steal, javascriptmvc, funcunit, and documentjs as submodules of your project...
+           git submodule add git@github.com:_YOU_/steal.git steal
+           git submodule add git@github.com:_YOU_/javascriptmvc.git jquery
+           git submodule add git@github.com:_YOU_/funcunit.git funcunit
+           git submodule add git@github.com:_YOU_/documentjs.git documentjs
+           
+      * Notice javascriptmvc is under the jquery folder
+  
+  4.  Learn a little more about submodules ...
+           http://johnleach.co.uk/words/archives/2008/10/12/323/git-submodules-in-n-easy-steps
+           
+  5.  Make changes in steal or jmvc, and push them back to your fork.
+  
+  6.  Make a pull request to your fork.

data/lib/javascriptmvc/steal/build/apps/apps.js

@@ -0,0 +1,208 @@
+steal(function( steal ) {
+
+	// recursively goes through steals and their dependencies.
+	var addDependencies = function( steel, files, app ) {
+		//add self to files
+		if ( !files[steel.path] ) {
+
+			var source = readFile(steel.path);
+			if ( steel.type && steal.build.types[steel.type] ) {
+
+				source = steal.build.types[steel.type]({
+					text: source,
+					id: steal.cleanId(steel.path)
+				});
+				print(" converting " + steel.path + " ");
+			} else {
+				print(" compressing " + steel.path + " ");
+
+			}
+			source = steal.build.builders.scripts.clean(source);
+			source = "" + steal.build.compressor(source, true);
+			//need to convert to other types.
+
+
+			files[steel.path] = {
+				path: steel.path,
+				apps: [],
+				dependencies: {},
+				size: source.length,
+				packaged: false,
+				source: source
+			}
+		}
+
+		var data = files[steel.path];
+
+		data.apps.push(app);
+		for ( var d = 0; d < steel.dependencies.length; d++ ) {
+			var dependency = steel.dependencies[d];
+			if ( dependency.dependencies ) { //this dependency was actually loaded
+				data.dependencies[dependency.path] = addDependencies(dependency, files, app);
+			}
+		}
+		return data;
+	},
+		/**
+		 * Adds an order to a directed acyclic graph 
+		 * @param {Object} appFiles
+		 */
+		orderFiles = function( appFiles ) {
+			var order = 0
+
+			function visit(f) {
+				if ( f.order === undefined ) {
+					for ( var name in f.dependencies ) {
+						visit(f.dependencies[name])
+					}
+					f.order = (order++);
+				}
+			}
+			for ( var d = 0; d < appFiles.length; d++ ) {
+				visit(appFiles[d])
+			}
+		},
+		getMostShared = function( files ) {
+			var shared = []; // count
+
+			for ( var fileName in files ) {
+				var file = files[fileName];
+				if ( file.packaged ) {
+					continue;
+				}
+				if (!shared[file.apps.length] ) {
+					shared[file.apps.length] = {};
+				}
+				var level = shared[file.apps.length]; //how many apps it is shared in (5?)
+
+
+				var appsName = file.apps.sort().join();
+
+
+
+				if (!level[appsName] ) {
+					level[appsName] = {
+						totalSize: 0,
+						files: [],
+						apps: file.apps
+					};
+				}
+				//add file, the count is how many files are shared among this many apps
+				level[appsName].files.push(file);
+				level[appsName].totalSize += file.size;
+			}
+			if (!shared.length ) {
+				return null;
+			}
+			//get the most
+			var mostShared = shared.pop(),
+				mostSize = 0,
+				most;
+			for ( var apps in mostShared ) {
+				if ( mostShared[apps].totalSize > mostSize ) {
+					most = mostShared[apps];
+					mostSize = most.totalSize;
+				}
+			}
+			//mark files 
+
+			for ( var i = 0; i < most.files.length; i++ ) {
+				var f = most.files[i];
+				f.packaged = true;
+			}
+			return most;
+		}
+
+
+		steal.build.apps = function( list, options ) {
+			options = steal.opts(options || {}, {
+				//compress everything, regardless of what you find
+				depth: 1,
+				//folder to build to, defaults to the folder the page is in
+				to: 1
+			});
+			// set the compressor globally
+			steal.build.compressor = steal.build.builders.scripts.compressors[options.compressor || "localClosure"]();
+
+			//a list of files hashed by their path
+			var files = {},
+
+				//keeps track of the packages an app needs
+				apps = {},
+
+				//a list of the apps (top most dependencies)
+				appFiles = [];
+
+			//set defaults
+			options.depth = options.depth || 2;
+			options.to = options.to || "packages/"
+
+			//go through, open each app, and make dependency graph
+			for ( var i = 0; i < list.length; i++ ) {
+				var startFile = list[i] + "/" + steal.File(list[i]).basename() + ".js"
+
+				var opener = steal.build.open('steal/rhino/blank.html', {
+					startFile: startFile
+				})
+				appFiles.push(addDependencies(opener.steal._start, files, list[i]));
+				apps[list[i]] = [];
+
+			}
+
+			//add an order so we can sort them nicely
+			orderFiles(appFiles);
+
+			// will be set to the biggest group
+			var pack,
+			//the package number
+			packageCount = 0;
+
+			//while there are files left to be packaged, get the most shared and largest package
+			while ((pack = getMostShared(files))) {
+
+				print('\njoining shared by ' + pack.apps.join(", "))
+
+				//the source of the package
+				var src = [],
+
+					//order the files, most base file first
+					ordered = pack.files.sort(function( f1, f2 ) {
+						return f1.order - f2.order;
+					});
+
+				// paths to files this package represents
+				var paths = [];
+
+				//go through files, put in src, and track
+				for ( var i = 0; i < ordered.length; i++ ) {
+					var f = ordered[i];
+					src.push("/* " + f.path + " */\n" + f.source);
+					print("  " + f.order + ":" + f.path);
+					paths.push(f.path)
+				}
+
+				//the final source, includes a steal of all the files in this source
+				var source = "steal('//" + paths.join("'\n,'//") + "');\nsteal.end();\n" + src.join(";steal.end();\n"),
+
+					//the path to save
+					saveFile = pack.apps.length == 1 ? pack.apps[0] + "/production.js" : "packages/" + packageCount + ".js";
+
+				//if we are the top most, replace production file with the following
+				if ( pack.apps.length == 1 ) {
+					var packages = apps[pack.apps[0]];
+					source = "steal.packs('" + packages.join("','") + "', function(){\n" + source + "\n});"
+				}
+
+				//save the file
+				print("saving " + saveFile);
+				steal.File(saveFile).save(source);
+
+				//add this package to the app's packages list
+				for ( var pa = 0; pa < pack.apps.length; pa++ ) {
+					apps[pack.apps[pa]].push(packageCount);
+				}
+				packageCount++;
+			}
+
+		}
+})