jazz-jss 0.0.2 → 0.0.3

data/templates/app_root/scripts/r.js/README.md

@@ -0,0 +1,177 @@
+# r.js
+
+A command line tool for running JavaScript scripts that use the
+[Asychronous Module Defintion API (AMD)](http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition)
+for declaring and using JavaScript modules and regular JavaScript script files.
+
+It is part of the [RequireJS project](http://requirejs.org), and works will with
+the RequireJS implementation of AMD.
+
+r.js is a single script that has two major functions:
+
+* Run AMD-based projects in Node and Rhino.
+* Includes the RequireJS Optimizer that combines scripts for optimal browser
+delivery.
+
+Releases of r.js are kept in the **dist** directory. To build your own from
+the files in this repo, run:
+
+    node dist.js
+
+That will generate an r.js file in the same directory as dist.js
+
+
+# Running AMD-based projects
+
+If your JS project's main application file is called main.js, then do
+the following:
+
+## Node
+
+    node path/to/r.js main.js
+
+Requires Node 0.4 or later.
+
+r.js allows using Node modules installed via npm. For more info see the
+[Use with Node](http://requirejs.org/docs/node.html) docs.
+
+## Java
+
+Java requires some JAR files in the CLASSPATH for it to work:
+
+* [rhino.jar](https://github.com/jrburke/r.js/blob/master/lib/rhino/js.jar?raw=true) from the [Rhino project](http://www.mozilla.org/rhino/).
+* [compiler.jar](https://github.com/jrburke/r.js/blob/master/lib/closure/compiler.jar?raw=true) if you are using the optimizer and want to use
+[Closure Compiler](http://code.google.com/closure/compiler/).
+
+Download those files to your machine. To run r.js, you can use this type of
+command:
+
+### OS X/Linux/Unix:
+
+    java -classpath path/to/rhino/js.jar:path/to/closure/compiler.jar org.mozilla.javascript.tools.shell.Main r.js main.js
+
+### Windows
+
+    java -classpath path/to/rhino/js.jar;path/to/closure/compiler.jar org.mozilla.javascript.tools.shell.Main r.js main.js
+
+If you want to run it in the debugger, replace
+org.mozilla.javascript.tools.shell.Main with
+**org.mozilla.javascript.tools.debugger.Main**.
+
+All further examples will use the Node notation, but substitute **node r.js** in the commands with the appropriate java command.
+
+# Optimizer
+
+The optimizer can be run by passing the **-o** command to r.js:
+
+    node r.js -o path/to/buildconfig.js
+
+See the [Optimization doc](http://requirejs.org/docs/optimization.html) for more
+information on the optimizer.
+
+If running in **Java**, be sure to grab the Rhino and Closure Compiler jar files in the lib/ directory, then run this command:
+
+### OS X/Linux/Unix:
+
+    java -classpath path/to/rhino/js.jar:path/to/closure/compiler.jar org.mozilla.javascript.tools.shell.Main r.js -o path/to/buildconfig.js
+
+### Windows
+
+    java -classpath path/to/rhino/js.jar;path/to/closure/compiler.jar org.mozilla.javascript.tools.shell.Main r.js -o path/to/buildconfig.js
+
+
+## What makes it special
+
+The optimizer is better than using a plain concatenation script because it runs
+require.js as part of the optimization, so it knows how to:
+
+* Use [Loader Plugins](http://requirejs.org/docs/plugins.html) to load non-script
+dependencies and inline them in built files.
+* [Name anonymous modules](http://requirejs.org/docs/api.html#modulename).
+If your optimization step does not do this, and you use anonymous modules, you
+will get errors running the built code.
+
+# Other r.js commands
+
+## Get Version
+
+To get the version of r.js and the version of require.js used by r.js:
+
+    node r.js -v
+
+## Convert CommonJS modules
+
+To convert a directory of CommonJS modules to ones that have define() wrappers:
+
+    node r.js -convert path/to/commonjs/dir output/dir
+
+Most, but not all, CommonJS modules can be converted to define()-wrapped modules
+and still work.
+
+However, there are some modules that may fail if:
+
+* They use code branches like if/else or try/catch to call require(). There are
+problems supporting this kind of dynamic module calls in an async environment.
+* Some kinds of circular dependencies will not work right. The kinds that fail
+are normally very brittle and depend on the execution order of the dependent
+modules.
+
+# Directory layout
+
+**NOTE**: If you clone this repository, it **must** be a sibling to a clone of the
+[RequireJS repository](https://github.com/jrburke/requirejs), where that
+repository is called **requirejs**. Otherwise the tests will not run.
+
+* **dist.js**: the script that builds r.js
+* **require.js**: the version of require.js to include in r.js
+* **dist** the directory containing releases of r.js
+* **build**: The files that make up the optimizer. dist.js includes a list of
+the files from this directory to build into r.js.
+* **lib**: The Java libraries for Rhino and Closure Compiler. Only needed if using
+Java/Rhino to run r.js
+* **tests**: command line tests. Run it under Node and Rhino by doing ../r.js all.js
+
+dist.js takes the build/jslib/x.js file and injects the require.js files and other
+files from the build/jslib directory into it.
+
+If you make changes to any of those files, you will need to run **node dist.js**
+to generate a new r.js. Be sure to run it through the tests , using both Node
+and Java/Rhino:
+
+    * node dist.js
+    * cd tests
+    * node ../r.js all.js
+    * java -classpath ../lib/rhino/js.jar:../lib/closure/compiler.jar org.mozilla.javascript.tools.shell.Main ./r.js all.js
+    * cd ../build/tests
+    * node ../../r.js all.js
+    * java -classpath ../../lib/rhino/js.jar:../../lib/closure/compiler.jar org.mozilla.javascript.tools.shell.Main ../../r.js all.js
+
+# Contributing code changes
+
+See the [RequireJS Contributing](http://requirejs.org/docs/contributing.html)
+page for info on how to contribute code/bug fixes to this project.
+
+Use GitHub pull requests to point to code changes, although for larger changes,
+contact the [requirejs mailing list](http://groups.google.com/group/requirejs)
+to discuss them first.
+
+# Doing a release
+
+To do a release of version 0.0.0:
+
+* git checkout -b 0.0.0
+* Make sure the right version of require.js is in the project.
+* Modify build/jslib/x.js to update the r.js version number in two places.
+* node dist.js
+* Run the tests (see above). They should pass. :)
+* mv r.js dist/r-0.0.0.js
+* git add dist/r-0.0.0.js
+* git commit -a -m "Release 0.0.0"
+* git tag -am "Release 0.0.0" 0.0.0
+* git checkout master
+* git merge 0.0.0
+* git push origin master
+* git push --tags
+* git branch -d 0.0.0
+
+Update the RequireJS download site to point to the latest release.

data/templates/app_root/scripts/r.js/build/build.js

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*
+ * Create a build.js file that has the build options you want and pass that
+ * build file to this file to do the build. See example.build.js for more information.
+ */
+
+/*jslint strict: false, nomen: false */
+/*global require: false */
+
+require({
+    baseUrl: require.s.contexts._.config.baseUrl,
+    //Use a separate context than the default context so that the
+    //build can use the default context.
+    context: 'build',
+    catchError: {
+        define: true
+    }
+},       ['env!env/args', 'build'],
+function (args,            build) {
+    build(args);
+});

data/templates/app_root/scripts/r.js/build/buildebug.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+MYDIR=`cd \`dirname "$0"\`; pwd`
+$MYDIR/../bin/xdebug $MYDIR/build.js "$@"

data/templates/app_root/scripts/r.js/build/example.build.js

@@ -0,0 +1,296 @@
+/*
+ * This is an example build file that demonstrates how to use the build system for
+ * require.js.
+ *
+ * THIS BUILD FILE WILL NOT WORK. It is referencing paths that probably
+ * do not exist on your machine. Just use it as a guide.
+ *
+ *
+ */
+
+({
+    //The top level directory that contains your app. If this option is used
+    //then it assumed your scripts are in a subdirectory under this path.
+    //This option is not required. If it is not specified, then baseUrl
+    //below is the anchor point for finding things. If this option is specified,
+    //then all the files from the app directory will be copied to the dir:
+    //output area, and baseUrl will assume to be a relative path under
+    //this directory.
+    appDir: "some/path/",
+
+    //By default, all modules are located relative to this path. If baseUrl
+    //is not explicitly set, then all modules are loaded relative to
+    //the directory that holds the build file. If appDir is set, then
+    //baseUrl should be specified as relative to the appDir.
+    baseUrl: "./",
+
+    //Set paths for modules. If relative paths, set relative to baseUrl above.
+    //If a special value of "empty:" is used for the path value, then that
+    //acts like mapping the path to an empty file. It allows the optimizer to
+    //resolve the dependency to path, but then does not include it in the output.
+    //Useful to map module names that are to resources on a CDN or other
+    //http: URL when running in the browser and during an optimization that
+    //file should be skipped because it has no dependencies.
+    paths: {
+        "foo.bar": "../scripts/foo/bar",
+        "baz": "../another/path/baz"
+    },
+
+    //Configure CommonJS packages. See http://requirejs.org/docs/api.html#packages
+    //for more information.
+    packagePaths: [],
+    packages: [],
+
+    //The directory path to save the output. If not specified, then
+    //the path will default to be a directory called "build" as a sibling
+    //to the build file. All relative paths are relative to the build file.
+    dir: "../some/path",
+
+    //Used to inline i18n resources into the built file. If no locale
+    //is specified, i18n resources will not be inlined. Only one locale
+    //can be inlined for a build. Root bundles referenced by a build layer
+    //will be included in a build layer regardless of locale being set.
+    locale: "en-us",
+
+    //How to optimize all the JS files in the build output directory.
+    //Right now only the following values
+    //are supported:
+    //- "uglify": (default) uses UglifyJS to minify the code.
+    //- "closure": uses Google's Closure Compiler in simple optimization
+    //mode to minify the code. Only available if running the optimizer using
+    //Java.
+    //- "closure.keepLines": Same as closure option, but keeps line returns
+    //in the minified files.
+    //- "none": no minification will be done.
+    optimize: "uglify",
+
+    //If using UglifyJS for script optimization, these config options can be
+    //used to pass configuration values to UglifyJS.
+    //See https://github.com/mishoo/UglifyJS for the possible values.
+    uglify: {
+        gen_codeOptions: {},
+        strict_semicolons: {},
+        do_toplevel: {},
+        ast_squeezeOptions: {}
+    },
+
+    //If using Closure Compiler for script optimization, these config options
+    //can be used to configure Closure Compiler. See the documentation for
+    //Closure compiler for more information.
+    closure: {
+        CompilerOptions: {},
+        CompilationLevel: 'SIMPLE_OPTIMIZATIONS',
+        loggingLevel: 'WARNING'
+    }
+
+    //Allow CSS optimizations. Allowed values:
+    //- "standard": @import inlining, comment removal and line returns.
+    //Removing line returns may have problems in IE, depending on the type
+    //of CSS.
+    //- "standard.keepLines": like "standard" but keeps line returns.
+    //- "none": skip CSS optimizations.
+    optimizeCss: "standard.keepLines",
+
+    //If optimizeCss is in use, a list of of files to ignore for the @import
+    //inlining. The value of this option should be a comma separated list
+    //of CSS file names to ignore. The file names should match whatever
+    //strings are used in the @import calls.
+    cssImportIgnore: null,
+
+    //Inlines the text for any text! dependencies, to avoid the separate
+    //async XMLHttpRequest calls to load those dependencies.
+    inlineText: true,
+
+    //Allow "use strict"; be included in the RequireJS files.
+    //Default is false because there are not many browsers that can properly
+    //process and give errors on code for ES5 strict mode,
+    //and there is a lot of legacy code that will not work in strict mode.
+    useStrict: false,
+
+    //Specify build pragmas. If the source files contain comments like so:
+    //>>excludeStart("fooExclude", pragmas.fooExclude);
+    //>>excludeEnd("fooExclude");
+    //Then the comments that start with //>> are the build pragmas.
+    //excludeStart/excludeEnd and includeStart/includeEnd work, and the
+    //the pragmas value to the includeStart or excludeStart lines
+    //is evaluated to see if the code between the Start and End pragma
+    //lines should be included or excluded. If you have a choice to use
+    //"has" code or pragmas, use "has" code instead. Pragmas are harder
+    //to read, but they can be a bit more flexible on code removal vs.
+    //has-based code, which must follow JavaScript language rules.
+    //Pragmas also remove code in non-minified source, where has branch
+    //trimming is only done if the code is minified via UglifyJS or
+    //Closure Compiler.
+    pragmas: {
+        fooExclude: true
+    },
+
+    //Same as "pragmas", but only applied once during the file save phase
+    //of an optimization. "pragmas" are applied both during the dependency
+    //mapping and file saving phases on an optimization. Some pragmas
+    //should not be processed during the dependency mapping phase of an
+    //operation, such as the pragma in the CoffeeScript loader plugin,
+    //which wants the CoffeeScript compiler during the dependency mapping
+    //phase, but once files are saved as plain JavaScript, the CoffeeScript
+    //compiler is no longer needed. In that case, pragmasOnSave would be used
+    //to exclude the compiler code during the save phase.
+    pragmasOnSave: {
+        //Just an example
+        excludeCoffeeScript: true
+    },
+
+    //Allows trimming of code branches that use has.js-based feature detection:
+    //https://github.com/phiggins42/has.js
+    //The code branch trimming only happens if minification with UglifyJS or
+    //Closure Compiler is done. For more information, see:
+    //http://requirejs.org/docs/optimization.html#hasjs
+    has: {
+        'function-bind': true,
+        'string-trim': false
+    },
+
+    //Similar to pragmasOnSave, but for has tests -- only applied during the
+    //file save phase of optimization, where "has" is applied to both
+    //dependency mapping and file save phases.
+    hasOnSave: {
+        'function-bind': true,
+        'string-trim': false
+    },
+
+    //Allows namespacing requirejs, require and define calls to a new name.
+    //This allows stronger assurances of getting a module space that will
+    //not interfere with others using a define/require AMD-based module
+    //system. The example below will rename define() calls to foo.define().
+    //See http://requirejs.org/docs/faq-advanced.html#rename for a more
+    //complete example.
+    namespace: 'foo',
+
+    //Skip processing for pragmas.
+    skipPragmas: false,
+
+    //If skipModuleInsertion is false, then files that do not use define()
+    //to define modules will get a define() placeholder inserted for them.
+    //Also, require.pause/resume calls will be inserted.
+    //Set it to true to avoid this. This is useful if you are building code that
+    //does not use require() in the built project or in the JS files, but you
+    //still want to use the optimization tool from RequireJS to concatenate modules
+    //together.
+    skipModuleInsertion: false,
+
+    //If it is not a one file optimization, scan through all .js files in the
+    //output directory for any plugin resource dependencies, and if the plugin
+    //supports optimizing them as separate files, optimize them. Can be a
+    //slower optimization. Only use if there are some plugins that use things
+    //like XMLHttpRequest that do not work across domains, but the built code
+    //will be placed on another domain.
+    optimizeAllPluginResources: false,
+
+    //Finds require() dependencies inside a require() or define call. By default
+    //this value is false, because those resources should be considered dynamic/runtime
+    //calls. However, for some optimization scenarios,
+    //Introduced in 1.0.3. Previous versions incorrectly found the nested calls
+    //by default.
+    findNestedDependencies: false,
+
+    //List the modules that will be optimized. All their immediate and deep
+    //dependencies will be included in the module's file when the build is
+    //done. If that module or any of its dependencies includes i18n bundles,
+    //only the root bundles will be included unless the locale: section is set above.
+    modules: [
+        //Just specifying a module name means that module will be converted into
+        //a built file that contains all of its dependencies. If that module or any
+        //of its dependencies includes i18n bundles, they may not be included in the
+        //built file unless the locale: section is set above.
+        {
+            name: "foo/bar/bop",
+
+            //For build profiles that contain more than one modules entry,
+            //allow overrides for the properties that set for the whole build,
+            //for example a different set of pragmas for this module.
+            //The override's value is an object that can
+            //contain any of the other build options in this file.
+            override: {
+                pragmas: {
+                    fooExclude: true
+                }
+            }
+        },
+
+        //This module entry combines all the dependencies of foo/bar/bop and foo/bar/bee
+        //and any of their dependencies into one file.
+        {
+            name: "foo/bar/bop",
+            include: ["foo/bar/bee"]
+        },
+
+        //This module entry combines all the dependencies of foo/bar/bip into one file,
+        //but excludes foo/bar/bop and its dependencies from the built file. If you want
+        //to exclude a module that is also another module being optimized, it is more
+        //efficient if you define that module optimization entry before using it
+        //in an exclude array.
+        {
+            name: "foo/bar/bip",
+            exclude: [
+                "foo/bar/bop"
+            ]
+        },
+
+        //This module entry shows how to specify a specific module be excluded
+        //from the built module file. excludeShallow means just exclude that
+        //specific module, but if that module has nested dependencies that are
+        //part of the built file, keep them in there. This is useful during
+        //development when you want to have a fast bundled set of modules, but
+        //just develop/debug one or two modules at a time.
+        {
+            name: "foo/bar/bin",
+            excludeShallow: [
+                "foo/bar/bot"
+            ]
+        }
+    ],
+
+    //Wrap any build layer in a start and end text specified by wrap.
+    //Use this to encapsulate the module code so that define/require are
+    //not globals. The end text can expose some globals from your file,
+    //making it easy to create stand-alone libraries that do not mandate
+    //the end user use requirejs.
+    wrap: {
+        start: "(function() {",
+        end: "}());"
+    },
+
+    //Another way to use wrap, but uses default wrapping of:
+    //(function() { + content + }());
+    wrap: true,
+
+    //Another way to use wrap, but uses file paths. This makes it easier
+    //to have the start text contain license information and the end text
+    //to contain the global variable exports, like
+    //window.myGlobal = requirejs('myModule');
+    //File paths are relative to the build file, or if running a commmand
+    //line build, the current directory.
+    wrap: {
+        startFile: "part/start.frag",
+        endFile: "parts/end.frag"
+    },
+
+    //When the optimizer copies files from the source location to the
+    //destination directory, it will skip directories and files that start
+    //with a ".". If you want to copy .directories or certain .files, for
+    //instance if you keep some packages in a .packages directory, or copy
+    //over .htaccess files, you can set this to null. If you want to change
+    //the exclusion rules, change it to a different regexp. If the regexp
+    //matches, it means the directory will be excluded. This used to be
+    //called dirExclusionRegExp before the 1.0.2 release.
+    //As of 1.0.3, this value can also be a string that is converted to a
+    //RegExp via new RegExp().
+    fileExclusionRegExp: /^\./,
+
+    //By default, comments that have a license in them are preserved in the
+    //output. However, for a larger built files there could be a lot of
+    //comment files that may be better served by having a smaller comment
+    //at the top of the file that points to the list of all the licenses.
+    //This option will turn off the auto-preservation, but you will need
+    //work out how best to surface the license information.
+    preserveLicenseComments: true
+})