spade-packager 0.1.0

data/packages/jquery/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "jquery",
+  "version": "1.4.3",
+  "summary": "write less, do more",
+  "author": "The jQuery Team",
+  "homepage": "http://jquery.com",
+  "description": "jQuery library for easy DOM manipulation",
+  "platform": ["browser"],
+  "directories": { "lib": "." }
+}

data/packages/json/lib/main.js

@@ -0,0 +1,14 @@
+
+exports.compileFormat = function(json) {
+  return 'return '+json+';';
+};
+
+// TODO: make these work on browsers w/o JSON.
+
+exports.parse = function(str) {
+  return JSON.parse(str);
+};
+
+exports.stringify = function(obj) {
+  return JSON.stringify(obj);
+};

data/packages/json/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "json",
+  "version": "1.0.0",
+  
+  "plugin:formats": {
+    "json": "json/main"
+  }
+}

data/packages/lproj/README.md

@@ -0,0 +1,77 @@
+This package provides infrastructure you need to localize your application. 
+You can use this package to automatically load the correct resources for your
+application as well as to handle localizing strings.
+
+# Activating Localization
+
+To add localized resources to your application, just create folders in your 
+package named {LANG}.lproj where {LANG} is the two-letter language and region
+code for your language, such as "en-US" or US english or just "en" for generic
+english. Place all of your localized resources for the selected language inside of this directory.
+
+To load resources in your application, first you must load lproj and have it
+modify the require() function in your module to make it localization aware.
+You must put this line into any file that requires use of localization:
+
+    require('lproj');
+    var loc = lproj(require); // makes require localization aware
+    
+**IMPORTANT** You must assign the lproj require to the 'loc' property on 
+require.  Otherwise calling loc will not locate your resource properly.
+
+
+# Adding Localized Resources
+
+Then, whenever you want to require a resource from your current language, just
+use the require.loc() function:
+
+    require.loc('my-app/~lproj/hello');
+    
+The require.loc() function replaces the '~lproj' in your module path with a 
+reference to the proper localized resource.  It will lookup the resource path
+using the following algorithm:
+
+  * First it will look for the most specific current language (fr-FR.lproj)
+  * Then it will look for the generic language (fr.lproj)
+  * Then it will look in the default language (en.lproj)
+  * Finally it will look in the 'resources' directory (i.e. non-localized)
+
+Note that in addition, require.async() and require.exists() are automatically
+modified to support localization as well.
+
+# Localizing Strings
+
+In addition to localizing resources, lproj makes it easy to localize strings
+as well.  To localize a string, you just need to wrap it in a call to loc:
+
+    loc('Localize Me'); // returns a localized version
+    
+This will lookup the string in a strings file defined in the current package.
+A strings file is a special file that appears in the .lproj directory of a 
+package mapping unlocalized strings to localized strings.  The strings file 
+should appear in your lproj, named 'localized.strings' with each line having
+the following format:
+
+    "Localize Me": "I am localized"
+  
+This will map the unlocalized string "Localize Me" to the localized string "I
+am localized".
+
+Note that the loc() method only works because it is uniquely generated for 
+EACH module that you load.  This is important because it allows lproj to 
+lookup the proper resources for your package.
+
+If you want to get the localized string relative to another module, you can
+do so as well with the require.string() method (added when you run lproj()):
+
+    require.string("another-package", "Localize Me");
+    // returns the localized value of 'Localize Me' from another-package
+    
+You can also choose to localize a string using an alternate language by 
+passing the language as a second parameter:
+
+    loc('Localize Me', 'fr'); // localize into french from my package
+    require.string('another-package', 'Localize Me', 'fr');
+    
+
+

data/packages/lproj/examples/demo-app/en.lproj/localized.strings

@@ -0,0 +1,2 @@
+"_Hello World": "Hello World"
+

data/packages/lproj/examples/demo-app/fr.lproj/localized.strings

@@ -0,0 +1,3 @@
+"_Hello World": "Bonjour le monde"
+
+

