javascriptmvc 3.0.0.pre15

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

@@ -0,0 +1,4 @@
+// load("steal/build/apps/test.js")
+
+_args = ['cookbook','phui/combobox','phui/modal'];
+load("steal/buildjs");

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

@@ -0,0 +1,281 @@
+//used to build a page's script
+/*global steal : false, Envjs : false, jQuery : false*/
+
+steal(function( steal ) {
+	var window = (function() {
+		return this;
+	}).call(null, 0);
+
+	/**
+	 * 
+	 * @parent stealjs
+	 * 
+	 * <p>Builds an html page's JavaScript and CSS files by compressing and concatenating them into
+	 * a single or several files.
+	 * </p>
+	 * <p>Steal can also build multiple applications at the same time and separate 
+	 * 	shared dependencies into standalone cache-able scripts.</p>
+	 * <h2>How it works</h2>
+	 * <p><code>Steal.build</code> opens a page in Envjs to extract all scripts and styles
+	 * from the page.  It compresses the resources into production.js and production.css
+	 * files.</p>
+	 * <p>Steal.build works with or without using steal.js, so it could work with other script loaders.</p>
+	 * 
+	 * 
+	 * <h2>Building with steal.js.</h2>
+	 * <p>Building with steal is easy, just point the <code>steal/buildjs</code> script at your page and
+	 * give it the name of your application folder:</p>
+	 * @codestart no-highlight
+	 * js steal/buildjs path/to/page.html -to myapp
+	 * @codeend 
+	 * <p>If you generated a steal app or plugin, there's a handy script already ready for you:</p>
+	 * @codestart no-highlight
+	 * js myapp/scripts/build.js
+	 * @codeend 
+	 * <h2>Building without steal.js</h2>
+	 * You can compress and package any page's JavaScript by adding <code>compress="true"</code>
+	 * attributes to your script tag like the following:
+	 * @codestart html
+	 * &lt;script src="file1.js" type="text/javascript" compress="true">&lt;/script>
+	 * &lt;script src="file2.js" type="text/javascript" compress="true">&lt;/script>		
+	 * @codeend
+	 * and then running either:
+	 * @codestart no-highlight
+	 * js steal/buildjs path/to/page.html -to [OUTPUT_FOLDER]
+	 * @codeend 
+	 * or: 
+	 * @codestart no-highlight
+	 * js steal/buildjs http://hostname/path/page.html -to [OUTPUT_FOLDER]
+	 * @codeend  
+	 * This will compress file1.js and file2.js into a file package named production.js an put it in OUTPUT_FOLDER.
+	 * 
+	 * <h2>Common Problems</h2>
+	 * <p>If you are getting errors building a production build, it's almost certainly because Envjs is
+	 * close, but not quite a fully featured browser.  So, you have to avoid doing things in your page that
+	 * Envjs doesn't like before onload.  The most common problems are:</p>
+	 * <h5>Malformed HTML or unescaped characters</h5>
+	 * <p>Steal does not have as tolerant of an HTML parser as Firefox.  Make sure your page's tags look good.
+	 * Also, make sure you escape characters like &amp; to &amp;amp;
+	 * </p>
+	 * <h5>DOM manipulations before onload</h5>
+	 * <p>EnvJS supports most DOM manipulations.  But, it's not a graphical browser so it completely punts
+	 * on styles and dimensional DOM features.  It's easy to protect against this, just wait until 
+	 * document ready or onload to do these things.
+	 * </p>
+	 * <h5>Unending timeouts or intervals before onload</h5>
+	 * <p>Envjs won't quit running until all timeouts or intervals have completed.  If you have a reoccuring
+	 * 'process', consider starting it on document ready or onload.</p>
+	 * <h2>Building With Shared Dependencies</h2>
+	 * <p>
+	 * If you are using steal in a setting with multiple pages loading similar
+	 * functionality, it's typically a good idea to build the shared functionality in
+	 * its own script.  This way when a user switches pages, they don't have to load
+	 * that functionality again.
+	 * </p>
+	 * <p>
+	 * To do this, use the buildjs script with the names of your apps:
+	 * </p>
+	 * @codestart
+	 * ./js steal/buildjs myco/search myco/searchresults music
+	 * @codeend
+	 * <h2>steal.build function</h2>
+	 * Takes a url, extracts
+	 * @param {String} url an html page to compress
+	 * @param {Object} options An object literal with the following optional values:
+	 * <table class='options'>
+	 *       <tr>
+	 *           <th>Name</th><th>Description</th>
+	 *       </tr>
+	 *       <tr><td>to</td>
+	 *           <td>The folder to put the production.js and production.css files.</td></tr>
+	 *       <tr><td>all</td>
+	 *       <td>Concat and compress all scripts and styles.  By default, this is set to false, meaning
+	 *           scripts and styles have to opt into being compress with the <code>compress='true'</code> attribute.</td></tr>
+	 *     </table>
+	 */
+	steal.build = function( url, options ) {
+		
+		//convert options (which might be an array) into an object
+		options = steal.opts(options || {}, {
+			//compress everything, regardless of what you find
+			all: 1,
+			//folder to build to, defaults to the folder the page is in
+			to: 1
+		});
+
+		// to is the folder packages will be put in
+		options.to = options.to || (url.match(/https?:\/\//) ? 
+					"" : 
+					url.substr(0, url.lastIndexOf('/')));
+		
+		// make sure to ends with /
+		if ( options.to.match(/\\$/) === null && options.to !== '' ) {
+			options.to += "/";
+		}
+
+		print("Building to " + options.to);
+
+		var opener = steal.build.open(url);
+		
+		// iterates through the types of builders.  For now
+		// there are just scripts and styles builders
+		for ( var builder in steal.build.builders ) {
+			steal.build.builders[builder](opener, options);
+		}
+	};
+	
+	// a place for the builders
+	steal.build.builders = {}; //builders
+	
+	// a helper function that gets the src of a script and returns
+	// the content for that script
+	var loadScriptText = function( src ) {
+		var text = "",
+			base = "" + window.location,
+			url = src.match(/([^\?#]*)/)[1];
+
+		if ( url.match(/^\/\//) ) {
+			url = steal.root.join(url.substr(2)); //can steal be removed?
+		}
+		url = Envjs.uri(url, base);
+
+		if ( url.match(/^file\:/) ) {
+			url = url.replace("file:/", "");
+			text = readFile("/" + url);
+		}
+
+		if ( url.match(/^http\:/) ) {
+			text = readUrl(url);
+		}
+
+		return text;
+	};
+
+	// types conversion
+	// the idea is for each type to return JavaScript (or css) that
+	// should be in its place
+	steal.build.types = {
+		'text/javascript': function( script ) {
+			if ( script.src ) {
+				return loadScriptText(script.src, script);
+			}
+			else {
+				return script.text;
+			}
+		},
+		'text/css': function( script ) {
+			if ( script.href ) {
+				return loadScriptText(script.href, script);
+			}
+			else {
+				return script.text;
+			}
+		},
+		'text/ejs': function( script ) {
+			var text = script.text || loadScriptText(script.src),
+				id = script.id || script.getAttribute("id");
+			return jQuery.View.registerScript("ejs", id, text);
+		},
+		'text/micro': function( script ) {
+			var text = script.text || loadScriptText(script.src),
+				id = script.id || script.getAttribute("id");
+			return jQuery.View.registerScript("micro", id, text);
+		},
+		'text/jaml': function( script ) {
+			var text =  script.text || loadScriptText(script.src),
+				id = script.id || script.getAttribute("id");
+			return jQuery.View.registerScript("jaml", id, text);
+		},
+		'text/tmpl': function( script ) {
+			var text =  script.text || loadScriptText(script.src),
+				id = script.id || script.getAttribute("id");
+			return jQuery.View.registerScript("tmpl", id, text);
+		},
+		loadScriptText: loadScriptText
+	};
+
+	/**
+	 * @function open
+	 * Opens a page by:
+	 *   temporarily deleting the rhino steal
+	 *   opening the page with Envjs
+	 *   setting back rhino steal, saving envjs's steal as steal._steal;
+	 * @param {String} url the html page to open
+	 * @return {Object} an object with properties that makes extracting 
+	 * the content for a certain tag slightly easier.
+	 * 
+	 */
+	steal.build.open = function( url , stealData ) {
+		var scripts = [],
+
+		// save and remove the old steal
+			oldSteal = window.steal || steal,
+			newSteal;
+		delete window.steal;
+		if(stealData){
+			window.steal = stealData;
+		}
+		// get envjs
+		load('steal/rhino/env.js'); //reload every time
+		
+		// open the url
+		Envjs(url, {
+			scriptTypes: {
+				"text/javascript": true,
+				"text/envjs": true
+			},
+			fireLoad: false,
+			logLevel: 2,
+			afterScriptLoad: {
+				".*": function( script ) {
+					scripts.push(script);
+				}
+			},
+			onLoadUnknownTypeScript: function( script ) {
+				scripts.push(script);
+			},
+			afterInlineScriptLoad: function( script ) {
+				scripts.push(script);
+			}
+		});
+		
+		// set back steal
+		newSteal = window.steal;
+		window.steal = oldSteal;
+		window.steal._steal = newSteal;
+		
+		
+		// check if newSteal added any build types (used to convert less to css for example).
+		for ( var buildType in newSteal.build.types ) {
+			oldSteal.build.types[buildType] = newSteal.build.types[buildType];
+		}
+
+		// return the helper
+		return {
+			/**
+			 * @hide
+			 * Gets all elements of a type, extracts their converted content, and calls a callback function with  
+			 * each element and its converted content.
+			 * @param {Object} [type] the tag to get
+			 * @param {Object} func a function to call back with the element and its content
+			 */
+			each: function( type, func ) {
+				if ( typeof type == 'function' ) {
+					func = type;
+					type = 'script';
+				}
+				var scripts = document.getElementsByTagName(type);
+				for ( var i = 0; i < scripts.length; i++ ) {
+					func(scripts[i], this.getScriptContent(scripts[i]), i);
+				}
+			},
+			getScriptContent: function( script ) {
+				return steal.build.types[script.type] && steal.build.types[script.type](script, loadScriptText);
+			},
+			// the 
+			steal: newSteal,
+			url: url
+		};
+	};
+
+});

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

@@ -0,0 +1,73 @@
+// usage: 
+// js steal\scripts\pluginify.js funcunit/functional -destination funcunit/dist/funcunit.js
+// js steal\scripts\pluginify.js jquery/controller
+// js steal\scripts\pluginify.js jquery/event/drag -exclude jquery/lang/vector/vector.js jquery/event/livehack/livehack.js
+// load("steal/rhino/steal.js");
+
+
+load("steal/rhino/steal.js");
+steal.plugins('steal/build','steal/build/scripts',function(){
+	
+/**
+ * 
+ * @param {Object} plugin
+ * @param {Object} opts
+ */
+steal.pluginify = function(plugin, opts){
+
+	var jq = true;
+	opts = steal.opts(opts, {
+		"destination": 1,
+		"exclude": -1,
+		"nojquery": 0,
+		"packagejquery": 0
+	}), destination = opts.destination || plugin + ".js";
+	
+	opts.exclude = !opts.exclude ? [] :
+		(steal.isArray(opts.exclude) ? opts.exclude : [opts.exclude]);
+		
+	if(opts.nojquery){
+		jq = false
+	}
+	if(!opts.packagejquery){
+		opts.exclude.push('jquery.js')
+	}
+	rhinoLoader = {
+		callback: function(s){
+			s.plugin(plugin)
+		}
+	}
+	
+	steal.win().build_in_progress = true;
+	
+	var pageSteal = steal.build.open("steal/rhino/empty.html").steal, 
+		out = [], 
+		str, 
+		i, 
+		inExclude = function(path){
+			for (var i = 0; i < opts.exclude.length; i++) {
+				if (opts.exclude[i].indexOf(path) > -1) {
+					return true
+				}
+			}
+			return false;
+		};
+
+	for (i = 0; i < pageSteal.total.length; i++) {
+		if (typeof pageSteal.total[i].func == "function") {
+			filePath = pageSteal.total[i].path;
+			if (!inExclude(filePath)) {
+				file = readFile(filePath);
+				match = file.match(/\.then\(\s*function\s*\([^\)]*\)\s*\{([\s\S]*)\}\s*\)\s*;*\s*/im)
+				str = "// " + filePath + "\n\n"
+				str += "(function($){\n" + steal.build.builders.scripts.clean(match[1]) + "\n})(" + (jq ? "jQuery" : "") + ");\n\n"
+				out.push(str);
+			}
+		}
+	}
+	print("saving to " + destination);
+	new steal.File(destination).save(out.join(""));
+	//print("pluginified " + plugin)
+}
+
+})

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

@@ -0,0 +1,155 @@
+steal(function( steal ) {
+
+	/**
+	 * Builds JavaScripts
+	 * @param {Object} opener the result of a steal.build.open
+	 * @param {Object} options options passed to the build script
+	 */
+	var scripts = (steal.build.builders.scripts = function( opener, options ) {
+		print("\nBUILDING SCRIPTS --------------- ");
+
+		// get the compressor
+		var compressor = scripts.compressors[options.compressor || "localClosure"](),
+
+			// packages that can be compressed somewhere
+			packages = {},
+
+			// the current package
+			currentPackage = [];
+
+		// compress all scripts by default
+		if ( options.all ) {
+			packages['production.js'] = currentPackage;
+		}
+
+		// for each script we find
+		opener.each("script", function( script, text, i ) {
+
+			// if we should ignore it, ignore it
+			if ( script.getAttribute('ignore') == "true" ) {
+				if ( script.src ) {
+					print('   ignoring ' + script.src);
+				}
+				return;
+			}
+
+			// if it has a src, let people know we are compressing it
+			if ( script.src ) {
+				print("   " + script.src.replace(/\?.*$/, "").replace(/^(\.\.\/)+/, ""));
+			}
+
+			// get the package, this will be production.js
+			var pack = script.getAttribute('package');
+
+
+			if ( pack ) {
+				//if we don't have it, create it and set it to the current package
+				if (!packages[pack] ) {
+					packages[pack] = [];
+				}
+				currentPackage = packages[pack];
+			}
+
+			// clean out any remove-start style comments
+			text = scripts.clean(text);
+
+			// if we should compress the script, compress it
+			if ( script.getAttribute('compress') == "true" || options.all ) {
+				text = compressor(text, true);
+			}
+
+			// put the result in the package
+			currentPackage.push(text);
+		});
+
+		print("");
+
+		// go through all the packages
+		for ( var p in packages ) {
+			if ( packages[p].length ) {
+				//join them
+				var compressed = packages[p].join(";\n");
+				//save them
+				new steal.File(options.to + p).save(compressed);
+				print("SCRIPT BUNDLE > " + options.to + p);
+			}
+		}
+	});
+	// removes  dev comments from text
+	scripts.clean = function( text ) {
+		return String(java.lang.String(text).replaceAll("(?s)\/\/@steal-remove-start(.*?)\/\/@steal-remove-end", "").replaceAll("steal[\n\s\r]*\.[\n\s\r]*dev[\n\s\r]*\.[\n\s\r]*(\\w+)[\n\s\r]*\\([^\\)]*\\)", ""));
+	};
+
+	//various compressors
+	scripts.compressors = {
+		// needs shrinksafe.jar at steal/build/javascripts/shrinksafe.jar
+		shrinksafe: function() {
+			print("steal.compress - Using ShrinkSafe");
+			// importPackages/Class doesn't really work
+			var URLClassLoader = Packages.java.net.URLClassLoader,
+				URL = java.net.URL,
+				File = java.io.File,
+				ss = new File("steal/build/javascripts/shrinksafe.jar"),
+				ssurl = ss.toURL(),
+				urls = java.lang.reflect.Array.newInstance(URL, 1);
+			urls[0] = new URL(ssurl);
+
+			var clazzLoader = new URLClassLoader(urls),
+				mthds = clazzLoader.loadClass("org.dojotoolkit.shrinksafe.Compressor").getDeclaredMethods(),
+				rawCompress = null;
+
+			//iterate through methods to find the one we are looking for
+			for ( var i = 0; i < mthds.length; i++ ) {
+				var meth = mthds[i];
+				if ( meth.toString().match(/compressScript\(java.lang.String,int,int,boolean\)/) ) {
+					rawCompress = meth;
+				}
+			}
+			return function( src ) {
+				var zero = new java.lang.Integer(0),
+					one = new java.lang.Integer(1),
+					tru = new java.lang.Boolean(false),
+					script = new java.lang.String(src);
+				return rawCompress.invoke(null, script, zero, one, tru);
+			};
+		},
+		closureService: function() {
+			print("steal.compress - Using Google Closure Service");
+
+			return function( src ) {
+				var xhr = new XMLHttpRequest();
+				xhr.open("POST", "http://closure-compiler.appspot.com/compile", false);
+				xhr.setRequestHeader["Content-Type"] = "application/x-www-form-urlencoded";
+				var params = "js_code=" + encodeURIComponent(src) + "&compilation_level=WHITESPACE_ONLY" + "&output_format=text&output_info=compiled_code";
+				xhr.send(params);
+				return "" + xhr.responseText;
+			};
+		},
+		localClosure: function() {
+			//was unable to use SS import method, so create a temp file
+			print("steal.compress - Using Google Closure app");
+			return function( src, quiet ) {
+				var rnd = Math.floor(Math.random() * 1000000 + 1),
+					filename = "tmp" + rnd + ".js",
+					tmpFile = new steal.File(filename);
+
+				tmpFile.save(src);
+
+				var outBaos = new java.io.ByteArrayOutputStream(),
+					output = new java.io.PrintStream(outBaos);
+				if ( quiet ) {
+					runCommand("java", "-jar", "steal/build/scripts/compiler.jar", "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--warning_level", "QUIET", "--js", filename, {
+						output: output
+					});
+				} else {
+					runCommand("java", "-jar", "steal/build/scripts/compiler.jar", "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--js", filename, {
+						output: output
+					});
+				}
+				tmpFile.remove();
+
+				return outBaos.toString();
+			};
+		}
+	};
+});