data/packages/lproj/examples/demo-app/index.html

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <script src="spade-boot.js" data-require="demo-app" ></script>
+  </head>
+  <body>
+    <h1>Loading</h1>
+  </body>
+</html>

data/packages/lproj/examples/demo-app/lib/main.js

@@ -0,0 +1,7 @@
+/*globals lproj */
+
+require('lproj');
+require('jquery');
+
+var loc = lproj(require); // activate lproj
+$('h1').text(loc('_Hello World'));

data/packages/lproj/examples/demo-app/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "demo-app",
+  "description": "basic demo of the lproj project",
+  
+  "dependencies": {
+    "lproj": "0.5.0",
+    "jquery": "1.4.3"
+  }
+}

data/packages/lproj/lib/main.js

@@ -0,0 +1,78 @@
+/*globals lproj ENV */ 
+
+// NOTE: expects to be called with 'this' equal to require
+function lookupString(moduleId, string, lang) {
+  
+  // get the strings...
+  moduleId = moduleId ? this.normalize(moduleId) : this.id;
+  var packageId = moduleId.slice(0, moduleId.indexOf('/'));
+  var strings   = this.loc(packageId+'/~lproj/localized', lang);
+
+  return strings && strings[string] ? strings[string] : string;
+}
+
+/**
+  Modifies the passed require function to support localization.  Also 
+  generates a 'loc' function, which can be used to localize strings.
+*/
+lproj = function(req) {
+  
+  if (req._lproj) return req._lproj; // make indempotent
+  
+  var _exists = req.exists,
+      _async  = req.async,
+      _normalize = req.normalize;
+
+  req.language = ENV.LANG || 'en-US';
+  req.defaultLanguage = 'en-US';
+  
+  function locit(req, id, lang) {
+    var working, langs, ret, idx, len;
+
+    id = _normalize.call(req, id);
+    if (!id.match(/^[^\/]+\/~lproj\//)) return id; // nothing to do
+
+    if (!lang) lang = req.language ;
+    langs = [lang];
+    if (lang.indexOf('-')>=0) langs.push(lang.slice(0, lang.indexOf('-')));
+    if (req.defaultLanguage !== lang) {
+      lang = req.defaultLanguage;
+      langs.push(lang);
+      if (lang.indexOf('-')>=0) langs.push(lang.slice(0, lang.indexOf('-')));
+    }
+    
+    len = langs.length;
+    for(idx=0;idx<len; idx++) {
+      working = id.replace('/~lproj', '/~'+langs[idx]+'.lproj');
+      if (_exists.call(req, working)) return working;
+    }
+
+    return id;
+  }
+  
+  // upgrade require
+  req.loc = function(id,lang) { return this(locit(this, id, lang)); };
+  
+  req.exists = function(id, lang) { 
+    return _exists.call(this, locit(this, id, lang));
+  };
+  
+  req.async = function(id, lang, callback) {
+    if (!callback && ('function' === typeof callback)) {
+      callback = lang;
+      lang = null;
+    }
+    return _async.call(this, locit(this, id, lang), callback);
+  };
+  
+  req.normalize = function(id, lang) {
+    return locit(this, id, lang);
+  };  
+
+  // add string support
+  req.string = lookupString;
+  req._lproj = function(str, lang) { return req.string(null, str, lang); };
+  return req._lproj;
+};
+
+return lproj; 

data/packages/lproj/lib/strings-format.js

@@ -0,0 +1,6 @@
+
+exports.compileFormat = function(strings) {
+  // basically, the strings is like a simplified form of JSON.
+  // We should probably replace this with a real parser at some point.
+  return "return {"+strings+"};";
+};

data/packages/lproj/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "lproj",
+  "version": "0.5.0",
+  "description": "Localization support for spade packages",
+  
+  "plugin:formats": {
+    "strings": "lproj/strings-format"
+  }
+}

data/packages/optparse/README.md

@@ -0,0 +1,161 @@
+optparse-js
+===========
+
+Optparse-js is a command line option parser for Javascript. It's slightly based on Ruby's implementation optparse but with some differences (different languages has different needs) such as custom parsers. 
+
+All examples in this readme is using [Node.js](http://nodejs.org/). How ever, the library works with all kinds of Javascript implementations.
+
+
+QUICK START
+-----------
+
+The library defines one class, the OptionParser class. The class constructor takes one single argument, a list with a set of rules. Here is a quick example:
+
+	// Import the sys library
+	var sys = require('sys');
+
+	// Import the optparse library.
+	var optparse = require('optparse');
+	
+	// Define an option called ´´help´´. We give it a quick alias named ´´-h´´ 	
+	// and a quick help text.
+	var switches = [
+		['-h', '--help', 'Shows help sections']
+	];
+	
+	// Create a new OptionParser.
+	var parser = new optparse.OptionParser(switches);
+	
+	// Hook the help option. The callback will be executed when the OptionParser 
+	// hits the switch ´´-h´´ or ´´--help´´. Each representatio
+	parser.on('help', function() {
+		sys.puts('Help');
+	});
+	
+
+
+DEFINING RULES
+--------------
+The OptionParser constructor takes an Array with rules. Each rule is represented by an array (tuple) of two or three values. A typical rule definition may look like this:
+
+	['-h', '--help', 'Print this help']
+	
+	
+The first value is optional, and represents an alias for the long-named switch (the second value, in this case ´´--help´´). 
+
+The second argument is the actual rule. The rule must start with a double dash followed by a switch name (in this case ´help´). The OptionParser also supports special option arguments. Define an option argument in the rule by adding a named argument after the leading double dash and switch name (E.G '--port-number PORT_NUMBER'). The argument is then parsed to the option handler. To define an optional option argument, just add a braces around argument in the rule (E.G '--port-number [PORT_NUMBER]). The OptionParser also supports filter. More on that in in the section called ´Option Filters´.
+
+The third argument is an optional rule description. 
+
+
+OPTION FILTERS
+--------------
+Filters is a neat feature that let you filter option arguments. The OptionParser itself as already a set of built-in common filter's. These are:
+
+- NUMBER, supports both decimal and hexadecimal numbers.
+- DATE, filters arguments that matches YYYY-MM-DD. 
+- EMAIL, filters arguments that matches my@email.com.
+ 
+It's simple to use any of the filter above in your rule-set. Here is a quick example how to filter number: 
+
+	var rules = [
+		['--first-option NUMBER', 'Takes a number as argument'],
+		['--second-option [NUMBER]', 'Takes an optional number as argument']
+	]
+
+You can add your own set of filter by calling the *parser_instance.filter* method:
+
+	parser.filter('single_char', function(value) {
+		if(value.length != 1) throw "Filter mismatch.";
+		return value;
+	});
+
+
+OPTION PARSER
+-------------
+The OptionParser class has the following properties and methods:
+
+### string banner
+An optional usage banner. This text is included when calling ´´toString´´. Default value is: "Usage: [Options]".
+
+
+### string options_title
+An optional title for the options list. This text is included when calling ´´toString´´. Default value is: "Available options:".
+
+
+### function on(switch_or_arg_index, callback)
+Add's a callback for a switch or an argument (defined by index). Switch hooks MUST be typed witout the leading ´´--´´. This example show how to hook a switch:
+
+	parser.on('help', function(optional_argument) {
+		// Show help section
+	});
+	
+And this example show how to hook an argument (an option without the leading - or --): 
+
+	parser.on(0, function(opt) {
+		puts('The first non-switch option is:' +  opt);
+	});
+	
+It's also possible to define a default handler. The default handler is called when no rule's are meet. Here is an example how to add a ´default handler´:
+
+	parser.on(function(opt) {
+		puts('No handler was defined for option:' +  opt);
+	});
+	
+Use the wildcard handler to build a custom ´´on´´ handler.
+
+	parser.on('*', function(opt, value) {
+		puts('option=' + opt + ', value=' + value);
+	});
+	
+### function filter(name, callback)
+Adds a new filter extension to the OptionParser instance. The first argument is the name of the filter (trigger). The second argument is the actual filter  See the ´OPTION FILTERS´ section for more info. 
+
+It's possible to override the default filters by passing the value "_DEFAULT" to the ´´name´´ argument. The name of the filter is automatically transformed into 
+upper case.
+
+
+### function halt([callback]) 
+Interrupt's further parsing. This function should be called from an ´on´ -callbacks, to cancel the parsing. This can be useful when the program should ignore all other arguments (when displaying help or version information).
+
+The function also takes an optional callback argument. If the callback argument is specified, a ´halt´ callback will be added (instead of executing the ´halt´ command).
+
+Here is an example how to add an ´on_halt´ callback:
+
+	parser.halt(function() {
+		puts('An option callback interupted the parser');
+	});
+
+	
+### function parse(arguments)
+Start's parsing of arguments. This should be the last thing you do.
+
+
+### function options()
+Returns an Array with all defined option rules 
+
+
+### function toString()
+Returns a string representation of this OptionParser instance (a formatted help section).
+
+
+MORE EXAMPLES
+-------------
+See examples/nodejs-test.js and examples/browser-test-html for more info how to
+use the script. 
+
+
+SUGGESTIONS
+-----------
+All comments in how to improve this library is very welcome. Feel free post  suggestions to the [Issue tracker](http://github.com/jfd/optparse-js/issues), or even better, fork the repository to implement your own features.
+
+
+LICENSE
+-------
+Released under a MIT-style license.
+
+
+COPYRIGHT
+---------
+Copyright (c) 2009 Johan Dahlberg
+

data/packages/optparse/TODO

@@ -0,0 +1 @@
+- Support for Argument lists (for switches)

data/packages/optparse/examples/browser-test.html

@@ -0,0 +1,75 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+	"http://www.w3.org/TR/html4/strict.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-type" content="text/html; charset=utf-8">
+		<title>optparse.js example</title>
+		<script type="text/javascript" charset="utf-8" src="../src/optparse.js"></script>
+		<script>
+			// Arguments to be passed to the parser
+			var ARGS = ['-p', 'This is a message', '-i', 'test.html', '--debug'];
+			
+			// Define some options
+			var SWITCHES = [
+			    ['-i', '--include-file FILE', "Includes a file"],
+			    ['-p', '--print [MESSAGE]', "Prints a message on screen"],
+			    ['-d', '--debug', "Enables debug mode"],
+			];
+			
+			function puts(msg) {
+				var body = document.getElementById('body');
+				var pre = document.createElement('pre');
+				pre.innerHTML = msg;
+				body.appendChild(pre);
+			}
+		
+			function onLoad() {
+				puts("optparse.js");
+				
+			  	// Create a new OptionParser with defined switches
+			    var parser = new optparse.OptionParser(SWITCHES);
+
+			    // Internal variable to store options.
+			    var options = {
+			        debug: false,
+			        files: []
+			    };
+
+			    // Handle the first argument (switches excluded)
+			    parser.on(0, function(value) {
+			        puts("First non-switch argument is: " + value);
+			    });
+
+			    // Handle the --include-file switch
+			    parser.on('include-file', function(value) {
+			        options.files.push(value);
+			    });
+
+			    // Handle the --print switch
+			    parser.on('print', function(value) {
+			        puts('PRINT: ' + value);
+			    });
+
+			    // Handle the --debug switch
+			    parser.on('debug', function() {
+			        options.debug = true;
+			    });
+
+			    // Parse command line arguments
+			    parser.parse(ARGS);
+
+			    // Output all files that was included.
+			    puts("No of files to include: " + options.files.length);
+			    for(var i = 0; i < options.files.length; i++) {
+			        puts("File [" + (i + 1) + "]:" + options.files[i]);
+			    }
+
+			    // Is debug-mode enabled?
+			    puts("Debug mode is set to: " + options.debug);	
+			}
+		</script>
+	</head>
+	<body id="body" onload="onLoad()">
+		
+	</body>
+</html>