pax_global_header00006660000000000000000000000064117771305440014523gustar00rootroot0000000000000052 comment=7d90561f24d872dd563448e15ec654544d1b4d25 lets_code_javascript-episode2/000077500000000000000000000000001177713054400167665ustar00rootroot00000000000000lets_code_javascript-episode2/.DS_Store000066400000000000000000000140041177713054400204500ustar00rootroot00000000000000Bud1%  @€ @€ @€ @ E%DSDB`€ @€ @€ @lets_code_javascript-episode2/.gitignore000066400000000000000000000000241177713054400207520ustar00rootroot00000000000000.idea/workspace.xml lets_code_javascript-episode2/.idea/000077500000000000000000000000001177713054400177465ustar00rootroot00000000000000lets_code_javascript-episode2/.idea/.name000066400000000000000000000000141177713054400206620ustar00rootroot00000000000000weewikipaintlets_code_javascript-episode2/.idea/encodings.xml000066400000000000000000000002461177713054400224430ustar00rootroot00000000000000 lets_code_javascript-episode2/.idea/misc.xml000066400000000000000000000001771177713054400214300ustar00rootroot00000000000000 lets_code_javascript-episode2/.idea/modules.xml000066400000000000000000000004261177713054400221420ustar00rootroot00000000000000 lets_code_javascript-episode2/.idea/scopes/000077500000000000000000000000001177713054400212425ustar00rootroot00000000000000lets_code_javascript-episode2/.idea/scopes/scope_settings.xml000066400000000000000000000002131177713054400250110ustar00rootroot00000000000000 lets_code_javascript-episode2/.idea/vcs.xml000066400000000000000000000003321177713054400212610ustar00rootroot00000000000000 lets_code_javascript-episode2/.idea/weewikipaint.iml000066400000000000000000000004331177713054400231510ustar00rootroot00000000000000 lets_code_javascript-episode2/README000066400000000000000000000001161177713054400176440ustar00rootroot00000000000000WeeWikiPaint To build: - Assumes presence of Node.js - Run ./jake.sh to buildlets_code_javascript-episode2/build/000077500000000000000000000000001177713054400200655ustar00rootroot00000000000000lets_code_javascript-episode2/build/lint/000077500000000000000000000000001177713054400210335ustar00rootroot00000000000000lets_code_javascript-episode2/build/lint/lint_runner.js000066400000000000000000000017411177713054400237330ustar00rootroot00000000000000/* Copyright (c) 2012 James Shore - See README.txt for license */ "use strict"; var jshint = require("jshint").JSHINT; var fs = require("fs"); exports.validateSource = function(sourceCode, options, globals, description) { description = description ? description + " " : ""; var pass = jshint(sourceCode, options, globals); if (pass) { console.log(description + "ok"); } else { console.log(description + "failed"); jshint.errors.forEach(function(error) { console.log(error.line + ": " + error.evidence.trim()); console.log(" " + error.reason); }); } return pass; }; exports.validateFile = function(filename, options, globals) { var sourceCode = fs.readFileSync(filename, "utf8"); return exports.validateSource(sourceCode, options, globals, filename); }; exports.validateFileList = function(fileList, options, globals) { var pass = true; fileList.forEach(function(filename) { pass = exports.validateFile(filename, options, globals) && pass; }); return pass; };lets_code_javascript-episode2/jake.sh000077500000000000000000000000321177713054400202320ustar00rootroot00000000000000node_modules/.bin/jake $* lets_code_javascript-episode2/jakefile.js000066400000000000000000000006001177713054400210720ustar00rootroot00000000000000/*global desc, task, jake, fail, complete */ "use strict"; task("default", ["lint"]); desc("Lint everything"); task("lint", [], function() { var lint = require("./build/lint/lint_runner.js"); var files = new jake.FileList(); files.include("**/*.js"); files.exclude("node_modules"); var options = { node: true }; lint.validateFileList(files.toArray(), options, {}); }); lets_code_javascript-episode2/node_modules/000077500000000000000000000000001177713054400214435ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/.bin/000077500000000000000000000000001177713054400222715ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/.bin/jake000077700000000000000000000000001177713054400261232../jake/bin/cli.jsustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/.bin/jshint000077700000000000000000000000001177713054400266552../jshint/bin/hintustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/000077500000000000000000000000001177713054400223555ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/Jakefile000066400000000000000000000017571177713054400240240ustar00rootroot00000000000000var fs = require('fs') , path = require('path'); var t = new jake.TestTask('Jake', function () { this.testFiles.include('tests/*.js'); this.testFiles.exclude('tests/helpers.js'); }); namespace('doc', function () { task('generate', ['doc:clobber'], function () { var cmd = '../node-jsdoc-toolkit/app/run.js -n -r=100 ' + '-t=../node-jsdoc-toolkit/templates/codeview -d=./doc/ ./lib'; jake.logger.log('Generating docs ...'); jake.exec([cmd], function () { jake.logger.log('Done.'); complete(); }); }, {async: true}); task('clobber', function () { var cmd = 'rm -fr ./doc/*'; jake.exec([cmd], function () { jake.logger.log('Clobbered old docs.'); complete(); }); }, {async: true}); }); desc('Generate docs for Jake'); task('doc', ['doc:generate']); var p = new jake.NpmPublishTask('jake', [ 'Makefile' , 'Jakefile' , 'README.md' , 'package.json' , 'lib/**' , 'bin/**' , 'tests/**' ]); jake.Task['npm:definePackage'].invoke(); lets_code_javascript-episode2/node_modules/jake/Makefile000066400000000000000000000023351177713054400240200ustar00rootroot00000000000000# # Jake JavaScript build tool # Copyright 2112 Matthew Eernisse (mde@fleegix.org) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # .PHONY: all build install clean uninstall PREFIX=/usr/local DESTDIR= all: build build: @echo 'Jake built.' install: @mkdir -p $(DESTDIR)$(PREFIX)/bin && \ mkdir -p $(DESTDIR)$(PREFIX)/lib/node_modules/jake && \ cp -R ./* $(DESTDIR)$(PREFIX)/lib/node_modules/jake/ && \ ln -snf ../lib/node_modules/jake/bin/cli.js $(DESTDIR)$(PREFIX)/bin/jake && \ chmod 755 $(DESTDIR)$(PREFIX)/lib/node_modules/jake/bin/cli.js && \ echo 'Jake installed.' clean: @true uninstall: @rm -f $(DESTDIR)$(PREFIX)/bin/jake && \ rm -fr $(DESTDIR)$(PREFIX)/lib/node_modules/jake/ && \ echo 'Jake uninstalled.' lets_code_javascript-episode2/node_modules/jake/README.md000066400000000000000000000610701177713054400236400ustar00rootroot00000000000000### Jake -- JavaScript build tool for Node.js ### Installing with [NPM](http://npmjs.org/) npm install -g jake Note that Jake is a system-level tool, and wants to be installed globally. ### Installing from source Prerequisites: Jake requires Node.js. () Get Jake: git clone git://github.com/mde/jake.git Build Jake: cd jake && make && sudo make install By default Jake is installed in "/usr/local." To install it into a different directory (e.g., one that doesn't require super-user privilege), pass the PREFIX variable to the `make install` command. For example, to install it into a "jake" directory in your home directory, you could use this: make && make install PREFIX=~/jake If do you install Jake somewhere special, you'll need to add the "bin" directory in the install target to your PATH to get access to the `jake` executable. ### Windows, installing from source For Windows users installing from source, there are some additional steps. *Assumed: current directory is the same directory where node.exe is present.* Get Jake: git clone git://github.com/mde/jake.git node_modules/jake Copy jake.bat and jake to the same directory as node.exe copy node_modules/jake/jake.bat jake.bat copy node_modules/jake/jake jake Add the directory of node.exe to the environment PATH variable. ### Basic usage jake [options ...] [env variables ...] target ### Description Jake is a simple JavaScript build program with capabilities similar to the regular make or rake command. Jake has the following features: * Jakefiles are in standard JavaScript syntax * Tasks with prerequisites * Namespaces for tasks * Async task execution ### Options -V/v --version Display the Jake version. -h --help Display help message. -f *FILE* --jakefile *FILE* Use FILE as the Jakefile. -C *DIRECTORY* --directory *DIRECTORY* Change to DIRECTORY before running tasks. -q --quiet Do not log messages to standard output. -J *JAKELIBDIR* --jakelibdir *JAKELIBDIR* Auto-import any .jake files in JAKELIBDIR. (default is 'jakelib') -B --always-make Unconditionally make all targets. -t --trace Enable full backtrace. -T --tasks Display the tasks (matching optional PATTERN) with descriptions, then exit. ### Jakefile syntax A Jakefile is just executable JavaScript. You can include whatever JavaScript you want in it. ## API Docs API docs [can be found here](http://mde.github.com/jake/doc/). ## Tasks Use `task` to define tasks. Call it with two arguments (and one optional argument): ```javascript task(name, [prerequisites], action, [opts]); ``` The `name` argument is a String with the name of the task, and `prerequisites` is an optional Array arg of the list of prerequisite tasks to perform first. The `action` is a Function defininng the action to take for the task. (Note that Object-literal syntax for name/prerequisites in a single argument a la Rake is also supported, but JavaScript's lack of support for dynamic keys in Object literals makes it not very useful.) The action is invoked with the Task object itself as the execution context (i.e, "this" inside the action references the Task object). The `opts` argument is optional. When a task's operations are asynchronous, the `async` property should be set to `true`, and the task must call `complete()` to signal to Jake that the task is done, and execution can proceed. By default the `async` property is `false`. Tasks created with `task` are always executed when asked for (or are a prerequisite). Tasks created with `file` are only executed if no file with the given name exists or if any of its file-prerequisites are more recent than the file named by the task. Also, if any prerequisite is a regular task, the file task will always be executed. Use `desc` to add a string description of the task. Here's an example: ```javascript desc('This is the default task.'); task('default', function (params) { console.log('This is the default task.'); }); desc('This task has prerequisites.'); task('hasPrereqs', ['foo', 'bar', 'baz'], function (params) { console.log('Ran some prereqs first.'); }); ``` And here's an example of an asynchronous task: ```javascript desc('This is an asynchronous task.'); task('asyncTask', function () { setTimeout(complete, 1000); }, {async: true}); ``` A Task is also an EventEmitter which emits the 'complete' event when it is finished. This allows asynchronous tasks to be run from within other asked via either `invoke` or `execute`, and ensure they will complete before the rest of the containing task executes. See the section "Running tasks from within other tasks," below. ### File-tasks Create a file-task by calling `file`. File-tasks create a file from one or more other files. With a file-task, Jake checks both that the file exists, and also that it is not older than the files specified by any prerequisite tasks. File-tasks are particularly useful for compiling something from a tree of source files. ```javascript desc('This builds a minified JS file for production.'); file('foo-minified.js', ['bar', 'foo-bar.js', 'foo-baz.js'], function () { // Code to concat and minify goes here }); ``` ### Directory-tasks Create a directory-task by calling `directory`. Directory-tasks create a directory for use with for file-tasks. Jake checks for the existence of the directory, and only creates it if needed. ```javascript desc('This creates the bar directory for use with the foo-minified.js file-task.'); directory('bar'); ``` This task will create the directory when used as a prerequisite for a file-task, or when run from the command-line. ### Namespaces Use `namespace` to create a namespace of tasks to perform. Call it with two arguments: ```javascript namespace(name, namespaceTasks); ``` Where is `name` is the name of the namespace, and `namespaceTasks` is a function with calls inside it to `task` or `desc` definining all the tasks for that namespace. Here's an example: ```javascript desc('This is the default task.'); task('default', function () { console.log('This is the default task.'); }); namespace('foo', function () { desc('This the foo:bar task'); task('bar', function () { console.log('doing foo:bar task'); }); desc('This the foo:baz task'); task('baz', ['default', 'foo:bar'], function () { console.log('doing foo:baz task'); }); }); ``` In this example, the foo:baz task depends on the the default and foo:bar tasks. ### Passing parameters to jake Parameters can be passed to Jake two ways: plain arguments, and environment variables. To pass positional arguments to the Jake tasks, enclose them in square braces, separated by commas, after the name of the task on the command-line. For example, with the following Jakefile: ```javascript desc('This is an awesome task.'); task('awesome', function (a, b, c) { console.log(a, b, c); }); ``` You could run `jake` like this: jake awesome[foo,bar,baz] And you'd get the following output: foo bar baz Note that you *cannot* uses spaces between the commas separating the parameters. Any parameters passed after the Jake task that contain an equals sign (=) will be added to process.env. With the following Jakefile: ```javascript desc('This is an awesome task.'); task('awesome', function (a, b, c) { console.log(a, b, c); console.log(process.env.qux, process.env.frang); }); ``` You could run `jake` like this: jake awesome[foo,bar,baz] qux=zoobie frang=asdf And you'd get the following output: foo bar baz zoobie asdf Running `jake` with no arguments runs the default task. __Note for zsh users__ : you will need to escape the brackets or wrap in single quotes like this to pass parameters : jake 'awesome[foo,bar,baz]' An other solution is to desactivate permannently file-globbing for the `jake` command. You can do this by adding this line to your `.zshrc` file : alias jake="noglob jake" ### Running tasks from within other tasks Jake supports the ability to run a task from within another task via the `invoke` and `execute` methods. The `invoke` method will run the desired task, along with its prerequisites: ```javascript desc('Calls the foo:bar task and its prerequisites.'); task('invokeFooBar', function () { // Calls foo:bar and its prereqs jake.Task['foo:bar'].invoke(); }); ``` The `invoke` method will only run the task once, even if you call it repeatedly. ```javascript desc('Calls the foo:bar task and its prerequisites.'); task('invokeFooBar', function () { // Calls foo:bar and its prereqs jake.Task['foo:bar'].invoke(); // Does nothing jake.Task['foo:bar'].invoke(); }); ``` The `execute` method will run the desired task without its prerequisites: ```javascript desc('Calls the foo:bar task without its prerequisites.'); task('executeFooBar', function () { // Calls foo:bar without its prereqs jake.Task['foo:baz'].execute(); }); ``` Calling `execute` repeatedly will run the desired task repeatedly. ```javascript desc('Calls the foo:bar task without its prerequisites.'); task('executeFooBar', function () { // Calls foo:bar without its prereqs jake.Task['foo:baz'].execute(); // Can keep running this over and over jake.Task['foo:baz'].execute(); jake.Task['foo:baz'].execute(); }); ``` If you want to run the task and its prerequisites more than once, you can use `invoke` with the `reenable` method. ```javascript desc('Calls the foo:bar task and its prerequisites.'); task('invokeFooBar', function () { // Calls foo:bar and its prereqs jake.Task['foo:bar'].invoke(); // Does nothing jake.Task['foo:bar'].invoke(); // Only re-runs foo:bar, but not its prerequisites jake.Task['foo:bar'].reenable(); jake.Task['foo:bar'].invoke(); }); ``` The `reenable` method takes a single Boolean arg, a 'deep' flag, which reenables the task's prerequisites if set to true. ```javascript desc('Calls the foo:bar task and its prerequisites.'); task('invokeFooBar', function () { // Calls foo:bar and its prereqs jake.Task['foo:bar'].invoke(); // Does nothing jake.Task['foo:bar'].invoke(); // Only re-runs foo:bar, but not its prerequisites jake.Task['foo:bar'].reenable(true); jake.Task['foo:bar'].invoke(); }); ``` It's easy to pass params on to a sub-task run via `invoke` or `execute`: ```javascript desc('Passes params on to other tasks.'); task('passParams', function () { var t = jake.Task['foo:bar']; // Calls foo:bar, passing along current args t.invoke.apply(t, arguments); }); ``` ### Evented tasks Tasks are EventEmitters. They can fire 'complete' and 'error' events. If a task called via `invoke` is asynchronous, you can set a listener on the 'complete' event to run any code that depends on it. ```javascript desc('Calls the async foo:baz task and its prerequisites.'); task('invokeFooBaz', function () { var t = jake.Task['foo:baz']; t.addListener('complete', function () { console.log('Finished executing foo:baz'); // Maybe run some other code // ... // Complete the containing task complete(); }); // Kick off foo:baz t.invoke(); }, {async: true}); ``` If you want to handle the errors in a task in some specific way, you can set a listener for the 'error' event, like so: ```javascript namespace('vronk', function () { task('groo', function () { var t = jake.Task['vronk:zong']; t.addListener('error', function (e) { console.log(e.message); }); t.invoke(); }); task('zong', function () { throw new Error('OMFGZONG'); }); }); ``` If no specific listener is set for the "error" event, errors are handled by Jake's generic error-handling. ### Aborting a task You can abort a task by calling the `fail` function, and Jake will abort the currently running task. You can pass a customized error message to `fail`: ```javascript desc('This task fails.'); task('failTask', function () { fail('Yikes. Something back happened.'); }); ``` You can also pass an optional exit status-code to the fail command, like so: ```javascript desc('This task fails with an exit-status of 42.'); task('failTaskQuestionCustomStatus', function () { fail('What is the answer?', 42); }); ``` The process will exit with a status of 42. Uncaught errors will also abort the currently running task. ### Showing the list of tasks Passing `jake` the -T or --tasks flag will display the full list of tasks available in a Jakefile, along with their descriptions: $ jake -T jake default # This is the default task. jake asdf # This is the asdf task. jake concat.txt # File task, concating two files together jake failure # Failing task. jake lookup # Jake task lookup by name. jake foo:bar # This the foo:bar task jake foo:fonebone # This the foo:fonebone task Setting a value for -T/--tasks will filter the list by that value: $ jake -T foo jake foo:bar # This the foo:bar task jake foo:fonebone # This the foo:fonebone task The list displayed will be all tasks whose namespace/name contain the filter-string. ## Breaking things up into multiple files Jake will automatically look for files with a .jake extension in a 'jakelib' directory in your project, and load them (via `require`) after loading your Jakefile. (The directory name can be overridden using the -J/--jakelibdir command-line option.) This allows you to break your tasks up over multiple files -- a good way to do it is one namespace per file: e.g., a `zardoz` namespace full of tasks in 'jakelib/zardox.jake'. Note that these .jake files each run in their own module-context, so they don't have access to each others' data. However, the Jake API methods, and the task-hierarchy are globally available, so you can use tasks in any file as prerequisites for tasks in any other, just as if everything were in a single file. Environment-variables set on the command-line are likewise also naturally available to code in all files via process.env. ## File-utils Since shelling out in Node is an asynchronous operation, Jake comes with a few useful file-utilities with a synchronous API, that make scripting easier. The `jake.mkdirP` utility recursively creates a set of nested directories. It will not throw an error if any of the directories already exists. Here's an example: ```javascript jake.mkdirP('app/views/layouts'); ``` The `jake.cpR` utility does a recursive copy of a file or directory. It takes two arguments, the file/directory to copy, and the destination. Note that this command can only copy files and directories; it does not perform globbing (so arguments like '*.txt' are not possible). ```javascript jake.cpR(path.join(sourceDir, '/templates'), currentDir); ``` This would copy 'templates' (and all its contents) into `currentDir`. The `jake.readdirR` utility gives you a recursive directory listing, giving you output somewhat similar to the Unix `find` command. It only works with a directory name, and does not perform filtering or globbing. ```javascript jake.readdirR('pkg'); ``` This would return an array of filepaths for all files in the 'pkg' directory, and all its subdirectories. The `jake.rmRf` utility recursively removes a directory and all its contents. ```javascript jake.rmRf('pkg'); ``` This would remove the 'pkg' directory, and all its contents. ## Running shell-commands: `jake.exec` and `jake.createExec` Jake also provides a more general utility function for running a sequence of shell-commands. ### `jake.exec` The `jake.exec` command takes an array of shell-command strings, and an optional callback to run after completing them. Here's an example from Jake's Jakefile, that runs the tests: ```javascript desc('Runs the Jake tests.'); task('test', function () { var cmds = [ 'node ./tests/parseargs.js' , 'node ./tests/task_base.js' , 'node ./tests/file_task.js' ]; jake.exec(cmds, function () { console.log('All tests passed.'); complete(); }, {printStdout: true}); }, {async: true}); ``` It also takes an optional options-object, with the following options: * `printStdout` (print to stdout, default false) * `printStderr` (print to stderr, default false) * `breakOnError` (stop execution on error, default true) This command doesn't pipe input between commands -- it's for simple execution. ### `jake.createExec` and the evented Exec object Jake also provides an evented interface for running shell commands. Calling `jake.createExec` returns an instance of `jake.Exec`, which is an `EventEmitter` that fires events as it executes commands. It emits the following events: * 'cmdStart': When a new command begins to run. Passes one arg, the command being run. * 'cmdEnd': When a command finishes. Passes one arg, the command being run. * 'stdout': When the stdout for the child-process recieves data. This streams the stdout data. Passes one arg, the chunk of data. * 'stdout': When the stderr for the child-process recieves data. This streams the sterr data. Passes one arg, the chunk of data. * 'error': When a shell-command exits with a non-zero status-code. Passes two args -- the error message, and the status code. If you do not set an error handler, and a command exits with an error-code, Jake will throw the unhandled error. If `breakOnError` is set to true, the Exec object will emit and 'error' event after the first error, and stop any further execution. To begin running the commands, you have to call the `run` method on it. It also has an `append` method for adding new commands to the list of commands to run. Here's an example: ```javascript var ex = jake.createExec(['do_thing.sh'], {printStdout: true}); ex.addListener('error', function (msg, code) { if (code == 127) { console.log("Couldn't find do_thing script, trying do_other_thing"); ex.append('do_other_thing.sh'); } else { fail('Fatal error: ' + msg, code); } }); ex.run(); ``` Using the evented Exec object gives you a lot more flexibility in running shell commmands. But if you need something more sophisticated, Procstreams () might be a good option. ## Logging and output Using the -q/--quiet flag at the command-line will stop Jake from sending its normal output to standard output. Note that this only applies to built-in output from Jake; anything you output normally from your tasks will still be displayed. If you want to take advantage of the -q/--quiet flag in your own programs, you can use `jake.logger.log` and `jake.logger.error` for displaying output. These two commands will respect the flag, and suppress output correctly when the quiet-flag is on. You can check the current value of this flag in your own tasks by using `jake.program.opts.quiet`. If you want the output of a `jake.exec` shell-command to respect the quiet-flag, set your `printStdout` and `printStderr` options to false if the quiet-option is on: ```javascript task('echo', function () { jake.exec(['echo "hello"'], function () { jake.logger.log('Done.'); complete(); }, {printStdout: !jake.program.opts.quiet}); }, {async: true}); ``` ## PackageTask Instantiating a PackageTask programmically creates a set of tasks for packaging up your project for distribution. Here's an example: ```javascript var t = new jake.PackageTask('fonebone', 'v0.1.2112', function () { var fileList = [ 'Jakefile' , 'README.md' , 'package.json' , 'lib/*' , 'bin/*' , 'tests/*' ]; this.packageFiles.include(fileList); this.needTarGz = true; this.needTarBz2 = true; }); ``` This will automatically create a 'package' task that will assemble the specified files in 'pkg/fonebone-v0.1.2112,' and compress them according to the specified options. After running `jake package`, you'll have the following in pkg/: fonebone-v0.1.2112 fonebone-v0.1.2112.tar.bz2 fonebone-v0.1.2112.tar.gz PackageTask also creates a 'clobber' task that removes the pkg/ directory. The [PackageTask API docs](http://mde.github.com/jake/doc/symbols/jake.PackageTask.html) include a lot more information, including different archiving options. ### FileList Jake's FileList takes a list of glob-patterns and file-names, and lazy-creates a list of files to include. Instead of immediately searching the filesystem to find the files, a FileList holds the pattern until it is actually used. When any of the normal JavaScript Array methods (or the `toArray` method) are called on the FileList, the pending patterns are resolved into an actual list of file-names. FileList uses the [minimatch](https://github.com/isaacs/minimatch) module. To build the list of files, use FileList's `include` and `exclude` methods: ```javascript var list = new jake.FileList(); list.include('foo/*.txt'); list.include(['bar/*.txt', 'README.md']); list.include('Makefile', 'package.json'); list.exclude('foo/zoobie.txt'); list.exclude(/foo\/src.*.txt/); console.log(list.toArray()); ``` The `include` method can be called either with an array of items, or multiple single parameters. Items can be either glob-patterns, or individual file-names. The `exclude` method will prevent files from being included in the list. These files must resolve to actual files on the filesystem. It can be called either with an array of items, or mutliple single parameters. Items can be glob-patterns, individual file-names, string-representations of regular-expressions, or regular-expression literals. ## TestTask Instantiating a TestTask programmically creates a simple task for running tests for your project. The first argument of the constructor is the project-name (used in the description of the task), and the second argument is a function that defines the task. It allows you to specifify what files to run as tests, and what to name the task that gets created (defaults to "test" if unset). ```javascript var t = new jake.TestTask('fonebone', function () { var fileList = [ 'tests/*' , 'lib/adapters/**/test.js' ]; this.testFiles.include(fileList); this.testFiles.exclude('tests/helper.js'); this.testName = 'testMainAndAdapters'; }); ``` Tests in the specified file should be in the very simple format of test-functions hung off the export. These tests are converted into Jake tasks which Jake then runs normally. If a test needs to run asynchronously, simply define the test-function with a single argument, a callback. Jake will define this as an asynchronous task, and will wait until the callback is called in the test function to run the next test. Here's an example test-file: ```javascript var assert = require('assert') , tests; tests = { 'sync test': function () { // Assert something assert.ok(true); } , 'async test': function (next) { // Assert something else assert.ok(true); // Won't go next until this is called next(); } , 'another sync test': function () { // Assert something else assert.ok(true); } }; module.exports = tests; ``` Jake's tests are also a good example of use of a TestTask. ## NpmPublishTask The NpmPublishTask builds on top of PackageTask to allow you to do a version bump of your project, package it, and publish it to NPM. Define the task with your project's name, and the list of files you want packaged and published to NPM. Here's an example from Jake's Jakefile: ```javascript var p = new jake.NpmPublishTask('jake', [ 'Makefile' , 'Jakefile' , 'README.md' , 'package.json' , 'lib/*' , 'bin/*' , 'tests/*' ]); ``` The NpmPublishTask will automatically create a `publish` task which performs the following steps: 1. Bump the version number in your package.json 2. Commit change in git, push it to GitHub 3. Create a git tag for the version 4. Push the tag to GitHub 5. Package the new version of your project 6. Publish it to NPM 7. Clean up the package ## CoffeeScript Jakefiles Jake can also handle Jakefiles in CoffeeScript. Be sure to make it Jakefile.coffee so Jake knows it's in CoffeeScript. Here's an example: ```coffeescript util = require('util') desc 'This is the default task.' task 'default', (params) -> console.log 'Ths is the default task.' console.log(util.inspect(arguments)) jake.Task['new'].invoke [] task 'new', -> console.log 'ello from new' jake.Task['foo:next'].invoke ['param'] namespace 'foo', -> task 'next', (param) -> console.log 'ello from next with param: ' + param ``` ## Related projects James Coglan's "Jake": Confusingly, this is a Ruby tool for building JavaScript packages from source code. 280 North's Jake: This is also a JavaScript port of Rake, which runs on the Narwhal platform. ### License Licensed under the Apache License, Version 2.0 () lets_code_javascript-episode2/node_modules/jake/bin/000077500000000000000000000000001177713054400231255ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/bin/cli.js000077500000000000000000000045151177713054400242420ustar00rootroot00000000000000#!/usr/bin/env node /* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var args = process.argv.slice(2) , libPath = __dirname + '/../lib' , fs = require('fs') , jake = require(libPath + '/jake') , api = require(libPath + '/api') , utils = require(libPath + '/utils') , Program = require(libPath + '/program').Program , program = new Program() , Loader = require(libPath + '/loader').Loader , loader = new Loader() , pkg = JSON.parse(fs.readFileSync(__dirname + '/../package.json').toString()) , opts , envVars , taskNames; jake.version = pkg.version; global.jake = jake; process.addListener('uncaughtException', function (err) { program.handleErr(err); }); program.parseArgs(args); if (!program.preemptiveOption()) { opts = program.opts envVars = program.envVars; // Globalize top-level API methods (e.g., `task`, `desc`) for (var p in api) { global[p] = api[p]; } // Convenience aliases jake.program = program; for (var p in utils) { jake[p] = utils[p]; } jake.FileList = require(libPath + '/file_list').FileList; jake.PackageTask = require(libPath + '/package_task').PackageTask; jake.NpmPublishTask = require(libPath + '/npm_publish_task').NpmPublishTask; jake.TestTask = require(libPath + '/test_task').TestTask; // Enhance env with any env vars passed in for (var p in envVars) { process.env[p] = envVars[p]; } loader.load(opts); // Set working dir var dirname = opts.directory; if (dirname) { process.chdir(dirname); } taskNames = program.taskNames; taskNames = taskNames.length ? taskNames : ['default']; task('__root__', taskNames, function () {}); if (opts.tasks) { jake.showAllTaskDescriptions(opts.tasks); } else { jake.Task['__root__'].invoke(); } } lets_code_javascript-episode2/node_modules/jake/lib/000077500000000000000000000000001177713054400231235ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/lib/api.js000066400000000000000000000154471177713054400242450ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var exec = require('child_process').exec; var api = new (function () { /** @name task @static @function @description Creates a Jake Task ` @param {String} name The name of the Task @param {Array} [prereqs] Prerequisites to be run before this task @param {Function} [action] The action to perform for this task @param {Object} [opts] @param {Boolean} [opts.asyc=false] Perform this task asynchronously. If you flag a task with this option, you must call the global `complete` method inside the task's action, for execution to proceed to the next task. @example desc('This is the default task.'); task('default', function (params) { console.log('This is the default task.'); }); desc('This task has prerequisites.'); task('hasPrereqs', ['foo', 'bar', 'baz'], function (params) { console.log('Ran some prereqs first.'); }); desc('This is an asynchronous task.'); task('asyncTask', function () { setTimeout(complete, 1000); }, {async: true}); */ this.task = function (name, prereqs, action, opts) { var args = Array.prototype.slice.call(arguments) , type , createdTask; args.unshift('task'); createdTask = jake.createTask.apply(global, args); jake.currentTaskDescription = null; return createdTask; }; /** @name directory @static @function @description Creates a Jake DirectoryTask. Can be used as a prerequisite for FileTasks, or for simply ensuring a directory exists for use with a Task's action. ` @param {String} name The name of the DiretoryTask @example // Creates the package directory for distribution directory('pkg'); */ this.directory = function (name) { var args = Array.prototype.slice.call(arguments) , createdTask; args.unshift('directory'); createdTask = jake.createTask.apply(global, args); jake.currentTaskDescription = null; return createdTask; }; /** @name file @static @function @description Creates a Jake FileTask. ` @param {String} name The name of the FileTask @param {Array} [prereqs] Prerequisites to be run before this task @param {Function} [action] The action to create this file, if it doesn't exist already. @param {Object} [opts] @param {Array} [opts.asyc=false] Perform this task asynchronously. If you flag a task with this option, you must call the global `complete` method inside the task's action, for execution to proceed to the next task. */ this.file = function (name, prereqs, action, opts) { var args = Array.prototype.slice.call(arguments) , createdTask; args.unshift('file'); createdTask = jake.createTask.apply(global, args); jake.currentTaskDescription = null; return createdTask; }; /** @name desc @static @function @description Creates a description for a Jake Task (or FileTask, DirectoryTask). When invoked, the description that iscreated will be associated with whatever Task is created next. ` @param {String} description The description for the Task */ this.desc = function (description) { jake.currentTaskDescription = description; }; /** @name namespace @static @function @description Creates a namespace which allows logical grouping of tasks, and prevents name-collisions with task-names. Namespaces can be nested inside of other namespaces. ` @param {String} name The name of the namespace @param {Function} scope The enclosing scope for the namespaced tasks @example namespace('doc', function () { task('generate', ['doc:clobber'], function () { // Generate some docs }); task('clobber', function () { // Clobber the doc directory first }); }); */ this.namespace = function (name, scope) { var curr = jake.currentNamespace , ns = new jake.Namespace(name, curr); curr.childNamespaces[name] = ns; jake.currentNamespace = ns; scope(); jake.currentNamespace = curr; jake.currentTaskDescription = null; return ns; }; /** @name complete @static @function @description Complets an asynchronous task, allowing Jake's execution to proceed to the next task ` @example task('generate', ['doc:clobber'], function () { exec('./generate_docs.sh', function (err, stdout, stderr) { if (err || stderr) { fail(err || stderr); } else { console.log(stdout); complete(); } }); }, {async: true}); */ this.complete = function () { var current = jake._invocationChain.pop(); if (current) { current.complete(); } }; /** @name fail @static @function @description Causes Jake execution to abort with an error. Allows passing an optional error code, which will be used to set the exit-code of exiting process. ` @param {Error|String} err The error to thow when aborting execution. If this argument is an Error object, it will simply be thrown. If a String, it will be used as the error-message. (If it is a multi-line String, the first line will be used as the Error message, and the remaining lines will be used as the error-stack.) @example task('createTests, function () { if (!fs.existsSync('./tests')) { fail('Test directory does not exist.'); } else { // Do some testing stuff ... } }); */ this.fail = function (err, code) { var msg , errObj; if (code) { jake.errorCode = code; } if (err) { if (typeof err == 'string') { // Use the initial or only line of the error as the error-message // If there was a multi-line error, use the rest as the stack msg = err.split('/n'); errObj = new Error(msg.shift()); if (msg.length) { errObj.stack = msg.join('\n'); } throw errObj; } else if (err instanceof Error) { throw err; } else { throw new Error(err.toString()); } } else { throw new Error(); } }; })(); module.exports = api; lets_code_javascript-episode2/node_modules/jake/lib/file_list.js000066400000000000000000000203161177713054400254350ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var fs = require('fs') , path = require('path') , minimatch // Lazy-required , globSync; globSync = function (pat) { var dirname = jake.basedir(pat) , files = jake.readdirR(dirname) , matches; matches = minimatch.match(files, pat, {'null': true}); return matches; }; // Constants // --------------- // List of all the builtin Array methods we want to override var ARRAY_METHODS = Object.getOwnPropertyNames(Array.prototype) // Array methods that return a copy instead of affecting the original , SPECIAL_RETURN = { 'concat': true , 'slice': true , 'filter': true , 'map': true } // Default file-patterns we want to ignore , DEFAULT_IGNORE_PATTERNS = [ /(^|[\/\\])CVS([\/\\]|$)/ , /(^|[\/\\])\.svn([\/\\]|$)/ , /(^|[\/\\])\.git([\/\\]|$)/ , /\.bak$/ , /~$/ ] // Ignore core files , DEFAULT_IGNORE_FUNCS = [ function (name) { var isDir = false , stats; try { stats = fs.statSync(name); isDir = stats.isDirectory(); } catch(e) {} return (/(^|[\/\\])core$/).test(name) && !isDir; } ]; // Utility methods // --------------- // Escapes special characters in a string to be used in generating // a regex var regexpEscape = (function() { var specials = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\' ] , sRE = new RegExp('(\\' + specials.join('|\\') + ')', 'g'); return function (text) { return text.replace(sRE, '\\$1'); }; })(); var FileList = function () { var self = this , wrap; // Lazy-require minimatch so that require of this file in cli.js won't bomb if (!minimatch) { try { minimatch = require('minimatch'); } catch(e) { // Hacky fallback, assume global install at /usr/local? try { minimatch = require('/usr/local/lib/node_modules/minimatch'); } catch(e) { fail('FileList requires minimatch ' + '(https://github.com/isaacs/minimatch). Try `npm install -g minimatch`.'); } } } // List of glob-patterns or specific filenames this.pendingAdd = []; // Switched to false after lazy-eval of files this.pending = true; // Used to calculate exclusions from the list of files this.excludes = { pats: DEFAULT_IGNORE_PATTERNS.slice() , funcs: DEFAULT_IGNORE_FUNCS.slice() , regex: null }; this.items = []; // Wrap the array methods with the delegates wrap = function (prop) { var arr; self[prop] = function () { if (self.pending) { self.resolve(); } if (typeof self.items[prop] == 'function') { // Special method that return a copy if (SPECIAL_RETURN[prop]) { arr = self.items[prop].apply(self.items, arguments); return FileList.clone(self, arr); } else { return self.items[prop].apply(self.items, arguments); } } else { return self.items[prop]; } }; }; for (var i = 0, ii = ARRAY_METHODS.length; i < ii; i++) { wrap(ARRAY_METHODS[i]); } // Include whatever files got passed to the constructor this.include.apply(this, arguments); // Fix constructor linkage this.constructor = FileList; }; FileList.prototype = new (function () { var globPattern = /[*?\[\{]/; var _addMatching = function (pat) { var matches = globSync(pat); this.items = this.items.concat(matches); } , _resolveAdd = function (name) { if (globPattern.test(name)) { _addMatching.call(this, name); } else { this.push(name); } } , _calculateExcludeRe = function () { var pats = this.excludes.pats , pat , excl = [] , matches = []; for (var i = 0, ii = pats.length; i < ii; i++) { pat = pats[i]; if (typeof pat == 'string') { // Glob, look up files if (/[*?]/.test(pat)) { matches = globSync(pat); excl = excl.concat(matches); } // String for regex else { excl.push(regexpEscape(pat)); } } // Regex, grab the string-representation else if (pat instanceof RegExp) { excl.push(pat.toString().replace(/^\/|\/$/g, '')); } } if (excl.length) { this.excludes.regex = new RegExp('(' + excl.join(')|(') + ')'); } else { this.excludes.regex = /^$/; } } , _resolveExclude = function () { var self = this; _calculateExcludeRe.call(this); // No `reject` method, so use reverse-filter this.items = this.items.filter(function (name) { return !self.shouldExclude(name); }); } /** * Includes file-patterns in the FileList. Should be called with one or more * pattern for finding file to include in the list. Arguments should be strings * for either a glob-pattern or a specific file-name, or an array of them */ this.include = function () { var args = Array.isArray(arguments[0]) ? arguments[0] : arguments; for (var i = 0, ii = args.length; i < ii; i++) { this.pendingAdd.push(args[i]); } return this; }; /** * Indicates whether a particular file would be filtered out by the current * exclusion rules for this FileList. * @param {String} name The filename to check * @return {Boolean} Whether or not the file should be excluded */ this.shouldExclude = function (name) { if (!this.excludes.regex) { _calculateExcludeRe.call(this); } var excl = this.excludes; return excl.regex.test(name) || excl.funcs.some(function (f) { return !!f(name); }); }; /** * Excludes file-patterns from the FileList. Should be called with one or more * pattern for finding file to include in the list. Arguments can be: * 1. Strings for either a glob-pattern or a specific file-name * 2. Regular expression literals * 3. Functions to be run on the filename that return a true/false */ this.exclude = function () { var args = Array.isArray(arguments[0]) ? arguments[0] : arguments , arg; for (var i = 0, ii = args.length; i < ii; i++) { arg = args[i]; if (typeof arg == 'function' && !(arg instanceof RegExp)) { this.excludes.funcs.push(arg); } else { this.excludes.pats.push(arg); } } if (!this.pending) { _resolveExclude.call(this); } return this; }; /** * Populates the FileList from the include/exclude rules with a list of * actual files */ this.resolve = function () { var name; if (this.pending) { this.pending = false; while ((name = this.pendingAdd.shift())) { _resolveAdd.call(this, name); } _resolveExclude.call(this); } return this; }; /** * Convert to a plain-jane array */ this.toArray = function () { // Call slice to ensure lazy-resolution before slicing items var ret = this.slice().items.slice(); return ret; }; /** * Get rid of any current exclusion rules */ this.clearExclude = function () { this.excludes = { pats: [] , funcs: [] , regex: null }; return this; }; })(); // Static method, used to create copy returned by special // array methods FileList.clone = function (list, items) { var clone = new FileList(); if (items) { clone.items = items; } clone.pendingAdd = list.pendingAdd; clone.pending = list.pending; for (var p in list.excludes) { clone.excludes[p] = list.excludes[p]; } return clone; }; exports.FileList = FileList; lets_code_javascript-episode2/node_modules/jake/lib/jake.js000066400000000000000000000140221177713054400243720ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var jake , fs = require('fs') , path = require('path') , task = require('./task') , Task = task.Task , FileTask = task.FileTask , DirectoryTask = task.DirectoryTask; var Namespace = function (name, parentNamespace) { this.name = name; this.parentNamespace = parentNamespace; this.childNamespaces = {}; this.tasks = {}; this.resolve = function(relativeName) { var parts = relativeName.split(':') , name = parts.pop() , ns = this , task; for(var i = 0, l = parts.length; ns && i < l; i++) { ns = ns.childNamespaces[parts[i]]; } return (ns && ns.tasks[name]) || (this.parentNamespace && this.parentNamespace.resolve(relativeName)); } }; var Invocation = function (taskName, args) { this.taskName = taskName; this.args = args; }; /** * @namespace * The main namespace for Jake */ jake = new function () { this._invocationChain = []; // Private variables // ================= // Local reference for scopage var self = this; // Public properties // ================= this.errorCode = undefined; // Name/value map of all the various tasks defined in a Jakefile. // Non-namespaced tasks are placed into 'default.' this.defaultNamespace = new Namespace('default', null); // For namespaced tasks -- tasks with no namespace are put into the // 'default' namespace so lookup code can work the same for both // namespaced and non-namespaced. this.currentNamespace = this.defaultNamespace; // Saves the description created by a 'desc' call that prefaces a // 'task' call that defines a task. this.currentTaskDescription = null; this.parseAllTasks = function () { var _parseNs = function (name, ns) { var nsTasks = ns.tasks , task , nsNamespaces = ns.childNamespaces , fullName; // Iterate through the tasks in each namespace for (var q in nsTasks) { task = nsTasks[q]; // Preface only the namespaced tasks fullName = name == 'default' ? q : name + ':' + q; // Save with 'taskname' or 'namespace:taskname' key task.fullName = fullName; jake.Task[fullName] = task; } for (var p in nsNamespaces) { fullName = name == 'default' ? p : name + ':' + p; _parseNs(fullName, nsNamespaces[p]); } }; _parseNs('default', jake.defaultNamespace); }; /** * Displays the list of descriptions avaliable for tasks defined in * a Jakefile */ this.showAllTaskDescriptions = function (f) { var maxTaskNameLength = 0 , task , str = '' , padding , name , descr , filter = typeof f == 'string' ? f : null; for (var p in jake.Task) { task = jake.Task[p]; // Record the length of the longest task name -- used for // pretty alignment of the task descriptions maxTaskNameLength = p.length > maxTaskNameLength ? p.length : maxTaskNameLength; } // Print out each entry with descriptions neatly aligned for (var p in jake.Task) { if (filter && p.indexOf(filter) == -1) { continue; } task = jake.Task[p]; name = '\033[32m' + p + '\033[39m '; // Create padding-string with calculated length padding = (new Array(maxTaskNameLength - p.length + 2)).join(' '); descr = task.description if (descr) { descr = '\033[90m # ' + descr + '\033[39m \033[37m \033[39m'; console.log('jake ' + name + padding + descr); } } }; this.createTask = function () { var args = Array.prototype.slice.call(arguments) , task , type , name , action , opts , prereqs = []; type = args.shift() // name, [deps], [action] // Name (string) + deps (array) format if (typeof args[0] == 'string') { name = args.shift(); if (Array.isArray(args[0])) { prereqs = args.shift(); } if (typeof args[0] == 'function') { action = args.shift(); opts = args.shift() || {}; } } // name:deps, [action] // Legacy object-literal syntax, e.g.: {'name': ['depA', 'depB']} else { obj = args.shift() for (var p in obj) { prereqs = prereqs.concat(obj[p]); name = p; } action = args.shift(); opts = args.shift() || {}; } task = jake.currentNamespace.resolve(name); if (task && !action) { // Task already exists and no action, just update prereqs, and return it. task.prereqs = task.prereqs.concat(prereqs); return task; } switch (type) { case 'directory': action = function () { jake.mkdirP(name); }; task = new DirectoryTask(name, prereqs, action, opts); break; case 'file': task = new FileTask(name, prereqs, action, opts); break; default: task = new Task(name, prereqs, action, opts); } if (jake.currentTaskDescription) { task.description = jake.currentTaskDescription; jake.currentTaskDescription = null; } jake.currentNamespace.tasks[name] = task; task.namespace = jake.currentNamespace; // FIXME: Should only need to add a new entry for the current // task-definition, not reparse the entire structure jake.parseAllTasks(); return task; }; }(); jake.Task = Task; jake.FileTask = FileTask; jake.DirectoryTask = DirectoryTask; jake.Namespace = Namespace; module.exports = jake; lets_code_javascript-episode2/node_modules/jake/lib/loader.js000066400000000000000000000054761177713054400247430ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var path = require('path') , fs = require('fs') , existsSync = typeof fs.existsSync == 'function' ? fs.existsSync : path.existsSync , fileUtils = require('./utils/file') , Loader; Loader = function () { var JAKEFILE_PAT = /\.jake(\.js|\.coffee)?$/; var _loadJakefile = function (file) { var jakefile = file ? file.replace(/\.js$/, '').replace(/\.coffee$/, '') : 'Jakefile' , fileSpecified = !!file // Dear God, why? , isCoffee = false // Warning, recursive , exists; exists = function () { var cwd = process.cwd(); if (existsSync(jakefile) || existsSync(jakefile + '.js') || existsSync(jakefile + '.coffee')) { return true; } if (!fileSpecified) { process.chdir(".."); if (cwd === process.cwd()) { return false; } return exists(); } }; if (!exists()) { fail('No Jakefile. Specify a valid path with -f/--jakefile, or place one in the current directory.'); } isCoffee = existsSync(jakefile + '.coffee'); if (isCoffee) { CoffeeScript = _requireCoffee(); } require(fileUtils.absolutize(jakefile)); } , _loadJakeLibdir = function (d) { var dirname = d || 'jakelib' , dirlist; dirname = fileUtils.absolutize(dirname); if (existsSync(dirname)) { dirlist = fs.readdirSync(dirname); dirlist.forEach(function (filePath) { if (JAKEFILE_PAT.test(filePath)) { if (/\.coffee$/.test(filePath)) { CoffeeScript = _requireCoffee(); } require(path.join(dirname, filePath)); } }); } } , _requireCoffee = function() { try { return require('coffee-script'); } catch (e) { fail('CoffeeScript is missing! Try `npm install coffee-script`'); } }; this.load = function (opts) { _loadJakefile(opts.jakefile); _loadJakeLibdir(opts.jakelibdir); }; }; module.exports.Loader = Loader; lets_code_javascript-episode2/node_modules/jake/lib/npm_publish_task.js000066400000000000000000000120771177713054400270320ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var fs = require('fs') , exec = require('child_process').exec , currDir = process.cwd(); var NpmPublishTask = function (name, packageFiles) { this.name = name; this.packageFiles = packageFiles; this.define(); }; NpmPublishTask.prototype = new (function () { var getPackage = function () { var pkg = JSON.parse(fs.readFileSync(process.cwd() + '/package.json').toString()); return pkg; }; var getPackageVersionNumber = function () { return getPackage().version; }; this.define = function () { var self = this; namespace('npm', function () { task('fetchTags', function () { // Make sure local tags are up to date cmds = [ 'git fetch --tags' ]; jake.exec(cmds, function () { console.log('Fetched remote tags.'); complete(); }); }, {async: true}); task('version', function () { // Only bump, push, and tag if the Git repo is clean exec('git status --porcelain --untracked-files=no', function (err, stdout, stderr) { var cmds , path , pkg , version , arr , patch , message; if (err) { fail(err); } if (stderr) { fail(new Error(stderr)); } if (stdout.length) { fail(new Error('Git repository is not clean.')); } // Grab the current version-string path = process.cwd() + '/package.json'; pkg = getPackage(); version = pkg.version; // Increment the patch-number for the version arr = version.split('.'); patch = parseInt(arr.pop(), 10) + 1; arr.push(patch); version = arr.join('.'); // New package-version pkg.version = version; // Commit-message message = 'Version ' + version // Update package.json with the new version-info fs.writeFileSync(path, JSON.stringify(pkg, true, 2)); cmds = [ 'git commit package.json -m "' + message + '"' , 'git push origin master' , 'git tag -a v' + version + ' -m "' + message + '"' , 'git push --tags' ]; jake.exec(cmds, function () { var version = getPackageVersionNumber(); console.log('Bumped version number to v' + version + '.'); complete(); }); }); }, {async: true}); task('definePackage', function () { var version = getPackageVersionNumber() , t; t = new jake.PackageTask(self.name, 'v' + version, function () { this.packageFiles.include(self.packageFiles); this.needTarGz = true; }); }); task('package', function () { var definePack = jake.Task['npm:definePackage'] , pack = jake.Task['package'] , version = getPackageVersionNumber(); // May have already been run definePack.reenable(true); definePack.addListener('complete', function () { pack.addListener('complete', function () { console.log('Created package for ' + self.name + ' v' + version); complete(); }); pack.invoke(); }); definePack.invoke(); }, {async: true}); task('publish', function () { var version = getPackageVersionNumber(); console.log('Publishing ' + self.name + ' v' + version); cmds = [ 'npm publish pkg/' + self.name + '-v' + version + '.tar.gz' ]; // Hackity hack -- NPM publish sometimes returns errror like: // Error sending version data\nnpm ERR! // Error: forbidden 0.2.4 is modified, should match modified time setTimeout(function () { jake.exec(cmds, function () { console.log('Published to NPM'); complete(); }, {stdout: true}); }, 5000); }, {async: true}); task('cleanup', function () { var clobber = jake.Task['clobber']; clobber.reenable(true); clobber.invoke(); console.log('Cleaned up package'); }); }); desc('Bump version-number, package, and publish to NPM.'); task('publish', ['npm:fetchTags', 'npm:version', 'npm:package', 'npm:publish', 'npm:cleanup'], function () {}); }; })(); jake.NpmPublishTask = NpmPublishTask; exports.NpmPublishTask = NpmPublishTask; lets_code_javascript-episode2/node_modules/jake/lib/package_task.js000066400000000000000000000222351177713054400261020ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var path = require('path') , fs = require('fs') , exec = require('child_process').exec; /** @name jake @namespace jake */ /** @name jake.PackageTask @constructor @description Instantiating a PackageTask creates a number of Jake Tasks that make packaging and distributing your software easy. @param {String} name The name of the project @param {String} version The current project version (will be appended to the project-name in the package-archive @param {Function} definition Defines the contents of the package, and format of the package-archive. Will be executed on the instantiated PackageTask (i.e., 'this', will be the PackageTask instance), to set the various instance-propertiess. @example var t = new jake.PackageTask('rous', 'v' + version, function () { var files = [ 'Capfile' , 'Jakefile' , 'README.md' , 'package.json' , 'app/*' , 'bin/*' , 'config/*' , 'lib/*' , 'node_modules/*' ]; this.packageFiles.include(files); this.packageFiles.exclude('node_modules/foobar'); this.needTarGz = true; }); */ var PackageTask = function (name, version, definition) { /** @name jake.PackageTask#name @public @type {String} @description The name of the project */ this.name = name; /** @name jake.PackageTask#version @public @type {String} @description The project version-string */ this.version = version; /** @name jake.PackageTask#version @public @type {String='pkg'} @description The directory-name to use for packaging the software */ this.packageDir = 'pkg'; /** @name jake.PackageTask#packageFiles @public @type {jake.FileList} @description The list of files and directories to include in the package-archive */ this.packageFiles = new jake.FileList(); /** @name jake.PackageTask#needTar @public @type {Boolean=false} @description If set to true, uses the `tar` utility to create a gzip .tgz archive of the pagckage */ this.needTar = false; /** @name jake.PackageTask#needTar @public @type {Boolean=false} @description If set to true, uses the `tar` utility to create a gzip .tar.gz archive of the pagckage */ this.needTarGz = false; /** @name jake.PackageTask#needTarBz2 @public @type {Boolean=false} @description If set to true, uses the `tar` utility to create a bzip2 .bz2 archive of the pagckage */ this.needTarBz2 = false; /** @name jake.PackageTask#needJar @public @type {Boolean=false} @description If set to true, uses the `jar` utility to create a .jar archive of the pagckage */ this.needJar = false; /** @name jake.PackageTask#needZip @public @type {Boolean=false} @description If set to true, uses the `zip` utility to create a .zip archive of the pagckage */ this.needZip = false; /** @name jake.PackageTask#manifestFile @public @type {String=null} @description Can be set to point the `jar` utility at a manifest file to use in a .jar archive. If unset, one will be automatically created by the `jar` utility. This path should be relative to the root of the package directory (this.packageDir above, likely 'pkg') */ this.manifestFile = null; /** @name jake.PackageTask#tarCommand @public @type {String='tar'} @description The shell-command to use for creating tar archives. */ this.tarCommand = 'tar'; /** @name jake.PackageTask#jarCommand @public @type {String='jar'} @description The shell-command to use for creating jar archives. */ this.jarCommand = 'jar'; /** @name jake.PackageTask#zipCommand @public @type {String='zip'} @description The shell-command to use for creating zip archives. */ this.zipCommand = 'zip'; /** @name jake.PackageTask#archiveChangeDir @public @type {String=null} @description Equivalent to the '-C' command for the `tar` and `jar` commands. ("Change to this directory before adding files.") */ this.archiveChangeDir = null; /** @name jake.PackageTask#archiveContentDir @public @type {String=null} @description Specifies the files and directories to include in the package-archive. If unset, this will default to the main package directory -- i.e., name + version. */ this.archiveContentDir = null; if (typeof definition == 'function') { definition.call(this); } this.define(); }; PackageTask.prototype = new (function () { var _compressOpts = { Tar: { ext: '.tgz' , flags: 'cvzf' , cmd: 'tar' } , TarGz: { ext: '.tar.gz' , flags: 'cvzf' , cmd: 'tar' } , TarBz2: { ext: '.tar.bz2' , flags: 'cvjf' , cmd: 'tar' } , Jar: { ext: '.jar' , flags: 'cf' , cmd: 'jar' } , Zip: { ext: '.zip' , flags: 'r' , cmd: 'zip' } }; this.define = function () { var self = this , packageDirPath = this.packageDirPath() , compressTaskArr = []; desc('Build the package for distribution'); task('package', ['clobberPackage', 'buildPackage']); // Backward-compat alias task('repackage', ['package']); task('clobberPackage', function () { jake.exec(['rm -fr ' + self.packageDir], function () { complete(); }); }, {async: true}); desc('Remove the package'); task('clobber', ['clobberPackage']); for (var p in _compressOpts) { if (this['need' + p]) { (function (p) { var filename = self.packageDir + '/' + self.packageName() + _compressOpts[p].ext; compressTaskArr.push(filename); file(filename, [packageDirPath], function () { var cmd , opts = _compressOpts[p] // Save the current dir so it's possible to pop back up // after compressing , currDir = process.cwd(); // Move into the package dir to compress (see below, after // exec) process.chdir(self.packageDir); cmd = self[opts.cmd + 'Command']; cmd += ' -' + opts.flags; if (opts.cmd == 'jar' && self.manifestFile) { cmd += 'm'; } cmd += ' ' + self.packageName() + opts.ext; if (opts.cmd == 'jar' && self.manifestFile) { cmd += ' ' + self.manifestFile; } if (self.archiveChangeDir) { cmd += ' -C ' + self.archiveChangeDir; } if (self.archiveContentDir) { cmd += ' ' + self.archiveContentDir; } else { cmd += ' ' + self.packageName(); } exec(cmd, function (err, stdout, stderr) { if (err) { throw err; } // Return back up to the starting directory (see above, // before exec) process.chdir(currDir); complete(); }); }, {async: true}); })(p); } } task('buildPackage', compressTaskArr, function () {}); directory(this.packageDir); file(packageDirPath, [this.packageDir].concat(self.packageFiles.toArray()), function () { var fileList = []; self.packageFiles.forEach(function (name) { var f = path.join(self.packageDirPath(), name) , fDir = path.dirname(f) , stats; jake.mkdirP(fDir, {silent: true}); // Add both files and directories fileList.push({ from: name , to: f }); }); var _copyFile = function () { var cmd , file = fileList.pop() , stat; if (file) { stat = fs.statSync(file.from); // Target is a directory, just create it if (stat.isDirectory()) { jake.mkdirP(file.to, {silent: true}); _copyFile(); } // Otherwise copy the file else { jake.cpR(file.from, file.to, {silent: true}); _copyFile(); } } else { complete(); } }; _copyFile(); }, {async: true}); }; this.packageName = function () { if (this.version) { return this.name + '-' + this.version; } else { return this.name; } }; this.packageDirPath = function () { return this.packageDir + '/' + this.packageName(); }; })(); jake.PackageTask = PackageTask; exports.PackageTask = PackageTask; lets_code_javascript-episode2/node_modules/jake/lib/parseargs.js000066400000000000000000000071161177713054400254550ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var parseargs = {}; /** * @constructor * Parses a list of command-line args into a key/value object of * options and an array of positional commands. * @ param {Array} opts A list of options in the following format: * [{full: 'foo', abbr: 'f'}, {full: 'bar', abbr: 'b'}]] */ parseargs.Parser = function (opts) { // A key/value object of matching options parsed out of the args this.opts = {}; this.taskNames = null; this.envVars = null; // Data structures used for parsing this.reg = []; this.shortOpts = {}; this.longOpts = {}; var item; for (var i = 0, ii = opts.length; i < ii; i++) { item = opts[i]; this.shortOpts[item.abbr] = item; this.longOpts[item.full] = item; } this.reg = opts; }; parseargs.Parser.prototype = new function () { var _trueOrNextVal = function (argParts, args) { if (argParts[1]) { return argParts[1]; } else { return (!args[0] || (args[0].indexOf('-') == 0)) ? true : args.shift(); } }; /** * Parses an array of arguments into options and positional commands * @param {Array} args The command-line args to parse */ this.parse = function (args) { var cmds = [] , cmd , envVars = {} , opts = {} , arg , argItem , argParts , cmdItems , taskNames = [] , preempt; while (args.length) { arg = args.shift(); if (arg.indexOf('-') == 0) { arg = arg.replace(/^--/, '').replace(/^-/, ''); argParts = arg.split('='); argItem = this.longOpts[argParts[0]] || this.shortOpts[argParts[0]]; if (argItem) { // First-encountered preemptive opt takes precedence -- no further opts // or possibility of ambiguity, so just look for a value, or set to // true and then bail if (argItem.preempts) { opts[argItem.full] = _trueOrNextVal(argParts, args); preempt = true; break; } // If the opt requires a value, see if we can get a value from the // next arg, or infer true from no-arg -- if it's followed by another // opt, throw an error if (argItem.expectValue) { opts[argItem.full] = _trueOrNextVal(argParts, args); if (!opts[argItem.full]) { throw new Error(argItem.full + ' option expects a value.'); } } else { opts[argItem.full] = true; } } } else { cmds.unshift(arg); } } if (!preempt) { // Parse out any env-vars and task-name while (!!(cmd = cmds.pop())) { cmdItems = cmd.split('='); if (cmdItems.length > 1) { envVars[cmdItems[0]] = cmdItems[1]; } else { taskNames.push(cmd); } } } return { opts: opts , envVars: envVars , taskNames: taskNames }; }; }; module.exports = parseargs; lets_code_javascript-episode2/node_modules/jake/lib/program.js000066400000000000000000000076231177713054400251400ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var parseargs = require('../lib/parseargs') , Program , optsReg , preempts , usage , die; optsReg = [ { full: 'jakefile' , abbr: 'f' , preempts: false , expectValue: true } , { full: 'quiet' , abbr: 'q' , preempts: false , expectValue: false } , { full: 'directory' , abbr: 'C' , preempts: false , expectValue: true } , { full: 'always-make' , abbr: 'B' , preempts: false , expectValue: false } , { full: 'tasks' , abbr: 'T' , preempts: true } , { full: 'trace' , abbr: 't' , preempts: false , expectValue: false } , { full: 'help' , abbr: 'h' , preempts: true } , { full: 'version' , abbr: 'V' , preempts: true } // Alias lowercase v , { full: 'version' , abbr: 'v' , preempts: true } , { full: 'jakelibdir' , abbr: 'J' , preempts: false , expectValue: true } ]; preempts = { version: function () { die(jake.version); } , help: function () { die(usage); } }; usage = '' + 'Jake JavaScript build tool\n' + '********************************************************************************\n' + 'If no flags are given, Jake looks for a Jakefile or Jakefile.js in the current directory.\n' + '********************************************************************************\n' + '{Usage}: jake [options ...] [env variables ...] target\n' + '\n' + '{Options}:\n' + ' -f, --jakefile FILE Use FILE as the Jakefile.\n' + ' -C, --directory DIRECTORY Change to DIRECTORY before running tasks.\n' + ' -q, --quiet Do not log messages to standard output.\n' + ' -B, --always-make Unconditionally make all targets.\n' + ' -T, --tasks Display the tasks (matching optional PATTERN) with descriptions, then exit.\n' + ' -J, --jakelibdir JAKELIBDIR Auto-import any .jake files in JAKELIBDIR. (default is \'jakelib\')\n' + ' -t, --trace Enable full backtrace.\n' + ' -h, --help Display this help message.\n' + ' -V/v, --version Display the Jake version.\n' + ''; Program = function () { this.opts = {}; this.taskNames = null; this.taskArgs = null; this.envVars = null; }; Program.prototype = new (function () { this.handleErr = function (err) { var msg; jake.logger.error('jake aborted.'); if (this.opts.trace && err.stack) { jake.logger.error(err.stack); } else { if (err.stack) { msg = err.stack.split('\n').slice(0, 2).join('\n'); jake.logger.error(msg); jake.logger.error('(See full trace by running task with --trace)'); } else { jake.logger.error(err.message); } } process.exit(jake.errorCode || 1); }; this.parseArgs = function (args) { var result = (new parseargs.Parser(optsReg)).parse(args); this.opts = result.opts; this.taskNames = result.taskNames; this.envVars = result.envVars; }; this.preemptiveOption = function () { var opts = this.opts; for (var p in opts) { if (preempts[p]) { preempts[p](); return true; } } return false; }; })(); die = function (msg) { console.log(msg); process.exit(); }; module.exports.Program = Program; lets_code_javascript-episode2/node_modules/jake/lib/task/000077500000000000000000000000001177713054400240655ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/lib/task/directory_task.js000066400000000000000000000012701177713054400274510ustar00rootroot00000000000000var DirectoryTask , FileTask = require('./file_task').FileTask; /** @name jake @namespace jake */ /** @name jake.DirectoryTask @constructor @augments EventEmitter @augments jake.Task @augments jake.FileTask @description A Jake DirectoryTask @param {String} name The name of the directory to create. */ DirectoryTask = function (name) { this.modTime = null; // Do constructor-work only on actual instances, not when used // for inheritance if (arguments.length) { this.constructor.prototype.init.apply(this, arguments); } }; DirectoryTask.prototype = new FileTask(); DirectoryTask.prototype.constructor = DirectoryTask; exports.DirectoryTask = DirectoryTask; lets_code_javascript-episode2/node_modules/jake/lib/task/file_task.js000066400000000000000000000071061177713054400263700ustar00rootroot00000000000000var fs = require('fs') , Task = require('./task').Task , FileTask , FileBase , DirectoryTask , utils = require('../utils'); FileBase = new (function () { var isFileOrDirectory = function (t) { return (t instanceof FileTask || t instanceof DirectoryTask); } , isFile = function (t) { return (t instanceof FileTask && !(t instanceof DirectoryTask)); }; this.shouldRunAction = function () { var runAction = false , prereqs = this.prereqs , prereqName , prereqTask; // No repeatsies if (this.done) { return false; } // The always-make override else if (jake.program.opts['always-make']) { // Run if there actually is an action if (typeof this.action == 'function') { return true; } else { return false; } } // Default case else { // We need either an existing file, or an action to create one. // First try grabbing the actual mod-time of the file try { this.updateModTime(); } // Then fall back to looking for an action catch(e) { if (typeof this.action == 'function') { return true; } else { throw new Error('File-task ' + this.fullName + ' has no ' + 'existing file, and no action to create one.'); } } // Compare mod-time of all the prereqs with its mod-time // If any prereqs are newer, need to run the action to update if (prereqs && prereqs.length) { for (var i = 0, ii = prereqs.length; i < ii; i++) { prereqName = prereqs[i]; prereqTask = jake.Task[prereqName]; // Run the action if: // 1. The prereq is a normal task (not file/dir) // 2. The prereq is a file-task with a mod-date more recent than // the one for this file/dir if (prereqTask) { if (!isFileOrDirectory(prereqTask) || (isFile(prereqTask) && prereqTask.modTime > this.modTime)) { return true; } } } } // File/dir has no prereqs, and exists -- no need to run else { return false; } } }; this.updateModTime = function () { var stats = fs.statSync(this.name); this.modTime = stats.mtime; }; this.complete = function () { this.updateModTime(); this._currentPrereqIndex = 0; this.done = true; this.emit('complete'); }; })(); /** @name jake @namespace jake */ /** @name jake.FileTask @constructor @augments EventEmitter @augments jake.Task @description A Jake FileTask @param {String} name The name of the Task @param {Array} [prereqs] Prerequisites to be run before this task @param {Function} [action] The action to perform to create this file @param {Object} [opts] @param {Array} [opts.asyc=false] Perform this task asynchronously. If you flag a task with this option, you must call the global `complete` method inside the task's action, for execution to proceed to the next task. */ FileTask = function (name, prereqs, action, opts) { this.modTime = null; // Do constructor-work only on actual instances, not when used // for inheritance if (arguments.length) { this.constructor.prototype.init.apply(this, arguments); } }; FileTask.prototype = new Task(); FileTask.prototype.constructor = FileTask; utils.mixin(FileTask.prototype, FileBase); exports.FileTask = FileTask; // DirectoryTask is a subclass of FileTask, depends on it // being defined DirectoryTask = require('./directory_task').DirectoryTask; lets_code_javascript-episode2/node_modules/jake/lib/task/index.js000066400000000000000000000003541177713054400255340ustar00rootroot00000000000000 var Task = require('./task').Task , FileTask = require('./file_task').FileTask , DirectoryTask = require('./directory_task').DirectoryTask; exports.Task = Task; exports.FileTask = FileTask; exports.DirectoryTask = DirectoryTask; lets_code_javascript-episode2/node_modules/jake/lib/task/task.js000066400000000000000000000127071177713054400253740ustar00rootroot00000000000000var fs = require('fs') , path = require('path') , existsSync = typeof fs.existsSync == 'function' ? fs.existsSync : path.existsSync , EventEmitter = require('events').EventEmitter , Task , TaskBase , utils = require('../utils'); /** @name jake @namespace jake */ /** @name jake.Task @constructor @augments EventEmitter @description A Jake Task @param {String} name The name of the Task @param {Array} [prereqs] Prerequisites to be run before this task @param {Function} [action] The action to perform for this task @param {Object} [opts] @param {Array} [opts.asyc=false] Perform this task asynchronously. If you flag a task with this option, you must call the global `complete` method inside the task's action, for execution to proceed to the next task. */ Task = function () { // Do constructor-work only on actual instances, not when used // for inheritance if (arguments.length) { this.constructor.prototype.init.apply(this, arguments); } }; Task.prototype = new EventEmitter(); Task.prototype.constructor = Task; TaskBase = new (function () { // Parse any positional args attached to the task-name var parsePrereqName = function (name) { var taskArr = name.split('[') , taskName = taskArr[0] , taskArgs = []; if (taskArr[1]) { taskArgs = taskArr[1].replace(/\]$/, ''); taskArgs = taskArgs.split(','); } return { name: taskName , args: taskArgs }; }; /** @name jake.Task#event:complete @event */ this.init = function (name, prereqs, action, options) { var opts = options || {}; this._currentPrereqIndex = 0; this.name = name; this.prereqs = prereqs; this.action = action; this.async = false; this.done = false; this.fullName = null; this.description = null; this.args = []; this.namespace = null; // Support legacy async-flag -- if not explicitly passed or falsy, will // be set to empty-object if (typeof opts == 'boolean' && opts === true) { this.async = true; } else { if (opts.async) { this.async = true; } } }; /** @name jake.Task#invoke @function @description Runs prerequisites, then this task. If the task has already been run, will not run the task again. */ this.invoke = function () { jake._invocationChain.push(this); this.args = Array.prototype.slice.call(arguments); this.runPrereqs(); }; /** @name jake.Task#reenable @function @description Runs this task, without running any prerequisites. If the task has already been run, it will still run it again. */ this.execute = function () { jake._invocationChain.push(this); this.reenable(); this.run(); }; this.runPrereqs = function () { if (this.prereqs && this.prereqs.length) { this.nextPrereq(); } else { this.run(); } }; this.nextPrereq = function () { var self = this , index = this._currentPrereqIndex , name = this.prereqs[index] , absolute , prereq , parsed , filePath , stats; if (name) { parsed = parsePrereqName(name); absolute = parsed.name[0] === '^'; if (absolute) { parsed.name = parsed.name.slice(1); prereq = jake.Task[parsed.name]; } else { prereq = this.namespace.resolve(parsed.name); } // Task doesn't exist, may be a static file if (!prereq) { filePath = name.split(':')[1] || name; // Create a dummy FileTask if file actually exists if (existsSync(filePath)) { stats = fs.statSync(filePath); prereq = new jake.FileTask(name); prereq.modTime = stats.mtime; // Put this dummy Task in the global Tasks list so // modTime will be eval'd correctly jake.Task[parsed.name] = prereq; } // Otherwise it's not a valid task else { throw new Error('Unknown task "' + name + '"'); } } // Do when done prereq.once('complete', function () { self.handlePrereqComplete(prereq); }); prereq.invoke.apply(prereq, parsed.args); } }; this.reenable = function (deep) { var prereqs , prereq; this.done = false; if (deep && this.prereqs) { prereqs = this.prereqs; for (var i = 0, ii = prereqs.length; i < ii; i++) { prereq = jake.Task[prereqs[i]]; if (prereq) { prereq.reenable(deep); } } } }; this.handlePrereqComplete = function (prereq) { var self = this; this._currentPrereqIndex++; if (this._currentPrereqIndex < this.prereqs.length) { setTimeout(function () { self.nextPrereq(); }, 0); } else { this.run(); } }; this.shouldRunAction = function () { if (this.done || typeof this.action != 'function') { return false } return true; }; this.run = function () { var runAction = this.shouldRunAction(); if (runAction) { try { this.action.apply(this, this.args); } catch (e) { this.emit('error', e); return; // Bail out, not complete } } if (!(runAction && this.async)) { complete(); } }; this.complete = function () { this._currentPrereqIndex = 0; this.done = true; this.emit('complete'); }; })(); utils.mixin(Task.prototype, TaskBase); exports.Task = Task; lets_code_javascript-episode2/node_modules/jake/lib/test_task.js000066400000000000000000000143031177713054400254630ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var path = require('path') , fs = require('fs') , exec = require('child_process').exec , currDir = process.cwd(); /** @name jake @namespace jake */ /** @name jake.TestTask @constructor @description Instantiating a TestTask creates a number of Jake Tasks that make running tests for your software easy. @param {String} name The name of the project @param {Function} definition Defines the list of files containing the tests, and the name of the namespace/task for running them. Will be executed on the instantiated TestTask (i.e., 'this', will be the TestTask instance), to set the various instance-propertiess. @example var t = new jake.TestTask('bij-js', function () { this.testName = 'testSpecial'; this.testFiles.include('test/**'); }); */ var TestTask = function (name, definition) { var self = this; /** @name jake.TestTask#testNam @public @type {String} @description The name of the namespace to place the tests in, and the top-level task for running tests. Defaults to "test" */ this.testName = 'test'; /** @name jake.TestTask#testFiles @public @type {jake.FileList} @description The list of files containing tests to load */ this.testFiles = new jake.FileList(); /** @name jake.TestTask#showDescription @public @type {Boolean} @description Show the created task when doing Jake -T */ this.showDescription = true; if (typeof definition == 'function') { definition.call(this); } if (this.showDescription) { desc('Run the tests for ' + name); } task(this.testName, function () { var t = jake.Task[self.testName + ':run']; t.invoke.apply(t, arguments); }, {async: true}); namespace(self.testName, function () { task('run', function (pat) { var p = pat || '.*' , re , testFiles; // Don't nest; make a top-level namespace. Don't want // re-calling from inside to nest infinitely jake.currentNamespace = jake.defaultNamespace; re = new RegExp(pat) testFiles = self.testFiles.toArray().filter(function (f) { return (re).test(f); }); // Create a namespace for all the testing tasks to live in namespace(self.testName + 'Exec', function () { // Each test will be a prereq for the dummy top-level task var prereqs = [] // Continuation to pass to the async tests, wrapping `continune` , next = function () { complete(); } // Create the task for this test-function , createTask = function (name, action) { // If the test-function is defined with a continuation // param, flag the task as async isAsync = !!action.length; // Define the actual namespaced task with the name, the // wrapped action, and the correc async-flag task(name, createAction(name, action), { async: isAsync }); } // Used as the action for the defined task for each test. , createAction = function (n, a) { // A wrapped function that passes in the `next` function // for any tasks that run asynchronously return function () { var cb; if (a.length) { cb = next; } if (!(n == 'before' || n == 'after')) { jake.logger.log('Running ' + n); } // 'this' will be the task when action is run return a.call(this, cb); }; } // Dummy top-level task for everything to be prereqs for , topLevel; // Pull in each test-file, and iterate over any exported // test-functions. Register each test-function as a prereq task testFiles.forEach(function (file) { var exp = require(path.join(currDir, file)) , name , action , isAsync; // Create a namespace for each filename, so test-name collisions // won't be a problem namespace(file, function () { if (typeof exp.before == 'function') { prereqs.push(self.testName + 'Exec:' + file + ':before'); // Create the task createTask('before', exp.before); } // Walk each exported function, and create a task for each for (var p in exp) { if (p == 'before' || p == 'after') { continue; } // Add the namespace:name of this test to the list of prereqs // for the dummy top-level task prereqs.push(self.testName + 'Exec:' + file + ':' + p); // Create the task createTask(p, exp[p]); } if (typeof exp.after == 'function') { prereqs.push(self.testName + 'Exec:' + file + ':after'); // Create the task createTask('after', exp.after); } }); }); // Create the dummy top-level task. When calling a task internally // with `invoke` that is async (or has async prereqs), have to listen // for the 'complete' event to know when it's done topLevel = task('__top__', prereqs); topLevel.addListener('complete', function () { jake.logger.log('All tests ran successfully'); complete(); }); topLevel.invoke(); // Do the thing! }); }, {async: true}); }); }; jake.TestTask = TestTask; exports.TestTask = TestTask; lets_code_javascript-episode2/node_modules/jake/lib/utils/000077500000000000000000000000001177713054400242635ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/lib/utils/file.js000066400000000000000000000150451177713054400255450ustar00rootroot00000000000000var fs = require('fs') , path = require('path') , logger = require('./logger'); var fileUtils = new (function () { var _copyFile = function(fromPath, toPath, opts) { var from = path.normalize(fromPath) , to = path.normalize(toPath) , options = opts || {} , fromStat , toStat , destExists , destDoesNotExistErr , content , filename , dirContents , targetDir; fromStat = fs.statSync(from); try { //console.dir(to + ' destExists'); toStat = fs.statSync(to); destExists = true; } catch(e) { //console.dir(to + ' does not exist'); destDoesNotExistErr = e; destExists = false; } // Destination dir or file exists, copy into (directory) // or overwrite (file) if (destExists) { // If there's a rename-via-copy file/dir name passed, use it. // Otherwise use the actual file/dir name filename = options.rename || path.basename(from); // Copying a directory if (fromStat.isDirectory()) { dirContents = fs.readdirSync(from); targetDir = path.join(to, filename); // We don't care if the target dir already exists try { fs.mkdirSync(targetDir, options.mode || 0755); } catch(e) { if (e.code != 'EEXIST') { throw e; } } for (var i = 0, ii = dirContents.length; i < ii; i++) { //console.log(dirContents[i]); _copyFile(path.join(from, dirContents[i]), targetDir); } } // Copying a file else { content = fs.readFileSync(from); // Copy into dir if (toStat.isDirectory()) { //console.log('copy into dir ' + to); fs.writeFileSync(path.join(to, filename), content); } // Overwrite file else { //console.log('overwriting ' + to); fs.writeFileSync(to, content); } } } // Dest doesn't exist, can't create it else { throw destDoesNotExistErr; } } , _copyDir = function (from, to, opts) { var createDir = opts.createDir; } , _readDir = function (dirPath) { var dir = path.normalize(dirPath) , paths = [] , ret = [dir]; paths = fs.readdirSync(dir); paths.forEach(function (p) { var curr = path.join(dir, p); var stat = fs.statSync(curr); if (stat.isDirectory()) { ret = ret.concat(_readDir(curr)); } else { ret.push(curr); } }); return ret; } , _rmDir = function (dirPath) { var dir = path.normalize(dirPath) , paths = []; paths = fs.readdirSync(dir); paths.forEach(function (p) { var curr = path.join(dir, p); var stat = fs.statSync(curr); if (stat.isDirectory()) { _rmDir(curr); } else { fs.unlinkSync(curr); } }); fs.rmdirSync(dir); }; this.cpR = function (fromPath, toPath, options) { var from = path.normalize(fromPath) , to = path.normalize(toPath) , toStat , doesNotExistErr , paths , filename , opts = options || {}; if (!opts.silent) { logger.log('cp -r ' + fromPath + ' ' + toPath); } opts = {}; // Reset if (from == to) { throw new Error('Cannot copy ' + from + ' to itself.'); } // Handle rename-via-copy try { toStat = fs.statSync(to); } catch(e) { doesNotExistErr = e; // Get abs path so it's possible to check parent dir if (!this.isAbsolute(to)) { to = path.join(process.cwd() , to); } // Save the file/dir name filename = path.basename(to); // See if a parent dir exists, so there's a place to put the /// renamed file/dir (resets the destination for the copy) to = path.dirname(to); try { toStat = fs.statSync(to); } catch(e) {} if (toStat && toStat.isDirectory()) { // Set the rename opt to pass to the copy func, will be used // as the new file/dir name opts.rename = filename; //console.log('filename ' + filename); } else { throw doesNotExistErr; } } _copyFile(from, to, opts); }; this.mkdirP = function (dir, mode) { var dirPath = path.normalize(dir) , paths = dirPath.split(/\/|\\/) , currPath , next; if (paths[0] == '' || /^[A-Za-z]+:/.test(paths[0])) { currPath = paths.shift() || '/'; currPath = path.join(currPath, paths.shift()); //console.log('basedir'); } while ((next = paths.shift())) { if (next == '..') { currPath = path.join(currPath, next); continue; } currPath = path.join(currPath, next); try { //console.log('making ' + currPath); fs.mkdirSync(currPath, mode || 0755); } catch(e) { if (e.code != 'EEXIST') { throw e; } } } }; this.readdirR = function (dir, opts) { var options = opts || {} , format = options.format || 'array' , ret; ret = _readDir(dir); return format == 'string' ? ret.join('\n') : ret; }; this.rmRf = function (p, options) { var stat , opts = options || {}; if (!opts.silent) { logger.log('rm -rf ' + p); } try { stat = fs.statSync(p); if (stat.isDirectory()) { _rmDir(p); } else { fs.unlinkSync(p); } } catch (e) {} }; this.isAbsolute = function (p) { var match = /^[A-Za-z]+:\\|^\//.exec(p); if (match && match.length) { return match[0]; } return false; }; this.absolutize = function (p) { if (this.isAbsolute(p)) { return p; } else { return path.join(process.cwd(), p); } }; this.basedir = function (p) { var str = p || '' , abs = this.isAbsolute(p); if (abs) { return abs; } // Split into segments str = str.split(/\\|\//)[0]; // If the path has a leading asterisk, basedir is the current dir if (str.indexOf('*') > -1) { return '.'; } // Otherwise it's the first segment in the path else { return str; } }; })(); module.exports = fileUtils; lets_code_javascript-episode2/node_modules/jake/lib/utils/index.js000066400000000000000000000173421177713054400257370ustar00rootroot00000000000000/* * Jake JavaScript build tool * Copyright 2112 Matthew Eernisse (mde@fleegix.org) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ var exec = require('child_process').exec , spawn = require('child_process').spawn , EventEmitter = require('events').EventEmitter , fileUtils = require('./file') , logger = require('./logger') , utils , Exec , _mix, _trim, _truncate; _mix = function (targ, src, merge, includeProto) { for (var p in src) { // Don't copy stuff from the prototype if (src.hasOwnProperty(p) || includeProto) { if (merge && // Assumes the source property is an Object you can // actually recurse down into (typeof src[p] == 'object') && (src[p] !== null) && !(src[p] instanceof Array)) { // Create the source property if it doesn't exist // TODO: What if it's something weird like a String or Number? if (typeof targ[p] == 'undefined') { targ[p] = {}; } _mix(targ[p], src[p], merge, includeProto); // Recurse } // If it's not a merge-copy, just set and forget else { targ[p] = src[p]; } } } }; _trim = function (s) { var str = s || ''; return str.replace(/^\s*|\s*$/g, ''); }; _truncate = function (s) { var str = s ? s.replace(/\n$/, '') : ''; return str; }; /** @name jake @namespace jake */ utils = new (function () { /** @name jake.exec @static @function @description Executes shell-commands asynchronously with an optional final callback. ` @param {String[]} cmds The list of shell-commands to execute @param {Function} [callback] Callback to run after executing the commands @param {Object} [opts] @param {Boolean} [opts.stdout=false] Print stdout from each command @param {Boolean} [opts.stderr=false] Print stderr from each command @param {Boolean} [opts.breakOnError=true] Stop further execution on the first error. @example var cmds = [ 'echo "showing directories"' , 'ls -al | grep ^d' , 'echo "moving up a directory"' , 'cd ../' ] , callback = function () { console.log('Finished running commands.'); } jake.exec(cmds, callback, {stdout: true}); */ this.exec = function (a, b, c) { var ex = new Exec(a, b, c); ex.addListener('error', function (msg, code) { if (ex._config.breakOnError) { fail(msg, code); } }); ex.run(); }; this.createExec = function (a, b, c) { return new Exec(a, b, c); }; this.objectToString = function (object) { var objectArray = []; for (var key in object) { if ('object' == typeof object[key]) { objectArray.push(this.objectToString(object[key])); } else { objectArray.push(key + '=' + object[key]); } } return objectArray.join(', '); }; /* * Mix in the properties on an object to another object * yam.mixin(target, source, [source,] [source, etc.] [merge-flag]); * 'merge' recurses, to merge object sub-properties together instead * of just overwriting with the source object. */ this.mixin = (function () { return function () { var args = Array.prototype.slice.apply(arguments), merge = false, targ, sources; if (args.length > 2) { if (typeof args[args.length - 1] == 'boolean') { merge = args.pop(); } } targ = args.shift(); sources = args; for (var i = 0, ii = sources.length; i < ii; i++) { _mix(targ, sources[i], merge); } return targ; }; }).call(this); this.enhance = (function () { return function () { var args = Array.prototype.slice.apply(arguments), merge = false, targ, sources; if (args.length > 2) { if (typeof args[args.length - 1] == 'boolean') { merge = args.pop(); } } targ = args.shift(); sources = args; for (var i = 0, ii = sources.length; i < ii; i++) { _mix(targ, sources[i], merge, true); } return targ; }; }).call(this); })(); Exec = function () { var args , arg , cmds , callback , opts = {}; args = Array.prototype.slice.call(arguments); cmds = args.shift(); // Arrayize if passed a single string command if (typeof cmds == 'string') { cmds = [cmds]; } // Make a copy if it's an actual list else { cmds = cmds.slice(); } // Get optional callback or opts while((arg = args.shift())) { if (typeof arg == 'function') { callback = arg; } else if (typeof arg == 'object') { opts = arg; } } // Backward-compat shim if (typeof opts.stdout != 'undefined') { opts.printStdout = opts.stdout; } if (typeof opts.stderr != 'undefined') { opts.printStderr = opts.stderr; } this._cmds = cmds; this._callback = callback; this._config = { printStdout: false , printStderr: false , breakOnError: true }; utils.mixin(this._config, opts); }; Exec.prototype = new EventEmitter(); Exec.prototype.constructor = Exec; utils.mixin(Exec.prototype, new (function () { var _run = function () { var self = this , sh , cmd , args , next = this._cmds.shift() , config = this._config , errData = ''; // Keep running as long as there are commands in the array if (next) { this.emit('cmdStart', next); // Ganking part of Node's child_process.exec to get cmdline args parsed cmd = '/bin/sh'; args = ['-c', next]; if (process.platform == 'win32') { cmd = 'cmd'; args = ['/c', next]; } // Spawn a child-process, set up output sh = spawn(cmd, args); // Out sh.stdout.on('data', function (data) { if (config.printStdout) { console.log(_truncate(data.toString())); } self.emit('stdout', data); }); // Err sh.stderr.on('data', function (data) { var d = data.toString(); if (config.printStderr) { console.error(_truncate(d)); } self.emit('stderr', data); // Accumulate the error-data so we can use it as the // stack if the process exits with an error errData += d; }); // Exit, handle err or run next sh.on('exit', function (code) { var msg; if (code != 0) { msg = errData || 'Process exited with error.'; msg = _trim(msg); self.emit('error', msg, code); } if (code == 0 || !config.breakOnError) { self.emit('cmdEnd', next); _run.call(self); } }); } else { self.emit('end'); if (typeof self._callback == 'function') { self._callback(); } } }; this.append = function (cmd) { this._cmds.push(cmd); }; this.run = function () { _run.call(this); }; })()); utils.Exec = Exec; utils.logger = logger; // Hang all the file utils off this too utils.mixin(utils, fileUtils); module.exports = utils; lets_code_javascript-episode2/node_modules/jake/lib/utils/logger.js000066400000000000000000000007701177713054400261040ustar00rootroot00000000000000var util = require('util'); var logger = new (function () { var _output = function (type, out) { var quiet = typeof jake != 'undefined' && jake.program && jake.program.opts && jake.program.opts.quiet , msg; if (!quiet) { msg = typeof out == 'string' ? out : util.inspect(out); console[type](msg); } }; this.log = function (out) { _output('log', out); }; this.error = function (out) { _output('error', out); }; })(); module.exports = logger; lets_code_javascript-episode2/node_modules/jake/node_modules/000077500000000000000000000000001177713054400250325ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/000077500000000000000000000000001177713054400270035ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/.travis.yml000066400000000000000000000000531177713054400311120ustar00rootroot00000000000000language: node_js node_js: - 0.4 - 0.6 lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/LICENSE000066400000000000000000000021041177713054400300050ustar00rootroot00000000000000Copyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/README.md000066400000000000000000000147741177713054400302770ustar00rootroot00000000000000# minimatch A minimal matching utility. [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch) This is the matching library used internally by npm. Eventually, it will replace the C binding in node-glob. It works by converting glob expressions into JavaScript `RegExp` objects. ## Usage ```javascript var minimatch = require("minimatch") minimatch("bar.foo", "*.foo") // true! minimatch("bar.foo", "*.bar") // false! ``` ## Features Supports these glob features: * Brace Expansion * Extended glob matching * "Globstar" `**` matching See: * `man sh` * `man bash` * `man 3 fnmatch` * `man 5 gitignore` ### Comparisons to other fnmatch/glob implementations While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between minimatch and other implementations, and are intentional. If the pattern starts with a `!` character, then it is negated. Set the `nonegate` flag to suppress this behavior, and treat leading `!` characters normally. This is perhaps relevant if you wish to start the pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` characters at the start of a pattern will negate the pattern multiple times. If a pattern starts with `#`, then it is treated as a comment, and will not match anything. Use `\#` to match a literal `#` at the start of a line, or set the `nocomment` flag to suppress this behavior. The double-star character `**` is supported by default, unless the `noglobstar` flag is set. This is supported in the manner of bsdglob and bash 4.1, where `**` only has special significance if it is the only thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but `a/**b` will not. **Note that this is different from the way that `**` is handled by ruby's `Dir` class.** If an escaped pattern has no matches, and the `nonull` flag is set, then minimatch.match returns the pattern as-provided, rather than interpreting the character escapes. For example, `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than `"*a?"`. This is akin to setting the `nullglob` option in bash, except that it does not resolve escaped pattern characters. If brace expansion is not disabled, then it is performed before any other interpretation of the glob pattern. Thus, a pattern like `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are checked for validity. Since those two are valid, matching proceeds. ## Minimatch Class Create a minimatch object by instanting the `minimatch.Minimatch` class. ```javascript var Minimatch = require("minimatch").Minimatch var mm = new Minimatch(pattern, options) ``` ### Properties * `pattern` The original pattern the minimatch object represents. * `options` The options supplied to the constructor. * `set` A 2-dimensional array of regexp or string expressions. Each row in the array corresponds to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For example, the pattern `{a,b/c}/d` would expand to a set of patterns like: [ [ a, d ] , [ b, c, d ] ] If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"` rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression. * `regexp` Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. * `negate` True if the pattern is negated. * `comment` True if the pattern is a comment. * `empty` True if the pattern is `""`. ### Methods * `makeRe` Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid. * `match(fname)` Return true if the filename matches the pattern, or false otherwise. * `matchOne(fileArray, patternArray, partial)` Take a `/`-split filename, and match it against a single row in the `regExpSet`. This method is mainly for internal use, but is exposed so that it can be used by a glob-walker that needs to avoid excessive filesystem calls. All other methods are internal, and will be called as necessary. ## Functions The top-level exported function has a `cache` property, which is an LRU cache set to store 100 items. So, calling these methods repeatedly with the same pattern and options will use the same Minimatch object, saving the cost of parsing it multiple times. ### minimatch(path, pattern, options) Main export. Tests a path against the pattern using the options. ```javascript var isJS = minimatch(file, "*.js", { matchBase: true }) ``` ### minimatch.filter(pattern, options) Returns a function that tests its supplied argument, suitable for use with `Array.filter`. Example: ```javascript var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})) ``` ### minimatch.match(list, pattern, options) Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself. ```javascript var javascripts = minimatch.match(fileList, "*.js", {matchBase: true})) ``` ### minimatch.makeRe(pattern, options) Make a regular expression object from the pattern. ## Options All options are `false` by default. ### debug Dump a ton of stuff to stderr. ### nobrace Do not expand `{a,b}` and `{1..3}` brace sets. ### noglobstar Disable `**` matching against multiple folder names. ### dot Allow patterns to match filenames starting with a period, even if the pattern does not explicitly have a period in that spot. Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` is set. ### noext Disable "extglob" style patterns like `+(a|b)`. ### nocase Perform a case-insensitive match. ### nonull When a match is not found by `minimatch.match`, return a list containing the pattern itself. When set, an empty list is returned if there are no matches. ### matchBase If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. ### nocomment Suppress the behavior of treating `#` at the start of a pattern as a comment. ### nonegate Suppress the behavior of treating a leading `!` character as negation. ### flipNegate Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.) lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/minimatch.js000066400000000000000000000665351177713054400313310ustar00rootroot00000000000000;(function (require, exports, module, platform) { if (module) module.exports = minimatch else exports.minimatch = minimatch if (!require) { require = function (id) { switch (id) { case "path": return { basename: function (f) { f = f.split(/[\/\\]/) var e = f.pop() if (!e) e = f.pop() return e }} case "lru-cache": return function LRUCache () { // not quite an LRU, but still space-limited. var cache = {} var cnt = 0 this.set = function (k, v) { cnt ++ if (cnt >= 100) cache = {} cache[k] = v } this.get = function (k) { return cache[k] } } } } } minimatch.Minimatch = Minimatch var LRU = require("lru-cache") , cache = minimatch.cache = new LRU(100) , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} var path = require("path") // any single thing other than / // don't need to escape / when using new RegExp() , qmark = "[^/]" // * => any number of characters , star = qmark + "*?" // ** when dots are allowed. Anything goes, except .. and . // not (^ or / followed by one or two dots followed by $ or /), // followed by anything, any number of times. , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?" // not a ^ or / followed by a dot, // followed by anything, any number of times. , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?" // characters that need to be escaped in RegExp. , reSpecials = charSet("().*{}+?[]^$\\!") // "abc" -> { a:true, b:true, c:true } function charSet (s) { return s.split("").reduce(function (set, c) { set[c] = true return set }, {}) } // normalizes slashes. var slashSplit = /\/+/ minimatch.monkeyPatch = monkeyPatch function monkeyPatch () { var desc = Object.getOwnPropertyDescriptor(String.prototype, "match") var orig = desc.value desc.value = function (p) { if (p instanceof Minimatch) return p.match(this) return orig.call(this, p) } Object.defineProperty(String.prototype, desc) } minimatch.filter = filter function filter (pattern, options) { options = options || {} return function (p, i, list) { return minimatch(p, pattern, options) } } function ext (a, b) { a = a || {} b = b || {} var t = {} Object.keys(b).forEach(function (k) { t[k] = b[k] }) Object.keys(a).forEach(function (k) { t[k] = a[k] }) return t } minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return minimatch var orig = minimatch var m = function minimatch (p, pattern, options) { return orig.minimatch(p, pattern, ext(def, options)) } m.Minimatch = function Minimatch (pattern, options) { return new orig.Minimatch(pattern, ext(def, options)) } return m } Minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return Minimatch return minimatch.defaults(def).Minimatch } function minimatch (p, pattern, options) { if (typeof pattern !== "string") { throw new TypeError("glob pattern string required") } if (!options) options = {} // shortcut: comments match nothing. if (!options.nocomment && pattern.charAt(0) === "#") { return false } // "" only matches "" if (pattern.trim() === "") return p === "" return new Minimatch(pattern, options).match(p) } function Minimatch (pattern, options) { if (!(this instanceof Minimatch)) { return new Minimatch(pattern, options, cache) } if (typeof pattern !== "string") { throw new TypeError("glob pattern string required") } if (!options) options = {} pattern = pattern.trim() // lru storage. // these things aren't particularly big, but walking down the string // and turning it into a regexp can get pretty costly. var cacheKey = pattern + "\n" + Object.keys(options).filter(function (k) { return options[k] }).join(":") var cached = minimatch.cache.get(cacheKey) if (cached) return cached minimatch.cache.set(cacheKey, this) this.options = options this.set = [] this.pattern = pattern this.regexp = null this.negate = false this.comment = false this.empty = false // make the set of regexps etc. this.make() } Minimatch.prototype.make = make function make () { // don't do it more than once. if (this._made) return var pattern = this.pattern var options = this.options // empty patterns and comments match nothing. if (!options.nocomment && pattern.charAt(0) === "#") { this.comment = true return } if (!pattern) { this.empty = true return } // step 1: figure out negation, etc. this.parseNegate() // step 2: expand braces var set = this.globSet = this.braceExpand() if (options.debug) console.error(this.pattern, set) // step 3: now we have a set, so turn each one into a series of path-portion // matching patterns. // These will be regexps, except in the case of "**", which is // set to the GLOBSTAR object for globstar behavior, // and will not contain any / characters set = this.globParts = set.map(function (s) { return s.split(slashSplit) }) if (options.debug) console.error(this.pattern, set) // glob --> regexps set = set.map(function (s, si, set) { return s.map(this.parse, this) }, this) if (options.debug) console.error(this.pattern, set) // filter out everything that didn't compile properly. set = set.filter(function (s) { return -1 === s.indexOf(false) }) if (options.debug) console.error(this.pattern, set) this.set = set } Minimatch.prototype.parseNegate = parseNegate function parseNegate () { var pattern = this.pattern , negate = false , options = this.options , negateOffset = 0 if (options.nonegate) return for ( var i = 0, l = pattern.length ; i < l && pattern.charAt(i) === "!" ; i ++) { negate = !negate negateOffset ++ } if (negateOffset) this.pattern = pattern.substr(negateOffset) this.negate = negate } // Brace expansion: // a{b,c}d -> abd acd // a{b,}c -> abc ac // a{0..3}d -> a0d a1d a2d a3d // a{b,c{d,e}f}g -> abg acdfg acefg // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg // // Invalid sets are not expanded. // a{2..}b -> a{2..}b // a{b}c -> a{b}c minimatch.braceExpand = function (pattern, options) { return new Minimatch(pattern, options).braceExpand() } Minimatch.prototype.braceExpand = braceExpand function braceExpand (pattern, options) { options = options || this.options pattern = typeof pattern === "undefined" ? this.pattern : pattern if (typeof pattern === "undefined") { throw new Error("undefined pattern") } if (options.nobrace || !pattern.match(/\{.*\}/)) { // shortcut. no need to expand. return [pattern] } var escaping = false // examples and comments refer to this crazy pattern: // a{b,c{d,e},{f,g}h}x{y,z} // expected: // abxy // abxz // acdxy // acdxz // acexy // acexz // afhxy // afhxz // aghxy // aghxz // everything before the first \{ is just a prefix. // So, we pluck that off, and work with the rest, // and then prepend it to everything we find. if (pattern.charAt(0) !== "{") { // console.error(pattern) var prefix = null for (var i = 0, l = pattern.length; i < l; i ++) { var c = pattern.charAt(i) // console.error(i, c) if (c === "\\") { escaping = !escaping } else if (c === "{" && !escaping) { prefix = pattern.substr(0, i) break } } // actually no sets, all { were escaped. if (prefix === null) { // console.error("no sets") return [pattern] } var tail = braceExpand(pattern.substr(i), options) return tail.map(function (t) { return prefix + t }) } // now we have something like: // {b,c{d,e},{f,g}h}x{y,z} // walk through the set, expanding each part, until // the set ends. then, we'll expand the suffix. // If the set only has a single member, then'll put the {} back // first, handle numeric sets, since they're easier var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/) if (numset) { // console.error("numset", numset[1], numset[2]) var suf = braceExpand(pattern.substr(numset[0].length), options) , start = +numset[1] , end = +numset[2] , inc = start > end ? -1 : 1 , set = [] for (var i = start; i != (end + inc); i += inc) { // append all the suffixes for (var ii = 0, ll = suf.length; ii < ll; ii ++) { set.push(i + suf[ii]) } } return set } // ok, walk through the set // We hope, somewhat optimistically, that there // will be a } at the end. // If the closing brace isn't found, then the pattern is // interpreted as braceExpand("\\" + pattern) so that // the leading \{ will be interpreted literally. var i = 1 // skip the \{ , depth = 1 , set = [] , member = "" , sawEnd = false , escaping = false function addMember () { set.push(member) member = "" } // console.error("Entering for") FOR: for (i = 1, l = pattern.length; i < l; i ++) { var c = pattern.charAt(i) // console.error("", i, c) if (escaping) { escaping = false member += "\\" + c } else { switch (c) { case "\\": escaping = true continue case "{": depth ++ member += "{" continue case "}": depth -- // if this closes the actual set, then we're done if (depth === 0) { addMember() // pluck off the close-brace i ++ break FOR } else { member += c continue } case ",": if (depth === 1) { addMember() } else { member += c } continue default: member += c continue } // switch } // else } // for // now we've either finished the set, and the suffix is // pattern.substr(i), or we have *not* closed the set, // and need to escape the leading brace if (depth !== 0) { // console.error("didn't close", pattern) return braceExpand("\\" + pattern, options) } // x{y,z} -> ["xy", "xz"] // console.error("set", set) // console.error("suffix", pattern.substr(i)) var suf = braceExpand(pattern.substr(i), options) // ["b", "c{d,e}","{f,g}h"] -> // [["b"], ["cd", "ce"], ["fh", "gh"]] var addBraces = set.length === 1 // console.error("set pre-expanded", set) set = set.map(function (p) { return braceExpand(p, options) }) // console.error("set expanded", set) // [["b"], ["cd", "ce"], ["fh", "gh"]] -> // ["b", "cd", "ce", "fh", "gh"] set = set.reduce(function (l, r) { return l.concat(r) }) if (addBraces) { set = set.map(function (s) { return "{" + s + "}" }) } // now attach the suffixes. var ret = [] for (var i = 0, l = set.length; i < l; i ++) { for (var ii = 0, ll = suf.length; ii < ll; ii ++) { ret.push(set[i] + suf[ii]) } } return ret } // parse a component of the expanded set. // At this point, no pattern may contain "/" in it // so we're going to return a 2d array, where each entry is the full // pattern, split on '/', and then turned into a regular expression. // A regexp is made at the end which joins each array with an // escaped /, and another full one which joins each regexp with |. // // Following the lead of Bash 4.1, note that "**" only has special meaning // when it is the *only* thing in a path portion. Otherwise, any series // of * is equivalent to a single *. Globstar behavior is enabled by // default, and can be disabled by setting options.noglobstar. Minimatch.prototype.parse = parse var SUBPARSE = {} function parse (pattern, isSub) { var options = this.options // shortcuts if (!options.noglobstar && pattern === "**") return GLOBSTAR if (pattern === "") return "" var re = "" , hasMagic = false , escaping = false // ? => one single character , patternListStack = [] , plType , stateChar , inClass = false , reClassStart = -1 , classStart = -1 // . and .. never match anything that doesn't start with ., // even when options.dot is set. , patternStart = pattern.charAt(0) === "." ? "" // anything // not (start or / followed by . or .. followed by / or end) : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))" : "(?!\\.)" function clearStateChar () { if (stateChar) { // we had some state-tracking character // that wasn't consumed by this pass. switch (stateChar) { case "*": re += star hasMagic = true break case "?": re += qmark hasMagic = true break default: re += "\\"+stateChar break } stateChar = false } } for ( var i = 0, len = pattern.length, c ; (i < len) && (c = pattern.charAt(i)) ; i ++ ) { if (options.debug) { console.error("%s\t%s %s %j", pattern, i, re, c) } // skip over any that are escaped. if (escaping && reSpecials[c]) { re += "\\" + c escaping = false continue } SWITCH: switch (c) { case "/": // completely not allowed, even escaped. // Should already be path-split by now. return false case "\\": clearStateChar() escaping = true continue // the various stateChar values // for the "extglob" stuff. case "?": case "*": case "+": case "@": case "!": if (options.debug) { console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c) } // all of those are literals inside a class, except that // the glob [!a] means [^a] in regexp if (inClass) { if (c === "!" && i === classStart + 1) c = "^" re += c continue } // if we already have a stateChar, then it means // that there was something like ** or +? in there. // Handle the stateChar, then proceed with this one. clearStateChar() stateChar = c // if extglob is disabled, then +(asdf|foo) isn't a thing. // just clear the statechar *now*, rather than even diving into // the patternList stuff. if (options.noext) clearStateChar() continue case "(": if (inClass) { re += "(" continue } if (!stateChar) { re += "\\(" continue } plType = stateChar patternListStack.push({ type: plType , start: i - 1 , reStart: re.length }) // negation is (?:(?!js)[^/]*) re += stateChar === "!" ? "(?:(?!" : "(?:" stateChar = false continue case ")": if (inClass || !patternListStack.length) { re += "\\)" continue } hasMagic = true re += ")" plType = patternListStack.pop().type // negation is (?:(?!js)[^/]*) // The others are (?:) switch (plType) { case "!": re += "[^/]*?)" break case "?": case "+": case "*": re += plType case "@": break // the default anyway } continue case "|": if (inClass || !patternListStack.length || escaping) { re += "\\|" escaping = false continue } re += "|" continue // these are mostly the same in regexp and glob case "[": // swallow any state-tracking char before the [ clearStateChar() if (inClass) { re += "\\" + c continue } inClass = true classStart = i reClassStart = re.length re += c continue case "]": // a right bracket shall lose its special // meaning and represent itself in // a bracket expression if it occurs // first in the list. -- POSIX.2 2.8.3.2 if (i === classStart + 1 || !inClass) { re += "\\" + c escaping = false continue } // finish up the class. hasMagic = true inClass = false re += c continue default: // swallow any state char that wasn't consumed clearStateChar() if (escaping) { // no need escaping = false } else if (reSpecials[c] && !(c === "^" && inClass)) { re += "\\" } re += c } // switch } // for // handle the case where we left a class open. // "[abc" is valid, equivalent to "\[abc" if (inClass) { // split where the last [ was, and escape it // this is a huge pita. We now have to re-walk // the contents of the would-be class to re-translate // any characters that were passed through as-is var cs = pattern.substr(classStart + 1) , sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + "\\[" + sp[0] hasMagic = hasMagic || sp[1] } // handle the case where we had a +( thing at the *end* // of the pattern. // each pattern list stack adds 3 chars, and we need to go through // and escape any | chars that were passed through as-is for the regexp. // Go through and escape them, taking care not to double-escape any // | chars that were already escaped. var pl while (pl = patternListStack.pop()) { var tail = re.slice(pl.reStart + 3) // maybe some even number of \, then maybe 1 \, followed by a | tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) { if (!$2) { // the | isn't already escaped, so escape it. $2 = "\\" } // need to escape all those slashes *again*, without escaping the // one that we need for escaping the | character. As it works out, // escaping an even number of slashes can be done by simply repeating // it exactly after itself. That's why this trick works. // // I am sorry that you have to see this. return $1 + $1 + $2 + "|" }) // console.error("tail=%j\n %s", tail, tail) var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type hasMagic = true re = re.slice(0, pl.reStart) + t + "\\(" + tail } // handle trailing things that only matter at the very end. clearStateChar() if (escaping) { // trailing \\ re += "\\\\" } // only need to apply the nodot start if the re starts with // something that could conceivably capture a dot var addPatternStart = false switch (re.charAt(0)) { case ".": case "[": case "(": addPatternStart = true } // if the re is not "" at this point, then we need to make sure // it doesn't match against an empty path part. // Otherwise a/* will match a/, which it should not. if (re !== "" && hasMagic) re = "(?=.)" + re if (addPatternStart) re = patternStart + re // parsing just a piece of a larger pattern. if (isSub === SUBPARSE) { return [ re, hasMagic ] } // skip the regexp for non-magical patterns // unescape anything in it, though, so that it'll be // an exact match against a file etc. if (!hasMagic) { return globUnescape(pattern) } var flags = options.nocase ? "i" : "" , regExp = new RegExp("^" + re + "$", flags) regExp._glob = pattern regExp._src = re return regExp } minimatch.makeRe = function (pattern, options) { return new Minimatch(pattern, options || {}).makeRe() } Minimatch.prototype.makeRe = makeRe function makeRe () { if (this.regexp || this.regexp === false) return this.regexp // at this point, this.set is a 2d array of partial // pattern strings, or "**". // // It's better to use .match(). This function shouldn't // be used, really, but it's pretty convenient sometimes, // when you just want to work with a regex. var set = this.set if (!set.length) return this.regexp = false var options = this.options var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot , flags = options.nocase ? "i" : "" var re = set.map(function (pattern) { return pattern.map(function (p) { return (p === GLOBSTAR) ? twoStar : (typeof p === "string") ? regExpEscape(p) : p._src }).join("\\\/") }).join("|") // must match entire pattern // ending in a * or ** will make it less strict. re = "^" + re + "$" // can match anything, as long as it's not this. if (this.negate) re = "^(?!" + re + ").*$" try { return this.regexp = new RegExp(re, flags) } catch (ex) { return this.regexp = false } } minimatch.match = function (list, pattern, options) { var mm = new Minimatch(pattern, options) list = list.filter(function (f) { return mm.match(f) }) if (options.nonull && !list.length) { list.push(pattern) } return list } Minimatch.prototype.match = match function match (f, partial) { // console.error("match", f, this.pattern) // short-circuit in the case of busted things. // comments, etc. if (this.comment) return false if (this.empty) return f === "" if (f === "/" && partial) return true var options = this.options // windows: need to use /, not \ // On other platforms, \ is a valid (albeit bad) filename char. if (platform === "win32") { f = f.split("\\").join("/") } // treat the test path as a set of pathparts. f = f.split(slashSplit) if (options.debug) { console.error(this.pattern, "split", f) } // just ONE of the pattern sets in this.set needs to match // in order for it to be valid. If negating, then just one // match means that we have failed. // Either way, return on the first hit. var set = this.set // console.error(this.pattern, "set", set) for (var i = 0, l = set.length; i < l; i ++) { var pattern = set[i] var hit = this.matchOne(f, pattern, partial) if (hit) { if (options.flipNegate) return true return !this.negate } } // didn't get any hits. this is success if it's a negative // pattern, failure otherwise. if (options.flipNegate) return false return this.negate } // set partial to true to test if, for example, // "/a/b" matches the start of "/*/b/*/d" // Partial means, if you run out of file before you run // out of pattern, then that's fine, as long as all // the parts match. Minimatch.prototype.matchOne = function (file, pattern, partial) { var options = this.options if (options.debug) { console.error("matchOne", { "this": this , file: file , pattern: pattern }) } if (options.matchBase && pattern.length === 1) { file = path.basename(file.join("/")).split("/") } if (options.debug) { console.error("matchOne", file.length, pattern.length) } for ( var fi = 0 , pi = 0 , fl = file.length , pl = pattern.length ; (fi < fl) && (pi < pl) ; fi ++, pi ++ ) { if (options.debug) { console.error("matchOne loop") } var p = pattern[pi] , f = file[fi] if (options.debug) { console.error(pattern, p, f) } // should be impossible. // some invalid regexp stuff in the set. if (p === false) return false if (p === GLOBSTAR) { // "**" // a/**/b/**/c would match the following: // a/b/x/y/z/c // a/x/y/z/b/c // a/b/x/b/x/c // a/b/c // To do this, take the rest of the pattern after // the **, and see if it would match the file remainder. // If so, return success. // If not, the ** "swallows" a segment, and try again. // This is recursively awful. // a/b/x/y/z/c // - a matches a // - doublestar // - matchOne(b/x/y/z/c, b/**/c) // - b matches b // - doublestar // - matchOne(x/y/z/c, c) -> no // - matchOne(y/z/c, c) -> no // - matchOne(z/c, c) -> no // - matchOne(c, c) yes, hit var fr = fi , pr = pi + 1 if (pr === pl) { // a ** at the end will just swallow the rest. // We have found a match. // however, it will not swallow /.x, unless // options.dot is set. // . and .. are *never* matched by **, for explosively // exponential reasons. for ( ; fi < fl; fi ++) { if (file[fi] === "." || file[fi] === ".." || (!options.dot && file[fi].charAt(0) === ".")) return false } return true } // ok, let's see if we can swallow whatever we can. WHILE: while (fr < fl) { var swallowee = file[fr] if (swallowee === "." || swallowee === ".." || (!options.dot && swallowee.charAt(0) === ".")) { // console.error("dot detected!") break WHILE } // XXX remove this slice. Just pass the start index. if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { // found a match. return true } else { // ** swallows a segment, and continue. fr ++ } } // no match was found. // However, in partial mode, we can't say this is necessarily over. // If there's more *pattern* left, then if (partial) { // ran out of file // console.error("\n>>> no match, partial?", file, fr, pattern, pr) if (fr === fl) return true } return false } // something other than ** // non-magic patterns just have to match exactly // patterns with magic have been turned into regexps. var hit if (typeof p === "string") { if (options.nocase) { hit = f.toLowerCase() === p.toLowerCase() } else { hit = f === p } if (options.debug) { console.error("string match", p, f, hit) } } else { hit = f.match(p) if (options.debug) { console.error("pattern match", p, f, hit) } } if (!hit) return false } // Note: ending in / means that we'll get a final "" // at the end of the pattern. This can only match a // corresponding "" at the end of the file. // If the file ends in /, then it can only match a // a pattern that ends in /, unless the pattern just // doesn't have any more for it. But, a/b/ should *not* // match "a/b/*", even though "" matches against the // [^/]*? pattern, except in partial mode, where it might // simply not be reached yet. // However, a/b/ should still satisfy a/* // now either we fell off the end of the pattern, or we're done. if (fi === fl && pi === pl) { // ran out of pattern and filename at the same time. // an exact hit! return true } else if (fi === fl) { // ran out of file, but still had pattern left. // this is ok if we're doing the match as part of // a glob fs traversal. return partial } else if (pi === pl) { // ran out of pattern, still have file left. // this is only acceptable if we're on the very last // empty segment of a file with a trailing slash. // a/* should match a/b/ var emptyFileEnd = (fi === fl - 1) && (file[fi] === "") return emptyFileEnd } // should be unreachable. throw new Error("wtf?") } // replace stuff like \* with * function globUnescape (s) { return s.replace(/\\(.)/g, "$1") } function regExpEscape (s) { return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") } })( typeof require === "function" ? require : null, this, typeof module === "object" ? module : null, typeof process === "object" ? process.platform : "win32" ) lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/000077500000000000000000000000001177713054400314605ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/000077500000000000000000000000001177713054400333235ustar00rootroot00000000000000.npmignore000066400000000000000000000000161177713054400352400ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/node_modules AUTHORS000066400000000000000000000003041177713054400343110ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache# Authors, sorted by whether or not they are me Isaac Z. Schlueter Carlos Brito Lage Marko Mikulicic Trent Mick LICENSE000066400000000000000000000021041177713054400342460ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cacheCopyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. README.md000066400000000000000000000013621177713054400345250ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache# lru cache A cache object that deletes the least-recently-used items. Usage: var LRU = require("lru-cache") , cache = LRU(10, // max length. default = Infinity // calculate how "big" each item is // // defaults to function(){return 1}, ie, just limit // the item count, without any knowledge as to their // relative size. function (item) { return item.length }) cache.set("key", "value") cache.get("key") // "value" cache.reset() // empty the cache If you put more stuff in it, then items will fall out. If you try to put an oversized thing in it, then it'll fall out right away. RTFS for more info. lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/lib/000077500000000000000000000000001177713054400340715ustar00rootroot00000000000000lru-cache.js000066400000000000000000000075041177713054400362210ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/lib;(function () { // closure for web browsers if (module) { module.exports = LRUCache } else { // just set the global for non-node platforms. ;(function () { return this })().LRUCache = LRUCache } function hOP (obj, key) { return Object.prototype.hasOwnProperty.call(obj, key) } function naiveLength () { return 1 } function LRUCache (maxLength, lengthCalculator) { if (!(this instanceof LRUCache)) { return new LRUCache(maxLength, lengthCalculator) } if (typeof lengthCalculator !== "function") { lengthCalculator = naiveLength } if (!maxLength || !(typeof maxLength === "number") || maxLength <= 0 ) { maxLength = Infinity } var cache = {} // hash of items by key , lruList = {} // list of items in order of use recency , lru = 0 // least recently used , mru = 0 // most recently used , length = 0 // number of items in the list , itemCount = 0 // resize the cache when the maxLength changes. Object.defineProperty(this, "maxLength", { set : function (mL) { if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity maxLength = mL // if it gets above double maxLength, trim right away. // otherwise, do it whenever it's convenient. if (length > maxLength) trim() } , get : function () { return maxLength } , enumerable : true }) // resize the cache when the lengthCalculator changes. Object.defineProperty(this, "lengthCalculator", { set : function (lC) { if (typeof lC !== "function") { lengthCalculator = naiveLength length = itemCount Object.keys(cache).forEach(function (key) { cache[key].length = 1 }) } else { lengthCalculator = lC length = 0 Object.keys(cache).forEach(function (key) { cache[key].length = lengthCalculator(cache[key].value) length += cache[key].length }) } if (length > maxLength) trim() } , get : function () { return lengthCalculator } , enumerable : true }) Object.defineProperty(this, "length", { get : function () { return length } , enumerable : true }) Object.defineProperty(this, "itemCount", { get : function () { return itemCount } , enumerable : true }) this.reset = function () { cache = {} lruList = {} lru = 0 mru = 0 length = 0 itemCount = 0 } // Provided for debugging/dev purposes only. No promises whatsoever that // this API stays stable. this.dump = function () { return cache } this.set = function (key, value) { if (hOP(cache, key)) { this.get(key) cache[key].value = value return } var hit = {key:key, value:value, lu:mru++, length:lengthCalculator(value)} // oversized objects fall out of cache automatically. if (hit.length > maxLength) return length += hit.length lruList[hit.lu] = cache[key] = hit itemCount ++ if (length > maxLength) trim() } this.get = function (key) { if (!hOP(cache, key)) return var hit = cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() hit.lu = mru ++ lruList[hit.lu] = hit return hit.value } this.del = function (key) { if (!hOP(cache, key)) return var hit = cache[key] delete cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() length -= hit.length itemCount -- } function lruWalk () { // lru has been deleted, hop up to the next hit. lru = Object.keys(lruList)[0] } function trim () { if (length <= maxLength) return var prune = Object.keys(lruList) for (var i = 0; i < prune.length && length > maxLength; i ++) { length -= lruList[prune[i]].length delete cache[ lruList[prune[i]].key ] delete lruList[prune[i]] } lruWalk() } } })() package.json000066400000000000000000000021561177713054400355360ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache{ "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", "version": "1.1.0", "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me" }, "scripts": { "test": "tap test" }, "main": "lib/lru-cache.js", "repository": { "type": "git", "url": "git://github.com/isaacs/node-lru-cache.git" }, "devDependencies": { "tap": "" }, "license": { "type": "MIT", "url": "http://github.com/isaacs/node-lru-cache/raw/master/LICENSE" }, "_id": "lru-cache@1.1.0", "contributors": [ { "name": "Isaac Z. Schlueter", "email": "i@izs.me" }, { "name": "Carlos Brito Lage", "email": "carlos@carloslage.net" }, { "name": "Marko Mikulicic", "email": "marko.mikulicic@isti.cnr.it" }, { "name": "Trent Mick", "email": "trentm@gmail.com" } ], "dependencies": {}, "optionalDependencies": {}, "engines": { "node": "*" }, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "lru-cache@~1" } lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/test/000077500000000000000000000000001177713054400343025ustar00rootroot00000000000000basic.js000066400000000000000000000102131177713054400356370ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/node_modules/lru-cache/testvar test = require("tap").test , LRU = require("../") test("basic", function (t) { var cache = new LRU(10) cache.set("key", "value") t.equal(cache.get("key"), "value") t.equal(cache.get("nada"), undefined) t.equal(cache.length, 1) t.equal(cache.maxLength, 10) t.end() }) test("least recently set", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), "B") t.equal(cache.get("a"), undefined) t.end() }) test("lru recently gotten", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.get("a") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), undefined) t.equal(cache.get("a"), "A") t.end() }) test("del", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.del("a") t.equal(cache.get("a"), undefined) t.end() }) test("maxLength", function (t) { var cache = new LRU(3) // test changing the maxLength, verify that the LRU items get dropped. cache.maxLength = 100 for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } // now remove the maxLength restriction, and try again. cache.maxLength = "hello" for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } // should trigger an immediate resize cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } t.end() }) test("reset", function (t) { var cache = new LRU(10) cache.set("a", "A") cache.set("b", "B") cache.reset() t.equal(cache.length, 0) t.equal(cache.maxLength, 10) t.equal(cache.get("a"), undefined) t.equal(cache.get("b"), undefined) t.end() }) // Note: `.dump()` is a debugging tool only. No guarantees are made // about the format/layout of the response. test("dump", function (t) { var cache = new LRU(10) var d = cache.dump(); t.equal(Object.keys(d).length, 0, "nothing in dump for empty cache") cache.set("a", "A") var d = cache.dump() // { a: { key: "a", value: "A", lu: 0 } } t.ok(d.a) t.equal(d.a.key, "a") t.equal(d.a.value, "A") t.equal(d.a.lu, 0) cache.set("b", "B") cache.get("b") d = cache.dump() t.ok(d.b) t.equal(d.b.key, "b") t.equal(d.b.value, "B") t.equal(d.b.lu, 2) t.end() }) test("basic with weighed length", function (t) { var cache = new LRU(100, function (item) { return item.size } ) cache.set("key", {val: "value", size: 50}) t.equal(cache.get("key").val, "value") t.equal(cache.get("nada"), undefined) t.equal(cache.lengthCalculator(cache.get("key")), 50) t.equal(cache.length, 50) t.equal(cache.maxLength, 100) t.end() }) test("weighed length item too large", function (t) { var cache = new LRU(10, function (item) { return item.size } ) t.equal(cache.maxLength, 10) // should fall out immediately cache.set("key", {val: "value", size: 50}) t.equal(cache.length, 0) t.equal(cache.get("key"), undefined) t.end() }) test("least recently set with weighed length", function (t) { var cache = new LRU(8, function (item) { return item.length }) cache.set("a", "A") cache.set("b", "BB") cache.set("c", "CCC") cache.set("d", "DDDD") t.equal(cache.get("d"), "DDDD") t.equal(cache.get("c"), "CCC") t.equal(cache.get("b"), undefined) t.equal(cache.get("a"), undefined) t.end() }) test("lru recently gotten with weighed length", function (t) { var cache = new LRU(8, function (item) { return item.length }) cache.set("a", "A") cache.set("b", "BB") cache.set("c", "CCC") cache.get("a") cache.get("b") cache.set("d", "DDDD") t.equal(cache.get("c"), undefined) t.equal(cache.get("d"), "DDDD") t.equal(cache.get("b"), "BB") t.equal(cache.get("a"), "A") t.end() }) lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/package.json000066400000000000000000000014601177713054400312720ustar00rootroot00000000000000{ "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me" }, "name": "minimatch", "description": "a glob matcher in javascript", "version": "0.2.5", "repository": { "type": "git", "url": "git://github.com/isaacs/minimatch.git" }, "main": "minimatch.js", "scripts": { "test": "tap test" }, "engines": { "node": "*" }, "dependencies": { "lru-cache": "~1" }, "devDependencies": { "tap": "" }, "licenses": [ { "type": "MIT", "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE" } ], "_id": "minimatch@0.2.5", "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "minimatch@0.2.x" } lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/test/000077500000000000000000000000001177713054400277625ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/test/basic.js000066400000000000000000000227321177713054400314070ustar00rootroot00000000000000// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require("tap") , globalBefore = Object.keys(global) , mm = require("../") , files = [ "a", "b", "c", "d", "abc" , "abd", "abe", "bb", "bcd" , "ca", "cb", "dd", "de" , "bdir/", "bdir/cfile"] , next = files.concat([ "a-b", "aXb" , ".x", ".y" ]) tap.test("basic tests", function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] ; [ "http://www.bashcookbook.com/bashinfo" + "/source/bash-1.14.7/tests/glob-test" , ["a*", ["a", "abc", "abd", "abe"]] , ["X*", ["X*"], {nonull: true}] // allow null glob expansion , ["X*", []] // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star , ["\\*", ["\\*"], {nonull: true}] , ["\\**", ["\\**"], {nonull: true}] , ["\\*\\*", ["\\*\\*"], {nonull: true}] , ["b*/", ["bdir/"]] , ["c*", ["c", "ca", "cb"]] , ["**", files] , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}] , ["s/\\..*//", ["s/\\..*//"], {nonull: true}] , "legendary larry crashes bashes" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}] , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}] , "character classes" , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]] , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd", "bdir/", "ca", "cb", "dd", "de"]] , ["a*[^c]", ["abd", "abe"]] , function () { files.push("a-b", "aXb") } , ["a[X-]b", ["a-b", "aXb"]] , function () { files.push(".x", ".y") } , ["[^a-c]*", ["d", "dd", "de"]] , function () { files.push("a*b/", "a*b/ooo") } , ["a\\*b/*", ["a*b/ooo"]] , ["a\\*?/*", ["a*b/ooo"]] , ["*\\\\!*", [], {null: true}, ["echo !7"]] , ["*\\!*", ["echo !7"], null, ["echo !7"]] , ["*.\\*", ["r.*"], null, ["r.*"]] , ["a[b]c", ["abc"]] , ["a[\\b]c", ["abc"]] , ["a?c", ["abc"]] , ["a\\*c", [], {null: true}, ["abc"]] , ["", [""], { null: true }, [""]] , "http://www.opensource.apple.com/source/bash/bash-23/" + "bash/tests/glob-test" , function () { files.push("man/", "man/man1/", "man/man1/bash.1") } , ["*/man*/bash.*", ["man/man1/bash.1"]] , ["man/man1/bash.1", ["man/man1/bash.1"]] , ["a***c", ["abc"], null, ["abc"]] , ["a*****?c", ["abc"], null, ["abc"]] , ["?*****??", ["abc"], null, ["abc"]] , ["*****??", ["abc"], null, ["abc"]] , ["?*****?c", ["abc"], null, ["abc"]] , ["?***?****c", ["abc"], null, ["abc"]] , ["?***?****?", ["abc"], null, ["abc"]] , ["?***?****", ["abc"], null, ["abc"]] , ["*******c", ["abc"], null, ["abc"]] , ["*******?", ["abc"], null, ["abc"]] , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["[-abc]", ["-"], null, ["-"]] , ["[abc-]", ["-"], null, ["-"]] , ["\\", ["\\"], null, ["\\"]] , ["[\\\\]", ["\\"], null, ["\\"]] , ["[[]", ["["], null, ["["]] , ["[", ["["], null, ["["]] , ["[*", ["[abc"], null, ["[abc"]] , "a right bracket shall lose its special meaning and\n" + "represent itself in a bracket expression if it occurs\n" + "first in the list. -- POSIX.2 2.8.3.2" , ["[]]", ["]"], null, ["]"]] , ["[]-]", ["]"], null, ["]"]] , ["[a-\z]", ["p"], null, ["p"]] , ["??**********?****?", [], { null: true }, ["abc"]] , ["??**********?****c", [], { null: true }, ["abc"]] , ["?************c****?****", [], { null: true }, ["abc"]] , ["*c*?**", [], { null: true }, ["abc"]] , ["a*****c*?**", [], { null: true }, ["abc"]] , ["a********???*******", [], { null: true }, ["abc"]] , ["[]", [], { null: true }, ["a"]] , ["[abc", [], { null: true }, ["["]] , "nocase tests" , ["XYZ", ["xYz"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["ab*", ["ABC"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] // [ pattern, [matches], MM opts, files, TAP opts] , "onestar/twostar" , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]] , ["{/?,*}", ["/a", "bb"], {null: true} , ["/a", "/b/b", "/a/b/c", "bb"]] , "dots should not match unless requested" , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]] // .. and . can only match patterns starting with ., // even when options.dot is set. , function () { files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"] } , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}] , ["a/*/b", ["a/c/b"], {dot:false}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}] // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! , ["**", ["a/b","a/.d",".a/.d"], { dot: true } , [ ".a/.d", "a/.d", "a/b"]] , "paren sets cannot contain slashes" , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]] // brace sets trump all else. // // invalid glob pattern. fails on bash4 and bsdglob. // however, in this implementation, it's easier just // to do the intuitive thing, and let brace-expansion // actually come before parsing any extglob patterns, // like the documentation seems to say. // // XXX: if anyone complains about this, either fix it // or tell them to grow up and stop complaining. // // bash/bsdglob says this: // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]] // but we do this instead: , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]] // test partial parsing in the presence of comment/negation chars , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]] , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]] // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped. , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g" , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"] , {} , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]] // crazy nested {,,} and *(||) tests. , function () { files = [ "a", "b", "c", "d" , "ab", "ac", "ad" , "bc", "cb" , "bc,d", "c,db", "c,d" , "d)", "(b|c", "*(b|c" , "b|c", "b|cc", "cb|c" , "x(a|b|c)", "x(a|c)" , "(a|b|c)", "(a|c)"] } , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]] , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]] // a // *(b|c) // *(b|d) , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]] , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]] // test various flag settings. , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"] , { noext: true } ] , ["a?b", ["x/y/acb", "acb/"], {matchBase: true} , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ] , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]] // begin channelling Boole and deMorgan... , "negation tests" , function () { files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"] } // anything that is NOT a* matches. , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]] // anything that IS !a* matches. , ["!a*", ["!ab", "!abc"], {nonegate: true}] // anything that IS a* matches , ["!!a*", ["a!b"]] // anything that is NOT !a* matches , ["!\\!a*", ["a!b", "d", "e", "\\!a"]] // negation nestled within a pattern , function () { files = [ "foo.js" , "foo.bar" // can't match this one without negative lookbehind. , "foo.js.js" , "blar.js" , "foo." , "boo.js.boo" ] } , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ] ].forEach(function (c) { if (typeof c === "function") return c() if (typeof c === "string") return t.comment(c) var pattern = c[0] , expect = c[1].sort(alpha) , options = c[2] || {} , f = c[3] || files , tapOpts = c[4] || {} // options.debug = true var m = new mm.Minimatch(pattern, options) var r = m.makeRe() tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect , JSON.stringify(pattern) + " " + JSON.stringify(expect) , tapOpts ) }) t.comment("time=" + (Date.now() - start) + "ms") t.end() }) tap.test("global leak test", function (t) { var globalAfter = Object.keys(global) t.equivalent(globalAfter, globalBefore, "no new globals, please") t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/test/brace-expand.js000066400000000000000000000012071177713054400326510ustar00rootroot00000000000000var tap = require("tap") , minimatch = require("../") tap.test("brace expansion", function (t) { // [ pattern, [expanded] ] ; [ [ "a{b,c{d,e},{f,g}h}x{y,z}" , [ "abxy" , "abxz" , "acdxy" , "acdxz" , "acexy" , "acexz" , "afhxy" , "afhxz" , "aghxy" , "aghxz" ] ] , [ "a{1..5}b" , [ "a1b" , "a2b" , "a3b" , "a4b" , "a5b" ] ] , [ "a{b}c", ["a{b}c"] ] ].forEach(function (tc) { var p = tc[0] , expect = tc[1] t.equivalent(minimatch.braceExpand(p), expect, p) }) console.error("ending") t.end() }) lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/test/caching.js000066400000000000000000000006641177713054400317220ustar00rootroot00000000000000var Minimatch = require("../minimatch.js").Minimatch var tap = require("tap") tap.test("cache test", function (t) { var mm1 = new Minimatch("a?b") var mm2 = new Minimatch("a?b") t.equal(mm1, mm2, "should get the same object") // the lru should drop it after 100 entries for (var i = 0; i < 100; i ++) { new Minimatch("a"+i) } mm2 = new Minimatch("a?b") t.notEqual(mm1, mm2, "cache should have dropped") t.end() }) lets_code_javascript-episode2/node_modules/jake/node_modules/minimatch/test/defaults.js000066400000000000000000000227771177713054400321460ustar00rootroot00000000000000// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require("tap") , globalBefore = Object.keys(global) , mm = require("../") , files = [ "a", "b", "c", "d", "abc" , "abd", "abe", "bb", "bcd" , "ca", "cb", "dd", "de" , "bdir/", "bdir/cfile"] , next = files.concat([ "a-b", "aXb" , ".x", ".y" ]) tap.test("basic tests", function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] ; [ "http://www.bashcookbook.com/bashinfo" + "/source/bash-1.14.7/tests/glob-test" , ["a*", ["a", "abc", "abd", "abe"]] , ["X*", ["X*"], {nonull: true}] // allow null glob expansion , ["X*", []] // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star , ["\\*", ["\\*"], {nonull: true}] , ["\\**", ["\\**"], {nonull: true}] , ["\\*\\*", ["\\*\\*"], {nonull: true}] , ["b*/", ["bdir/"]] , ["c*", ["c", "ca", "cb"]] , ["**", files] , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}] , ["s/\\..*//", ["s/\\..*//"], {nonull: true}] , "legendary larry crashes bashes" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}] , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}] , "character classes" , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]] , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd", "bdir/", "ca", "cb", "dd", "de"]] , ["a*[^c]", ["abd", "abe"]] , function () { files.push("a-b", "aXb") } , ["a[X-]b", ["a-b", "aXb"]] , function () { files.push(".x", ".y") } , ["[^a-c]*", ["d", "dd", "de"]] , function () { files.push("a*b/", "a*b/ooo") } , ["a\\*b/*", ["a*b/ooo"]] , ["a\\*?/*", ["a*b/ooo"]] , ["*\\\\!*", [], {null: true}, ["echo !7"]] , ["*\\!*", ["echo !7"], null, ["echo !7"]] , ["*.\\*", ["r.*"], null, ["r.*"]] , ["a[b]c", ["abc"]] , ["a[\\b]c", ["abc"]] , ["a?c", ["abc"]] , ["a\\*c", [], {null: true}, ["abc"]] , ["", [""], { null: true }, [""]] , "http://www.opensource.apple.com/source/bash/bash-23/" + "bash/tests/glob-test" , function () { files.push("man/", "man/man1/", "man/man1/bash.1") } , ["*/man*/bash.*", ["man/man1/bash.1"]] , ["man/man1/bash.1", ["man/man1/bash.1"]] , ["a***c", ["abc"], null, ["abc"]] , ["a*****?c", ["abc"], null, ["abc"]] , ["?*****??", ["abc"], null, ["abc"]] , ["*****??", ["abc"], null, ["abc"]] , ["?*****?c", ["abc"], null, ["abc"]] , ["?***?****c", ["abc"], null, ["abc"]] , ["?***?****?", ["abc"], null, ["abc"]] , ["?***?****", ["abc"], null, ["abc"]] , ["*******c", ["abc"], null, ["abc"]] , ["*******?", ["abc"], null, ["abc"]] , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["[-abc]", ["-"], null, ["-"]] , ["[abc-]", ["-"], null, ["-"]] , ["\\", ["\\"], null, ["\\"]] , ["[\\\\]", ["\\"], null, ["\\"]] , ["[[]", ["["], null, ["["]] , ["[", ["["], null, ["["]] , ["[*", ["[abc"], null, ["[abc"]] , "a right bracket shall lose its special meaning and\n" + "represent itself in a bracket expression if it occurs\n" + "first in the list. -- POSIX.2 2.8.3.2" , ["[]]", ["]"], null, ["]"]] , ["[]-]", ["]"], null, ["]"]] , ["[a-\z]", ["p"], null, ["p"]] , ["??**********?****?", [], { null: true }, ["abc"]] , ["??**********?****c", [], { null: true }, ["abc"]] , ["?************c****?****", [], { null: true }, ["abc"]] , ["*c*?**", [], { null: true }, ["abc"]] , ["a*****c*?**", [], { null: true }, ["abc"]] , ["a********???*******", [], { null: true }, ["abc"]] , ["[]", [], { null: true }, ["a"]] , ["[abc", [], { null: true }, ["["]] , "nocase tests" , ["XYZ", ["xYz"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["ab*", ["ABC"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] // [ pattern, [matches], MM opts, files, TAP opts] , "onestar/twostar" , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]] , ["{/?,*}", ["/a", "bb"], {null: true} , ["/a", "/b/b", "/a/b/c", "bb"]] , "dots should not match unless requested" , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]] // .. and . can only match patterns starting with ., // even when options.dot is set. , function () { files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"] } , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}] , ["a/*/b", ["a/c/b"], {dot:false}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}] // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! , ["**", ["a/b","a/.d",".a/.d"], { dot: true } , [ ".a/.d", "a/.d", "a/b"]] , "paren sets cannot contain slashes" , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]] // brace sets trump all else. // // invalid glob pattern. fails on bash4 and bsdglob. // however, in this implementation, it's easier just // to do the intuitive thing, and let brace-expansion // actually come before parsing any extglob patterns, // like the documentation seems to say. // // XXX: if anyone complains about this, either fix it // or tell them to grow up and stop complaining. // // bash/bsdglob says this: // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]] // but we do this instead: , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]] // test partial parsing in the presence of comment/negation chars , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]] , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]] // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped. , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g" , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"] , {} , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]] // crazy nested {,,} and *(||) tests. , function () { files = [ "a", "b", "c", "d" , "ab", "ac", "ad" , "bc", "cb" , "bc,d", "c,db", "c,d" , "d)", "(b|c", "*(b|c" , "b|c", "b|cc", "cb|c" , "x(a|b|c)", "x(a|c)" , "(a|b|c)", "(a|c)"] } , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]] , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]] // a // *(b|c) // *(b|d) , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]] , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]] // test various flag settings. , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"] , { noext: true } ] , ["a?b", ["x/y/acb", "acb/"], {matchBase: true} , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ] , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]] // begin channelling Boole and deMorgan... , "negation tests" , function () { files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"] } // anything that is NOT a* matches. , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]] // anything that IS !a* matches. , ["!a*", ["!ab", "!abc"], {nonegate: true}] // anything that IS a* matches , ["!!a*", ["a!b"]] // anything that is NOT !a* matches , ["!\\!a*", ["a!b", "d", "e", "\\!a"]] // negation nestled within a pattern , function () { files = [ "foo.js" , "foo.bar" // can't match this one without negative lookbehind. , "foo.js.js" , "blar.js" , "foo." , "boo.js.boo" ] } , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ] ].forEach(function (c) { if (typeof c === "function") return c() if (typeof c === "string") return t.comment(c) var pattern = c[0] , expect = c[1].sort(alpha) , options = c[2] || {} , f = c[3] || files , tapOpts = c[4] || {} // options.debug = true var Class = mm.defaults(options).Minimatch var m = new Class(pattern, {}) var r = m.makeRe() tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect , JSON.stringify(pattern) + " " + JSON.stringify(expect) , tapOpts ) }) t.comment("time=" + (Date.now() - start) + "ms") t.end() }) tap.test("global leak test", function (t) { var globalAfter = Object.keys(global) t.equivalent(globalAfter, globalBefore, "no new globals, please") t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } lets_code_javascript-episode2/node_modules/jake/package.json000066400000000000000000000013761177713054400246520ustar00rootroot00000000000000{ "name": "jake", "description": "JavaScript build tool, similar to Make or Rake", "keywords": [ "build", "cli", "make", "rake" ], "version": "0.3.7", "author": { "name": "Matthew Eernisse", "email": "mde@fleegix.org", "url": "http://fleegix.org" }, "bin": { "jake": "./bin/cli.js" }, "main": "./lib/jake.js", "repository": { "type": "git", "url": "git://github.com/mde/jake.git" }, "preferGlobal": true, "dependencies": { "minimatch": "0.2.x" }, "devDependencies": {}, "engines": { "node": "*" }, "_id": "jake@0.3.7", "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "jake" } lets_code_javascript-episode2/node_modules/jake/tests/000077500000000000000000000000001177713054400235175ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jake/tests/Jakefile000066400000000000000000000124741177713054400251640ustar00rootroot00000000000000var exec = require('child_process').exec , fs = require('fs'); desc('The default task.'); task('default', function () { console.log('default task'); }); desc('No action.'); task({'noAction': ['default']}); desc('No action, no prereqs.'); task('noActionNoPrereqs'); desc('Accepts args and env vars.'); task('argsEnvVars', function () { var res = { args: arguments , env: { foo: process.env.foo , baz: process.env.baz } }; console.log(JSON.stringify(res)); }); namespace('foo', function () { desc('The foo:bar task.'); task('bar', function () { if (arguments.length) { console.log('foo:bar[' + Array.prototype.join.call(arguments, ',') + '] task'); } else { console.log('foo:bar task'); } }); desc('The foo:baz task, calls foo:bar as a prerequisite.'); task('baz', ['foo:bar'], function () { console.log('foo:baz task'); }); desc('The foo:qux task, calls foo:bar with cmdline args as a prerequisite.'); task('qux', ['foo:bar[asdf,qwer]'], function () { console.log('foo:qux task'); }); desc('The foo:frang task, calls foo:bar with passed args as a prerequisite.'); task('frang', function () { var task = jake.Task['foo:bar']; // Do args pass-through task.invoke.apply(task, arguments); console.log('foo:frang task'); }); desc('The foo:zoobie task, has no prerequisites.'); task('zoobie', function () { console.log('foo:zoobie task'); }); desc('The foo:voom task, has no prerequisites.'); task('voom', function () { console.log('foo:voom task'); }); desc('The foo:asdf task, has the same prereq twice.'); task('asdf', ['foo:bar', 'foo:baz'], function () { console.log('foo:asdf task'); }); }); namespace('bar', function () { desc('The bar:foo task, has no prerequisites, is async.'); task('foo', function () { console.log('bar:foo task'); complete(); }, {async: true}); desc('The bar:bar task, has the async bar:foo task as a prerequisite.'); task('bar', ['bar:foo'], function () { console.log('bar:bar task'); }); }); namespace('hoge', function () { desc('The hoge:hoge task, has no prerequisites.'); task('hoge', function () { console.log('hoge:hoge task'); }); desc('The hoge:piyo task, has no prerequisites.'); task('piyo', function () { console.log('hoge:piyo task'); }); desc('The hoge:fuga task, has hoge:hoge and hoge:piyo as prerequisites.'); task('fuga', ['hoge:hoge', 'hoge:piyo'], function () { console.log('hoge:fuga task'); }); desc('The hoge:charan task, has hoge:fuga as a prerequisite.'); task('charan', ['hoge:fuga'], function () { console.log('hoge:charan task'); }); desc('The hoge:gero task, has hoge:fuga as a prerequisite.'); task('gero', ['hoge:fuga'], function () { console.log('hoge:gero task'); }); desc('The hoge:kira task, has hoge:charan and hoge:gero as prerequisites.'); task('kira', ['hoge:charan', 'hoge:gero'], function () { console.log('hoge:kira task'); }); }); namespace('fileTest', function () { directory('foo'); desc('File task, concatenating two files together'); file({'foo/concat.txt': ['fileTest:foo', 'fileTest:foo/src1.txt', 'fileTest:foo/src2.txt']}, function () { console.log('fileTest:foo/concat.txt task'); var data1 = fs.readFileSync('foo/src1.txt'); var data2 = fs.readFileSync('foo/src2.txt'); fs.writeFileSync('foo/concat.txt', data1 + data2); }); desc('File task, async creation with child_process.exec'); file('foo/src1.txt', function () { fs.writeFile('foo/src1.txt', 'src1', function (err) { if (err) { throw err; } console.log('fileTest:foo/src1.txt task'); complete(); }); }, {async: true}); desc('File task, sync creation with writeFileSync'); file('foo/src2.txt', ['default'], function () { fs.writeFileSync('foo/src2.txt', 'src2'); console.log('fileTest:foo/src2.txt task'); }); desc('File task, do not run unless the prereq file changes'); file('foo/from-src1.txt', ['fileTest:foo', 'fileTest:foo/src1.txt'], function () { var data = fs.readFileSync('foo/src1.txt'); fs.writeFileSync('foo/from-src1.txt', data); console.log('fileTest:foo/from-src1.txt task'); }, {async: true}); desc('File task, run if the prereq file changes'); task('touch-prereq', function() { fs.writeFileSync('foo/prereq.txt', 'UPDATED'); }) desc('File task, has a preexisting file (with no associated task) as a prereq'); file('foo/from-prereq.txt', ['fileTest:foo', 'foo/prereq.txt'], function () { var data = fs.readFileSync('foo/prereq.txt'); fs.writeFileSync('foo/from-prereq.txt', data); console.log('fileTest:foo/from-prereq.txt task'); }); directory('foo/bar/baz'); desc('Write a file in a nested subdirectory'); file('foo/bar/baz/bamf.txt', ['foo/bar/baz'], function () { fs.writeFileSync('foo/bar/baz/bamf.txt', 'w00t'); }); }); task('blammo'); // Define task task('voom', ['blammo'], function () { console.log(this.prereqs.length); }); // Modify, add a prereq task('voom', ['noActionNoPrereqs']); namespace('vronk', function () { task('groo', function () { var t = jake.Task['vronk:zong']; t.addListener('error', function (e) { console.log(e.message); }); t.invoke(); }); task('zong', function () { throw new Error('OMFGZONG'); }); }); lets_code_javascript-episode2/node_modules/jake/tests/exec.js000066400000000000000000000055401177713054400250050ustar00rootroot00000000000000var assert = require('assert') , h = require('./helpers') , jake = {} , utils = require('../lib/utils'); utils.mixin(jake, utils); var tests = { 'before': function () { process.chdir('./tests'); } , 'after': function () { process.chdir('../'); } , 'test basic exec': function (next) { var ex = jake.createExec('ls', function () {}) , evts = { // Events should fire in this order cmdStart: [0, null] , stdout: [1, null] , cmdEnd: [2, null] , end: [3, null] } , incr = 0; // Increment with each event to check order assert.ok(ex instanceof jake.Exec); // Make sure basic events fire and fire in the right order for (var p in evts) { (function (p) { ex.addListener(p, function () { evts[p][1] = incr; incr++; }); })(p); } ex.run(); ex.addListener('end', function () { for (var p in evts) { assert.equal(evts[p][0], evts[p][1]); } next(); }); } , 'test an exec failure': function (next) { var ex = jake.createExec('false', function () {}); ex.addListener('error', function (msg, code) { assert.equal(1, code); next(); }); ex.run(); } , 'test exec stdout events': function (next) { var ex = jake.createExec('echo "foo"', function () {}); ex.addListener('stdout', function (data) { assert.equal("foo", h.trim(data.toString())); next(); }); ex.run(); } , 'test exec stderr events': function (next) { var ex = jake.createExec('echo "foo" 1>&2', function () {}); ex.addListener('stderr', function (data) { assert.equal("foo", h.trim(data.toString())); next(); }); ex.run(); } , 'test piping results into next command': function (next) { var ex = jake.createExec('ls', function () {}) , data , appended = false; ex.addListener('stdout', function (d) { data += h.trim(d.toString()); }); // After the first command ends, get the accumulated result, // and use it to build a new command to append to the queue. // Grep through the result for files that end in .js ex.addListener('cmdEnd', function () { // Only append after the first cmd, avoid infinite loop if (appended) { return; } appended = true; // Take the original output and build the new command ex.append('echo "' + data + '" | grep "\\.js$"'); // Clear out data data = ''; }); // And the end, the stdout data has been cleared once, and the new // data should be the result of the second command ex.addListener('end', function () { // Should be a list of files ending in .js data = data.split('\n'); data.forEach(function (d) { assert.ok(/\.js$/.test(d)); }); next(); }); ex.run(); } }; module.exports = tests; lets_code_javascript-episode2/node_modules/jake/tests/file_task.js000066400000000000000000000067651177713054400260340ustar00rootroot00000000000000var assert = require('assert') , fs = require('fs') , path = require('path') , exec = require('child_process').exec , h = require('./helpers'); var cleanUpAndNext = function (callback) { exec('rm -fr ./foo', function (err, stdout, stderr) { if (err) { throw err } if (stderr || stdout) { console.log (stderr || stdout); } callback(); }); }; var tests = { 'before': function () { process.chdir('./tests'); } , 'after': function () { process.chdir('../'); } , 'test concating two files': function (next) { h.exec('../bin/cli.js fileTest:foo/concat.txt', function (out) { var data; assert.equal('fileTest:foo/src1.txt task\ndefault task\nfileTest:foo/src2.txt task\n' + 'fileTest:foo/concat.txt task', out); // Check to see the two files got concat'd data = fs.readFileSync(process.cwd() + '/foo/concat.txt'); assert.equal('src1src2', data.toString()); cleanUpAndNext(next); }); } , 'test where a file-task prereq does not change': function (next) { h.exec('../bin/cli.js fileTest:foo/from-src1.txt', function (out) { assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task', out); h.exec('../bin/cli.js fileTest:foo/from-src1.txt', function (out) { // Second time should be a no-op assert.equal('', out); cleanUpAndNext(next); }); }); } , 'test where a file-task prereq does not change with --always-make': function (next) { h.exec('../bin/cli.js fileTest:foo/from-src1.txt', function (out) { assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task', out); h.exec('../bin/cli.js -B fileTest:foo/from-src1.txt', function (out) { assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task', out); cleanUpAndNext(next); }); }); } , 'test a preexisting file': function (next) { var prereqData = 'howdy'; h.exec('mkdir -p foo', function (out) { fs.writeFileSync('foo/prereq.txt', prereqData); h.exec('../bin/cli.js fileTest:foo/from-prereq.txt', function (out) { var data; assert.equal('fileTest:foo/from-prereq.txt task', out); data = fs.readFileSync(process.cwd() + '/foo/from-prereq.txt'); assert.equal(prereqData, data.toString()); h.exec('../bin/cli.js fileTest:foo/from-prereq.txt', function (out) { // Second time should be a no-op assert.equal('', out); cleanUpAndNext(next); }); }); }); } , 'test a preexisting file with --always-make flag': function (next) { var prereqData = 'howdy'; h.exec('mkdir -p foo', function (out) { fs.writeFileSync('foo/prereq.txt', prereqData); h.exec('../bin/cli.js fileTest:foo/from-prereq.txt', function (out) { var data; assert.equal('fileTest:foo/from-prereq.txt task', out); data = fs.readFileSync(process.cwd() + '/foo/from-prereq.txt'); assert.equal(prereqData, data.toString()); h.exec('../bin/cli.js -B fileTest:foo/from-prereq.txt', function (out) { assert.equal('fileTest:foo/from-prereq.txt task', out); cleanUpAndNext(next); }); }); }); } , 'test nested directory-task': function (next) { h.exec('../bin/cli.js fileTest:foo/bar/baz/bamf.txt', function (out) { data = fs.readFileSync(process.cwd() + '/foo/bar/baz/bamf.txt'); assert.equal('w00t', data); cleanUpAndNext(next); }); } }; module.exports = tests; lets_code_javascript-episode2/node_modules/jake/tests/file_utils.js000066400000000000000000000037051177713054400262210ustar00rootroot00000000000000var assert = require('assert') , fs = require('fs') , h = require('./helpers') , fileUtils = require('../lib/utils/file'); var tests = { 'before': function () { process.chdir('./tests'); } , 'after': function () { process.chdir('../'); } , 'test mkdirP': function () { var expected = [ 'foo' , 'foo/bar' , 'foo/bar/baz' , 'foo/bar/baz/qux' ] , res; fileUtils.mkdirP('foo/bar/baz/qux'); res = fileUtils.readdirR('foo'); for (var i = 0, ii = res.length; i < ii; i++) { assert.equal(expected[i], res[i]); } fileUtils.rmRf('foo', {silent: true}); } , 'test rmRf': function () { fileUtils.mkdirP('foo/bar/baz/qux', {silent: true}); fileUtils.rmRf('foo/bar', {silent: true}); res = fileUtils.readdirR('foo'); assert.equal(1, res.length); assert.equal('foo', res[0]); fs.rmdirSync('foo'); } // TODO: Need Windows test with c:\\ , 'test basedir with Unix absolute path': function () { var p = '/foo/bar/baz'; assert.equal('/', fileUtils.basedir(p)); } , 'test basedir with Unix absolute path and double-asterisk': function () { var p = '/**/foo/bar/baz'; assert.equal('/', fileUtils.basedir(p)); } , 'test basedir with leading double-asterisk': function () { var p = '**/foo'; assert.equal('.', fileUtils.basedir(p)); } , 'test basedir with leading asterisk': function () { var p = '*.js'; assert.equal('.', fileUtils.basedir(p)); } , 'test basedir with leading dot-slash and double-asterisk': function () { var p = './**/foo'; assert.equal('.', fileUtils.basedir(p)); } , 'test basedir with leading dirname and double-asterisk': function () { var p = 'a/**/*.js'; assert.equal('a', fileUtils.basedir(p)); } , 'test basedir with leading dot-dot-slash and double-asterisk': function () { var p = '../test/**/*.js'; assert.equal('..', fileUtils.basedir(p)); } }; module.exports = tests; lets_code_javascript-episode2/node_modules/jake/tests/helpers.js000066400000000000000000000021151177713054400255160ustar00rootroot00000000000000var exec = require('child_process').exec; var helpers = new (function () { var _tests , _names = [] , _name , _callback , _runner = function () { if (!!(_name = _names.shift())) { console.log('Running ' + _name); _tests[_name](); } else { _callback(); } }; this.exec = function (cmd, callback) { exec(cmd, function (err, stdout, stderr) { var out = helpers.trim(stdout); if (err) { throw err; } if (stderr) { callback(stderr); } else { callback(out); } }); }; this.trim = function (s) { var str = s || ''; return str.replace(/^\s*|\s*$/g, ''); }; this.parse = function (s) { var str = s || ''; str = helpers.trim(str); str = str.replace(/'/g, '"'); return JSON.parse(str); }; this.run = function (tests, callback) { _tests = tests; _names = Object.keys(tests); _callback = callback; _runner(); }; this.next = function () { _runner(); }; })(); module.exports = helpers; lets_code_javascript-episode2/node_modules/jake/tests/parseargs.js000066400000000000000000000107531177713054400260520ustar00rootroot00000000000000var parseargs = require('../lib/parseargs') , assert = require('assert') , optsReg = [ { full: 'directory' , abbr: 'C' , preempts: false , expectValue: true } , { full: 'jakefile' , abbr: 'f' , preempts: false , expectValue: true } , { full: 'tasks' , abbr: 'T' , preempts: true } , { full: 'trace' , abbr: 't' , preempts: false , expectValue: false } , { full: 'help' , abbr: 'h' , preempts: true } , { full: 'version' , abbr: 'V' , preempts: true } ] , p = new parseargs.Parser(optsReg) , z = function (s) { return s.split(' '); } , res; var tests = { 'test long preemptive opt and val with equal-sign, ignore further opts': function () { res = p.parse(z('--tasks=foo --jakefile=asdf')); assert.equal('foo', res.opts.tasks); assert.equal(undefined, res.opts.jakefile); } , 'test long preemptive opt and val without equal-sign, ignore further opts': function () { res = p.parse(z('--tasks foo --jakefile=asdf')); assert.equal('foo', res.opts.tasks); assert.equal(undefined, res.opts.jakefile); } , 'test long preemptive opt and no val, ignore further opts': function () { res = p.parse(z('--tasks --jakefile=asdf')); assert.equal(true, res.opts.tasks); assert.equal(undefined, res.opts.jakefile); } , 'test preemptive opt with no val, should be true': function () { res = p.parse(z('-T')); assert.equal(true, res.opts.tasks); } , 'test preemptive opt with no val, should be true and ignore further opts': function () { res = p.parse(z('-T -f')); assert.equal(true, res.opts.tasks); assert.equal(undefined, res.opts.jakefile); } , 'test preemptive opt with val, should be val': function () { res = p.parse(z('-T zoobie -f foo/bar/baz')); assert.equal('zoobie', res.opts.tasks); assert.equal(undefined, res.opts.jakefile); } , 'test -f expects a value, -t does not (howdy is task-name)': function () { res = p.parse(z('-f zoobie -t howdy')); assert.equal('zoobie', res.opts.jakefile); assert.equal(true, res.opts.trace); assert.equal('howdy', res.taskNames[0]); } , 'test different order, -f expects a value, -t does not (howdy is task-name)': function () { res = p.parse(z('-f zoobie howdy -t')); assert.equal('zoobie', res.opts.jakefile); assert.equal(true, res.opts.trace); assert.equal('howdy', res.taskNames[0]); } , 'test -f expects a value, -t does not (foo=bar is env var)': function () { res = p.parse(z('-f zoobie -t foo=bar')); assert.equal('zoobie', res.opts.jakefile); assert.equal(true, res.opts.trace); assert.equal('bar', res.envVars.foo); assert.equal(undefined, res.taskName); } , 'test -f expects a value, -t does not (foo=bar is env-var, task-name follows)': function () { res = p.parse(z('-f zoobie -t howdy foo=bar')); assert.equal('zoobie', res.opts.jakefile); assert.equal(true, res.opts.trace); assert.equal('bar', res.envVars.foo); assert.equal('howdy', res.taskNames[0]); } , 'test -t does not expect a value, -f does (throw howdy away)': function () { res = p.parse(z('-t howdy -f zoobie')); assert.equal(true, res.opts.trace); assert.equal('zoobie', res.opts.jakefile); assert.equal(undefined, res.taskName); } , 'test --trace does not expect a value, -f does (throw howdy away)': function () { res = p.parse(z('--trace howdy --jakefile zoobie')); assert.equal(true, res.opts.trace); assert.equal('zoobie', res.opts.jakefile); assert.equal(undefined, res.taskName); } , 'test --trace does not expect a value, -f does (throw howdy away)': function () { res = p.parse(z('--trace=howdy --jakefile=zoobie')); assert.equal(true, res.opts.trace); assert.equal('zoobie', res.opts.jakefile); assert.equal(undefined, res.taskName); } /* , 'test task-name with positional args': function () { res = p.parse(z('foo:bar[asdf,qwer]')); assert.equal('asdf', p.taskArgs[0]); assert.equal('qwer', p.taskArgs[1]); } , 'test opts, env vars, task-name with positional args': function () { res = p.parse(z('-f ./tests/Jakefile -t default[asdf,qwer] foo=bar')); assert.equal('./tests/Jakefile', res.opts.jakefile); assert.equal(true, res.opts.trace); assert.equal('bar', res.envVars.foo); assert.equal('default', res.taskName); assert.equal('asdf', p.taskArgs[0]); assert.equal('qwer', p.taskArgs[1]); } */ }; module.exports = tests; lets_code_javascript-episode2/node_modules/jake/tests/task_base.js000066400000000000000000000070711177713054400260160ustar00rootroot00000000000000var assert = require('assert') , h = require('./helpers'); var tests = { 'before': function () { process.chdir('./tests'); } , 'after': function () { process.chdir('../'); } , 'test default task': function (next) { h.exec('../bin/cli.js', function (out) { assert.equal('default task', out); h.exec('../bin/cli.js default', function (out) { assert.equal('default task', out); next(); }); }); } , 'test task with no action': function (next) { h.exec('../bin/cli.js noAction', function (out) { assert.equal('default task', out); next(); }); } , 'test a task with no action and no prereqs': function (next) { h.exec('../bin/cli.js noActionNoPrereqs', function () { next(); }); } , 'test passing args to a task': function (next) { h.exec('../bin/cli.js argsEnvVars[foo,bar]', function (out) { var parsed = h.parse(out) , args = parsed.args; assert.equal(args[0], 'foo'); assert.equal(args[1], 'bar'); next(); }); } , 'test a task with environment vars': function (next) { h.exec('../bin/cli.js argsEnvVars foo=bar baz=qux', function (out) { var parsed = h.parse(out) , env = parsed.env; assert.equal(env.foo, 'bar'); assert.equal(env.baz, 'qux'); next(); }); } , 'test passing args and using environment vars': function (next) { h.exec('../bin/cli.js argsEnvVars[foo,bar] foo=bar baz=qux', function (out) { var parsed = h.parse(out) , args = parsed.args , env = parsed.env; assert.equal(args[0], 'foo'); assert.equal(args[1], 'bar'); assert.equal(env.foo, 'bar'); assert.equal(env.baz, 'qux'); next(); }); } , 'test a simple prereq': function (next) { h.exec('../bin/cli.js foo:baz', function (out) { assert.equal('foo:bar task\nfoo:baz task', out); next(); }); } , 'test a duplicate prereq only runs once': function (next) { h.exec('../bin/cli.js foo:asdf', function (out) { assert.equal('foo:bar task\nfoo:baz task\nfoo:asdf task', out); next(); }); } , 'test a prereq with command-line args': function (next) { h.exec('../bin/cli.js foo:qux', function (out) { assert.equal('foo:bar[asdf,qwer] task\nfoo:qux task', out); next(); }); } , 'test a prereq with args via invoke': function (next) { h.exec('../bin/cli.js foo:frang[zxcv,uiop]', function (out) { assert.equal('foo:bar[zxcv,uiop] task\nfoo:frang task', out); next(); }); } , 'test prereq execution-order': function (next) { h.exec('../bin/cli.js hoge:fuga', function (out) { assert.equal('hoge:hoge task\nhoge:piyo task\nhoge:fuga task', out); next(); }); } , 'test basic async task': function (next) { h.exec('../bin/cli.js bar:bar', function (out) { assert.equal('bar:foo task\nbar:bar task', out); next(); }); } , 'test that current-prereq index gets reset': function (next) { h.exec('../bin/cli.js hoge:kira', function (out) { assert.equal('hoge:hoge task\nhoge:piyo task\nhoge:fuga task\n' + 'hoge:charan task\nhoge:gero task\nhoge:kira task', out); next(); }); } , 'test modifying a task by adding prereq during execution': function (next) { h.exec('../bin/cli.js voom', function (out) { assert.equal(2, out); next(); }); } , 'test listening for task error-event': function (next) { h.exec('../bin/cli.js vronk:groo', function (out) { assert.equal('OMFGZONG', out); next(); }); } }; module.exports = tests; lets_code_javascript-episode2/node_modules/jshint/000077500000000000000000000000001177713054400227425ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/LICENSE000066400000000000000000000001351177713054400237460ustar00rootroot00000000000000** Licensed Under ** The MIT License http://www.opensource.org/licenses/mit-license.php lets_code_javascript-episode2/node_modules/jshint/README.md000066400000000000000000000062501177713054400242240ustar00rootroot00000000000000# node-jshint A command line interface and npm package for jshint. ## Install To use jshint from any location (for npm v1.x) you need to install using the global (-g) flag. npm install -g jshint ## Usage jshint -h You can also require JSHint itself as a module. var jshint = require('jshint'); Note: If you are using npm v1.x be sure to install jshint locally (without the -g flag) or link it globally. ## Text Editor Plugins * [gedit-node-jshint](https://github.com/niftylettuce/gedit-node-jshint) - Simply use CTRL+J in gedit to run JSHint using `node-jshint`. * [vim syntastic](https://github.com/scrooloose/syntastic) - Run node-jshint at each file save. * [sublime-jshint](https://github.com/uipoet/sublime-jshint) - `F7` or `command-B` on any .js file. `F4` next error line,column. `shift-F4` previous error line,column. ## Custom Reporters Specify a custom reporter module (see example/reporter.js). --reporter path/to/reporter.js Use a jslint compatible xml reporter. --jslint-reporter Show additional non-error data generated by jshint (unused globals etc). --show-non-errors ## Configuration Options **Note:** This behavior described below is very different from versions prior to `0.6`. The CLI uses the default options that come with JSHint. To have your own configuration apply, there are several methods you can use: ### Specify Manually Setting the `--config=/path/to/your/config` command line option to specify your own configuration file outside of the directory tree for your project. ### Within your Project's Directory Tree When the CLI is called, and a configuration file isn't specified already, `node-jshint` will attempt to locate one for you starting in `pwd`. (or "present working directory") If this does not yield a `.jshintrc` file, it will move one level up (`..`) the directory tree all the way up to the filesystem root. If a file is found, it stops immediately and uses that set of configuration. This setup allows you to set up **one** configuration file for your entire project. (place it in the root folder) As long as you run `jshint` from anywhere within your project directory tree, the same configuration file will be used. ### Home Directory If all the methods above do not yield a `.jshintrc` to use, the last place that will be checked is your user's `$HOME` directory. ## File Extensions Default extension for files is ".js". If you want to use JSHint with other file extensions (.json), you need to pass this extra extension as an option : --extra-ext .json ## Ignoring Files and Directories If there is a .jshintignore file in your project's directory tree, (also provided you run `jshint` from within your project's directory) then any directories or files specified will be skipped over. (behaves just like a `.gitignore` file) **Note:** Pattern matching uses minimatch, with the nocase [option](https://github.com/isaacs/minimatch). When there is no match, it performs a left side match (when no forward slashes present and path is a directory). ## Installing dependencies for development ./configure ## Build Commands jake -T ## Project Guidelines * All tests are passing. * No (new) JSHint errors are introduced. lets_code_javascript-episode2/node_modules/jshint/bin/000077500000000000000000000000001177713054400235125ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/bin/hint000077500000000000000000000001051177713054400243760ustar00rootroot00000000000000#!/usr/bin/env node require('./../lib/cli').interpret(process.argv); lets_code_javascript-episode2/node_modules/jshint/lib/000077500000000000000000000000001177713054400235105ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/lib/cli.js000066400000000000000000000112041177713054400246130ustar00rootroot00000000000000var fs = require('fs'), path = require('path'), cli = require('cli').enable('glob', 'help'), hint = require('./hint'); function existsSync() { var obj = fs.existsSync ? fs : path; return obj.existsSync.apply(obj, arguments); } function _removeJsComments(str) { str = str || ''; // replace everything between "/* */" in a non-greedy way // The English version of the regex is: // match '/*' // then match 0 or more instances of any character (including newlines) // except for instances of '*/' // then match '*/' str = str.replace(/\/\*(?:(?!\*\/)[\s\S])*\*\//g, ''); str = str.replace(/\/\/[^\n\r]*/g, ''); //everything after "//" return str; } function _loadAndParseConfig(filePath) { return filePath && existsSync(filePath) ? JSON.parse(_removeJsComments(fs.readFileSync(filePath, "utf-8"))) : {}; } /** * This function searches for a file with a specified name, it starts * with the dir passed, and traverses up the filesystem until it either * finds the file, or hits the root * * @param {String} name Filename to search for (.jshintrc, .jshintignore) * @param {String} dir Defaults to process.cwd() */ function _searchFile(name, dir) { dir = dir || process.cwd(); var filename = path.normalize(path.join(dir, name)), parent = path.resolve(dir, ".."); if (existsSync(filename)) { return filename; } return dir === parent ? null : _searchFile(name, parent); } function _findConfig(target) { var name = ".jshintrc", projectConfig = _searchFile(name), homeConfig = path.normalize(path.join(process.env.HOME, name)); if (projectConfig) { return projectConfig; } // if no project config, check $HOME if (existsSync(homeConfig)) { return homeConfig; } return false; } function _print(results) { function exit() { process.exit(results.length > 0 ? 1 : 0); } // avoid stdout cutoff in node 0.4.x, also supports 0.5.x // see https://github.com/joyent/node/issues/1669 try { if (!process.stdout.flush()) { process.stdout.once("drain", exit); } else { exit(); } } catch (e) { exit(); } } module.exports = { interpret: function (args) { var config, reporter, options, customConfig, customReporter, ignoreFile, ignores, extraExtensionList; cli.setArgv(args); cli.options = {}; options = cli.parse({ 'version': ['v', 'display package version', 'boolean', false], 'config': ['config', 'custom config file', 'string', false], 'reporter': ['reporter', 'custom reporter', 'string', undefined], 'jslint-reporter': ['jslint-reporter', 'use a jslint compatible xml reporter'], 'show-non-errors': ['show-non-errors', 'show additional data generated by jshint'], 'extra-ext': ['extra-ext', 'comma-separated list of file extensions to use (.js is default)', 'string', ''] }); customConfig = options.config; customReporter = options.reporter ? path.resolve(process.cwd(), options.reporter) : null; extraExtensionList = options["extra-ext"]; if (options.version) { cli.setApp(path.resolve(__dirname + "/../package.json")); process.stdout.write(cli.version + "\n"); return; } if (options.help || !cli.args.length) { cli.getUsage(); process.exit(); return; } if (options['jslint-reporter']) { customReporter = "./reporters/jslint_xml.js"; } if (options['show-non-errors']) { customReporter = "./reporters/non_error.js"; } config = _loadAndParseConfig(customConfig ? customConfig : _findConfig()); if (customReporter) { try { reporter = require(customReporter).reporter; } catch (r) { process.stdout.write("Error opening reporter file: " + customReporter); process.stdout.write(r + "\n"); process.exit(1); } } ignoreFile = _searchFile(".jshintignore"); if (ignoreFile) { ignores = fs.readFileSync(ignoreFile, "utf8").split("\n") .filter(function (line) { return !!line.trim(); }) .map(function (line) { return path.resolve(path.dirname(ignoreFile), line.trim()); }); } _print(hint.hint(cli.args, config, reporter, ignores, extraExtensionList)); } }; lets_code_javascript-episode2/node_modules/jshint/lib/hint.js000066400000000000000000000056111177713054400250130ustar00rootroot00000000000000var fs = require('fs'), minimatch = require('minimatch'), path = require('path'), jshint = require('./../packages/jshint/jshint.js'), _reporter = require('./reporters/default').reporter, _cache = { directories: {} }; function _lint(file, results, config, data) { var buffer, lintdata; try { buffer = fs.readFileSync(file, 'utf-8'); } catch (e) { process.stdout.write("Error: Cant open: " + file); process.stdout.write(e + '\n'); } // Remove potential Unicode Byte Order Mark. buffer = buffer.replace(/^\uFEFF/, ''); if (!jshint.JSHINT(buffer, config)) { jshint.JSHINT.errors.forEach(function (error) { if (error) { results.push({file: file, error: error}); } }); } lintdata = jshint.JSHINT.data(); if (lintdata) { lintdata.file = file; data.push(lintdata); } } function isDirectory(aPath) { var isDir; try { if (_cache.directories.hasOwnProperty(aPath)) { isDir = _cache.directories[aPath]; } else { isDir = fs.statSync(aPath).isDirectory(); _cache.directories[aPath] = isDir; } } catch (e) { isDir = false; } return isDir; } function _shouldIgnore(somePath, ignore) { function isIgnored(p) { var fnmatch = minimatch(somePath, p, {nocase: true}), absmatch = path.resolve(somePath) === p, lsmatch = isDirectory(p) && p.match(/^[^\/]*\/?$/) && somePath.match(new RegExp("^" + p + ".*")); return !!(fnmatch || lsmatch || absmatch); } return ignore.some(function (ignorePath) { return isIgnored(ignorePath); }); } function _collect(filePath, files, ignore, regExtension) { if (ignore && _shouldIgnore(filePath, ignore)) { return; } if (fs.statSync(filePath).isDirectory()) { fs.readdirSync(filePath).forEach(function (item) { _collect(path.join(filePath, item), files, ignore, regExtension); }); } else if (filePath.match(regExtension)) { files.push(filePath); } } module.exports = { hint: function (targets, config, reporter, ignore, extraExtensionList) { var files = [], results = [], data = [], regExtension; extraExtensionList = extraExtensionList || ""; regExtension = new RegExp('\\.(js' + (extraExtensionList === "" ? "" : "|" + extraExtensionList.replace(/,/g, "|").replace(/[\. ]/g, "")) + ")$"); targets.forEach(function (target) { _collect(target, files, ignore, regExtension); }); files.forEach(function (file) { _lint(file, results, config, data); }); _cache = { directories: {} }; (reporter || _reporter)(results, data); return results; } }; lets_code_javascript-episode2/node_modules/jshint/lib/reporters/000077500000000000000000000000001177713054400255355ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/lib/reporters/default.js000066400000000000000000000010151177713054400275140ustar00rootroot00000000000000module.exports = { reporter: function (results, data) { var len = results.length, str = '', file, error; results.forEach(function (result) { file = result.file; error = result.error; str += file + ': line ' + error.line + ', col ' + error.character + ', ' + error.reason + '\n'; }); if (str) { process.stdout.write(str + "\n" + len + ' error' + ((len === 1) ? '' : 's') + "\n"); } } }; lets_code_javascript-episode2/node_modules/jshint/lib/reporters/jslint_xml.js000066400000000000000000000027261177713054400302650ustar00rootroot00000000000000// Author: Vasili Sviridov // http://github.com/vsviridov module.exports = { reporter: function (results) { "use strict"; var files = {}, out = [], pairs = { "&": "&", '"': """, "'": "'", "<": "<", ">": ">" }, file, i, issue; function encode(s) { for (var r in pairs) { if (typeof(s) !== "undefined") { s = s.replace(new RegExp(r, "g"), pairs[r]); } } return s || ""; } results.forEach(function (result) { result.file = result.file.replace(/^\.\//, ''); if (!files[result.file]) { files[result.file] = []; } files[result.file].push(result.error); }); out.push(""); out.push(""); for (file in files) { out.push("\t"); for (i = 0; i < files[file].length; i++) { issue = files[file][i]; out.push("\t\t"); } out.push("\t"); } out.push(""); process.stdout.write(out.join("\n") + "\n"); } }; lets_code_javascript-episode2/node_modules/jshint/lib/reporters/non_error.js000066400000000000000000000024631177713054400301030ustar00rootroot00000000000000/*jshint node: true */ module.exports = { reporter: function (results, data, done) { var len = results.length, str = '', file, error, globals, unuseds; results.forEach(function (result) { file = result.file; error = result.error; str += file + ': line ' + error.line + ', col ' + error.character + ', ' + error.reason + '\n'; }); str += len > 0 ? ("\n" + len + ' error' + ((len === 1) ? '' : 's')) : ""; data.forEach(function (data) { file = data.file; globals = data.implieds; unuseds = data.unused; if (globals || unuseds) { str += '\n\n' + file + ' :\n'; } if (globals) { str += '\tImplied globals:\n'; globals.forEach(function (global) { str += '\t\t' + global.name + ': ' + global.line + '\n'; }); } if (unuseds) { str += '\tUnused Variables:\n\t\t'; unuseds.forEach(function (unused) { str += unused.name + '(' + unused.line + '), '; }); } }); if (str) { process.stdout.write(str + "\n"); } } }; lets_code_javascript-episode2/node_modules/jshint/node_modules/000077500000000000000000000000001177713054400254175ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/000077500000000000000000000000001177713054400261665ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/README.md000066400000000000000000000141171177713054400274510ustar00rootroot00000000000000**cli is a toolkit for rapidly building command line apps - it includes:** - Full featured opts/args parser - Plugin support for adding common options and switches - Helper methods for working with input/output and spawning child processes - Output colored/styled messages, [progress bars](https://github.com/chriso/cli/blob/master/examples/progress.js) or [spinners](https://github.com/chriso/cli/blob/master/examples/spinner.js) - Command [auto-completion](https://github.com/chriso/cli/blob/master/examples/command.js) and [glob support](https://github.com/chriso/cli/blob/master/examples/glob.js) Install using `npm install cli` or just bundle [cli.js](https://github.com/chriso/cli/raw/master/cli-min.js) with your app. ## Example apps ### sort.js ```javascript #!/usr/bin/env node require('cli').withStdinLines(function(lines, newline) { this.output(lines.sort().join(newline)); }); ``` Try it out ```bash $ ./sort.js < input.txt ``` Let's add support for an `-n` switch to use a numeric sort, and a `-r` switch to reverse output - only 5 extra lines of code (!) ```javascript var cli = require('cli'), options = cli.parse(); cli.withStdinLines(function(lines, newline) { lines.sort(!options.n ? null : function(a, b) { return parseInt(a) > parseInt(b); }); if (options.r) lines.reverse(); this.output(lines.join(newline)); }); ``` ### static.js Let's create a static file server with daemon support to see the opts parser + plugins in use - note: this requires `npm install creationix daemon` ```javascript var cli = require('cli').enable('daemon', 'status'); //Enable 2 plugins cli.parse({ log: ['l', 'Enable logging'], port: ['p', 'Listen on this port', 'number', 8080], serve: [false, 'Serve static files from PATH', 'path', './public'] }); cli.main(function(args, options) { var server, middleware = []; if (options.log) { this.debug('Enabling logging'); middleware.push(require('creationix/log')()); } this.debug('Serving files from ' + options.serve); middleware.push(require('creationix/static')('/', options.serve, 'index.html')); server = this.createServer(middleware).listen(options.port); this.ok('Listening on port ' + options.port); }); ``` To output usage information ```bash $ ./static.js --help ``` To create a daemon that serves files from */tmp*, run ```bash $ ./static.js -ld --serve=/tmp ``` For more examples, see [./examples](https://github.com/chriso/cli/tree/master/examples) ## Helper methods cli has methods that collect stdin (newline is autodetected as \n or \r\n) ```javascript cli.withStdin(callback); //callback receives stdin as a string cli.withStdinLines(callback); //callback receives stdin split into an array of lines (lines, newline) ``` cli also has a lower level method for working with input line by line (see [./examples/cat.js](https://github.com/chriso/cli/blob/master/examples/cat.js) for an example). ```javascript cli.withInput(file, function (line, newline, eof) { if (!eof) { this.output(line + newline); } }); ``` *Note: `file` can be omitted if you want to work with stdin* To output a progress bar, call ```javascript cli.progress(progress); //Where 0 <= progress <= 1 ``` To spawn a child process, use ```javascript cli.exec(cmd, callback); //callback receives the output of the process (split into lines) ``` cli also comes bundled with kof's [node-natives](https://github.com/kof/node-natives) (access with cli.native) and creationix' [stack](https://github.com/creationix/stack) (access with cli.createServer) ## Plugins Plugins are a way of adding common opts and can be enabled using ```javascript cli.enable(plugin1, [plugin2, ...]); //To disable, use the equivalent disable() method ``` **help** - *enabled by default* Adds `-h,--help` to output auto-generated usage information **version** Adds `-v,--version` to output version information for the app. cli will attempt to locate and parse a nearby *package.json* To set your own app name and version, use `cli.setApp(app_name, version)` **status** Adds options to show/hide the stylized status messages that are output to the console when using one of these methods ```javascript cli.debug(msg); //Only shown when using --debug cli.error(msg); cli.fatal(msg); //Exits the process after outputting msg cli.info(msg); cli.ok(msg); ``` `-k,--no-color` will omit ANSI color escapes from the output **glob** - *requires* `npm install glob` Enables glob matching of arguments **daemon** - *requires* `npm install daemon` Adds `-d,--daemon ARG` for daemonizing the process and controlling the resulting daemon `ARG` can be either start (default), stop, restart, pid (outputs the daemon's pid if it's running), or log (output the daemon's stdout+stderr) **timeout** Adds `-t,--timeout N` to exit the process after N seconds with an error **catchall** Adds `-c,--catch` to catch and output uncaughtExceptions and resume execution *Note: Plugins are automatically disabled if an option or switch of the same name is already defined* ## LICENSE (MIT license) Copyright (c) 2010 Chris O'Hara 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. lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/cli.js000066400000000000000000001063441177713054400273030ustar00rootroot00000000000000/** * Copyright (c) 2010 Chris O'Hara * * 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. */ //Note: cli includes kof/node-natives and creationix/stack. I couldn't find //license information for either - contact me if you want your license added var cli = exports, argv, curr_opt, curr_val, full_opt, is_long, short_tags = [], opt_list, parsed = {}, usage, argv_parsed, command_list, commands, daemon, daemon_arg, no_color, show_debug; cli.app = null; cli.version = null; cli.argv = []; cli.argc = 0; cli.options = {}; cli.args = []; cli.command; cli.width = 70; cli.option_width = 25; /** * Bind kof's node-natives (https://github.com/kof/node-natives) to `cli.native` * * Rather than requiring node natives (e.g. var fs = require('fs')), all * native modules can be accessed like `cli.native.fs` */ cli.native = {}; var define_native = function (module) { Object.defineProperty(cli.native, module, { enumerable: true, configurable: true, get: function() { delete cli.native[module]; return cli.native[module] = require(module); } }); }; var natives = process.binding('natives'); for (var module in natives) { define_native(module); } cli.output = cli.native.util.print; cli.exit = process.exit; /** * Define plugins. Plugins can be enabled and disabled by calling: * * `cli.enable(plugin1, [plugin2, ...])` * `cli.disable(plugin1, [plugin2, ...])` * * Methods are chainable - `cli.enable(plugin).disable(plugin2)`. * * The 'help' plugin is enabled by default. */ var enable = { help: true, //Adds -h, --help version: false, //Adds -v,--version => gets version by parsing a nearby package.json daemon: false, //Adds -d,--daemon [ARG] => (see cli.daemon() below) status: false, //Adds -k,--no-color & --debug => display plain status messages /display debug messages timeout: false, //Adds -t,--timeout N => timeout the process after N seconds catchall: false, //Adds -c,--catch => catch and output uncaughtExceptions glob: false //Adds glob matching => use cli.glob(arg) } cli.enable = function (/*plugins*/) { Array.prototype.slice.call(arguments).forEach(function (plugin) { switch (plugin) { case 'daemon': try { daemon = require('daemon'); if (typeof daemon.daemonize !== 'function') { throw 'Invalid module'; } } catch (e) { cli.fatal('daemon.node not installed. Please run `npm install daemon`'); } break; case 'catchall': process.on('uncaughtException', function (err) { cli.error('Uncaught exception: ' + (err.msg || err)); }); break; case 'help': case 'version': case 'status': case 'autocomplete': case 'timeout': //Just add switches. break; case 'glob': cli.glob = require('glob'); break; default: cli.fatal('Unknown plugin "' + plugin + '"'); break; } enable[plugin] = true; }); return cli; } cli.disable = function (/*plugins*/) { Array.prototype.slice.call(arguments).forEach(function (plugin) { if (enable[plugin]) { enable[plugin] = false; } }); return cli; } /** * Sets argv (default is process.argv). * * @param {Array|String} argv * @param {Boolean} keep_arg0 (optional - default is false) * @api public */ cli.setArgv = function (arr, keep_arg0) { if (typeof arr == 'string') { arr = arr.split(' '); } else { arr = arr.slice(); } cli.app = arr.shift(); //Strip off argv[0] if it's a node binary if (!keep_arg0 && ('node' === cli.native.path.basename(cli.app) || process.execPath === cli.app)) { cli.app = arr.shift(); } cli.app = cli.native.path.basename(cli.app); argv_parsed = false; cli.args = cli.argv = argv = arr; cli.argc = argv.length; }; cli.setArgv(process.argv); /** * Returns the next opt, or false if no opts are found. * * @return {String} opt * @api public */ cli.next = function () { if (!argv_parsed) { cli.args = []; argv_parsed = true; } curr_val = null; //If we're currently in a group of short opts (e.g. -abc), return the next opt if (short_tags.length) { curr_opt = short_tags.shift(); full_opt = '-' + curr_opt; return curr_opt; } if (!argv.length) { return false; } curr_opt = argv.shift(); //If an escape sequence is found (- or --), subsequent opts are ignored if (curr_opt === '-' || curr_opt === '--') { while (argv.length) { cli.args.push(argv.shift()); } return false; } //If the next element in argv isn't an opt, add it to the list of args if (curr_opt[0] !== '-') { cli.args.push(curr_opt); return cli.next(); } else { //Check if the opt is short/long is_long = curr_opt[1] === '-'; curr_opt = curr_opt.substr(is_long ? 2 : 1); } //Accept grouped short opts, e.g. -abc => -a -b -c if (!is_long && curr_opt.length > 1) { short_tags = curr_opt.split(''); return cli.next(); } var eq, len; //Check if the long opt is in the form --option=VALUE if (is_long && (eq = curr_opt.indexOf('=')) >= 0) { curr_val = curr_opt.substr(eq + 1); curr_opt = curr_opt.substr(0, eq); len = curr_val.length; //Allow values to be quoted if ((curr_val[0] === '"' && curr_val[len - 1] === '"') || (curr_val[0] === "'" && curr_val[len - 1] === "'")) { curr_val = curr_val.substr(1, len-2); } if (curr_val.match(/^[0-9]+$/)) { curr_val = parseInt(curr_val, 10); } } //Save the opt representation for later full_opt = (is_long ? '--' : '-') + curr_opt; return curr_opt; }; /** * Parses command line opts. * * `opts` must be an object with opts defined like: * long_tag: [short_tag, description, value_type, default_value]; * * `commands` is an optional array or object for apps that are of the form * my_app [OPTIONS] [ARGS] * The command list is output with usage information + there is bundled * support for auto-completion, etc. * * See README.md for more information. * * @param {Object} opts * @param {Object} commands (optional) * @return {Object} opts (parsed) * @api public */ cli.parse = function (opts, command_def) { var default_val, i, parsed = cli.options, seen, catch_all = !opts; opt_list = opts || {}; commands = command_def; command_list = commands || []; if (commands && !Array.isArray(commands)) { command_list = Object.keys(commands); } while (o = cli.next()) { seen = false; for (opt in opt_list) { if (!(opt_list[opt] instanceof Array)) { continue; } if (!opt_list[opt][0]) { opt_list[opt][0] = opt; } if (o === opt || o === opt_list[opt][0]) { seen = true; if (opt_list[opt].length === 2) { parsed[opt] = true; break; } default_val = null; if (opt_list[opt].length === 4) { default_val = opt_list[opt][3]; } if (opt_list[opt][2] instanceof Array) { for (i = 0, l = opt_list[opt][2].length; i < l; i++) { if (typeof opt_list[opt][2][i] === 'number') { opt_list[opt][2][i] += ''; } } parsed[opt] = cli.getArrayValue(opt_list[opt][2], is_long ? null : default_val); break; } if (opt_list[opt][2].toLowerCase) { opt_list[opt][2] = opt_list[opt][2].toLowerCase(); } switch (opt_list[opt][2]) { case 'string': case 1: case true: parsed[opt] = cli.getValue(default_val); break; case 'int': case 'number': case 'num': case 'time': case 'seconds': case 'secs': case 'minutes': case 'mins': case 'x': case 'n': parsed[opt] = cli.getInt(default_val); break; case 'float': case 'decimal': parsed[opt] = cli.getFloat(default_val); break; case 'path': case 'file': case 'directory': case 'dir': parsed[opt] = cli.getPath(default_val, opt_list[opt][2]); break; case 'email': parsed[opt] = cli.getEmail(default_val); break; case 'url': case 'uri': case 'domain': case 'host': parsed[opt] = cli.getUrl(default_val, opt_list[opt][2]); break; case 'ip': parsed[opt] = cli.getIp(default_val); break; case 'bool': case 'boolean': case 'on': parsed[opt] = true; break; case 'false': case 'off': case false: case 0: parsed[opt] = false; break; default: cli.fatal('Unknown opt type "' + opt_list[opt][2] + '"'); } break; } } if (process.env.NODE_DISABLE_COLORS) { no_color = true; } if (!seen) { if (enable.help && (o === 'h' || o === 'help')) { cli.getUsage(); process.exit(); } else if (enable.version && (o === 'v' || o === 'version')) { if (cli.version == null) { cli.parsePackageJson(); } console.error(cli.app + ' v' + cli.version); process.exit(); } else if (enable.daemon && (o === 'd' || o === 'daemon')) { daemon_arg = cli.getArrayValue(['start','stop','restart','pid','log'], is_long ? null : 'start'); continue; } else if (enable.catchall && (o === 'c' || o === 'catch')) { continue; } else if (enable.status && (o === 'k' || o === 'no-color' || o === 'debug')) { no_color = (o === 'k' || o === 'no-color'); show_debug = o === 'debug'; continue; } else if (enable.timeout && (o === 't' || o === 'timeout')) { var secs = cli.getInt(); setTimeout(function () { cli.fatal('Process timed out after ' + secs + 's'); }, secs * 1000); continue; } else if (catch_all) { parsed[o] = curr_val || true; continue; } cli.fatal('Unknown option ' + full_opt); } } //Fill the remaining options with their default value or null for (opt in opt_list) { default_val = opt_list[opt].length === 4 ? opt_list[opt][3] : null; if (!(opt_list[opt] instanceof Array)) { parsed[opt] = opt_list[opt]; continue; } else if (typeof parsed[opt] === 'undefined') { parsed[opt] = default_val; } } if (command_list.length) { if (cli.args.length === 0) { if (enable.help) { cli.getUsage(); } else { cli.fatal('A command is required (' + command_list.join(', ') + ').'); } process.exit(1); } else { cli.command = cli.autocompleteCommand(cli.args.shift()); } } cli.argc = cli.args.length; return parsed; }; /** * Helper method for matching a command from the command list. * * @param {String} command * @return {String} full_command * @api public */ cli.autocompleteCommand = function (command) { var list; if (!(command_list instanceof Array)) { list = Object.keys(command_list); } else { list = command_list; } var i, j = 0, c = command.length, tmp_list; if (list.length === 0 || list.indexOf(command) !== -1) { return command; } for (i = 0; i < c; i++) { tmp_list = []; l = list.length; if (l <= 1) break; for (j = 0; j < l; j++) if (list[j].length >= i && list[j][i] === command[i]) tmp_list.push(list[j]); list = tmp_list; } l = list.length; if (l === 1) { return list[0]; } else if (l === 0) { cli.fatal('Unknown command "' + command + '"' + (enable.help ? '. Please see --help for more information' : '')); } else { list.sort(); cli.fatal('The command "' + command + '" is ambiguous and could mean "' + list.join('", "') + '"'); } }; /** * Adds methods to output styled status messages to stderr. * * Added methods are cli.info(msg), cli.error(msg), cli.ok(msg), and * cli.debug(msg). * * To control status messages, use the 'status' plugin * 1) debug() messages are hidden by default. Display them with * the --debug opt. * 2) to hide all status messages, use the -s or --silent opt. * * @api private */ cli.status = function (msg, type) { var pre; switch (type) { case 'info': pre = no_color ? 'INFO:' : '\x1B[33mINFO\x1B[0m:'; break; case 'debug': pre = no_color ? 'DEBUG:' : '\x1B[36mDEBUG\x1B[0m:'; break; case 'error': case 'fatal': pre = no_color ? 'ERROR:' : '\x1B[31mERROR\x1B[0m:'; break; case 'ok': pre = no_color ? 'OK:' : '\x1B[32mOK\x1B[0m:'; break; } msg = pre + ' ' + msg; if (type === 'fatal') { console.error(msg); process.exit(1); } if (enable.status && !show_debug && type === 'debug') { return; } console.error(msg); }; ['info','error','ok','debug','fatal'].forEach(function (type) { cli[type] = function (msg) { cli.status(msg, type); }; }); /** * Sets the app name and version. * * Usage: * setApp('myapp', '0.1.0'); * setApp('./package.json'); //Pull name/version from package.json * * @param {String} name * @return cli (for chaining) * @api public */ cli.setApp = function (name, version) { if (name.indexOf('package.json') !== -1) { cli.parsePackageJson(name); } else { cli.app = name; cli.version = version; } return cli; }; /** * Parses the version number from package.json. If no path is specified, cli * will attempt to locate a package.json in ./, ../ or ../../ * * @param {String} path (optional) * @api public */ cli.parsePackageJson = function (path) { var parse_packagejson = function (path) { var packagejson = JSON.parse(cli.native.fs.readFileSync(path, 'utf8')); cli.version = packagejson.version; cli.app = packagejson.name; }; var try_all = function (arr, func, err) { for (var i = 0, l = arr.length; i < l; i++) { try { func(arr[i]); return; } catch (e) { if (i === l-1) { cli.fatal(err); } } } }; try { if (path) { return parse_packagejson(path); } try_all([ __dirname + '/package.json', __dirname + '/../package.json', __dirname + '/../../package.json' ], parse_packagejson); } catch (e) { cli.fatal('Could not detect ' + cli.app + ' version'); } }; /** * Sets the usage string - default is `app [OPTIONS] [ARGS]`. * * @param {String} u * @return cli (for chaining) * @api public */ cli.setUsage = function (u) { usage = u; return cli; }; var pad = function (str, len) { if (typeof len === 'undefined') { len = str; str = ''; } if (str.length < len) { len -= str.length; while (len--) str += ' '; } return str; }; /** * Automatically build usage information from the opts list. If the help * plugin is enabled (default), this info is displayed with -h, --help. * * @api public */ cli.getUsage = function () { var short, desc, optional, line, seen_opts = [], switch_pad = cli.option_width; var trunc_desc = function (pref, desc, len) { var pref_len = pref.length, desc_len = cli.width - pref_len, truncated = ''; if (desc.length <= desc_len) { return desc; } var desc_words = (desc+'').split(' '), chars = 0, word; while (desc_words.length) { truncated += (word = desc_words.shift()) + ' '; chars += word.length; if (desc_words.length && chars + desc_words[0].length > desc_len) { truncated += '\n' + pad(pref_len); chars = 0; } } return truncated; }; usage = usage || cli.app + ' [OPTIONS]' + (command_list.length ? ' ' : '') + ' [ARGS]'; if (no_color) { console.error('Usage:\n ' + usage); console.error('Options: '); } else { console.error('\x1b[1mUsage\x1b[0m:\n ' + usage); console.error('\n\x1b[1mOptions\x1b[0m: '); } for (opt in opt_list) { if (opt.length === 1) { long = opt_list[opt][0]; short = opt; } else { long = opt; short = opt_list[opt][0]; } //Parse opt_list desc = opt_list[opt][1].trim(); type = opt_list[opt].length >= 3 ? opt_list[opt][2] : null; optional = opt_list[opt].length === 4 ? opt_list[opt][3] : null; //Build usage line if (short === long) { if (short.length === 1) { line = ' -' + short; } else { line = ' --' + long; } } else { line = ' -' + short + ', --' + long; } line += ' '; if (type) { if (type instanceof Array) { desc += '. VALUE must be either [' + type.join('|') + ']'; type = 'VALUE'; } if (type === true || type === 1) { type = long.toUpperCase(); } type = type.toUpperCase(); if (type === 'FLOAT' || type === 'INT') { type = 'NUMBER'; } line += optional ? '[' + type + ']' : type; } line = pad(line, switch_pad); line += trunc_desc(line, desc); line += optional ? ' (Default is ' + optional + ')' : ''; console.error(line.replace('%s', '%\0s')); seen_opts.push(short); seen_opts.push(long); } if (enable.timeout && seen_opts.indexOf('t') === -1 && seen_opts.indexOf('timeout') === -1) { console.error(pad(' -t, --timeout N', switch_pad) + 'Exit if the process takes longer than N seconds'); } if (enable.status) { if (seen_opts.indexOf('k') === -1 && seen_opts.indexOf('no-color') === -1) { console.error(pad(' -k, --no-color', switch_pad) + 'Omit color from output'); } if (seen_opts.indexOf('debug') === -1) { console.error(pad(' --debug', switch_pad) + 'Show debug information'); } } if (enable.catchall && seen_opts.indexOf('c') === -1 && seen_opts.indexOf('catch') === -1) { console.error(pad(' -c, --catch', switch_pad) + 'Catch unanticipated errors'); } if (enable.daemon && seen_opts.indexOf('d') === -1 && seen_opts.indexOf('daemon') === -1) { console.error(pad(' -d, --daemon [ARG]', switch_pad) + 'Daemonize the process. Control the daemon using [start, stop, restart, log, pid]'); } if (enable.version && seen_opts.indexOf('v') === -1 && seen_opts.indexOf('version') === -1) { console.error(pad(' -v, --version', switch_pad) + 'Display the current version'); } if (enable.help && seen_opts.indexOf('h') === -1 && seen_opts.indexOf('help') === -1) { console.error(pad(' -h, --help', switch_pad) + 'Display help and usage details'); } if (command_list.length) { console.error('\n\x1b[1mCommands\x1b[0m: '); if (!Array.isArray(commands)) { for (var c in commands) { line = ' ' + pad(c, switch_pad - 2); line += trunc_desc(line, commands[c]); console.error(line); } } else { command_list.sort(); console.error(' ' + trunc_desc(' ', command_list.join(', '))); } } process.exit(); }; /** * Generates an error message when an opt is incorrectly used. * * @param {String} expects (e.g. 'a value') * @param {String} type (e.g. 'VALUE') * @api public */ cli.getOptError = function (expects, type) { var err = full_opt + ' expects ' + expects + '. Use `' + cli.app + ' ' + full_opt + (is_long ? '=' : ' ') + type + '`'; return err; }; /** * Gets the next opt value and validates it with an optional validation * function. If validation fails or no value can be obtained, this method * will return the default value (if specified) or exit with err_msg. * * @param {String} default_val * @param {Function} validate_func * @param {String} err_msg * @api public */ cli.getValue = function (default_val, validate_func, err_msg) { err_msg = err_msg || cli.getOptError('a value', 'VALUE'); var value; try { if (curr_val) { if (validate_func) { curr_val = validate_func(curr_val); } return curr_val; } //Grouped short opts aren't allowed to have values if (short_tags.length) { throw 'Short tags'; } //If there's no args left or the next arg is an opt, return the //default value (if specified) - otherwise fail if (!argv.length || argv[0][0] === '-') { throw 'No value'; } value = argv.shift(); if (value.match(/^[0-9]+$/)) { value = parseInt(value, 10); } //Run the value through a validation/transformation function if specified if (validate_func) { value = validate_func(value); } } catch (e) { //The value didn't pass the validation/transformation. Unshift the value and //return the default value (if specified) if (value) { argv.unshift(value); } return default_val != null ? default_val : cli.fatal(err_msg); } return value; }; cli.getInt = function (default_val) { return cli.getValue(default_val, function (value) { if (typeof value === 'number') return value; if (!value.match(/^(?:-?(?:0|[1-9][0-9]*))$/)) { throw 'Invalid int'; } return parseInt(value); }, cli.getOptError('a number', 'NUMBER')); } cli.getFloat = function (default_val) { return cli.getValue(default_val, function (value) { if (!value.match(/^(?:-?(?:0|[1-9][0-9]*))?(?:\.[0-9]*)?$/)) { throw 'Invalid float'; } return parseFloat(value, 10); }, cli.getOptError('a number', 'NUMBER')); } cli.getUrl = function (default_val, identifier) { identifier = identifier || 'url'; return cli.getValue(default_val, function (value) { if (!value.match(/^(?:(?:ht|f)tp(?:s?)\:\/\/|~\/|\/)?(?:\w+:\w+@)?((?:(?:[-\w\d{1-3}]+\.)+(?:com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|edu|co\.uk|ac\.uk|it|fr|tv|museum|asia|local|travel|[a-z]{2})?)|((\b25[0-5]\b|\b[2][0-4][0-9]\b|\b[0-1]?[0-9]?[0-9]\b)(\.(\b25[0-5]\b|\b[2][0-4][0-9]\b|\b[0-1]?[0-9]?[0-9]\b)){3}))(?::[\d]{1,5})?(?:(?:(?:\/(?:[-\w~!$+|.,=]|%[a-f\d]{2})+)+|\/)+|\?|#)?(?:(?:\?(?:[-\w~!$+|.,*:]|%[a-f\d{2}])+=?(?:[-\w~!$+|.,*:=]|%[a-f\d]{2})*)(?:&(?:[-\w~!$+|.,*:]|%[a-f\d{2}])+=?(?:[-\w~!$+|.,*:=]|%[a-f\d]{2})*)*)*(?:#(?:[-\w~!$ |\/.,*:;=]|%[a-f\d]{2})*)?$/i)) { throw 'Invalid URL'; } return value; }, cli.getOptError('a ' + identifier, identifier.toUpperCase())); } cli.getEmail = function (default_val) { return cli.getValue(default_val, function (value) { if (!value.match(/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/)) { throw 'Invalid email'; } return value; }, cli.getOptError('an email', 'EMAIL')); } cli.getIp = function (default_val) { return cli.getValue(default_val, function (value) { if (!value.match(/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/)) { throw 'Invalid IP'; } return value; }, cli.getOptError('an IP', 'IP')); } cli.getPath = function (default_val, identifier) { identifier = identifier || 'path'; return cli.getValue(default_val, function (value) { if (value.match(/[?*:;{}]/)) { throw 'Invalid path'; } return value; }, cli.getOptError('a ' + identifier, identifier.toUpperCase())); } cli.getArrayValue = function (arr, default_val) { return cli.getValue(default_val, function (value) { if (arr.indexOf(value) === -1) { throw 'Unexpected value'; } return value; }, cli.getOptError('either [' + arr.join('|') + ']', 'VALUE')); } /** * Gets all data from STDIN (with optional encoding) and sends it to callback. * * @param {String} encoding (optional - default is 'utf8') * @param {Function} callback * @api public */ cli.withStdin = function (encoding, callback) { if (typeof encoding === 'function') { callback = encoding; encoding = 'utf8'; } var stream = process.openStdin(), data = ''; stream.setEncoding(encoding); stream.on('data', function (chunk) { data += chunk; }); stream.on('end', function () { callback.apply(cli, [data]); }); }; /** * Gets all data from STDIN, splits the data into lines and sends it * to callback (callback isn't called until all of STDIN is read. To * process each line as it's received, see the method below * * @param {Function} callback * @api public */ cli.withStdinLines = function (callback) { cli.withStdin(function (data) { var sep = data.indexOf('\r\n') !== -1 ? '\r\n' : '\n'; callback.apply(cli, [data.split(sep), sep]); }); }; /** * Asynchronously reads a file line by line. When a line is received, * callback is called with (line, sep) - when EOF is reached, callback * receives (null, null, true) * * @param {String} file (optional - default is 'stdin') * @param {String} encoding (optional - default is 'utf8') * @param {Function} callback (line, sep, eof) * @api public */ cli.withInput = function (file, encoding, callback) { if (typeof encoding === 'function') { callback = encoding; encoding = 'utf8'; } else if (typeof file === 'function') { callback = file; encoding = 'utf8'; file = 'stdin'; } if (file === 'stdin') { file = process.openStdin(); } else { try { file = cli.native.fs.createReadStream(file); file.on('error', cli.fatal); } catch (e) { return cli.fatal(e); } } file.setEncoding(encoding); var lines = [], data = '', eof, sep; file.on('data', function (chunk) { if (eof) return; data += chunk; if (!sep) { if (data.indexOf('\r\n') !== -1) { sep = '\r\n'; } else if (data.indexOf('\n') !== -1) { sep = '\n'; } else { last_line = data; return; } } lines = data.split(sep); data = eof ? null : lines.pop(); while (lines.length) { callback.apply(cli, [lines.shift(), sep, false]); } }); file.on('end', function () { eof = true; if (data.length) { callback.apply(cli, [data, sep || '', false]); } callback.apply(cli, [null, null, true]); }); }; /** * A method for creating and controlling a daemon. * * `arg` can be: * start = daemonizes the process * stop = stops the daemon if it is running * restart = alias for stop -> start * pid = outputs the daemon's PID if it is running * log = outputs the daemon's log file (stdout + stderr) * * @param {String} arg (Optional - default is 'start') * @param {Function} callback * @api public */ cli.daemon = function (arg, callback) { if (typeof daemon === 'undefined') { cli.fatal('Daemon is not initialized'); } if (typeof arg === 'function') { callback = arg; arg = 'start'; } var lock_file = '/tmp/' + cli.app + '.pid', log_file = '/tmp/' + cli.app + '.log'; var start = function () { daemon.daemonize(log_file, lock_file, function (err) { if (err) return cli.error('Error starting daemon: ' + err); callback(); }); }; var stop = function () { try { cli.native.fs.readFileSync(lock_file); } catch (e) { return cli.error('Daemon is not running'); }; daemon.kill(lock_file, function (err, pid) { if (err && err.errno === 3) { return cli.error('Daemon is not running'); } else if (err) { return cli.error('Error stopping daemon: ' + err.errno); } cli.ok('Successfully stopped daemon with pid: ' + pid); }); }; switch(arg) { case 'stop': stop(); break; case 'restart': daemon.stop(lock_file, function () { start(); }); break; case 'log': try { cli.native.fs.createReadStream(log_file, {encoding: 'utf8'}).pipe(process.stdout); } catch (e) { return cli.error('No daemon log file'); }; break; case 'pid': try { var pid = cli.native.fs.readFileSync(lock_file, 'utf8'); cli.native.fs.statSync('/proc/' + pid); cli.info(pid); } catch (e) { return cli.error('Daemon is not running'); }; break; default: start(); break; } } /** * The main entry method. Calling cli.main() is only necessary in * scripts that have daemon support enabled. `callback` receives (args, options) * * @param {Function} callback * @api public */ cli.main = function (callback) { var after = function () { callback.apply(cli, [cli.args, cli.options]); }; if (enable.daemon && daemon_arg) { cli.daemon(daemon_arg, after); } else { after(); } } /** * Bind creationix's stack (https://github.com/creationix/stack). * * Create a simple middleware stack by calling: * * cli.createServer(middleware).listen(port); * * @return {Server} server * @api public */ cli.createServer = function(/*layers*/) { var defaultStackErrorHandler = function (req, res, err) { if (err) { console.error(err.stack); res.writeHead(500, {"Content-Type": "text/plain"}); return res.end(err.stack + "\n"); } res.writeHead(404, {"Content-Type": "text/plain"}); res.end("Not Found\n"); }; var handle = error = defaultStackErrorHandler, layers = Array.prototype.slice.call(arguments); //Allow createServer(a,b,c) and createServer([a,b,c]) if (layers.length && layers[0] instanceof Array) { layers = layers[0]; } layers.reverse().forEach(function (layer) { var child = handle; handle = function (req, res) { try { layer(req, res, function (err) { if (err) return error(req, res, err); child(req, res); }); } catch (err) { error(req, res, err); } }; }); return cli.native.http.createServer(handle); }; /** * A wrapper for child_process.exec(). * * If the child_process exits successfully, `callback` receives an array of * stdout lines. The current process exits if the child process has an error * and `errback` isn't defined. * * @param {String} cmd * @param {Function} callback (optional) * @param {Function} errback (optional) * @api public */ cli.exec = function (cmd, callback, errback) { cli.native.child_process.exec(cmd, function (err, stdout, stderr) { err = err || stderr; if (err) { if (errback) { return errback(err); } return cli.fatal('exec() failed\n' + err); } if (callback) { callback(stdout.split('\n')); } }); }; /** * Helper method for outputting a progress bar to the console. * * @param {Number} progress (0 <= progress <= 1) * @api public */ var last_progress_call, progress_len = 74; cli.progress = function (progress) { if (progress < 0 || progress > 1 || isNaN(progress)) return; var now = (new Date()).getTime(); if (last_progress_call && (now - last_progress_call) < 100 && progress !== 1) { return; //Throttle progress calls } last_progress_call = now; var barLength = Math.floor(progress_len * progress), str = ''; if (barLength == 0 && progress > 0) { barLength = 1; } for (var i = 1; i <= progress_len; i++) { str += i <= barLength ? '#' : ' '; } cli.native.util.print('[' + str + '] ' + Math.floor(progress * 100) + '%' + (progress === 1 ? '\n' : '\u000D')); }; /** * Helper method for outputting a spinner to the console. * * @param {String|Boolean} prefix (optional) * @api public */ var spinnerInterval; cli.spinner = function (prefix, end) { if (end) { cli.native.util.print('\u000D' + prefix); return clearInterval(spinnerInterval); } prefix = prefix + ' ' || ''; var spinner = ['-','\\','|','/'], i = 0, l = spinner.length; spinnerInterval = setInterval(function () { cli.native.util.print('\u000D' + prefix + spinner[i++]); if (i == l) i = 0; }, 200); }; lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/000077500000000000000000000000001177713054400300045ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/cat.js000077500000000000000000000005421177713054400311150ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli'); var output_file = function (file) { cli.withInput(file, function (line, sep, eof) { if (!eof) { cli.output(line + sep); } else if (cli.args.length) { output_file(cli.args.shift()); } }); }; if (cli.args.length) { output_file(cli.args.shift()); }lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/command.js000077500000000000000000000007631177713054400317710ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli'); //The second (optional) argument of cli.parse() is a command list //Type `./command.js --help` for usage info //cli enables auto-completion of commands (similiar to npm), e.g. all of //the following are equivalent and result in "Command is: install": // $ ./command.js install // $ ./command.js inst // $ ./command.js i cli.parse(null, ['install', 'test', 'edit', 'remove', 'uninstall', 'ls']); console.log('Command is: ' + cli.command); lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/echo.js000077500000000000000000000033701177713054400312660ustar00rootroot00000000000000#!/usr/bin/env node /* All of the following commands are equivalent and write `foo\tbar foo` to out.txt $ ./echo.js -n -e --output=out.txt "foo\tbar" "foo" $ ./echo.js --newline --escape --output "out.txt" "foo\tbar" "foo" $ ./echo.js -ne --output=out.txt "foo\tbar" "foo" $ ./echo.js -en --output="out.txt" "foo\tbar" "foo" */ var cli = require('cli'); cli.parse({ newline: ['n', 'Do not output the trailing newline'], escape: ['e', 'Enable interpretation of backslash escapes'], separator: ['s', 'Separate arguments using this value', 'string', ' '], output: [false, 'Write to FILE rather than the console', 'file'] }); cli.main(function (args, options) { var output = '', i, j, l, output_stream; if (this.argc) { if (options.escape) { var replace = {'\\n':'\n','\\r':'\r','\\t':'\t','\\e':'\e','\\v':'\v','\\f':'\f','\\c':'\c','\\b':'\b','\\a':'\a','\\\\':'\\'}; var escape = function (str) { string += ''; for (j in replace) { string = string.replace(i, replace[i]); } return string; } for (i = 0, l = this.argc; i < l; i++) { args[i] = escape(args[i]); } options.separator = escape(options.separator); } output += args.join(options.separator); } if (!options.newline) { output += '\n'; } try { if (options.output) { output_stream = this.native.fs.createWriteStream(options.output) } else { output_stream = process.stdout; } output_stream.write(output); } catch (e) { this.fatal('Could not write to output stream'); } });lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/glob.js000077500000000000000000000002421177713054400312660ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli').enable('glob'); //Running `./glob.js *.js` will output a list of .js files in this directory console.log(cli.args);lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/long_desc.js000077500000000000000000000016651177713054400323120ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('../'); //You can (optionally) boost the width of output with: //cli.width = 120; //You can also adjust the width of the options/command definitions //cli.option_width = 25; var long_desc = 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s ' + 'standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make' + ' a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, ' + 'remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing ' + 'Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions' + ' of Lorem Ipsum.'; cli.parse({ foo: ['f', long_desc] }); lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/progress.js000077500000000000000000000003371177713054400322140ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli'); var i = 0, interval = setInterval(function () { cli.progress(++i / 100); if (i === 100) { clearInterval(interval); cli.ok('Finished!'); } }, 50);lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/sort.js000077500000000000000000000006541177713054400313410ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli'); var options = cli.parse({ numeric: ['n', 'Compare using a numeric sort'], reverse: ['r', 'Reverse the results'] }); cli.withStdinLines(function (lines, newline) { lines.sort(!options.numeric ? null : function (a, b) { return parseInt(a) > parseInt(b); }); if (options.reverse) { lines.reverse(); } this.output(lines.join(newline)); });lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/spinner.js000077500000000000000000000002511177713054400320210ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli'); cli.spinner('Working..'); setTimeout(function () { cli.spinner('Working.. done!', true); //End the spinner }, 3000);lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/static.coffee000077500000000000000000000012601177713054400324460ustar00rootroot00000000000000#!/usr/bin/env coffee cli = require 'cli' cli.enable('daemon','status') .setUsage('static.coffee [OPTIONS]') cli.parse { log: ['l', 'Enable logging'] port: ['p', 'Listen on this port', 'number', 8080] serve: [false, 'Serve static files from PATH', 'path', './public'] } middleware = [] cli.main (args, options) -> if options.log @debug 'Enabling logging' middleware.push require('creationix/log')() @debug 'Serving files from ' + options.serve middleware.push require('creationix/static')('/', options.serve, 'index.html') server = @createServer(middleware).listen options.port @ok 'Listening on port ' + options.portlets_code_javascript-episode2/node_modules/jshint/node_modules/cli/examples/static.js000077500000000000000000000013221177713054400316320ustar00rootroot00000000000000#!/usr/bin/env node var cli = require('cli').enable('status', 'daemon'); cli.parse({ log: ['l', 'Enable logging'], port: ['p', 'Listen on this port', 'number', 8080], serve: [false, 'Serve static files from PATH', 'path', './public'] }); cli.main(function (args, options) { var server, middleware = []; if (options.log) { this.debug('Enabling logging'); middleware.push(require('creationix/log')()); } this.debug('Serving files from ' + options.serve); middleware.push(require('creationix/static')('/', options.serve, 'index.html')); server = this.createServer(middleware).listen(options.port); this.ok('Listening on port ' + options.port); });lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/index.js000066400000000000000000000000431177713054400276300ustar00rootroot00000000000000module.exports = require('./cli'); lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/000077500000000000000000000000001177713054400306435ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/000077500000000000000000000000001177713054400315665ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/.npmignore000066400000000000000000000000171177713054400335630ustar00rootroot00000000000000.*.swp test/a/ lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/.travis.yml000066400000000000000000000000531177713054400336750ustar00rootroot00000000000000language: node_js node_js: - 0.6 - 0.7 lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/LICENCE000066400000000000000000000024461177713054400325610ustar00rootroot00000000000000Copyright (c) Isaac Z. Schlueter All rights reserved. The BSD License Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/README.md000066400000000000000000000215221177713054400330470ustar00rootroot00000000000000# Glob This is a glob implementation in JavaScript. It uses the `minimatch` library to do its matching. ## Attention: node-glob users! The API has changed dramatically between 2.x and 3.x. This library is now 100% JavaScript, and the integer flags have been replaced with an options object. Also, there's an event emitter class, proper tests, and all the other things you've come to expect from node modules. And best of all, no compilation! ## Usage ```javascript var glob = require("glob") // options is optional glob("**/*.js", options, function (er, files) { // files is an array of filenames. // If the `nonull` option is set, and nothing // was found, then files is ["**/*.js"] // er is an error object or null. }) ``` ## Features Please see the [minimatch documentation](https://github.com/isaacs/minimatch) for more details. Supports these glob features: * Brace Expansion * Extended glob matching * "Globstar" `**` matching See: * `man sh` * `man bash` * `man 3 fnmatch` * `man 5 gitignore` * [minimatch documentation](https://github.com/isaacs/minimatch) ## glob(pattern, [options], cb) * `pattern` {String} Pattern to be matched * `options` {Object} * `cb` {Function} * `err` {Error | null} * `matches` {Array} filenames found matching the pattern Perform an asynchronous glob search. ## glob.sync(pattern, [options] * `pattern` {String} Pattern to be matched * `options` {Object} * return: {Array} filenames found matching the pattern Perform a synchronous glob search. ## Class: glob.Glob Create a Glob object by instanting the `glob.Glob` class. ```javascript var Glob = require("glob").Glob var mg = new Glob(pattern, options, cb) ``` It's an EventEmitter, and starts walking the filesystem to find matches immediately. ### new glob.Glob(pattern, [options], [cb]) * `pattern` {String} pattern to search for * `options` {Object} * `cb` {Function} Called when an error occurs, or matches are found * `err` {Error | null} * `matches` {Array} filenames found matching the pattern Note that if the `sync` flag is set in the options, then matches will be immediately available on the `g.found` member. ### Properties * `minimatch` The minimatch object that the glob uses. * `options` The options object passed in. * `error` The error encountered. When an error is encountered, the glob object is in an undefined state, and should be discarded. * `aborted` Boolean which is set to true when calling `abort()`. There is no way at this time to continue a glob search after aborting, but you can re-use the statCache to avoid having to duplicate syscalls. ### Events * `end` When the matching is finished, this is emitted with all the matches found. If the `nonull` option is set, and no match was found, then the `matches` list contains the original pattern. The matches are sorted, unless the `nosort` flag is set. * `match` Every time a match is found, this is emitted with the matched. * `error` Emitted when an unexpected error is encountered, or whenever any fs error occurs if `options.strict` is set. * `abort` When `abort()` is called, this event is raised. ### Methods * `abort` Stop the search. ### Options All the options that can be passed to Minimatch can also be passed to Glob to change pattern matching behavior. Also, some have been added, or have glob-specific ramifications. All options are false by default, unless otherwise noted. All options are added to the glob object, as well. * `cwd` The current working directory in which to search. Defaults to `process.cwd()`. * `root` The place where patterns starting with `/` will be mounted onto. Defaults to `path.resolve(options.cwd, "/")` (`/` on Unix systems, and `C:\` or some such on Windows.) * `nomount` By default, a pattern starting with a forward-slash will be "mounted" onto the root setting, so that a valid filesystem path is returned. Set this flag to disable that behavior. * `mark` Add a `/` character to directory matches. Note that this requires additional stat calls. * `nosort` Don't sort the results. * `stat` Set to true to stat *all* results. This reduces performance somewhat, and is completely unnecessary, unless `readdir` is presumed to be an untrustworthy indicator of file existence. It will cause ELOOP to be triggered one level sooner in the case of cyclical symbolic links. * `silent` When an unusual error is encountered when attempting to read a directory, a warning will be printed to stderr. Set the `silent` option to true to suppress these warnings. * `strict` When an unusual error is encountered when attempting to read a directory, the process will just continue on in search of other matches. Set the `strict` option to raise an error in these cases. * `statCache` A cache of results of filesystem information, to prevent unnecessary stat calls. While it should not normally be necessary to set this, you may pass the statCache from one glob() call to the options object of another, if you know that the filesystem will not change between calls. (See "Race Conditions" below.) * `sync` Perform a synchronous glob search. * `nounique` In some cases, brace-expanded patterns can result in the same file showing up multiple times in the result set. By default, this implementation prevents duplicates in the result set. Set this flag to disable that behavior. * `nonull` Set to never return an empty set, instead returning a set containing the pattern itself. This is the default in glob(3). * `nocase` Perform a case-insensitive match. Note that case-insensitive filesystems will sometimes result in glob returning results that are case-insensitively matched anyway, since readdir and stat will not raise an error. * `debug` Set to enable debug logging in minimatch and glob. * `globDebug` Set to enable debug logging in glob, but not minimatch. ## Comparisons to other fnmatch/glob implementations While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between node-glob and other implementations, and are intentional. If the pattern starts with a `!` character, then it is negated. Set the `nonegate` flag to suppress this behavior, and treat leading `!` characters normally. This is perhaps relevant if you wish to start the pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` characters at the start of a pattern will negate the pattern multiple times. If a pattern starts with `#`, then it is treated as a comment, and will not match anything. Use `\#` to match a literal `#` at the start of a line, or set the `nocomment` flag to suppress this behavior. The double-star character `**` is supported by default, unless the `noglobstar` flag is set. This is supported in the manner of bsdglob and bash 4.1, where `**` only has special significance if it is the only thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but `a/**b` will not. **Note that this is different from the way that `**` is handled by ruby's `Dir` class.** If an escaped pattern has no matches, and the `nonull` flag is set, then glob returns the pattern as-provided, rather than interpreting the character escapes. For example, `glob.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than `"*a?"`. This is akin to setting the `nullglob` option in bash, except that it does not resolve escaped pattern characters. If brace expansion is not disabled, then it is performed before any other interpretation of the glob pattern. Thus, a pattern like `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are checked for validity. Since those two are valid, matching proceeds. ## Windows **Please only use forward-slashes in glob expressions.** Though windows uses either `/` or `\` as its path separator, only `/` characters are used by this glob implementation. You must use forward-slashes **only** in glob expressions. Back-slashes will always be interpreted as escape characters, not path separators. Results from absolute patterns such as `/foo/*` are mounted onto the root setting using `path.join`. On windows, this will by default result in `/foo/*` matching `C:\foo\bar.txt`. ## Race Conditions Glob searching, by its very nature, is susceptible to race conditions, since it relies on directory walking and such. As a result, it is possible that a file that exists when glob looks for it may have been deleted or modified by the time it returns the result. As part of its internal implementation, this program caches all stat and readdir calls that it makes, in order to cut down on system overhead. However, this also makes it even more susceptible to races, especially if the statCache object is reused between glob calls. Users are thus advised not to use a glob result as a guarantee of filesystem state in the face of rapid changes. For the vast majority of operations, this is never a problem. lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/examples/000077500000000000000000000000001177713054400334045ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/examples/g.js000066400000000000000000000003441177713054400341710ustar00rootroot00000000000000var Glob = require("../").Glob var pattern = "test/a/**/[cg]/../[cg]" console.log(pattern) var mg = new Glob(pattern, {mark: true, sync:true}, function (er, matches) { console.log("matches", matches) }) console.log("after") usr-local.js000066400000000000000000000003321177713054400355620ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/examplesvar Glob = require("../").Glob var pattern = "{./*/*,/*,/usr/local/*}" console.log(pattern) var mg = new Glob(pattern, {mark: true}, function (er, matches) { console.log("matches", matches) }) console.log("after") lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/glob.js000066400000000000000000000401511177713054400330500ustar00rootroot00000000000000// Approach: // // 1. Get the minimatch set // 2. For each pattern in the set, PROCESS(pattern) // 3. Store matches per-set, then uniq them // // PROCESS(pattern) // Get the first [n] items from pattern that are all strings // Join these together. This is PREFIX. // If there is no more remaining, then stat(PREFIX) and // add to matches if it succeeds. END. // readdir(PREFIX) as ENTRIES // If fails, END // If pattern[n] is GLOBSTAR // // handle the case where the globstar match is empty // // by pruning it out, and testing the resulting pattern // PROCESS(pattern[0..n] + pattern[n+1 .. $]) // // handle other cases. // for ENTRY in ENTRIES (not dotfiles) // // attach globstar + tail onto the entry // PROCESS(pattern[0..n] + ENTRY + pattern[n .. $]) // // else // not globstar // for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot) // Test ENTRY against pattern[n+1] // If fails, continue // If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $]) // // Caveat: // Cache all stats and readdirs results to minimize syscall. Since all // we ever care about is existence and directory-ness, we can just keep // `true` for files, and [children,...] for directories, or `false` for // things that don't exist. module.exports = glob var fs = require("graceful-fs") , minimatch = require("minimatch") , Minimatch = minimatch.Minimatch , inherits = require("inherits") , EE = require("events").EventEmitter , path = require("path") , isDir = {} , assert = require("assert").ok , EOF = {} function glob (pattern, options, cb) { if (typeof options === "function") cb = options, options = {} if (!options) options = {} if (typeof options === "number") { deprecated() return } var g = new Glob(pattern, options, cb) return g.sync ? g.found : g } glob.fnmatch = deprecated function deprecated () { throw new Error("glob's interface has changed. Please see the docs.") } glob.sync = globSync function globSync (pattern, options) { if (typeof options === "number") { deprecated() return } options = options || {} options.sync = true return glob(pattern, options) } glob.Glob = Glob inherits(Glob, EE) function Glob (pattern, options, cb) { if (!(this instanceof Glob)) { return new Glob(pattern, options, cb) } if (typeof cb === "function") { this.on("error", cb) this.on("end", function (matches) { // console.error("cb with matches", matches) cb(null, matches) }) } options = options || {} this.maxDepth = options.maxDepth || 1000 this.maxLength = options.maxLength || Infinity this.statCache = options.statCache || {} this.changedCwd = false var cwd = process.cwd() if (!options.hasOwnProperty("cwd")) this.cwd = cwd else { this.cwd = options.cwd this.changedCwd = path.resolve(options.cwd) !== cwd } this.root = options.root || path.resolve(this.cwd, "/") this.root = path.resolve(this.root) this.nomount = !!options.nomount if (!pattern) { throw new Error("must provide pattern") } // base-matching: just use globstar for that. if (options.matchBase && -1 === pattern.indexOf("/")) { if (options.noglobstar) { throw new Error("base matching requires globstar") } pattern = "**/" + pattern } this.dot = !!options.dot this.mark = !!options.mark this.sync = !!options.sync this.nounique = !!options.nounique this.nonull = !!options.nonull this.nosort = !!options.nosort this.nocase = !!options.nocase this.stat = !!options.stat this.debug = !!options.debug || !!options.globDebug this.silent = !!options.silent var mm = this.minimatch = new Minimatch(pattern, options) this.options = mm.options pattern = this.pattern = mm.pattern this.error = null this.aborted = false EE.call(this) // process each pattern in the minimatch set var n = this.minimatch.set.length // The matches are stored as {: true,...} so that // duplicates are automagically pruned. // Later, we do an Object.keys() on these. // Keep them as a list so we can fill in when nonull is set. this.matches = new Array(n) this.minimatch.set.forEach(iterator.bind(this)) function iterator (pattern, i, set) { this._process(pattern, 0, i, function (er) { if (er) this.emit("error", er) if (-- n <= 0) this._finish() }) } } Glob.prototype._finish = function () { assert(this instanceof Glob) var nou = this.nounique , all = nou ? [] : {} for (var i = 0, l = this.matches.length; i < l; i ++) { var matches = this.matches[i] if (this.debug) console.error("matches[%d] =", i, matches) // do like the shell, and spit out the literal glob if (!matches) { if (this.nonull) { var literal = this.minimatch.globSet[i] if (nou) all.push(literal) else nou[literal] = true } } else { // had matches var m = Object.keys(matches) if (nou) all.push.apply(all, m) else m.forEach(function (m) { all[m] = true }) } } if (!nou) all = Object.keys(all) if (!this.nosort) { all = all.sort(this.nocase ? alphasorti : alphasort) } if (this.mark) { // at *some* point we statted all of these all = all.map(function (m) { var sc = this.statCache[m] if (!sc) return m if (m.slice(-1) !== "/" && (Array.isArray(sc) || sc === 2)) { return m + "/" } if (m.slice(-1) === "/") { return m.replace(/\/$/, "") } return m }, this) } if (this.debug) console.error("emitting end", all) EOF = this.found = all this.emitMatch(EOF) } function alphasorti (a, b) { a = a.toLowerCase() b = b.toLowerCase() return alphasort(a, b) } function alphasort (a, b) { return a > b ? 1 : a < b ? -1 : 0 } Glob.prototype.abort = function () { this.aborted = true this.emit("abort") } Glob.prototype.pause = function () { if (this.paused) return if (this.sync) this.emit("error", new Error("Can't pause/resume sync glob")) this.paused = true this.emit("pause") } Glob.prototype.resume = function () { if (!this.paused) return if (this.sync) this.emit("error", new Error("Can't pause/resume sync glob")) this.paused = false this.emit("resume") } Glob.prototype.emitMatch = function (m) { if (!this.paused) { this.emit(m === EOF ? "end" : "match", m) return } if (!this._emitQueue) { this._emitQueue = [] this.once("resume", function () { var q = this._emitQueue this._emitQueue = null q.forEach(function (m) { this.emitMatch(m) }, this) }) } this._emitQueue.push(m) //this.once("resume", this.emitMatch.bind(this, m)) } Glob.prototype._process = function (pattern, depth, index, cb_) { assert(this instanceof Glob) var cb = function cb (er, res) { assert(this instanceof Glob) if (this.paused) { if (!this._processQueue) { this._processQueue = [] this.once("resume", function () { var q = this._processQueue this._processQueue = null q.forEach(function (cb) { cb() }) }) } this._processQueue.push(cb_.bind(this, er, res)) } else { cb_.call(this, er, res) } }.bind(this) if (this.aborted) return cb() if (depth > this.maxDepth) return cb() // Get the first [n] parts of pattern that are all strings. var n = 0 while (typeof pattern[n] === "string") { n ++ } // now n is the index of the first one that is *not* a string. // see if there's anything else var prefix switch (n) { // if not, then this is rather simple case pattern.length: prefix = pattern.join("/") this._stat(prefix, function (exists, isDir) { // either it's there, or it isn't. // nothing more to do, either way. if (exists) { if (prefix.charAt(0) === "/" && !this.nomount) { prefix = path.join(this.root, prefix) } this.matches[index] = this.matches[index] || {} this.matches[index][prefix] = true this.emitMatch(prefix) } return cb() }) return case 0: // pattern *starts* with some non-trivial item. // going to readdir(cwd), but not include the prefix in matches. prefix = null break default: // pattern has some string bits in the front. // whatever it starts with, whether that's "absolute" like /foo/bar, // or "relative" like "../baz" prefix = pattern.slice(0, n) prefix = prefix.join("/") break } // get the list of entries. var read if (prefix === null) read = "." else if (isAbsolute(prefix)) { read = prefix = path.join("/", prefix) if (this.debug) console.error('absolute: ', prefix, this.root, pattern) } else read = prefix if (this.debug) console.error('readdir(%j)', read, this.cwd, this.root) return this._readdir(read, function (er, entries) { if (er) { // not a directory! // this means that, whatever else comes after this, it can never match return cb() } // globstar is special if (pattern[n] === minimatch.GLOBSTAR) { // test without the globstar, and with every child both below // and replacing the globstar. var s = [ pattern.slice(0, n).concat(pattern.slice(n + 1)) ] entries.forEach(function (e) { if (e.charAt(0) === "." && !this.dot) return // instead of the globstar s.push(pattern.slice(0, n).concat(e).concat(pattern.slice(n + 1))) // below the globstar s.push(pattern.slice(0, n).concat(e).concat(pattern.slice(n))) }, this) // now asyncForEach over this var l = s.length , errState = null s.forEach(function (gsPattern) { this._process(gsPattern, depth + 1, index, function (er) { if (errState) return if (er) return cb(errState = er) if (--l <= 0) return cb() }) }, this) return } // not a globstar // It will only match dot entries if it starts with a dot, or if // dot is set. Stuff like @(.foo|.bar) isn't allowed. var pn = pattern[n] if (typeof pn === "string") { var found = entries.indexOf(pn) !== -1 entries = found ? entries[pn] : [] } else { var rawGlob = pattern[n]._glob , dotOk = this.dot || rawGlob.charAt(0) === "." entries = entries.filter(function (e) { return (e.charAt(0) !== "." || dotOk) && (typeof pattern[n] === "string" && e === pattern[n] || e.match(pattern[n])) }) } // If n === pattern.length - 1, then there's no need for the extra stat // *unless* the user has specified "mark" or "stat" explicitly. // We know that they exist, since the readdir returned them. if (n === pattern.length - 1 && !this.mark && !this.stat) { entries.forEach(function (e) { if (prefix) { if (prefix !== "/") e = prefix + "/" + e else e = prefix + e } if (e.charAt(0) === "/" && !this.nomount) { e = path.join(this.root, e) } this.matches[index] = this.matches[index] || {} this.matches[index][e] = true this.emitMatch(e) }, this) return cb.call(this) } // now test all the remaining entries as stand-ins for that part // of the pattern. var l = entries.length , errState = null if (l === 0) return cb() // no matches possible entries.forEach(function (e) { var p = pattern.slice(0, n).concat(e).concat(pattern.slice(n + 1)) this._process(p, depth + 1, index, function (er) { if (errState) return if (er) return cb(errState = er) if (--l === 0) return cb.call(this) }) }, this) }) } Glob.prototype._stat = function (f, cb) { assert(this instanceof Glob) var abs = f if (f.charAt(0) === "/") { abs = path.join(this.root, f) } else if (this.changedCwd) { abs = path.resolve(this.cwd, f) } if (this.debug) console.error('stat', [this.cwd, f, '=', abs]) if (f.length > this.maxLength) { var er = new Error("Path name too long") er.code = "ENAMETOOLONG" er.path = f return this._afterStat(f, abs, cb, er) } if (this.statCache.hasOwnProperty(f)) { var exists = this.statCache[f] , isDir = exists && (Array.isArray(exists) || exists === 2) if (this.sync) return cb.call(this, !!exists, isDir) return process.nextTick(cb.bind(this, !!exists, isDir)) } if (this.sync) { var er, stat try { stat = fs.statSync(abs) } catch (e) { er = e } this._afterStat(f, abs, cb, er, stat) } else { fs.stat(abs, this._afterStat.bind(this, f, abs, cb)) } } Glob.prototype._afterStat = function (f, abs, cb, er, stat) { var exists assert(this instanceof Glob) if (er || !stat) { exists = false } else { exists = stat.isDirectory() ? 2 : 1 } this.statCache[f] = this.statCache[f] || exists cb.call(this, !!exists, exists === 2) } Glob.prototype._readdir = function (f, cb) { assert(this instanceof Glob) var abs = f if (f.charAt(0) === "/") { abs = path.join(this.root, f) } else if (isAbsolute(f)) { abs = f } else if (this.changedCwd) { abs = path.resolve(this.cwd, f) } if (this.debug) console.error('readdir', [this.cwd, f, abs]) if (f.length > this.maxLength) { var er = new Error("Path name too long") er.code = "ENAMETOOLONG" er.path = f return this._afterReaddir(f, abs, cb, er) } if (this.statCache.hasOwnProperty(f)) { var c = this.statCache[f] if (Array.isArray(c)) { if (this.sync) return cb.call(this, null, c) return process.nextTick(cb.bind(this, null, c)) } if (!c || c === 1) { // either ENOENT or ENOTDIR var code = c ? "ENOTDIR" : "ENOENT" , er = new Error((c ? "Not a directory" : "Not found") + ": " + f) er.path = f er.code = code if (this.debug) console.error(f, er) if (this.sync) return cb.call(this, er) return process.nextTick(cb.bind(this, er)) } // at this point, c === 2, meaning it's a dir, but we haven't // had to read it yet, or c === true, meaning it's *something* // but we don't have any idea what. Need to read it, either way. } if (this.sync) { var er, entries try { entries = fs.readdirSync(abs) } catch (e) { er = e } return this._afterReaddir(f, abs, cb, er, entries) } fs.readdir(abs, this._afterReaddir.bind(this, f, abs, cb)) } Glob.prototype._afterReaddir = function (f, abs, cb, er, entries) { assert(this instanceof Glob) if (entries && !er) { this.statCache[f] = entries // if we haven't asked to stat everything for suresies, then just // assume that everything in there exists, so we can avoid // having to stat it a second time. This also gets us one step // further into ELOOP territory. if (!this.mark && !this.stat) { entries.forEach(function (e) { if (f === "/") e = f + e else e = f + "/" + e this.statCache[e] = true }, this) } return cb.call(this, er, entries) } // now handle errors, and cache the information if (er) switch (er.code) { case "ENOTDIR": // totally normal. means it *does* exist. this.statCache[f] = 1 return cb.call(this, er) case "ENOENT": // not terribly unusual case "ELOOP": case "ENAMETOOLONG": case "UNKNOWN": this.statCache[f] = false return cb.call(this, er) default: // some unusual error. Treat as failure. this.statCache[f] = false if (this.strict) this.emit("error", er) if (!this.silent) console.error("glob error", er) return cb.call(this, er) } } var isAbsolute = process.platform === "win32" ? absWin : absUnix function absWin (p) { if (absUnix(p)) return true // pull off the device/UNC bit from a windows path. // from node's lib/path.js var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?([\\\/])?/ , result = splitDeviceRe.exec(p) , device = result[1] || '' , isUnc = device && device.charAt(1) !== ':' , isAbsolute = !!result[2] || isUnc // UNC paths are always absolute return isAbsolute } function absUnix (p) { return p.charAt(0) === "/" || p === "" } lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/000077500000000000000000000000001177713054400342435ustar00rootroot00000000000000graceful-fs/000077500000000000000000000000001177713054400363625ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules.npmignore000066400000000000000000000000161177713054400403560ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/graceful-fsnode_modules/ LICENSE000066400000000000000000000021041177713054400373640ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/graceful-fsCopyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. README.md000066400000000000000000000002701177713054400376400ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/graceful-fsJust like node's `fs` module, but it does an incremental back-off when EMFILE is encountered. Useful in asynchronous situations where one needs to try to open lots and lots of files. graceful-fs.js000066400000000000000000000153031177713054400411200ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/graceful-fs// this keeps a queue of opened file descriptors, and will make // fs operations wait until some have closed before trying to open more. var fs = require("fs") // there is such a thing as TOO graceful. if (fs.open === gracefulOpen) return var queue = [] , curOpen = 0 , constants = require("constants") exports = module.exports = fs fs.MIN_MAX_OPEN = 64 fs.MAX_OPEN = 1024 var originalOpen = fs.open , originalOpenSync = fs.openSync , originalClose = fs.close , originalCloseSync = fs.closeSync // prevent EMFILE errors function OpenReq (path, flags, mode, cb) { this.path = path this.flags = flags this.mode = mode this.cb = cb } function noop () {} fs.open = gracefulOpen function gracefulOpen (path, flags, mode, cb) { if (typeof mode === "function") cb = mode, mode = null if (typeof cb !== "function") cb = noop if (curOpen >= fs.MAX_OPEN) { queue.push(new OpenReq(path, flags, mode, cb)) setTimeout(flush) return } open(path, flags, mode, function (er, fd) { if (er && er.code === "EMFILE" && curOpen > fs.MIN_MAX_OPEN) { // that was too many. reduce max, get back in queue. // this should only happen once in a great while, and only // if the ulimit -n is set lower than 1024. fs.MAX_OPEN = curOpen - 1 return fs.open(path, flags, mode, cb) } cb(er, fd) }) } function open (path, flags, mode, cb) { cb = cb || noop curOpen ++ originalOpen.call(fs, path, flags, mode, function (er, fd) { if (er) { onclose() } cb(er, fd) }) } fs.openSync = function (path, flags, mode) { curOpen ++ return originalOpenSync.call(fs, path, flags, mode) } function onclose () { curOpen -- flush() } function flush () { while (curOpen < fs.MAX_OPEN) { var req = queue.shift() if (!req) break open(req.path, req.flags || "r", req.mode || 0777, req.cb) } if (queue.length === 0) return } fs.close = function (fd, cb) { cb = cb || noop originalClose.call(fs, fd, function (er) { onclose() cb(er) }) } fs.closeSync = function (fd) { onclose() return originalCloseSync.call(fs, fd) } // (re-)implement some things that are known busted or missing. var constants = require("constants") // lchmod, broken prior to 0.6.2 // back-port the fix here. if (constants.hasOwnProperty('O_SYMLINK') && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { fs.lchmod = function (path, mode, callback) { callback = callback || noop fs.open( path , constants.O_WRONLY | constants.O_SYMLINK , mode , function (err, fd) { if (err) { callback(err) return } // prefer to return the chmod error, if one occurs, // but still try to close, and report closing errors if they occur. fs.fchmod(fd, mode, function (err) { fs.close(fd, function(err2) { callback(err || err2) }) }) }) } fs.lchmodSync = function (path, mode) { var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode) // prefer to return the chmod error, if one occurs, // but still try to close, and report closing errors if they occur. var err, err2 try { var ret = fs.fchmodSync(fd, mode) } catch (er) { err = er } try { fs.closeSync(fd) } catch (er) { err2 = er } if (err || err2) throw (err || err2) return ret } } // lstat on windows, missing from early 0.5 versions // replacing with stat isn't quite perfect, but good enough to get by. if (process.platform === "win32" && !process.binding("fs").lstat) { fs.lstat = fs.stat fs.lstatSync = fs.statSync } // lutimes implementation, or no-op if (!fs.lutimes) { if (constants.hasOwnProperty("O_SYMLINK")) { fs.lutimes = function (path, at, mt, cb) { fs.open(path, constants.O_SYMLINK, function (er, fd) { cb = cb || noop if (er) return cb(er) fs.futimes(fd, at, mt, function (er) { fs.close(fd, function (er2) { return cb(er || er2) }) }) }) } fs.lutimesSync = function (path, at, mt) { var fd = fs.openSync(path, constants.O_SYMLINK) , err , err2 , ret try { var ret = fs.futimesSync(fd, at, mt) } catch (er) { err = er } try { fs.closeSync(fd) } catch (er) { err2 = er } if (err || err2) throw (err || err2) return ret } } else if (fs.utimensat && constants.hasOwnProperty("AT_SYMLINK_NOFOLLOW")) { // maybe utimensat will be bound soonish? fs.lutimes = function (path, at, mt, cb) { fs.utimensat(path, at, mt, constants.AT_SYMLINK_NOFOLLOW, cb) } fs.lutimesSync = function (path, at, mt) { return fs.utimensatSync(path, at, mt, constants.AT_SYMLINK_NOFOLLOW) } } else { fs.lutimes = function (_a, _b, _c, cb) { process.nextTick(cb) } fs.lutimesSync = function () {} } } // https://github.com/isaacs/node-graceful-fs/issues/4 // Chown should not fail on einval or eperm if non-root. fs.chown = chownFix(fs.chown) fs.fchown = chownFix(fs.fchown) fs.lchown = chownFix(fs.lchown) fs.chownSync = chownFixSync(fs.chownSync) fs.fchownSync = chownFixSync(fs.fchownSync) fs.lchownSync = chownFixSync(fs.lchownSync) function chownFix (orig) { if (!orig) return orig return function (target, uid, gid, cb) { return orig.call(fs, target, uid, gid, function (er, res) { if (chownErOk(er)) er = null cb(er, res) }) } } function chownFixSync (orig) { if (!orig) return orig return function (target, uid, gid) { try { return orig.call(fs, target, uid, gid) } catch (er) { if (!chownErOk(er)) throw er } } } function chownErOk (er) { // if there's no getuid, or if getuid() is something other than 0, // and the error is EINVAL or EPERM, then just ignore it. // This specific case is a silent failure in cp, install, tar, // and most other unix tools that manage permissions. // When running as root, or if other types of errors are encountered, // then it's strict. if (!er || (!process.getuid || process.getuid() !== 0) && (er.code === "EINVAL" || er.code === "EPERM")) return true } // on Windows, A/V software can lock the directory, causing this // to fail with an EACCES or EPERM if the directory contains newly // created files. Try again on failure, for up to 1 second. if (process.platform === "win32") { var rename_ = fs.rename fs.rename = function rename (from, to, cb) { var start = Date.now() rename_(from, to, function CB (er) { if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 1000) { return rename_(from, to, CB) } cb(er) }) } } package.json000066400000000000000000000012171177713054400406510ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/graceful-fs{ "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me" }, "name": "graceful-fs", "description": "fs monkey-patching to avoid EMFILE and other problems", "version": "1.1.8", "repository": { "type": "git", "url": "git://github.com/isaacs/node-graceful-fs.git" }, "main": "graceful-fs.js", "engines": { "node": ">=0.4.0" }, "devDependencies": {}, "_id": "graceful-fs@1.1.8", "dependencies": {}, "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "graceful-fs@~1.1.2" } inherits/000077500000000000000000000000001177713054400360115ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modulesREADME.md000066400000000000000000000021251177713054400372700ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/inheritsA dead simple way to do inheritance in JS. var inherits = require("inherits") function Animal () { this.alive = true } Animal.prototype.say = function (what) { console.log(what) } inherits(Dog, Animal) function Dog () { Dog.super.apply(this) } Dog.prototype.sniff = function () { this.say("sniff sniff") } Dog.prototype.bark = function () { this.say("woof woof") } inherits(Chihuahua, Dog) function Chihuahua () { Chihuahua.super.apply(this) } Chihuahua.prototype.bark = function () { this.say("yip yip") } // also works function Cat () { Cat.super.apply(this) } Cat.prototype.hiss = function () { this.say("CHSKKSS!!") } inherits(Cat, Animal, { meow: function () { this.say("miao miao") } }) Cat.prototype.purr = function () { this.say("purr purr") } var c = new Chihuahua assert(c instanceof Chihuahua) assert(c instanceof Dog) assert(c instanceof Animal) The actual function is laughably small. 10-lines small. inherits.js000066400000000000000000000015361177713054400402010ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/inheritsmodule.exports = inherits function inherits (c, p, proto) { proto = proto || {} var e = {} ;[c.prototype, proto].forEach(function (s) { Object.getOwnPropertyNames(s).forEach(function (k) { e[k] = Object.getOwnPropertyDescriptor(s, k) }) }) c.prototype = Object.create(p.prototype, e) c.super = p } //function Child () { // Child.super.call(this) // console.error([this // ,this.constructor // ,this.constructor === Child // ,this.constructor.super === Parent // ,Object.getPrototypeOf(this) === Child.prototype // ,Object.getPrototypeOf(Object.getPrototypeOf(this)) // === Parent.prototype // ,this instanceof Child // ,this instanceof Parent]) //} //function Parent () {} //inherits(Child, Parent) //new Child package.json000066400000000000000000000013221177713054400402750ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/inherits{ "name": "inherits", "description": "A tiny simple way to do classic inheritance in js", "version": "1.0.0", "keywords": [ "inheritance", "class", "klass", "oop", "object-oriented" ], "main": "./inherits.js", "repository": { "type": "git", "url": "git://github.com/isaacs/inherits.git" }, "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me/" }, "_id": "inherits@1.0.0", "dependencies": {}, "devDependencies": {}, "optionalDependencies": {}, "engines": { "node": "*" }, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "inherits@1" } minimatch/000077500000000000000000000000001177713054400361355ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules.travis.yml000066400000000000000000000000531177713054400402440ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatchlanguage: node_js node_js: - 0.4 - 0.6 LICENSE000066400000000000000000000021041177713054400371370ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatchCopyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. README.md000066400000000000000000000147741177713054400374310ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch# minimatch A minimal matching utility. [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch) This is the matching library used internally by npm. Eventually, it will replace the C binding in node-glob. It works by converting glob expressions into JavaScript `RegExp` objects. ## Usage ```javascript var minimatch = require("minimatch") minimatch("bar.foo", "*.foo") // true! minimatch("bar.foo", "*.bar") // false! ``` ## Features Supports these glob features: * Brace Expansion * Extended glob matching * "Globstar" `**` matching See: * `man sh` * `man bash` * `man 3 fnmatch` * `man 5 gitignore` ### Comparisons to other fnmatch/glob implementations While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between minimatch and other implementations, and are intentional. If the pattern starts with a `!` character, then it is negated. Set the `nonegate` flag to suppress this behavior, and treat leading `!` characters normally. This is perhaps relevant if you wish to start the pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` characters at the start of a pattern will negate the pattern multiple times. If a pattern starts with `#`, then it is treated as a comment, and will not match anything. Use `\#` to match a literal `#` at the start of a line, or set the `nocomment` flag to suppress this behavior. The double-star character `**` is supported by default, unless the `noglobstar` flag is set. This is supported in the manner of bsdglob and bash 4.1, where `**` only has special significance if it is the only thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but `a/**b` will not. **Note that this is different from the way that `**` is handled by ruby's `Dir` class.** If an escaped pattern has no matches, and the `nonull` flag is set, then minimatch.match returns the pattern as-provided, rather than interpreting the character escapes. For example, `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than `"*a?"`. This is akin to setting the `nullglob` option in bash, except that it does not resolve escaped pattern characters. If brace expansion is not disabled, then it is performed before any other interpretation of the glob pattern. Thus, a pattern like `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are checked for validity. Since those two are valid, matching proceeds. ## Minimatch Class Create a minimatch object by instanting the `minimatch.Minimatch` class. ```javascript var Minimatch = require("minimatch").Minimatch var mm = new Minimatch(pattern, options) ``` ### Properties * `pattern` The original pattern the minimatch object represents. * `options` The options supplied to the constructor. * `set` A 2-dimensional array of regexp or string expressions. Each row in the array corresponds to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For example, the pattern `{a,b/c}/d` would expand to a set of patterns like: [ [ a, d ] , [ b, c, d ] ] If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"` rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression. * `regexp` Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. * `negate` True if the pattern is negated. * `comment` True if the pattern is a comment. * `empty` True if the pattern is `""`. ### Methods * `makeRe` Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid. * `match(fname)` Return true if the filename matches the pattern, or false otherwise. * `matchOne(fileArray, patternArray, partial)` Take a `/`-split filename, and match it against a single row in the `regExpSet`. This method is mainly for internal use, but is exposed so that it can be used by a glob-walker that needs to avoid excessive filesystem calls. All other methods are internal, and will be called as necessary. ## Functions The top-level exported function has a `cache` property, which is an LRU cache set to store 100 items. So, calling these methods repeatedly with the same pattern and options will use the same Minimatch object, saving the cost of parsing it multiple times. ### minimatch(path, pattern, options) Main export. Tests a path against the pattern using the options. ```javascript var isJS = minimatch(file, "*.js", { matchBase: true }) ``` ### minimatch.filter(pattern, options) Returns a function that tests its supplied argument, suitable for use with `Array.filter`. Example: ```javascript var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})) ``` ### minimatch.match(list, pattern, options) Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself. ```javascript var javascripts = minimatch.match(fileList, "*.js", {matchBase: true})) ``` ### minimatch.makeRe(pattern, options) Make a regular expression object from the pattern. ## Options All options are `false` by default. ### debug Dump a ton of stuff to stderr. ### nobrace Do not expand `{a,b}` and `{1..3}` brace sets. ### noglobstar Disable `**` matching against multiple folder names. ### dot Allow patterns to match filenames starting with a period, even if the pattern does not explicitly have a period in that spot. Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` is set. ### noext Disable "extglob" style patterns like `+(a|b)`. ### nocase Perform a case-insensitive match. ### nonull When a match is not found by `minimatch.match`, return a list containing the pattern itself. When set, an empty list is returned if there are no matches. ### matchBase If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. ### nocomment Suppress the behavior of treating `#` at the start of a pattern as a comment. ### nonegate Suppress the behavior of treating a leading `!` character as negation. ### flipNegate Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.) minimatch.js000066400000000000000000000665351177713054400404630ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch;(function (require, exports, module, platform) { if (module) module.exports = minimatch else exports.minimatch = minimatch if (!require) { require = function (id) { switch (id) { case "path": return { basename: function (f) { f = f.split(/[\/\\]/) var e = f.pop() if (!e) e = f.pop() return e }} case "lru-cache": return function LRUCache () { // not quite an LRU, but still space-limited. var cache = {} var cnt = 0 this.set = function (k, v) { cnt ++ if (cnt >= 100) cache = {} cache[k] = v } this.get = function (k) { return cache[k] } } } } } minimatch.Minimatch = Minimatch var LRU = require("lru-cache") , cache = minimatch.cache = new LRU(100) , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} var path = require("path") // any single thing other than / // don't need to escape / when using new RegExp() , qmark = "[^/]" // * => any number of characters , star = qmark + "*?" // ** when dots are allowed. Anything goes, except .. and . // not (^ or / followed by one or two dots followed by $ or /), // followed by anything, any number of times. , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?" // not a ^ or / followed by a dot, // followed by anything, any number of times. , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?" // characters that need to be escaped in RegExp. , reSpecials = charSet("().*{}+?[]^$\\!") // "abc" -> { a:true, b:true, c:true } function charSet (s) { return s.split("").reduce(function (set, c) { set[c] = true return set }, {}) } // normalizes slashes. var slashSplit = /\/+/ minimatch.monkeyPatch = monkeyPatch function monkeyPatch () { var desc = Object.getOwnPropertyDescriptor(String.prototype, "match") var orig = desc.value desc.value = function (p) { if (p instanceof Minimatch) return p.match(this) return orig.call(this, p) } Object.defineProperty(String.prototype, desc) } minimatch.filter = filter function filter (pattern, options) { options = options || {} return function (p, i, list) { return minimatch(p, pattern, options) } } function ext (a, b) { a = a || {} b = b || {} var t = {} Object.keys(b).forEach(function (k) { t[k] = b[k] }) Object.keys(a).forEach(function (k) { t[k] = a[k] }) return t } minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return minimatch var orig = minimatch var m = function minimatch (p, pattern, options) { return orig.minimatch(p, pattern, ext(def, options)) } m.Minimatch = function Minimatch (pattern, options) { return new orig.Minimatch(pattern, ext(def, options)) } return m } Minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return Minimatch return minimatch.defaults(def).Minimatch } function minimatch (p, pattern, options) { if (typeof pattern !== "string") { throw new TypeError("glob pattern string required") } if (!options) options = {} // shortcut: comments match nothing. if (!options.nocomment && pattern.charAt(0) === "#") { return false } // "" only matches "" if (pattern.trim() === "") return p === "" return new Minimatch(pattern, options).match(p) } function Minimatch (pattern, options) { if (!(this instanceof Minimatch)) { return new Minimatch(pattern, options, cache) } if (typeof pattern !== "string") { throw new TypeError("glob pattern string required") } if (!options) options = {} pattern = pattern.trim() // lru storage. // these things aren't particularly big, but walking down the string // and turning it into a regexp can get pretty costly. var cacheKey = pattern + "\n" + Object.keys(options).filter(function (k) { return options[k] }).join(":") var cached = minimatch.cache.get(cacheKey) if (cached) return cached minimatch.cache.set(cacheKey, this) this.options = options this.set = [] this.pattern = pattern this.regexp = null this.negate = false this.comment = false this.empty = false // make the set of regexps etc. this.make() } Minimatch.prototype.make = make function make () { // don't do it more than once. if (this._made) return var pattern = this.pattern var options = this.options // empty patterns and comments match nothing. if (!options.nocomment && pattern.charAt(0) === "#") { this.comment = true return } if (!pattern) { this.empty = true return } // step 1: figure out negation, etc. this.parseNegate() // step 2: expand braces var set = this.globSet = this.braceExpand() if (options.debug) console.error(this.pattern, set) // step 3: now we have a set, so turn each one into a series of path-portion // matching patterns. // These will be regexps, except in the case of "**", which is // set to the GLOBSTAR object for globstar behavior, // and will not contain any / characters set = this.globParts = set.map(function (s) { return s.split(slashSplit) }) if (options.debug) console.error(this.pattern, set) // glob --> regexps set = set.map(function (s, si, set) { return s.map(this.parse, this) }, this) if (options.debug) console.error(this.pattern, set) // filter out everything that didn't compile properly. set = set.filter(function (s) { return -1 === s.indexOf(false) }) if (options.debug) console.error(this.pattern, set) this.set = set } Minimatch.prototype.parseNegate = parseNegate function parseNegate () { var pattern = this.pattern , negate = false , options = this.options , negateOffset = 0 if (options.nonegate) return for ( var i = 0, l = pattern.length ; i < l && pattern.charAt(i) === "!" ; i ++) { negate = !negate negateOffset ++ } if (negateOffset) this.pattern = pattern.substr(negateOffset) this.negate = negate } // Brace expansion: // a{b,c}d -> abd acd // a{b,}c -> abc ac // a{0..3}d -> a0d a1d a2d a3d // a{b,c{d,e}f}g -> abg acdfg acefg // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg // // Invalid sets are not expanded. // a{2..}b -> a{2..}b // a{b}c -> a{b}c minimatch.braceExpand = function (pattern, options) { return new Minimatch(pattern, options).braceExpand() } Minimatch.prototype.braceExpand = braceExpand function braceExpand (pattern, options) { options = options || this.options pattern = typeof pattern === "undefined" ? this.pattern : pattern if (typeof pattern === "undefined") { throw new Error("undefined pattern") } if (options.nobrace || !pattern.match(/\{.*\}/)) { // shortcut. no need to expand. return [pattern] } var escaping = false // examples and comments refer to this crazy pattern: // a{b,c{d,e},{f,g}h}x{y,z} // expected: // abxy // abxz // acdxy // acdxz // acexy // acexz // afhxy // afhxz // aghxy // aghxz // everything before the first \{ is just a prefix. // So, we pluck that off, and work with the rest, // and then prepend it to everything we find. if (pattern.charAt(0) !== "{") { // console.error(pattern) var prefix = null for (var i = 0, l = pattern.length; i < l; i ++) { var c = pattern.charAt(i) // console.error(i, c) if (c === "\\") { escaping = !escaping } else if (c === "{" && !escaping) { prefix = pattern.substr(0, i) break } } // actually no sets, all { were escaped. if (prefix === null) { // console.error("no sets") return [pattern] } var tail = braceExpand(pattern.substr(i), options) return tail.map(function (t) { return prefix + t }) } // now we have something like: // {b,c{d,e},{f,g}h}x{y,z} // walk through the set, expanding each part, until // the set ends. then, we'll expand the suffix. // If the set only has a single member, then'll put the {} back // first, handle numeric sets, since they're easier var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/) if (numset) { // console.error("numset", numset[1], numset[2]) var suf = braceExpand(pattern.substr(numset[0].length), options) , start = +numset[1] , end = +numset[2] , inc = start > end ? -1 : 1 , set = [] for (var i = start; i != (end + inc); i += inc) { // append all the suffixes for (var ii = 0, ll = suf.length; ii < ll; ii ++) { set.push(i + suf[ii]) } } return set } // ok, walk through the set // We hope, somewhat optimistically, that there // will be a } at the end. // If the closing brace isn't found, then the pattern is // interpreted as braceExpand("\\" + pattern) so that // the leading \{ will be interpreted literally. var i = 1 // skip the \{ , depth = 1 , set = [] , member = "" , sawEnd = false , escaping = false function addMember () { set.push(member) member = "" } // console.error("Entering for") FOR: for (i = 1, l = pattern.length; i < l; i ++) { var c = pattern.charAt(i) // console.error("", i, c) if (escaping) { escaping = false member += "\\" + c } else { switch (c) { case "\\": escaping = true continue case "{": depth ++ member += "{" continue case "}": depth -- // if this closes the actual set, then we're done if (depth === 0) { addMember() // pluck off the close-brace i ++ break FOR } else { member += c continue } case ",": if (depth === 1) { addMember() } else { member += c } continue default: member += c continue } // switch } // else } // for // now we've either finished the set, and the suffix is // pattern.substr(i), or we have *not* closed the set, // and need to escape the leading brace if (depth !== 0) { // console.error("didn't close", pattern) return braceExpand("\\" + pattern, options) } // x{y,z} -> ["xy", "xz"] // console.error("set", set) // console.error("suffix", pattern.substr(i)) var suf = braceExpand(pattern.substr(i), options) // ["b", "c{d,e}","{f,g}h"] -> // [["b"], ["cd", "ce"], ["fh", "gh"]] var addBraces = set.length === 1 // console.error("set pre-expanded", set) set = set.map(function (p) { return braceExpand(p, options) }) // console.error("set expanded", set) // [["b"], ["cd", "ce"], ["fh", "gh"]] -> // ["b", "cd", "ce", "fh", "gh"] set = set.reduce(function (l, r) { return l.concat(r) }) if (addBraces) { set = set.map(function (s) { return "{" + s + "}" }) } // now attach the suffixes. var ret = [] for (var i = 0, l = set.length; i < l; i ++) { for (var ii = 0, ll = suf.length; ii < ll; ii ++) { ret.push(set[i] + suf[ii]) } } return ret } // parse a component of the expanded set. // At this point, no pattern may contain "/" in it // so we're going to return a 2d array, where each entry is the full // pattern, split on '/', and then turned into a regular expression. // A regexp is made at the end which joins each array with an // escaped /, and another full one which joins each regexp with |. // // Following the lead of Bash 4.1, note that "**" only has special meaning // when it is the *only* thing in a path portion. Otherwise, any series // of * is equivalent to a single *. Globstar behavior is enabled by // default, and can be disabled by setting options.noglobstar. Minimatch.prototype.parse = parse var SUBPARSE = {} function parse (pattern, isSub) { var options = this.options // shortcuts if (!options.noglobstar && pattern === "**") return GLOBSTAR if (pattern === "") return "" var re = "" , hasMagic = false , escaping = false // ? => one single character , patternListStack = [] , plType , stateChar , inClass = false , reClassStart = -1 , classStart = -1 // . and .. never match anything that doesn't start with ., // even when options.dot is set. , patternStart = pattern.charAt(0) === "." ? "" // anything // not (start or / followed by . or .. followed by / or end) : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))" : "(?!\\.)" function clearStateChar () { if (stateChar) { // we had some state-tracking character // that wasn't consumed by this pass. switch (stateChar) { case "*": re += star hasMagic = true break case "?": re += qmark hasMagic = true break default: re += "\\"+stateChar break } stateChar = false } } for ( var i = 0, len = pattern.length, c ; (i < len) && (c = pattern.charAt(i)) ; i ++ ) { if (options.debug) { console.error("%s\t%s %s %j", pattern, i, re, c) } // skip over any that are escaped. if (escaping && reSpecials[c]) { re += "\\" + c escaping = false continue } SWITCH: switch (c) { case "/": // completely not allowed, even escaped. // Should already be path-split by now. return false case "\\": clearStateChar() escaping = true continue // the various stateChar values // for the "extglob" stuff. case "?": case "*": case "+": case "@": case "!": if (options.debug) { console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c) } // all of those are literals inside a class, except that // the glob [!a] means [^a] in regexp if (inClass) { if (c === "!" && i === classStart + 1) c = "^" re += c continue } // if we already have a stateChar, then it means // that there was something like ** or +? in there. // Handle the stateChar, then proceed with this one. clearStateChar() stateChar = c // if extglob is disabled, then +(asdf|foo) isn't a thing. // just clear the statechar *now*, rather than even diving into // the patternList stuff. if (options.noext) clearStateChar() continue case "(": if (inClass) { re += "(" continue } if (!stateChar) { re += "\\(" continue } plType = stateChar patternListStack.push({ type: plType , start: i - 1 , reStart: re.length }) // negation is (?:(?!js)[^/]*) re += stateChar === "!" ? "(?:(?!" : "(?:" stateChar = false continue case ")": if (inClass || !patternListStack.length) { re += "\\)" continue } hasMagic = true re += ")" plType = patternListStack.pop().type // negation is (?:(?!js)[^/]*) // The others are (?:) switch (plType) { case "!": re += "[^/]*?)" break case "?": case "+": case "*": re += plType case "@": break // the default anyway } continue case "|": if (inClass || !patternListStack.length || escaping) { re += "\\|" escaping = false continue } re += "|" continue // these are mostly the same in regexp and glob case "[": // swallow any state-tracking char before the [ clearStateChar() if (inClass) { re += "\\" + c continue } inClass = true classStart = i reClassStart = re.length re += c continue case "]": // a right bracket shall lose its special // meaning and represent itself in // a bracket expression if it occurs // first in the list. -- POSIX.2 2.8.3.2 if (i === classStart + 1 || !inClass) { re += "\\" + c escaping = false continue } // finish up the class. hasMagic = true inClass = false re += c continue default: // swallow any state char that wasn't consumed clearStateChar() if (escaping) { // no need escaping = false } else if (reSpecials[c] && !(c === "^" && inClass)) { re += "\\" } re += c } // switch } // for // handle the case where we left a class open. // "[abc" is valid, equivalent to "\[abc" if (inClass) { // split where the last [ was, and escape it // this is a huge pita. We now have to re-walk // the contents of the would-be class to re-translate // any characters that were passed through as-is var cs = pattern.substr(classStart + 1) , sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + "\\[" + sp[0] hasMagic = hasMagic || sp[1] } // handle the case where we had a +( thing at the *end* // of the pattern. // each pattern list stack adds 3 chars, and we need to go through // and escape any | chars that were passed through as-is for the regexp. // Go through and escape them, taking care not to double-escape any // | chars that were already escaped. var pl while (pl = patternListStack.pop()) { var tail = re.slice(pl.reStart + 3) // maybe some even number of \, then maybe 1 \, followed by a | tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) { if (!$2) { // the | isn't already escaped, so escape it. $2 = "\\" } // need to escape all those slashes *again*, without escaping the // one that we need for escaping the | character. As it works out, // escaping an even number of slashes can be done by simply repeating // it exactly after itself. That's why this trick works. // // I am sorry that you have to see this. return $1 + $1 + $2 + "|" }) // console.error("tail=%j\n %s", tail, tail) var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type hasMagic = true re = re.slice(0, pl.reStart) + t + "\\(" + tail } // handle trailing things that only matter at the very end. clearStateChar() if (escaping) { // trailing \\ re += "\\\\" } // only need to apply the nodot start if the re starts with // something that could conceivably capture a dot var addPatternStart = false switch (re.charAt(0)) { case ".": case "[": case "(": addPatternStart = true } // if the re is not "" at this point, then we need to make sure // it doesn't match against an empty path part. // Otherwise a/* will match a/, which it should not. if (re !== "" && hasMagic) re = "(?=.)" + re if (addPatternStart) re = patternStart + re // parsing just a piece of a larger pattern. if (isSub === SUBPARSE) { return [ re, hasMagic ] } // skip the regexp for non-magical patterns // unescape anything in it, though, so that it'll be // an exact match against a file etc. if (!hasMagic) { return globUnescape(pattern) } var flags = options.nocase ? "i" : "" , regExp = new RegExp("^" + re + "$", flags) regExp._glob = pattern regExp._src = re return regExp } minimatch.makeRe = function (pattern, options) { return new Minimatch(pattern, options || {}).makeRe() } Minimatch.prototype.makeRe = makeRe function makeRe () { if (this.regexp || this.regexp === false) return this.regexp // at this point, this.set is a 2d array of partial // pattern strings, or "**". // // It's better to use .match(). This function shouldn't // be used, really, but it's pretty convenient sometimes, // when you just want to work with a regex. var set = this.set if (!set.length) return this.regexp = false var options = this.options var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot , flags = options.nocase ? "i" : "" var re = set.map(function (pattern) { return pattern.map(function (p) { return (p === GLOBSTAR) ? twoStar : (typeof p === "string") ? regExpEscape(p) : p._src }).join("\\\/") }).join("|") // must match entire pattern // ending in a * or ** will make it less strict. re = "^" + re + "$" // can match anything, as long as it's not this. if (this.negate) re = "^(?!" + re + ").*$" try { return this.regexp = new RegExp(re, flags) } catch (ex) { return this.regexp = false } } minimatch.match = function (list, pattern, options) { var mm = new Minimatch(pattern, options) list = list.filter(function (f) { return mm.match(f) }) if (options.nonull && !list.length) { list.push(pattern) } return list } Minimatch.prototype.match = match function match (f, partial) { // console.error("match", f, this.pattern) // short-circuit in the case of busted things. // comments, etc. if (this.comment) return false if (this.empty) return f === "" if (f === "/" && partial) return true var options = this.options // windows: need to use /, not \ // On other platforms, \ is a valid (albeit bad) filename char. if (platform === "win32") { f = f.split("\\").join("/") } // treat the test path as a set of pathparts. f = f.split(slashSplit) if (options.debug) { console.error(this.pattern, "split", f) } // just ONE of the pattern sets in this.set needs to match // in order for it to be valid. If negating, then just one // match means that we have failed. // Either way, return on the first hit. var set = this.set // console.error(this.pattern, "set", set) for (var i = 0, l = set.length; i < l; i ++) { var pattern = set[i] var hit = this.matchOne(f, pattern, partial) if (hit) { if (options.flipNegate) return true return !this.negate } } // didn't get any hits. this is success if it's a negative // pattern, failure otherwise. if (options.flipNegate) return false return this.negate } // set partial to true to test if, for example, // "/a/b" matches the start of "/*/b/*/d" // Partial means, if you run out of file before you run // out of pattern, then that's fine, as long as all // the parts match. Minimatch.prototype.matchOne = function (file, pattern, partial) { var options = this.options if (options.debug) { console.error("matchOne", { "this": this , file: file , pattern: pattern }) } if (options.matchBase && pattern.length === 1) { file = path.basename(file.join("/")).split("/") } if (options.debug) { console.error("matchOne", file.length, pattern.length) } for ( var fi = 0 , pi = 0 , fl = file.length , pl = pattern.length ; (fi < fl) && (pi < pl) ; fi ++, pi ++ ) { if (options.debug) { console.error("matchOne loop") } var p = pattern[pi] , f = file[fi] if (options.debug) { console.error(pattern, p, f) } // should be impossible. // some invalid regexp stuff in the set. if (p === false) return false if (p === GLOBSTAR) { // "**" // a/**/b/**/c would match the following: // a/b/x/y/z/c // a/x/y/z/b/c // a/b/x/b/x/c // a/b/c // To do this, take the rest of the pattern after // the **, and see if it would match the file remainder. // If so, return success. // If not, the ** "swallows" a segment, and try again. // This is recursively awful. // a/b/x/y/z/c // - a matches a // - doublestar // - matchOne(b/x/y/z/c, b/**/c) // - b matches b // - doublestar // - matchOne(x/y/z/c, c) -> no // - matchOne(y/z/c, c) -> no // - matchOne(z/c, c) -> no // - matchOne(c, c) yes, hit var fr = fi , pr = pi + 1 if (pr === pl) { // a ** at the end will just swallow the rest. // We have found a match. // however, it will not swallow /.x, unless // options.dot is set. // . and .. are *never* matched by **, for explosively // exponential reasons. for ( ; fi < fl; fi ++) { if (file[fi] === "." || file[fi] === ".." || (!options.dot && file[fi].charAt(0) === ".")) return false } return true } // ok, let's see if we can swallow whatever we can. WHILE: while (fr < fl) { var swallowee = file[fr] if (swallowee === "." || swallowee === ".." || (!options.dot && swallowee.charAt(0) === ".")) { // console.error("dot detected!") break WHILE } // XXX remove this slice. Just pass the start index. if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { // found a match. return true } else { // ** swallows a segment, and continue. fr ++ } } // no match was found. // However, in partial mode, we can't say this is necessarily over. // If there's more *pattern* left, then if (partial) { // ran out of file // console.error("\n>>> no match, partial?", file, fr, pattern, pr) if (fr === fl) return true } return false } // something other than ** // non-magic patterns just have to match exactly // patterns with magic have been turned into regexps. var hit if (typeof p === "string") { if (options.nocase) { hit = f.toLowerCase() === p.toLowerCase() } else { hit = f === p } if (options.debug) { console.error("string match", p, f, hit) } } else { hit = f.match(p) if (options.debug) { console.error("pattern match", p, f, hit) } } if (!hit) return false } // Note: ending in / means that we'll get a final "" // at the end of the pattern. This can only match a // corresponding "" at the end of the file. // If the file ends in /, then it can only match a // a pattern that ends in /, unless the pattern just // doesn't have any more for it. But, a/b/ should *not* // match "a/b/*", even though "" matches against the // [^/]*? pattern, except in partial mode, where it might // simply not be reached yet. // However, a/b/ should still satisfy a/* // now either we fell off the end of the pattern, or we're done. if (fi === fl && pi === pl) { // ran out of pattern and filename at the same time. // an exact hit! return true } else if (fi === fl) { // ran out of file, but still had pattern left. // this is ok if we're doing the match as part of // a glob fs traversal. return partial } else if (pi === pl) { // ran out of pattern, still have file left. // this is only acceptable if we're on the very last // empty segment of a file with a trailing slash. // a/* should match a/b/ var emptyFileEnd = (fi === fl - 1) && (file[fi] === "") return emptyFileEnd } // should be unreachable. throw new Error("wtf?") } // replace stuff like \* with * function globUnescape (s) { return s.replace(/\\(.)/g, "$1") } function regExpEscape (s) { return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") } })( typeof require === "function" ? require : null, this, typeof module === "object" ? module : null, typeof process === "object" ? process.platform : "win32" ) node_modules/000077500000000000000000000000001177713054400406125ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatchlru-cache/000077500000000000000000000000001177713054400424555ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules.npmignore000066400000000000000000000000161177713054400444510ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/node_modules AUTHORS000066400000000000000000000003041177713054400435220ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache# Authors, sorted by whether or not they are me Isaac Z. Schlueter Carlos Brito Lage Marko Mikulicic Trent Mick LICENSE000066400000000000000000000021041177713054400434570ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cacheCopyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. README.md000066400000000000000000000013621177713054400437360ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache# lru cache A cache object that deletes the least-recently-used items. Usage: var LRU = require("lru-cache") , cache = LRU(10, // max length. default = Infinity // calculate how "big" each item is // // defaults to function(){return 1}, ie, just limit // the item count, without any knowledge as to their // relative size. function (item) { return item.length }) cache.set("key", "value") cache.get("key") // "value" cache.reset() // empty the cache If you put more stuff in it, then items will fall out. If you try to put an oversized thing in it, then it'll fall out right away. RTFS for more info. lib/000077500000000000000000000000001177713054400432235ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cachelru-cache.js000066400000000000000000000075041177713054400454320ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/lib;(function () { // closure for web browsers if (module) { module.exports = LRUCache } else { // just set the global for non-node platforms. ;(function () { return this })().LRUCache = LRUCache } function hOP (obj, key) { return Object.prototype.hasOwnProperty.call(obj, key) } function naiveLength () { return 1 } function LRUCache (maxLength, lengthCalculator) { if (!(this instanceof LRUCache)) { return new LRUCache(maxLength, lengthCalculator) } if (typeof lengthCalculator !== "function") { lengthCalculator = naiveLength } if (!maxLength || !(typeof maxLength === "number") || maxLength <= 0 ) { maxLength = Infinity } var cache = {} // hash of items by key , lruList = {} // list of items in order of use recency , lru = 0 // least recently used , mru = 0 // most recently used , length = 0 // number of items in the list , itemCount = 0 // resize the cache when the maxLength changes. Object.defineProperty(this, "maxLength", { set : function (mL) { if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity maxLength = mL // if it gets above double maxLength, trim right away. // otherwise, do it whenever it's convenient. if (length > maxLength) trim() } , get : function () { return maxLength } , enumerable : true }) // resize the cache when the lengthCalculator changes. Object.defineProperty(this, "lengthCalculator", { set : function (lC) { if (typeof lC !== "function") { lengthCalculator = naiveLength length = itemCount Object.keys(cache).forEach(function (key) { cache[key].length = 1 }) } else { lengthCalculator = lC length = 0 Object.keys(cache).forEach(function (key) { cache[key].length = lengthCalculator(cache[key].value) length += cache[key].length }) } if (length > maxLength) trim() } , get : function () { return lengthCalculator } , enumerable : true }) Object.defineProperty(this, "length", { get : function () { return length } , enumerable : true }) Object.defineProperty(this, "itemCount", { get : function () { return itemCount } , enumerable : true }) this.reset = function () { cache = {} lruList = {} lru = 0 mru = 0 length = 0 itemCount = 0 } // Provided for debugging/dev purposes only. No promises whatsoever that // this API stays stable. this.dump = function () { return cache } this.set = function (key, value) { if (hOP(cache, key)) { this.get(key) cache[key].value = value return } var hit = {key:key, value:value, lu:mru++, length:lengthCalculator(value)} // oversized objects fall out of cache automatically. if (hit.length > maxLength) return length += hit.length lruList[hit.lu] = cache[key] = hit itemCount ++ if (length > maxLength) trim() } this.get = function (key) { if (!hOP(cache, key)) return var hit = cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() hit.lu = mru ++ lruList[hit.lu] = hit return hit.value } this.del = function (key) { if (!hOP(cache, key)) return var hit = cache[key] delete cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() length -= hit.length itemCount -- } function lruWalk () { // lru has been deleted, hop up to the next hit. lru = Object.keys(lruList)[0] } function trim () { if (length <= maxLength) return var prune = Object.keys(lruList) for (var i = 0; i < prune.length && length > maxLength; i ++) { length -= lruList[prune[i]].length delete cache[ lruList[prune[i]].key ] delete lruList[prune[i]] } lruWalk() } } })() package.json000066400000000000000000000021561177713054400447470ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache{ "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", "version": "1.1.0", "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me" }, "scripts": { "test": "tap test" }, "main": "lib/lru-cache.js", "repository": { "type": "git", "url": "git://github.com/isaacs/node-lru-cache.git" }, "devDependencies": { "tap": "" }, "license": { "type": "MIT", "url": "http://github.com/isaacs/node-lru-cache/raw/master/LICENSE" }, "_id": "lru-cache@1.1.0", "contributors": [ { "name": "Isaac Z. Schlueter", "email": "i@izs.me" }, { "name": "Carlos Brito Lage", "email": "carlos@carloslage.net" }, { "name": "Marko Mikulicic", "email": "marko.mikulicic@isti.cnr.it" }, { "name": "Trent Mick", "email": "trentm@gmail.com" } ], "dependencies": {}, "optionalDependencies": {}, "engines": { "node": "*" }, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "lru-cache@~1" } test/000077500000000000000000000000001177713054400434345ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cachebasic.js000066400000000000000000000102131177713054400450500ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/testvar test = require("tap").test , LRU = require("../") test("basic", function (t) { var cache = new LRU(10) cache.set("key", "value") t.equal(cache.get("key"), "value") t.equal(cache.get("nada"), undefined) t.equal(cache.length, 1) t.equal(cache.maxLength, 10) t.end() }) test("least recently set", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), "B") t.equal(cache.get("a"), undefined) t.end() }) test("lru recently gotten", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.get("a") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), undefined) t.equal(cache.get("a"), "A") t.end() }) test("del", function (t) { var cache = new LRU(2) cache.set("a", "A") cache.del("a") t.equal(cache.get("a"), undefined) t.end() }) test("maxLength", function (t) { var cache = new LRU(3) // test changing the maxLength, verify that the LRU items get dropped. cache.maxLength = 100 for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } // now remove the maxLength restriction, and try again. cache.maxLength = "hello" for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } // should trigger an immediate resize cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } t.end() }) test("reset", function (t) { var cache = new LRU(10) cache.set("a", "A") cache.set("b", "B") cache.reset() t.equal(cache.length, 0) t.equal(cache.maxLength, 10) t.equal(cache.get("a"), undefined) t.equal(cache.get("b"), undefined) t.end() }) // Note: `.dump()` is a debugging tool only. No guarantees are made // about the format/layout of the response. test("dump", function (t) { var cache = new LRU(10) var d = cache.dump(); t.equal(Object.keys(d).length, 0, "nothing in dump for empty cache") cache.set("a", "A") var d = cache.dump() // { a: { key: "a", value: "A", lu: 0 } } t.ok(d.a) t.equal(d.a.key, "a") t.equal(d.a.value, "A") t.equal(d.a.lu, 0) cache.set("b", "B") cache.get("b") d = cache.dump() t.ok(d.b) t.equal(d.b.key, "b") t.equal(d.b.value, "B") t.equal(d.b.lu, 2) t.end() }) test("basic with weighed length", function (t) { var cache = new LRU(100, function (item) { return item.size } ) cache.set("key", {val: "value", size: 50}) t.equal(cache.get("key").val, "value") t.equal(cache.get("nada"), undefined) t.equal(cache.lengthCalculator(cache.get("key")), 50) t.equal(cache.length, 50) t.equal(cache.maxLength, 100) t.end() }) test("weighed length item too large", function (t) { var cache = new LRU(10, function (item) { return item.size } ) t.equal(cache.maxLength, 10) // should fall out immediately cache.set("key", {val: "value", size: 50}) t.equal(cache.length, 0) t.equal(cache.get("key"), undefined) t.end() }) test("least recently set with weighed length", function (t) { var cache = new LRU(8, function (item) { return item.length }) cache.set("a", "A") cache.set("b", "BB") cache.set("c", "CCC") cache.set("d", "DDDD") t.equal(cache.get("d"), "DDDD") t.equal(cache.get("c"), "CCC") t.equal(cache.get("b"), undefined) t.equal(cache.get("a"), undefined) t.end() }) test("lru recently gotten with weighed length", function (t) { var cache = new LRU(8, function (item) { return item.length }) cache.set("a", "A") cache.set("b", "BB") cache.set("c", "CCC") cache.get("a") cache.get("b") cache.set("d", "DDDD") t.equal(cache.get("c"), undefined) t.equal(cache.get("d"), "DDDD") t.equal(cache.get("b"), "BB") t.equal(cache.get("a"), "A") t.end() }) package.json000066400000000000000000000014561177713054400404310ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch{ "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me" }, "name": "minimatch", "description": "a glob matcher in javascript", "version": "0.2.5", "repository": { "type": "git", "url": "git://github.com/isaacs/minimatch.git" }, "main": "minimatch.js", "scripts": { "test": "tap test" }, "engines": { "node": "*" }, "dependencies": { "lru-cache": "~1" }, "devDependencies": { "tap": "" }, "licenses": [ { "type": "MIT", "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE" } ], "_id": "minimatch@0.2.5", "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "minimatch@0.2" } test/000077500000000000000000000000001177713054400371145ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatchbasic.js000066400000000000000000000227321177713054400405410ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/test// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require("tap") , globalBefore = Object.keys(global) , mm = require("../") , files = [ "a", "b", "c", "d", "abc" , "abd", "abe", "bb", "bcd" , "ca", "cb", "dd", "de" , "bdir/", "bdir/cfile"] , next = files.concat([ "a-b", "aXb" , ".x", ".y" ]) tap.test("basic tests", function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] ; [ "http://www.bashcookbook.com/bashinfo" + "/source/bash-1.14.7/tests/glob-test" , ["a*", ["a", "abc", "abd", "abe"]] , ["X*", ["X*"], {nonull: true}] // allow null glob expansion , ["X*", []] // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star , ["\\*", ["\\*"], {nonull: true}] , ["\\**", ["\\**"], {nonull: true}] , ["\\*\\*", ["\\*\\*"], {nonull: true}] , ["b*/", ["bdir/"]] , ["c*", ["c", "ca", "cb"]] , ["**", files] , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}] , ["s/\\..*//", ["s/\\..*//"], {nonull: true}] , "legendary larry crashes bashes" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}] , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}] , "character classes" , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]] , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd", "bdir/", "ca", "cb", "dd", "de"]] , ["a*[^c]", ["abd", "abe"]] , function () { files.push("a-b", "aXb") } , ["a[X-]b", ["a-b", "aXb"]] , function () { files.push(".x", ".y") } , ["[^a-c]*", ["d", "dd", "de"]] , function () { files.push("a*b/", "a*b/ooo") } , ["a\\*b/*", ["a*b/ooo"]] , ["a\\*?/*", ["a*b/ooo"]] , ["*\\\\!*", [], {null: true}, ["echo !7"]] , ["*\\!*", ["echo !7"], null, ["echo !7"]] , ["*.\\*", ["r.*"], null, ["r.*"]] , ["a[b]c", ["abc"]] , ["a[\\b]c", ["abc"]] , ["a?c", ["abc"]] , ["a\\*c", [], {null: true}, ["abc"]] , ["", [""], { null: true }, [""]] , "http://www.opensource.apple.com/source/bash/bash-23/" + "bash/tests/glob-test" , function () { files.push("man/", "man/man1/", "man/man1/bash.1") } , ["*/man*/bash.*", ["man/man1/bash.1"]] , ["man/man1/bash.1", ["man/man1/bash.1"]] , ["a***c", ["abc"], null, ["abc"]] , ["a*****?c", ["abc"], null, ["abc"]] , ["?*****??", ["abc"], null, ["abc"]] , ["*****??", ["abc"], null, ["abc"]] , ["?*****?c", ["abc"], null, ["abc"]] , ["?***?****c", ["abc"], null, ["abc"]] , ["?***?****?", ["abc"], null, ["abc"]] , ["?***?****", ["abc"], null, ["abc"]] , ["*******c", ["abc"], null, ["abc"]] , ["*******?", ["abc"], null, ["abc"]] , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["[-abc]", ["-"], null, ["-"]] , ["[abc-]", ["-"], null, ["-"]] , ["\\", ["\\"], null, ["\\"]] , ["[\\\\]", ["\\"], null, ["\\"]] , ["[[]", ["["], null, ["["]] , ["[", ["["], null, ["["]] , ["[*", ["[abc"], null, ["[abc"]] , "a right bracket shall lose its special meaning and\n" + "represent itself in a bracket expression if it occurs\n" + "first in the list. -- POSIX.2 2.8.3.2" , ["[]]", ["]"], null, ["]"]] , ["[]-]", ["]"], null, ["]"]] , ["[a-\z]", ["p"], null, ["p"]] , ["??**********?****?", [], { null: true }, ["abc"]] , ["??**********?****c", [], { null: true }, ["abc"]] , ["?************c****?****", [], { null: true }, ["abc"]] , ["*c*?**", [], { null: true }, ["abc"]] , ["a*****c*?**", [], { null: true }, ["abc"]] , ["a********???*******", [], { null: true }, ["abc"]] , ["[]", [], { null: true }, ["a"]] , ["[abc", [], { null: true }, ["["]] , "nocase tests" , ["XYZ", ["xYz"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["ab*", ["ABC"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] // [ pattern, [matches], MM opts, files, TAP opts] , "onestar/twostar" , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]] , ["{/?,*}", ["/a", "bb"], {null: true} , ["/a", "/b/b", "/a/b/c", "bb"]] , "dots should not match unless requested" , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]] // .. and . can only match patterns starting with ., // even when options.dot is set. , function () { files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"] } , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}] , ["a/*/b", ["a/c/b"], {dot:false}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}] // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! , ["**", ["a/b","a/.d",".a/.d"], { dot: true } , [ ".a/.d", "a/.d", "a/b"]] , "paren sets cannot contain slashes" , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]] // brace sets trump all else. // // invalid glob pattern. fails on bash4 and bsdglob. // however, in this implementation, it's easier just // to do the intuitive thing, and let brace-expansion // actually come before parsing any extglob patterns, // like the documentation seems to say. // // XXX: if anyone complains about this, either fix it // or tell them to grow up and stop complaining. // // bash/bsdglob says this: // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]] // but we do this instead: , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]] // test partial parsing in the presence of comment/negation chars , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]] , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]] // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped. , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g" , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"] , {} , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]] // crazy nested {,,} and *(||) tests. , function () { files = [ "a", "b", "c", "d" , "ab", "ac", "ad" , "bc", "cb" , "bc,d", "c,db", "c,d" , "d)", "(b|c", "*(b|c" , "b|c", "b|cc", "cb|c" , "x(a|b|c)", "x(a|c)" , "(a|b|c)", "(a|c)"] } , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]] , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]] // a // *(b|c) // *(b|d) , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]] , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]] // test various flag settings. , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"] , { noext: true } ] , ["a?b", ["x/y/acb", "acb/"], {matchBase: true} , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ] , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]] // begin channelling Boole and deMorgan... , "negation tests" , function () { files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"] } // anything that is NOT a* matches. , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]] // anything that IS !a* matches. , ["!a*", ["!ab", "!abc"], {nonegate: true}] // anything that IS a* matches , ["!!a*", ["a!b"]] // anything that is NOT !a* matches , ["!\\!a*", ["a!b", "d", "e", "\\!a"]] // negation nestled within a pattern , function () { files = [ "foo.js" , "foo.bar" // can't match this one without negative lookbehind. , "foo.js.js" , "blar.js" , "foo." , "boo.js.boo" ] } , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ] ].forEach(function (c) { if (typeof c === "function") return c() if (typeof c === "string") return t.comment(c) var pattern = c[0] , expect = c[1].sort(alpha) , options = c[2] || {} , f = c[3] || files , tapOpts = c[4] || {} // options.debug = true var m = new mm.Minimatch(pattern, options) var r = m.makeRe() tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect , JSON.stringify(pattern) + " " + JSON.stringify(expect) , tapOpts ) }) t.comment("time=" + (Date.now() - start) + "ms") t.end() }) tap.test("global leak test", function (t) { var globalAfter = Object.keys(global) t.equivalent(globalAfter, globalBefore, "no new globals, please") t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } brace-expand.js000066400000000000000000000012071177713054400420030ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/testvar tap = require("tap") , minimatch = require("../") tap.test("brace expansion", function (t) { // [ pattern, [expanded] ] ; [ [ "a{b,c{d,e},{f,g}h}x{y,z}" , [ "abxy" , "abxz" , "acdxy" , "acdxz" , "acexy" , "acexz" , "afhxy" , "afhxz" , "aghxy" , "aghxz" ] ] , [ "a{1..5}b" , [ "a1b" , "a2b" , "a3b" , "a4b" , "a5b" ] ] , [ "a{b}c", ["a{b}c"] ] ].forEach(function (tc) { var p = tc[0] , expect = tc[1] t.equivalent(minimatch.braceExpand(p), expect, p) }) console.error("ending") t.end() }) caching.js000066400000000000000000000006641177713054400410540ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/testvar Minimatch = require("../minimatch.js").Minimatch var tap = require("tap") tap.test("cache test", function (t) { var mm1 = new Minimatch("a?b") var mm2 = new Minimatch("a?b") t.equal(mm1, mm2, "should get the same object") // the lru should drop it after 100 entries for (var i = 0; i < 100; i ++) { new Minimatch("a"+i) } mm2 = new Minimatch("a?b") t.notEqual(mm1, mm2, "cache should have dropped") t.end() }) defaults.js000066400000000000000000000227771177713054400413000ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/node_modules/minimatch/test// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require("tap") , globalBefore = Object.keys(global) , mm = require("../") , files = [ "a", "b", "c", "d", "abc" , "abd", "abe", "bb", "bcd" , "ca", "cb", "dd", "de" , "bdir/", "bdir/cfile"] , next = files.concat([ "a-b", "aXb" , ".x", ".y" ]) tap.test("basic tests", function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] ; [ "http://www.bashcookbook.com/bashinfo" + "/source/bash-1.14.7/tests/glob-test" , ["a*", ["a", "abc", "abd", "abe"]] , ["X*", ["X*"], {nonull: true}] // allow null glob expansion , ["X*", []] // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star , ["\\*", ["\\*"], {nonull: true}] , ["\\**", ["\\**"], {nonull: true}] , ["\\*\\*", ["\\*\\*"], {nonull: true}] , ["b*/", ["bdir/"]] , ["c*", ["c", "ca", "cb"]] , ["**", files] , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}] , ["s/\\..*//", ["s/\\..*//"], {nonull: true}] , "legendary larry crashes bashes" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}] , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}] , "character classes" , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]] , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd", "bdir/", "ca", "cb", "dd", "de"]] , ["a*[^c]", ["abd", "abe"]] , function () { files.push("a-b", "aXb") } , ["a[X-]b", ["a-b", "aXb"]] , function () { files.push(".x", ".y") } , ["[^a-c]*", ["d", "dd", "de"]] , function () { files.push("a*b/", "a*b/ooo") } , ["a\\*b/*", ["a*b/ooo"]] , ["a\\*?/*", ["a*b/ooo"]] , ["*\\\\!*", [], {null: true}, ["echo !7"]] , ["*\\!*", ["echo !7"], null, ["echo !7"]] , ["*.\\*", ["r.*"], null, ["r.*"]] , ["a[b]c", ["abc"]] , ["a[\\b]c", ["abc"]] , ["a?c", ["abc"]] , ["a\\*c", [], {null: true}, ["abc"]] , ["", [""], { null: true }, [""]] , "http://www.opensource.apple.com/source/bash/bash-23/" + "bash/tests/glob-test" , function () { files.push("man/", "man/man1/", "man/man1/bash.1") } , ["*/man*/bash.*", ["man/man1/bash.1"]] , ["man/man1/bash.1", ["man/man1/bash.1"]] , ["a***c", ["abc"], null, ["abc"]] , ["a*****?c", ["abc"], null, ["abc"]] , ["?*****??", ["abc"], null, ["abc"]] , ["*****??", ["abc"], null, ["abc"]] , ["?*****?c", ["abc"], null, ["abc"]] , ["?***?****c", ["abc"], null, ["abc"]] , ["?***?****?", ["abc"], null, ["abc"]] , ["?***?****", ["abc"], null, ["abc"]] , ["*******c", ["abc"], null, ["abc"]] , ["*******?", ["abc"], null, ["abc"]] , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["[-abc]", ["-"], null, ["-"]] , ["[abc-]", ["-"], null, ["-"]] , ["\\", ["\\"], null, ["\\"]] , ["[\\\\]", ["\\"], null, ["\\"]] , ["[[]", ["["], null, ["["]] , ["[", ["["], null, ["["]] , ["[*", ["[abc"], null, ["[abc"]] , "a right bracket shall lose its special meaning and\n" + "represent itself in a bracket expression if it occurs\n" + "first in the list. -- POSIX.2 2.8.3.2" , ["[]]", ["]"], null, ["]"]] , ["[]-]", ["]"], null, ["]"]] , ["[a-\z]", ["p"], null, ["p"]] , ["??**********?****?", [], { null: true }, ["abc"]] , ["??**********?****c", [], { null: true }, ["abc"]] , ["?************c****?****", [], { null: true }, ["abc"]] , ["*c*?**", [], { null: true }, ["abc"]] , ["a*****c*?**", [], { null: true }, ["abc"]] , ["a********???*******", [], { null: true }, ["abc"]] , ["[]", [], { null: true }, ["a"]] , ["[abc", [], { null: true }, ["["]] , "nocase tests" , ["XYZ", ["xYz"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["ab*", ["ABC"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] // [ pattern, [matches], MM opts, files, TAP opts] , "onestar/twostar" , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]] , ["{/?,*}", ["/a", "bb"], {null: true} , ["/a", "/b/b", "/a/b/c", "bb"]] , "dots should not match unless requested" , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]] // .. and . can only match patterns starting with ., // even when options.dot is set. , function () { files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"] } , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}] , ["a/*/b", ["a/c/b"], {dot:false}] , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}] // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! , ["**", ["a/b","a/.d",".a/.d"], { dot: true } , [ ".a/.d", "a/.d", "a/b"]] , "paren sets cannot contain slashes" , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]] // brace sets trump all else. // // invalid glob pattern. fails on bash4 and bsdglob. // however, in this implementation, it's easier just // to do the intuitive thing, and let brace-expansion // actually come before parsing any extglob patterns, // like the documentation seems to say. // // XXX: if anyone complains about this, either fix it // or tell them to grow up and stop complaining. // // bash/bsdglob says this: // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]] // but we do this instead: , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]] // test partial parsing in the presence of comment/negation chars , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]] , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]] // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped. , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g" , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"] , {} , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]] // crazy nested {,,} and *(||) tests. , function () { files = [ "a", "b", "c", "d" , "ab", "ac", "ad" , "bc", "cb" , "bc,d", "c,db", "c,d" , "d)", "(b|c", "*(b|c" , "b|c", "b|cc", "cb|c" , "x(a|b|c)", "x(a|c)" , "(a|b|c)", "(a|c)"] } , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]] , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]] // a // *(b|c) // *(b|d) , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]] , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]] // test various flag settings. , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"] , { noext: true } ] , ["a?b", ["x/y/acb", "acb/"], {matchBase: true} , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ] , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]] // begin channelling Boole and deMorgan... , "negation tests" , function () { files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"] } // anything that is NOT a* matches. , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]] // anything that IS !a* matches. , ["!a*", ["!ab", "!abc"], {nonegate: true}] // anything that IS a* matches , ["!!a*", ["a!b"]] // anything that is NOT !a* matches , ["!\\!a*", ["a!b", "d", "e", "\\!a"]] // negation nestled within a pattern , function () { files = [ "foo.js" , "foo.bar" // can't match this one without negative lookbehind. , "foo.js.js" , "blar.js" , "foo." , "boo.js.boo" ] } , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ] ].forEach(function (c) { if (typeof c === "function") return c() if (typeof c === "string") return t.comment(c) var pattern = c[0] , expect = c[1].sort(alpha) , options = c[2] || {} , f = c[3] || files , tapOpts = c[4] || {} // options.debug = true var Class = mm.defaults(options).Minimatch var m = new Class(pattern, {}) var r = m.makeRe() tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect , JSON.stringify(pattern) + " " + JSON.stringify(expect) , tapOpts ) }) t.comment("time=" + (Date.now() - start) + "ms") t.end() }) tap.test("global leak test", function (t) { var globalAfter = Object.keys(global) t.equivalent(globalAfter, globalBefore, "no new globals, please") t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/package.json000066400000000000000000000015351177713054400340600ustar00rootroot00000000000000{ "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me/" }, "name": "glob", "description": "a little globber", "version": "3.1.10", "repository": { "type": "git", "url": "git://github.com/isaacs/node-glob.git" }, "main": "glob.js", "engines": { "node": "*" }, "dependencies": { "minimatch": "0.2", "graceful-fs": "~1.1.2", "inherits": "1" }, "devDependencies": { "tap": "~0.2.3", "mkdirp": "0", "rimraf": "1" }, "scripts": { "test": "tap test/*.js" }, "license": "BSD", "_id": "glob@3.1.10", "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "dist": { "shasum": "82fcdc1204277ef9951a4412bc03f06f39383de7" }, "_from": "glob@>= 3.1.4" } lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test/000077500000000000000000000000001177713054400325455ustar00rootroot0000000000000000-setup.js000066400000000000000000000023561177713054400344070ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test// just a little pre-run script to set up the fixtures. // zz-finish cleans it up var mkdirp = require("mkdirp") var path = require("path") var i = 0 var tap = require("tap") var fs = require("fs") var rimraf = require("rimraf") var files = [ "a/.abcdef/x/y/z/a" , "a/abcdef/g/h" , "a/abcfed/g/h" , "a/b/c/d" , "a/bc/e/f" , "a/c/d/c/b" , "a/cb/e/f" ] var symlinkTo = path.resolve(__dirname, "a/symlink/a/b/c") var symlinkFrom = "../.." files = files.map(function (f) { return path.resolve(__dirname, f) }) tap.test("remove fixtures", function (t) { rimraf(path.resolve(__dirname, "a"), function (er) { t.ifError(er, "remove fixtures") t.end() }) }) files.forEach(function (f) { tap.test(f, function (t) { var d = path.dirname(f) mkdirp(d, 0755, function (er) { if (er) { t.fail(er) return t.bailout() } fs.writeFile(f, "i like tests", function (er) { t.ifError(er, "make file") t.end() }) }) }) }) tap.test("symlinky", function (t) { var d = path.dirname(symlinkTo) console.error("mkdirp", d) mkdirp(d, 0755, function (er) { t.ifError(er) fs.symlink(symlinkFrom, symlinkTo, function (er) { t.ifError(er, "make symlink") t.end() }) }) }) bash-comparison.js000066400000000000000000000064031177713054400361140ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test// basic test // show that it does the same thing by default as the shell. var tap = require("tap") , child_process = require("child_process") // put more patterns here. , globs = [ "test/a/*/+(c|g)/./d" ,"test/a/**/[cg]/../[cg]" ,"test/a/{b,c,d,e,f}/**/g" ,"test/a/b/**" ,"test/**/g" ,"test/a/abc{fed,def}/g/h" ,"test/a/abc{fed/g,def}/**/" ,"test/a/abc{fed/g,def}/**///**/" ,"test/**/a/**/" ,"test/+(a|b|c)/a{/,bc*}/**" ,"test/*/*/*/f" ,"test/**/f" ,"test/a/symlink/a/b/c/a/b/c/a/b/c//a/b/c////a/b/c/**/b/c/**" ,"{./*/*,/usr/local/*}" ,"{/*,*}" // evil owl face! how you taunt me! ] , glob = require("../") , path = require("path") // run from the root of the project // this is usually where you're at anyway, but be sure. process.chdir(path.resolve(__dirname, "..")) function alphasort (a, b) { a = a.toLowerCase() b = b.toLowerCase() return a > b ? 1 : a < b ? -1 : 0 } globs.forEach(function (pattern) { var echoOutput tap.test(pattern, function (t) { var bashPattern = pattern , cmd = "shopt -s globstar && " + "shopt -s extglob && " + "shopt -s nullglob && " + // "shopt >&2; " + "eval \'for i in " + bashPattern + "; do echo $i; done\'" , cp = child_process.spawn("bash", ["-c",cmd]) , out = [] , globResult cp.stdout.on("data", function (c) { out.push(c) }) cp.stderr.on("data", function (c) { process.stderr.write(c) }) cp.stdout.on("close", function () { echoOutput = flatten(out) if (!echoOutput) echoOutput = [] else { echoOutput = echoOutput.split(/\r*\n/).map(function (m) { // Bash is a oddly inconsistent with slashes in the // the results. This implementation is a bit more // normalized. Account for this in the test results. return m.replace(/\/+/g, "/").replace(/\/$/, "") }).sort(alphasort).reduce(function (set, f) { if (f !== set[set.length - 1]) set.push(f) return set }, []).sort(alphasort) } next() }) glob(pattern, function (er, matches) { // sort and unpark, just to match the shell results matches = matches.map(function (m) { return m.replace(/\/+/g, "/").replace(/\/$/, "") }).sort(alphasort).reduce(function (set, f) { if (f !== set[set.length - 1]) set.push(f) return set }, []).sort(alphasort) t.ifError(er, pattern + " should not error") globResult = matches next() }) function next () { if (!echoOutput || !globResult) return t.deepEqual(globResult, echoOutput, "should match shell") t.end() } }) tap.test(pattern + " sync", function (t) { var matches = glob.sync(pattern).map(function (m) { return m.replace(/\/+/g, "/").replace(/\/$/, "") }).sort(alphasort).reduce(function (set, f) { if (f !== set[set.length - 1]) set.push(f) return set }, []).sort(alphasort) t.deepEqual(matches, echoOutput, "should match shell") t.end() }) }) function flatten (chunks) { var s = 0 chunks.forEach(function (c) { s += c.length }) var out = new Buffer(s) s = 0 chunks.forEach(function (c) { c.copy(out, s) s += c.length }) return out.toString().trim() } cwd-test.js000066400000000000000000000022431177713054400345570ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/testvar tap = require("tap") var origCwd = process.cwd() process.chdir(__dirname) tap.test("changing cwd and searching for **/d", function (t) { var glob = require('../') var path = require('path') t.test('.', function (t) { glob('**/d', function (er, matches) { t.ifError(er) t.like(matches, [ 'a/b/c/d', 'a/c/d' ]) t.end() }) }) t.test('a', function (t) { glob('**/d', {cwd:path.resolve('a')}, function (er, matches) { t.ifError(er) t.like(matches, [ 'b/c/d', 'c/d' ]) t.end() }) }) t.test('a/b', function (t) { glob('**/d', {cwd:path.resolve('a/b')}, function (er, matches) { t.ifError(er) t.like(matches, [ 'c/d' ]) t.end() }) }) t.test('a/b/', function (t) { glob('**/d', {cwd:path.resolve('a/b/')}, function (er, matches) { t.ifError(er) t.like(matches, [ 'c/d' ]) t.end() }) }) t.test('.', function (t) { glob('**/d', {cwd: process.cwd()}, function (er, matches) { t.ifError(er) t.like(matches, [ 'a/b/c/d', 'a/c/d' ]) t.end() }) }) t.test('cd -', function (t) { process.chdir(origCwd) t.end() }) t.end() }) pause-resume.js000066400000000000000000000050551177713054400354440ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test// show that no match events happen while paused. var tap = require("tap") , child_process = require("child_process") // just some gnarly pattern with lots of matches , pattern = "test/a/symlink/a/b/c/a/b/c/a/b/c//a/b/c////a/b/c/**/b/c/**" , glob = require("../") , Glob = glob.Glob , path = require("path") // run from the root of the project // this is usually where you're at anyway, but be sure. process.chdir(path.resolve(__dirname, "..")) function alphasort (a, b) { a = a.toLowerCase() b = b.toLowerCase() return a > b ? 1 : a < b ? -1 : 0 } function cleanResults (m) { // normalize discrepancies in ordering, duplication, // and ending slashes. return m.map(function (m) { return m.replace(/\/+/g, "/").replace(/\/$/, "") }).sort(alphasort).reduce(function (set, f) { if (f !== set[set.length - 1]) set.push(f) return set }, []).sort(alphasort) } function flatten (chunks) { var s = 0 chunks.forEach(function (c) { s += c.length }) var out = new Buffer(s) s = 0 chunks.forEach(function (c) { c.copy(out, s) s += c.length }) return out.toString().trim() } var bashResults tap.test("get bash output", function (t) { var bashPattern = pattern , cmd = "shopt -s globstar && " + "shopt -s extglob && " + "shopt -s nullglob && " + // "shopt >&2; " + "eval \'for i in " + bashPattern + "; do echo $i; done\'" , cp = child_process.spawn("bash", ["-c",cmd]) , out = [] , globResult cp.stdout.on("data", function (c) { out.push(c) }) cp.stderr.on("data", function (c) { process.stderr.write(c) }) cp.stdout.on("close", function () { bashResults = flatten(out) if (!bashResults) return t.fail("Didn't get results from bash") else { bashResults = cleanResults(bashResults.split(/\r*\n/)) } t.ok(bashResults.length, "got some results") t.end() }) }) var globResults = [] tap.test("use a Glob object, and pause/resume it", function (t) { var g = new Glob(pattern) , paused = false , res = [] g.on("match", function (m) { t.notOk(g.paused, "must not be paused") globResults.push(m) g.pause() t.ok(g.paused, "must be paused") setTimeout(g.resume.bind(g), 1) }) g.on("end", function (matches) { t.pass("reached glob end") globResults = cleanResults(globResults) matches = cleanResults(matches) t.deepEqual(matches, globResults, "end event matches should be the same as match events") t.deepEqual(matches, bashResults, "glob matches should be the same as bash results") t.end() }) }) root-nomount.js000066400000000000000000000020041177713054400355000ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/testvar tap = require("tap") var origCwd = process.cwd() process.chdir(__dirname) tap.test("changing root and searching for /b*/**", function (t) { var glob = require('../') var path = require('path') t.test('.', function (t) { glob('/b*/**', { globDebug: true, root: '.', nomount: true }, function (er, matches) { t.ifError(er) t.like(matches, []) t.end() }) }) t.test('a', function (t) { glob('/b*/**', { globDebug: true, root: path.resolve('a'), nomount: true }, function (er, matches) { t.ifError(er) t.like(matches, [ '/b', '/b/c', '/b/c/d', '/bc', '/bc/e', '/bc/e/f' ]) t.end() }) }) t.test('root=a, cwd=a/b', function (t) { glob('/b*/**', { globDebug: true, root: 'a', cwd: path.resolve('a/b'), nomount: true }, function (er, matches) { t.ifError(er) t.like(matches, [ '/b', '/b/c', '/b/c/d', '/bc', '/bc/e', '/bc/e/f' ]) t.end() }) }) t.test('cd -', function (t) { process.chdir(origCwd) t.end() }) t.end() }) lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test/root.js000066400000000000000000000021551177713054400340710ustar00rootroot00000000000000var tap = require("tap") var origCwd = process.cwd() process.chdir(__dirname) tap.test("changing root and searching for /b*/**", function (t) { var glob = require('../') var path = require('path') t.test('.', function (t) { glob('/b*/**', { globDebug: true, root: '.' }, function (er, matches) { t.ifError(er) t.like(matches, []) t.end() }) }) t.test('a', function (t) { glob('/b*/**', { globDebug: true, root: path.resolve('a') }, function (er, matches) { t.ifError(er) t.like(matches, [ '/b', '/b/c', '/b/c/d', '/bc', '/bc/e', '/bc/e/f' ].map(function (m) { return path.join(path.resolve('a'), m) })) t.end() }) }) t.test('root=a, cwd=a/b', function (t) { glob('/b*/**', { globDebug: true, root: 'a', cwd: path.resolve('a/b') }, function (er, matches) { t.ifError(er) t.like(matches, [ '/b', '/b/c', '/b/c/d', '/bc', '/bc/e', '/bc/e/f' ].map(function (m) { return path.join(path.resolve('a'), m) })) t.end() }) }) t.test('cd -', function (t) { process.chdir(origCwd) t.end() }) t.end() }) zz-cleanup.js000066400000000000000000000003731177713054400351170ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/node_modules/glob/test// remove the fixtures var tap = require("tap") , rimraf = require("rimraf") , path = require("path") tap.test("cleanup fixtures", function (t) { rimraf(path.resolve(__dirname, "a"), function (er) { t.ifError(er, "removed") t.end() }) }) lets_code_javascript-episode2/node_modules/jshint/node_modules/cli/package.json000077500000000000000000000022101177713054400304520ustar00rootroot00000000000000{ "name": "cli", "description": "A tool for rapidly building command line apps", "version": "0.4.3", "homepage": "http://github.com/chriso/cli", "keywords": [ "cli", "command line", "opts", "parseopt", "opt", "args", "console", "argsparse", "optparse", "daemon", "autocomplete", "command", "autocompletion" ], "author": { "name": "Chris O'Hara", "email": "cohara87@gmail.com" }, "main": "cli.js", "bugs": { "email": "cohara87@gmail.com", "url": "http://github.com/chriso/cli/issues" }, "repository": { "type": "git", "url": "git://github.com/chriso/cli.git" }, "dependencies": { "glob": ">= 3.1.4" }, "contributors": [ { "name": "Douglas Meyer" } ], "engines": { "node": ">=0.2.5" }, "licenses": [ { "type": "MIT" } ], "_id": "cli@0.4.3", "devDependencies": {}, "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "dist": { "shasum": "261afa5aa46c7d27425317f157e1848a00f9d0fe" }, "_from": "cli@0.4.3" } lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/000077500000000000000000000000001177713054400273705ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/.travis.yml000066400000000000000000000000531177713054400314770ustar00rootroot00000000000000language: node_js node_js: - 0.4 - 0.6 lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/LICENSE000066400000000000000000000021041177713054400303720ustar00rootroot00000000000000Copyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/README.md000066400000000000000000000047351177713054400306600ustar00rootroot00000000000000# minimatch A minimal matching utility. [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch) This is the matching library used internally by npm. Eventually, it will replace the C binding in node-glob. It works by converting glob expressions into JavaScript `RegExp` objects. ## Usage ```javascript var minimatch = require("minimatch") minimatch("bar.foo", "*.foo") // true! minimatch("bar.foo", "*.bar") // false! ``` ## Features Supports all glob features. See: * `man sh` * `man fnmatch` * `man 5 gitignore` ### Departures from zsh/bash/ksh/sh If the pattern starts with a `!` character, then it is negated. If a pattern starts with `#`, then it is treated as a comment, and will not match anything. (Use `\#` to match a literal `#` at the start of a line.) The double-star `**` is always supported, instead of requiring a special flag. If an escaped pattern has no matches, and the `null` flag is not set, then minimatch.match returns the pattern as-provided, rather than interpreting the character escapes. For example, `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than `"*a?"`. ## Functions ### minimatch(path, pattern, options) Main export. Tests a path against the pattern using the options. ### minimatch.filter(pattern, options) Returns a function that tests its supplied argument, suitable for use with `Array.filter`. ### minimatch.match(list, pattern, options) Match against the list of files, in the style of fnmatch or glob. If nothing is matched, then return the pattern (unless `{ null: true }` in the options.) ### minimatch.makeRe(pattern, options) Make a regular expression object from the pattern. ## Options All options are `false` by default. ### debug Dump a ton of stuff to stderr. ### null Return an empty list from minimatch.match, instead of a list containing the pattern itself. ### nocase Perform a case-insensitive match. ### cache An LRU cache with `.get(k)` and `.set(k,v)` methods. By default, an instance of `node-lru-cache` is used, with 1000 max entries. ### slash If set, then `a/*` will match `a/` as well as `a/b`. ### matchBase If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match `xyz/123/acb`. ### partial Internal. Used by `minimatch.makeRe`. ### dot Allow patterns to match paths starting with a period, even if the pattern does not explicitly start with a period. lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/blerg.js000066400000000000000000000031341177713054400310220ustar00rootroot00000000000000 // Turn something like {a,b{c,d},}x{e,f} into // ["axe", "axf", "bcxe", "bcxf", "bdxe", "bdxf", "xe", "xf"] // Only {,} groups are expanded. While in many cases {x,y} is // functionally equivalent to @(x|y), for the purpose of globbing // files, only {x,y} gets expanded as multiple patterns. minimatch.patternSet = patternSet function patternSet (pattern) { if (!pattern.match(/{/) || !pattern.match(/}/)) { // shortcut - no sets. return [pattern] } // a{b,c{d,e},{f,g}h}x{y,z} // // t=[before set, set, after set] // t=["a", ["b", "c{d,e}", "{f,g}h"], "x{y,z}"] // start walking, and note the position of the first { // and the corresponding } var p = pattern.indexOf("{") , l = pattern.length , d = 0 , escaping = false , inClass = false while (++ p < l) { switch (pattern.charAt(p)) { case "{": d ++ continue case "}": // t[2] = patternSet(t[2]) // t = [t[0]].concat([t[1].map(patternSet)]).concat([t[2]]) // // t=["a",[["b"],[["cd","ce"]],[["fh","gh"]]],["xy","xz"]] // // // first turn into // // [["ab"], ["acd", "ace"], ["afh", "agh"]] // return t[1].map(function (p) { // return p.map(function (p) { // return t[0] + p // }) // }) // // flatten into ["ab", "acd", "ace", "afh", "agh"] // .reduce(function (l, r) { // return l.concat(r) // }, []) // // tack all the endings onto each one // .map(function (p) { // return t[2].map(function (e) { // return p + e // }) // }) // // flatten again // .reduce(function (l, r) { // return l.concat(r) // }, []) } lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/minimatch.js000066400000000000000000000222431177713054400317020ustar00rootroot00000000000000// This is a JavaScript implementation of the fnmatch-like // stuff that git uses in its .gitignore files. // See `man 5 gitignore`. module.exports = minimatch var path = require("path") , LRU = require("lru-cache") minimatch.filter = function (pattern, options) { options = options || {} return function (p, i, list) { return minimatch(p, pattern, options) } } minimatch.match = function (list, pattern, options) { if (!options) options = {} var ret = list.filter(minimatch.filter(pattern, options)) if (options.debug) console.error("\nmatch: %s %j %j", pattern, list, ret) // set the null flag to allow empty match sets // Note that minimatch itself, and filter(), do not // respect this flag, only minimatch.match(list, pattern) does. if (!options.null && !ret.length) { return [pattern] } return ret } function minimatch (p, pattern, options) { if (typeof pattern !== "string") { throw new TypeError("glob pattern string required") } options = options || {} // to set the cache, just replace with a different obj // supporting set(k,v) and v=get(k) methods. var cache = options.cache || minimatch.cache if (!cache) cache = minimatch.cache = new LRU(1000) // "" only matches "" if (!pattern) return p === "" // comments. if (pattern.trim().charAt(0) === "#") return false // check the cache var re = cache.get(pattern + "\n" + JSON.stringify(options)) if (!re && re !== false) { cache.set(pattern, re = minimatch.makeRe(pattern, options)) } if (options.debug) { console.error(pattern + "\t" + re, JSON.stringify(p)) } // some kind of invalid thing if (!re) return false // patterns that end in / can only match dirs // however, dirs also match the same thing that *doesn't* // end in a slash. var match = // a/ should not match a/*, but will match */ // accomplish this by not applying the regexp // directly, unless the pattern would match // trailing slash'ed things, or the thing isn't // a trailing slash, or slashes are opted-in ( ( options.slash || p.substr(-1) !== "/" || pattern.substr(-1) === "/" ) && !!p.match(re) ) // a/ should match * or a || ( p.substr(-1) === "/" && !!p.slice(0, -1).match(re) ) // a pattern with *no* slashes will match against // either the full path, or just the basename. || ( options.matchBase && pattern.indexOf("/") === -1 && path.basename(p).match(re) ) //console.error(" MINIMATCH: %j %j %j %j", // re.toString(), pattern, p, match) return match } minimatch.makeRe = makeRe function makeRe (pattern, options) { options = options || {} function clearStateChar () { if (stateChar) { // we had some state-tracking character // that wasn't consumed by this pass. switch (stateChar) { case "*": re += oneStar break case "?": re += "." break default: re += "\\"+stateChar break } stateChar = false } } var braceDepth = 0 , re = "" , escaping = false , oneStar = options.dot ? "[^\\/]*?" : "(?:(?!(?:\\\/|^)\\.)[^\\/])*?" , twoStar = options.dot ? ".*?" // not a ^ or / followed by a dot, // followed by anything, any number of times. : "(?:(?!(?:\\\/|^)\\.).)*?" , reSpecials = "().*{}+?[]^$/\\" , patternListStack = [] , stateChar , negate = false , negating = false , inClass = false , reClassStart = -1 , classStart = -1 , classStartPattern = options.dot ? "" : "(?:(?!(?:\\\/|^)\\.)" , classEndPattern = options.dot ? "" : ")" for ( var i = 0, len = pattern.length, c ; (i < len) && (c = pattern.charAt(i)) ; i ++ ) { if (options.debug) { console.error("%s\t%s %s %j", pattern, i, re, c) } switch (c) { case "\\": if (stateChar) { if (stateChar === "*") re += oneStar else re += "\\" + stateChar stateChar = false } if (escaping) { re += "\\\\" // must match literal \ escaping = false } else { escaping = true } continue // the various stateChar values case "!": if (i === 0 || negating) { negate = !negate negating = true break } else { negating = false } // fallthrough case "+": case "@": case "*": case "?": if (options.debug) { console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c) } negating = false if (escaping) { re += "\\" + c escaping = false } else if (inClass) { re += c } else if (c === "*" && stateChar === "*") { // ** re += twoStar stateChar = false } else { if (stateChar) { if (stateChar === "*") re += oneStar else if (stateChar === "?") re += "." else re += "\\" + stateChar } stateChar = c } continue case "(": if (escaping) { re += "\\(" escaping = false } else if (inClass) { re += "(" } else if (stateChar) { plType = stateChar patternListStack.push(plType) re += stateChar === "!" ? "(?!" : "(?:" stateChar = false } else { re += "\\(" } continue case ")": if (escaping || inClass) { re += "\\)" escaping = false } else if (patternListStack.length) { re += ")" plType = patternListStack.pop() switch (plType) { case "?": case "+": case "*": re += plType case "!": case "@": break } } else { re += "\\)" } continue case "|": if (escaping || inClass) { re += "\\|" escaping = false } else if (patternListStack.length) { re += "|" } else { re += "\\|" } continue // these are mostly the same in regexp and glob :) case "[": // swallow any state-tracking char before the [ clearStateChar() if (escaping || inClass) { re += "\\" + c escaping = false } else { inClass = true classStart = i reClassStart = re.length re += classStartPattern re += c } continue case "]": // a right bracket shall lose its special // meaning and represent itself in // a bracket expression if it occurs // first in the list. -- POSIX.2 2.8.3.2 if (i === classStart + 1) escaping = true if (escaping || !inClass) { re += "\\" + c escaping = false } else { inClass = false re += c + classEndPattern } continue case "{": if (escaping || inClass) { re += "\\{" escaping = false } else { re += "(?:" braceDepth ++ } continue case "}": if (escaping || inClass || braceDepth === 0) { re += "\\}" escaping = false } else { // swallow any state char that wasn't consumed clearStateChar() re += ")" braceDepth -- } continue case ",": if (escaping || inClass || braceDepth === 0) { re += "," escaping = false } else { // swallow any state char that wasn't consumed clearStateChar() re += "|" } continue default: // swallow any state char that wasn't consumed clearStateChar() if (escaping) { // no need escaping = false } else if (reSpecials.indexOf(c) !== -1 && !(c === "^" && inClass)) { re += "\\" } re += c } // switch if (negating && c !== "!") negating = false } // for // handle trailing things that only matter at the very end. if (stateChar) { clearStateChar() } else if (escaping) { re += "\\\\" } // "[abc" is valid, equivalent to "\[abc" if (inClass) { // split where the last [ was, and escape it // this is a huge pita. We now have to re-walk // the contents of the would-be class to re-translate // any characters that were passed through as-is var cs = re.substr(reClassStart + classStartPattern.length + 1) , csOpts = Object.create(options) csOpts.partial = true re = re.substr(0, reClassStart) + "\\[" + makeRe(cs, csOpts) } if (options.partial) return re // must match entire pattern // ending in a * or ** will make it less strict. re = "^" + re + "$" // fail on the pattern, but allow anything otherwise. if (negate) re = "^(?!" + re + ").*$" // really insane glob patterns can cause bad things. var flags = "" if (options.nocase) flags += "i" if (options.debug) { console.error("/%s/%s", re, flags) } try { return new RegExp(re, flags) } catch(ex) { return false } } lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/000077500000000000000000000000001177713054400320455ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache/000077500000000000000000000000001177713054400337105ustar00rootroot00000000000000.npmignore000066400000000000000000000000161177713054400356250ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache/node_modules LICENSE000066400000000000000000000021041177713054400346330ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cacheCopyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. 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. README.md000066400000000000000000000004541177713054400351130ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache# lru cache A cache object that deletes the least-recently-used items. Usage: var LRU = require("lru-cache") , cache = LRU(10) // max 10 items. default = Infinity cache.set("key", "value") cache.get("key") // "value" cache.reset() // empty the cache RTFS for more info. lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache/lib/000077500000000000000000000000001177713054400344565ustar00rootroot00000000000000lru-cache.js000066400000000000000000000051161177713054400366030ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache/lib;(function () { // closure for web browsers if (module) { module.exports = LRUCache } else { // just set the global for non-node platforms. ;(function () { return this })().LRUCache = LRUCache } function hOP (obj, key) { return Object.prototype.hasOwnProperty.call(obj, key) } function LRUCache (maxLength) { if (!(this instanceof LRUCache)) { return new LRUCache(maxLength) } var cache = {} // hash of items by key , lruList = {} // list of items in order of use recency , lru = 0 // least recently used , mru = 0 // most recently used , length = 0 // number of items in the list // resize the cache when the maxLength changes. Object.defineProperty(this, "maxLength", { set : function (mL) { if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity maxLength = mL // if it gets above double maxLength, trim right away. // otherwise, do it whenever it's convenient. if (length > maxLength) trim() } , get : function () { return maxLength } , enumerable : true }) this.maxLength = maxLength Object.defineProperty(this, "length", { get : function () { return length } , enumerable : true }) this.reset = function () { cache = {} lruList = {} lru = 0 mru = 0 length = 0 } // Provided for debugging/dev purposes only. No promises whatsoever that // this API stays stable. this.dump = function () { return cache } this.set = function (key, value) { if (hOP(cache, key)) { this.get(key) cache[key].value = value return undefined } var hit = {key:key, value:value, lu:mru++} lruList[hit.lu] = cache[key] = hit length ++ if (length > maxLength) trim() } this.get = function (key) { if (!hOP(cache, key)) return undefined var hit = cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() hit.lu = mru ++ lruList[hit.lu] = hit return hit.value } this.del = function (key) { if (!hOP(cache, key)) return undefined var hit = cache[key] delete cache[key] delete lruList[hit.lu] if (hit.lu === lru) lruWalk() length -- } function lruWalk () { // lru has been deleted, hop up to the next hit. lru = Object.keys(lruList).shift() } function trim () { if (length <= maxLength) return undefined var prune = Object.keys(lruList).slice(0, length - maxLength) for (var i = 0, l = (length - maxLength); i < l; i ++) { delete cache[ lruList[prune[i]].key ] delete lruList[prune[i]] } length = maxLength lruWalk() } } })() package.json000066400000000000000000000014231177713054400361170ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache{ "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", "version": "1.0.6", "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me" }, "scripts": { "test": "tap test" }, "main": "lib/lru-cache.js", "repository": { "type": "git", "url": "git://github.com/isaacs/node-lru-cache.git" }, "devDependencies": { "tap": "0" }, "license": { "type": "MIT", "url": "http://github.com/isaacs/node-lru-cache/raw/master/LICENSE" }, "_id": "lru-cache@1.0.6", "dependencies": {}, "optionalDependencies": {}, "engines": { "node": "*" }, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "lru-cache@~1.0.2" } test/000077500000000000000000000000001177713054400346105ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cachebasic.js000066400000000000000000000053241177713054400362330ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/node_modules/lru-cache/testvar test = require('tap').test , LRU = require('../') test('basic', function (t) { var cache = new LRU(10) cache.set("key", "value") t.equal(cache.get("key"), "value") t.equal(cache.get("nada"), undefined) t.equal(cache.length, 1) t.equal(cache.maxLength, 10) t.end() }) test('least recently set', function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), "B") t.equal(cache.get("a"), undefined) t.end() }) test('lru recently gotten', function (t) { var cache = new LRU(2) cache.set("a", "A") cache.set("b", "B") cache.get("a") cache.set("c", "C") t.equal(cache.get("c"), "C") t.equal(cache.get("b"), undefined) t.equal(cache.get("a"), "A") t.end() }) test('del', function (t) { var cache = new LRU(2) cache.set("a", "A") cache.del("a") t.equal(cache.get("a"), undefined) t.end() }) test('maxLength', function (t) { var cache = new LRU(3) // test changing the maxLength, verify that the LRU items get dropped. cache.maxLength = 100 for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } // now remove the maxLength restriction, and try again. cache.maxLength = "hello" for (var i = 0; i < 100; i ++) cache.set(i, i) t.equal(cache.length, 100) for (var i = 0; i < 100; i ++) { t.equal(cache.get(i), i) } // should trigger an immediate resize cache.maxLength = 3 t.equal(cache.length, 3) for (var i = 0; i < 97; i ++) { t.equal(cache.get(i), undefined) } for (var i = 98; i < 100; i ++) { t.equal(cache.get(i), i) } t.end() }) test('reset', function (t) { var cache = new LRU(10) cache.set("a", "A") cache.set("b", "B") cache.reset() t.equal(cache.length, 0) t.equal(cache.maxLength, 10) t.equal(cache.get("a"), undefined) t.equal(cache.get("b"), undefined) t.end() }) // Note: `.dump()` is a debugging tool only. No guarantees are made // about the format/layout of the response. test('dump', function (t) { var cache = new LRU(10) var d = cache.dump(); t.equal(Object.keys(d).length, 0, "nothing in dump for empty cache") cache.set("a", "A") var d = cache.dump() // { a: { key: 'a', value: 'A', lu: 0 } } t.ok(d.a) t.equal(d.a.key, 'a') t.equal(d.a.value, 'A') t.equal(d.a.lu, 0) cache.set("b", "B") cache.get("b") d = cache.dump() t.ok(d.b) t.equal(d.b.key, 'b') t.equal(d.b.value, 'B') t.equal(d.b.lu, 2) t.end() }) lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/package.json000066400000000000000000000014721177713054400316620ustar00rootroot00000000000000{ "author": { "name": "Isaac Z. Schlueter", "email": "i@izs.me", "url": "http://blog.izs.me" }, "name": "minimatch", "description": "a glob matcher in javascript", "version": "0.0.5", "repository": { "type": "git", "url": "git://github.com/isaacs/minimatch.git" }, "main": "minimatch.js", "scripts": { "test": "tap test" }, "engines": { "node": "*" }, "dependencies": { "lru-cache": "~1.0.2" }, "devDependencies": { "tap": "~0.0.5" }, "licenses": [ { "type": "MIT", "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE" } ], "_id": "minimatch@0.0.5", "optionalDependencies": {}, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "minimatch@0.0.x" } lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/t.js000066400000000000000000000002061177713054400301670ustar00rootroot00000000000000console.error(Object.keys(global).length) var m = require("./") console.log(m.makeRe("**")) console.error(Object.keys(global).length) lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/test/000077500000000000000000000000001177713054400303475ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/node_modules/minimatch/test/basic.js000066400000000000000000000135431177713054400317740ustar00rootroot00000000000000// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test var tap = require("tap") , globalBefore = Object.keys(global) , mm = require("../") , files = [ "a", "b", "c", "d", "abc" , "abd", "abe", "bb", "bcd" , "ca", "cb", "dd", "de" , "bdir/", "bdir/cfile"] , next = files.concat([ "a-b", "aXb" , ".x", ".y" ]) tap.test("basic tests", function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] ; [ "http://www.bashcookbook.com/bashinfo" + "/source/bash-1.14.7/tests/glob-test" , ["a*", ["a", "abc", "abd", "abe"]] , ["X*", ["X*"]] // allow null glob expansion , ["X*", [], { null: true }] // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star , ["\\*", ["\\*"]] , ["\\**", ["\\**"]] , ["b*/", ["bdir/"]] , ["c*", ["c", "ca", "cb"]] , ["**", files] , ["\\.\\./*/", ["\\.\\./*/"]] , ["s/\\..*//", ["s/\\..*//"]] , "legendary larry crashes bashes" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"]] , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/" , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"]] , "character classes" , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]] , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd", "bdir/", "ca", "cb", "dd", "de"]] , ["a*[^c]", ["abd", "abe"]] , function () { files.push("a-b", "aXb") } , ["a[X-]b", ["a-b", "aXb"]] , function () { files.push(".x", ".y") } , ["[^a-c]*", ["d", "dd", "de"]] , function () { files.push("a*b/", "a*b/ooo") } , ["a\\*b/*", ["a*b/ooo"]] , ["a\\*?/*", ["a*b/ooo"]] , ["*\\\\!*", [], {null: true}, ["echo !7"]] , ["*\\!*", ["echo !7"], null, ["echo !7"]] , ["*.\\*", ["r.*"], null, ["r.*"]] , ["a[b]c", ["abc"]] , ["a[\\b]c", ["abc"]] , ["a?c", ["abc"]] , ["a\\*c", [], {null: true}, ["abc"]] , ["", [""], { null: true }, [""]] , "http://www.opensource.apple.com/source/bash/bash-23/" + "bash/tests/glob-test" , function () { files.push("man/", "man/man1/", "man/man1/bash.1") } , ["*/man*/bash.*", ["man/man1/bash.1"]] , ["man/man1/bash.1", ["man/man1/bash.1"]] , ["a***c", ["abc"], null, ["abc"]] , ["a*****?c", ["abc"], null, ["abc"]] , ["?*****??", ["abc"], null, ["abc"]] , ["*****??", ["abc"], null, ["abc"]] , ["?*****?c", ["abc"], null, ["abc"]] , ["?***?****c", ["abc"], null, ["abc"]] , ["?***?****?", ["abc"], null, ["abc"]] , ["?***?****", ["abc"], null, ["abc"]] , ["*******c", ["abc"], null, ["abc"]] , ["*******?", ["abc"], null, ["abc"]] , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]] , ["[-abc]", ["-"], null, ["-"]] , ["[abc-]", ["-"], null, ["-"]] , ["\\", ["\\"], null, ["\\"]] , ["[\\\\]", ["\\"], null, ["\\"]] , ["[[]", ["["], null, ["["]] , ["[", ["["], null, ["["]] , ["[*", ["[abc"], null, ["[abc"]] , "a right bracket shall lose its special meaning and\n" + "represent itself in a bracket expression if it occurs\n" + "first in the list. -- POSIX.2 2.8.3.2" , ["[]]", ["]"], null, ["]"]] , ["[]-]", ["]"], null, ["]"]] , ["[a-\z]", ["p"], null, ["p"]] , ["[/\\\\]*", ["/tmp"], null, ["/tmp"]] , ["??**********?****?", [], { null: true }, ["abc"]] , ["??**********?****c", [], { null: true }, ["abc"]] , ["?************c****?****", [], { null: true }, ["abc"]] , ["*c*?**", [], { null: true }, ["abc"]] , ["a*****c*?**", [], { null: true }, ["abc"]] , ["a********???*******", [], { null: true }, ["abc"]] , ["[]", [], { null: true }, ["a"]] , ["[abc", [], { null: true }, ["["]] , "nocase tests" , ["XYZ", ["xYz"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["ab*", ["ABC"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true } , ["xYz", "ABC", "IjK"]] // [ pattern, [matches], MM opts, files, TAP opts] , "onestar/twostar" , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]] , ["{/?,*}", ["/a", "bb"], {null: true} , ["/a", "/b/b", "/a/b/c", "bb"]] , "dots should not match unless requested" , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]] // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! , ["**", ["a/b","a/.d",".a/.d"], { dot: true } , [ ".a/.d", "a/.d", "a/b"]] ].forEach(function (c) { if (typeof c === "function") return c() if (typeof c === "string") return t.comment(c) var pattern = c[0] , expect = c[1].sort(alpha) , options = c[2] || {} , f = c[3] || files , tapOpts = c[4] || {} // options.debug = true var r = mm.makeRe(pattern, options) tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern var actual = mm.match(f, pattern, options) t.equivalent( actual, expect , JSON.stringify(pattern) + " " + JSON.stringify(expect) , tapOpts ) }) t.comment("time=" + (Date.now() - start) + "ms") t.end() }) tap.test("global leak test", function (t) { var globalAfter = Object.keys(global) t.equivalent(globalAfter, globalBefore, "no new globals, please") t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } lets_code_javascript-episode2/node_modules/jshint/package.json000066400000000000000000000017341177713054400252350ustar00rootroot00000000000000{ "name": "jshint", "version": "0.7.1", "description": "A CLI for JSHint", "homepage": "http://github.com/jshint/node-jshint", "author": { "name": "Brent Lintner", "email": "brent.lintner@gmail.com", "url": "http://github.com/brentlintner" }, "licenses": [ { "type": "MIT", "url": "http://www.opensource.org/licenses/mit-license.php" } ], "bin": { "jshint": "./bin/hint" }, "main": "packages/jshint/jshint", "files": [ "packages/jshint/README.markdown", "packages/jshint/jshint.js", "README.md", "LICENSE", "bin/hint", "lib" ], "dependencies": { "cli": "0.4.3", "minimatch": "0.0.x" }, "devDependencies": { "jasmine-node": "1.0.x" }, "preferGlobal": true, "_id": "jshint@0.7.1", "optionalDependencies": {}, "engines": { "node": "*" }, "_engineSupported": true, "_npmVersion": "1.1.21", "_nodeVersion": "v0.6.17", "_defaultsLoaded": true, "_from": "jshint" } lets_code_javascript-episode2/node_modules/jshint/packages/000077500000000000000000000000001177713054400245205ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/packages/jshint/000077500000000000000000000000001177713054400260175ustar00rootroot00000000000000lets_code_javascript-episode2/node_modules/jshint/packages/jshint/README.markdown000077500000000000000000000053011177713054400305220ustar00rootroot00000000000000JSHint, A Static Code Analysis Tool for JavaScript ================================================== JSHint is a community-driven tool to detect errors and potential problems in JavaScript code and to enforce your team's coding conventions. **IMPORTANT**: * This README is for people who are thinking about contributing to JSHint. For general usage please refer to [our website](http://jshint.com/). * If you want to report a bug about the website, please go to the [jshint/site](https://github.com/jshint/site/) repository. * If you want to report a bug or contribute to our NPM package, please go to the [jshint/node-jshint](https://github.com/jshint/node-jshint/) repository. Reporting a bug --------------- To report a bug simply create a [new GitHub Issue](https://github.com/jshint/jshint/issues/new) and describe your problem or suggestion. We welcome all kind of feedback regarding JSHint including but not limited to: * When JSHint doesn't work as expected * When JSHint complains about valid JavaScript code that works in all browsers * When you simply want a new option or feature Please, before reporting a bug look around to see if there are any open or closed tickets that cover your issue. And remember the wisdom: pull request > bug report > tweet. Submitting patches ------------------ The best way to make sure your issue is addressed is to submit a patch. GitHub provides a very nice interface--pull requests--for that but we accept patches through all mediums: email, issue comment, tweet with a link to a snippet, etc. Before submitting a patch make sure that you comply to our style. We don't have specific style guide so just look around the code you are changing. Also, make sure that you write tests for new features and make sure that all tests pass before submitting a patch. Patches that break the build will be rejected. **FEATURE FREEZE**: Please note that we currently have a feature freeze on new environments and styling options. The only patches we accept at this time are for bug fixes. Tests ----- To run tests you will need to install [node.js](http://nodejs.org/) and expresso. You can install the latter with npm: npm install expresso After that, running the unit tests is as easy as: expresso tests/unit/*.js Attribution ----------- Core Team members: * [Anton Kovalyov](http://anton.kovalyov.net/) ([@valueof](http://twitter.com/valueof)) * [Wolfgang Kluge](http://klugesoftware.de/) ([blog](http://gehirnwindung.de/)) * [Josh Perez](http://www.goatslacker.com/) ([@goatslacker](http://twitter.com/goatslacker)) Maintainer: Anton Kovalyov Thank you! ---------- We really appreciate all kind of feedback and contributions. Thanks for using and supporting JSHint! lets_code_javascript-episode2/node_modules/jshint/packages/jshint/jshint.js000066400000000000000000004773211177713054400276720ustar00rootroot00000000000000/*! * JSHint, by JSHint Community. * * Licensed under the same slightly modified MIT license that JSLint is. * It stops evil-doers everywhere. * * JSHint is a derivative work of JSLint: * * Copyright (c) 2002 Douglas Crockford (www.JSLint.com) * * 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 shall be used for Good, not Evil. * * 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. * * JSHint was forked from 2010-12-16 edition of JSLint. * */ /* JSHINT is a global function. It takes two parameters. var myResult = JSHINT(source, option); The first parameter is either a string or an array of strings. If it is a string, it will be split on '\n' or '\r'. If it is an array of strings, it is assumed that each string represents one line. The source can be a JavaScript text or a JSON text. The second parameter is an optional object of options which control the operation of JSHINT. Most of the options are booleans: They are all optional and have a default value of false. One of the options, predef, can be an array of names, which will be used to declare global variables, or an object whose keys are used as global names, with a boolean value that determines if they are assignable. If it checks out, JSHINT returns true. Otherwise, it returns false. If false, you can inspect JSHINT.errors to find out the problems. JSHINT.errors is an array of objects containing these members: { line : The line (relative to 0) at which the lint was found character : The character (relative to 0) at which the lint was found reason : The problem evidence : The text line in which the problem occurred raw : The raw message before the details were inserted a : The first detail b : The second detail c : The third detail d : The fourth detail } If a fatal error was found, a null will be the last element of the JSHINT.errors array. You can request a Function Report, which shows all of the functions and the parameters and vars that they use. This can be used to find implied global variables and other problems. The report is in HTML and can be inserted in an HTML . var myReport = JSHINT.report(limited); If limited is true, then the report will be limited to only errors. You can request a data structure which contains JSHint's results. var myData = JSHINT.data(); It returns a structure with this form: { errors: [ { line: NUMBER, character: NUMBER, reason: STRING, evidence: STRING } ], functions: [ name: STRING, line: NUMBER, last: NUMBER, param: [ STRING ], closure: [ STRING ], var: [ STRING ], exception: [ STRING ], outer: [ STRING ], unused: [ STRING ], global: [ STRING ], label: [ STRING ] ], globals: [ STRING ], member: { STRING: NUMBER }, unused: [ { name: STRING, line: NUMBER } ], implieds: [ { name: STRING, line: NUMBER } ], urls: [ STRING ], json: BOOLEAN } Empty arrays will not be included. */ /*jshint evil: true, nomen: false, onevar: false, regexp: false, strict: true, boss: true, undef: true, maxlen: 100, indent:4 */ /*members "\b", "\t", "\n", "\f", "\r", "!=", "!==", "\"", "%", "(begin)", "(breakage)", "(context)", "(error)", "(global)", "(identifier)", "(last)", "(line)", "(loopage)", "(name)", "(onevar)", "(params)", "(scope)", "(statement)", "(verb)", "*", "+", "++", "-", "--", "\/", "<", "<=", "==", "===", ">", ">=", $, $$, $A, $F, $H, $R, $break, $continue, $w, Abstract, Ajax, __filename, __dirname, ActiveXObject, Array, ArrayBuffer, ArrayBufferView, Audio, Autocompleter, Assets, Boolean, Builder, Buffer, Browser, COM, CScript, Canvas, CustomAnimation, Class, Control, Chain, Color, Cookie, Core, DataView, Date, Debug, Draggable, Draggables, Droppables, Document, DomReady, DOMReady, DOMParser, Drag, E, Enumerator, Enumerable, Element, Elements, Error, Effect, EvalError, Event, Events, FadeAnimation, Field, Flash, Float32Array, Float64Array, Form, FormField, Frame, FormData, Function, Fx, GetObject, Group, Hash, HotKey, HTMLElement, HTMLAnchorElement, HTMLBaseElement, HTMLBlockquoteElement, HTMLBodyElement, HTMLBRElement, HTMLButtonElement, HTMLCanvasElement, HTMLDirectoryElement, HTMLDivElement, HTMLDListElement, HTMLFieldSetElement, HTMLFontElement, HTMLFormElement, HTMLFrameElement, HTMLFrameSetElement, HTMLHeadElement, HTMLHeadingElement, HTMLHRElement, HTMLHtmlElement, HTMLIFrameElement, HTMLImageElement, HTMLInputElement, HTMLIsIndexElement, HTMLLabelElement, HTMLLayerElement, HTMLLegendElement, HTMLLIElement, HTMLLinkElement, HTMLMapElement, HTMLMenuElement, HTMLMetaElement, HTMLModElement, HTMLObjectElement, HTMLOListElement, HTMLOptGroupElement, HTMLOptionElement, HTMLParagraphElement, HTMLParamElement, HTMLPreElement, HTMLQuoteElement, HTMLScriptElement, HTMLSelectElement, HTMLStyleElement, HtmlTable, HTMLTableCaptionElement, HTMLTableCellElement, HTMLTableColElement, HTMLTableElement, HTMLTableRowElement, HTMLTableSectionElement, HTMLTextAreaElement, HTMLTitleElement, HTMLUListElement, HTMLVideoElement, Iframe, IframeShim, Image, Int16Array, Int32Array, Int8Array, Insertion, InputValidator, JSON, Keyboard, Locale, LN10, LN2, LOG10E, LOG2E, MAX_VALUE, MIN_VALUE, Mask, Math, MenuItem, MessageChannel, MessageEvent, MessagePort, MoveAnimation, MooTools, Native, NEGATIVE_INFINITY, Number, Object, ObjectRange, Option, Options, OverText, PI, POSITIVE_INFINITY, PeriodicalExecuter, Point, Position, Prototype, RangeError, Rectangle, ReferenceError, RegExp, ResizeAnimation, Request, RotateAnimation, SQRT1_2, SQRT2, ScrollBar, ScriptEngine, ScriptEngineBuildVersion, ScriptEngineMajorVersion, ScriptEngineMinorVersion, Scriptaculous, Scroller, Slick, Slider, Selector, SharedWorker, String, Style, SyntaxError, Sortable, Sortables, SortableObserver, Sound, Spinner, System, Swiff, Text, TextArea, Template, Timer, Tips, Type, TypeError, Toggle, Try, "use strict", unescape, URI, URIError, URL, VBArray, WSH, WScript, XDomainRequest, Web, Window, XMLDOM, XMLHttpRequest, XMLSerializer, XPathEvaluator, XPathException, XPathExpression, XPathNamespace, XPathNSResolver, XPathResult, "\\", a, addEventListener, address, alert, apply, applicationCache, arguments, arity, asi, atob, b, basic, basicToken, bitwise, block, blur, boolOptions, boss, browser, btoa, c, call, callee, caller, cases, charAt, charCodeAt, character, clearInterval, clearTimeout, close, closed, closure, comment, condition, confirm, console, constructor, content, couch, create, css, curly, d, data, datalist, dd, debug, decodeURI, decodeURIComponent, defaultStatus, defineClass, deserialize, devel, document, dojo, dijit, dojox, define, else, emit, encodeURI, encodeURIComponent, entityify, eqeq, eqeqeq, eqnull, errors, es5, escape, esnext, eval, event, evidence, evil, ex, exception, exec, exps, expr, exports, FileReader, first, floor, focus, forin, fragment, frames, from, fromCharCode, fud, funcscope, funct, function, functions, g, gc, getComputedStyle, getRow, getter, getterToken, GLOBAL, global, globals, globalstrict, hasOwnProperty, help, history, i, id, identifier, immed, implieds, importPackage, include, indent, indexOf, init, ins, instanceOf, isAlpha, isApplicationRunning, isArray, isDigit, isFinite, isNaN, iterator, java, join, jshint, JSHINT, json, jquery, jQuery, keys, label, labelled, last, lastsemic, laxbreak, laxcomma, latedef, lbp, led, left, length, line, load, loadClass, localStorage, location, log, loopfunc, m, match, maxerr, maxlen, member,message, meta, module, moveBy, moveTo, mootools, multistr, name, navigator, new, newcap, noarg, node, noempty, nomen, nonew, nonstandard, nud, onbeforeunload, onblur, onerror, onevar, onecase, onfocus, onload, onresize, onunload, open, openDatabase, openURL, opener, opera, options, outer, param, parent, parseFloat, parseInt, passfail, plusplus, predef, print, process, prompt, proto, prototype, prototypejs, provides, push, quit, range, raw, reach, reason, regexp, readFile, readUrl, regexdash, removeEventListener, replace, report, require, reserved, resizeBy, resizeTo, resolvePath, resumeUpdates, respond, rhino, right, runCommand, scroll, screen, scripturl, scrollBy, scrollTo, scrollbar, search, seal, send, serialize, sessionStorage, setInterval, setTimeout, setter, setterToken, shift, slice, smarttabs, sort, spawn, split, stack, status, start, strict, sub, substr, supernew, shadow, supplant, sum, sync, test, toLowerCase, toString, toUpperCase, toint32, token, top, trailing, type, typeOf, Uint16Array, Uint32Array, Uint8Array, undef, undefs, unused, urls, validthis, value, valueOf, var, vars, version, WebSocket, withstmt, white, window, windows, Worker, wsh*/ /*global exports: false */ // We build the application inside a function so that we produce only a single // global variable. That function will be invoked immediately, and its return // value is the JSHINT function itself. var JSHINT = (function () { "use strict"; var anonname, // The guessed name for anonymous functions. // These are operators that should not be used with the ! operator. bang = { '<' : true, '<=' : true, '==' : true, '===': true, '!==': true, '!=' : true, '>' : true, '>=' : true, '+' : true, '-' : true, '*' : true, '/' : true, '%' : true }, // These are the JSHint boolean options. boolOptions = { asi : true, // if automatic semicolon insertion should be tolerated bitwise : true, // if bitwise operators should not be allowed boss : true, // if advanced usage of assignments should be allowed browser : true, // if the standard browser globals should be predefined couch : true, // if CouchDB globals should be predefined curly : true, // if curly braces around all blocks should be required debug : true, // if debugger statements should be allowed devel : true, // if logging globals should be predefined (console, // alert, etc.) dojo : true, // if Dojo Toolkit globals should be predefined eqeqeq : true, // if === should be required eqnull : true, // if == null comparisons should be tolerated es5 : true, // if ES5 syntax should be allowed esnext : true, // if es.next specific syntax should be allowed evil : true, // if eval should be allowed expr : true, // if ExpressionStatement should be allowed as Programs forin : true, // if for in statements must filter funcscope : true, // if only function scope should be used for scope tests globalstrict: true, // if global "use strict"; should be allowed (also // enables 'strict') immed : true, // if immediate invocations must be wrapped in parens iterator : true, // if the `__iterator__` property should be allowed jquery : true, // if jQuery globals should be predefined lastsemic : true, // if semicolons may be ommitted for the trailing // statements inside of a one-line blocks. latedef : true, // if the use before definition should not be tolerated laxbreak : true, // if line breaks should not be checked laxcomma : true, // if line breaks should not be checked around commas loopfunc : true, // if functions should be allowed to be defined within // loops mootools : true, // if MooTools globals should be predefined multistr : true, // allow multiline strings newcap : true, // if constructor names must be capitalized noarg : true, // if arguments.caller and arguments.callee should be // disallowed node : true, // if the Node.js environment globals should be // predefined noempty : true, // if empty blocks should be disallowed nonew : true, // if using `new` for side-effects should be disallowed nonstandard : true, // if non-standard (but widely adopted) globals should // be predefined nomen : true, // if names should be checked onevar : true, // if only one var statement per function should be // allowed onecase : true, // if one case switch statements should be allowed passfail : true, // if the scan should stop on first error plusplus : true, // if increment/decrement should not be allowed proto : true, // if the `__proto__` property should be allowed prototypejs : true, // if Prototype and Scriptaculous globals should be // predefined regexdash : true, // if unescaped first/last dash (-) inside brackets // should be tolerated regexp : true, // if the . should not be allowed in regexp literals rhino : true, // if the Rhino environment globals should be predefined undef : true, // if variables should be declared before used scripturl : true, // if script-targeted URLs should be tolerated shadow : true, // if variable shadowing should be tolerated smarttabs : true, // if smarttabs should be tolerated // (http://www.emacswiki.org/emacs/SmartTabs) strict : true, // require the "use strict"; pragma sub : true, // if all forms of subscript notation are tolerated supernew : true, // if `new function () { ... };` and `new Object;` // should be tolerated trailing : true, // if trailing whitespace rules apply validthis : true, // if 'this' inside a non-constructor function is valid. // This is a function scoped option only. withstmt : true, // if with statements should be allowed white : true, // if strict whitespace rules apply wsh : true // if the Windows Scripting Host environment globals // should be predefined }, // These are the JSHint options that can take any value // (we use this object to detect invalid options) valOptions = { maxlen: false, indent: false, maxerr: false, predef: false }, // These are JSHint boolean options which are shared with JSLint // where the definition in JSHint is opposite JSLint invertedOptions = { bitwise : true, forin : true, newcap : true, nomen : true, plusplus : true, regexp : true, undef : true, white : true, // Inverted and renamed, use JSHint name here eqeqeq : true, onevar : true }, // These are JSHint boolean options which are shared with JSLint // where the name has been changed but the effect is unchanged renamedOptions = { eqeq : "eqeqeq", vars : "onevar", windows : "wsh" }, // browser contains a set of global names which are commonly provided by a // web browser environment. browser = { ArrayBuffer : false, ArrayBufferView : false, Audio : false, addEventListener : false, applicationCache : false, atob : false, blur : false, btoa : false, clearInterval : false, clearTimeout : false, close : false, closed : false, DataView : false, DOMParser : false, defaultStatus : false, document : false, event : false, FileReader : false, Float32Array : false, Float64Array : false, FormData : false, focus : false, frames : false, getComputedStyle : false, HTMLElement : false, HTMLAnchorElement : false, HTMLBaseElement : false, HTMLBlockquoteElement : false, HTMLBodyElement : false, HTMLBRElement : false, HTMLButtonElement : false, HTMLCanvasElement : false, HTMLDirectoryElement : false, HTMLDivElement : false, HTMLDListElement : false, HTMLFieldSetElement : false, HTMLFontElement : false, HTMLFormElement : false, HTMLFrameElement : false, HTMLFrameSetElement : false, HTMLHeadElement : false, HTMLHeadingElement : false, HTMLHRElement : false, HTMLHtmlElement : false, HTMLIFrameElement : false, HTMLImageElement : false, HTMLInputElement : false, HTMLIsIndexElement : false, HTMLLabelElement : false, HTMLLayerElement : false, HTMLLegendElement : false, HTMLLIElement : false, HTMLLinkElement : false, HTMLMapElement : false, HTMLMenuElement : false, HTMLMetaElement : false, HTMLModElement : false, HTMLObjectElement : false, HTMLOListElement : false, HTMLOptGroupElement : false, HTMLOptionElement : false, HTMLParagraphElement : false, HTMLParamElement : false, HTMLPreElement : false, HTMLQuoteElement : false, HTMLScriptElement : false, HTMLSelectElement : false, HTMLStyleElement : false, HTMLTableCaptionElement : false, HTMLTableCellElement : false, HTMLTableColElement : false, HTMLTableElement : false, HTMLTableRowElement : false, HTMLTableSectionElement : false, HTMLTextAreaElement : false, HTMLTitleElement : false, HTMLUListElement : false, HTMLVideoElement : false, history : false, Int16Array : false, Int32Array : false, Int8Array : false, Image : false, length : false, localStorage : false, location : false, MessageChannel : false, MessageEvent : false, MessagePort : false, moveBy : false, moveTo : false, name : false, navigator : false, onbeforeunload : true, onblur : true, onerror : true, onfocus : true, onload : true, onresize : true, onunload : true, open : false, openDatabase : false, opener : false, Option : false, parent : false, print : false, removeEventListener : false, resizeBy : false, resizeTo : false, screen : false, scroll : false, scrollBy : false, scrollTo : false, sessionStorage : false, setInterval : false, setTimeout : false, SharedWorker : false, status : false, top : false, Uint16Array : false, Uint32Array : false, Uint8Array : false, WebSocket : false, window : false, Worker : false, XMLHttpRequest : false, XMLSerializer : false, XPathEvaluator : false, XPathException : false, XPathExpression : false, XPathNamespace : false, XPathNSResolver : false, XPathResult : false }, couch = { "require" : false, respond : false, getRow : false, emit : false, send : false, start : false, sum : false, log : false, exports : false, module : false, provides : false }, devel = { alert : false, confirm : false, console : false, Debug : false, opera : false, prompt : false }, dojo = { dojo : false, dijit : false, dojox : false, define : false, "require" : false }, escapes = { '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '/' : '\\/', '\\': '\\\\' }, funct, // The current function functionicity = [ 'closure', 'exception', 'global', 'label', 'outer', 'unused', 'var' ], functions, // All of the functions global, // The global scope implied, // Implied globals inblock, indent, jsonmode, jquery = { '$' : false, jQuery : false }, lines, lookahead, member, membersOnly, mootools = { '$' : false, '$$' : false, Assets : false, Browser : false, Chain : false, Class : false, Color : false, Cookie : false, Core : false, Document : false, DomReady : false, DOMReady : false, Drag : false, Element : false, Elements : false, Event : false, Events : false, Fx : false, Group : false, Hash : false, HtmlTable : false, Iframe : false, IframeShim : false, InputValidator : false, instanceOf : false, Keyboard : false, Locale : false, Mask : false, MooTools : false, Native : false, Options : false, OverText : false, Request : false, Scroller : false, Slick : false, Slider : false, Sortables : false, Spinner : false, Swiff : false, Tips : false, Type : false, typeOf : false, URI : false, Window : false }, nexttoken, node = { __filename : false, __dirname : false, Buffer : false, console : false, exports : false, GLOBAL : false, global : false, module : false, process : false, require : false, setTimeout : false, clearTimeout : false, setInterval : false, clearInterval : false }, noreach, option, predefined, // Global variables defined by option prereg, prevtoken, prototypejs = { '$' : false, '$$' : false, '$A' : false, '$F' : false, '$H' : false, '$R' : false, '$break' : false, '$continue' : false, '$w' : false, Abstract : false, Ajax : false, Class : false, Enumerable : false, Element : false, Event : false, Field : false, Form : false, Hash : false, Insertion : false, ObjectRange : false, PeriodicalExecuter: false, Position : false, Prototype : false, Selector : false, Template : false, Toggle : false, Try : false, Autocompleter : false, Builder : false, Control : false, Draggable : false, Draggables : false, Droppables : false, Effect : false, Sortable : false, SortableObserver : false, Sound : false, Scriptaculous : false }, rhino = { defineClass : false, deserialize : false, gc : false, help : false, importPackage: false, "java" : false, load : false, loadClass : false, print : false, quit : false, readFile : false, readUrl : false, runCommand : false, seal : false, serialize : false, spawn : false, sync : false, toint32 : false, version : false }, scope, // The current scope stack, // standard contains the global names that are provided by the // ECMAScript standard. standard = { Array : false, Boolean : false, Date : false, decodeURI : false, decodeURIComponent : false, encodeURI : false, encodeURIComponent : false, Error : false, 'eval' : false, EvalError : false, Function : false, hasOwnProperty : false, isFinite : false, isNaN : false, JSON : false, Math : false, Number : false, Object : false, parseInt : false, parseFloat : false, RangeError : false, ReferenceError : false, RegExp : false, String : false, SyntaxError : false, TypeError : false, URIError : false }, // widely adopted global names that are not part of ECMAScript standard nonstandard = { escape : false, unescape : false }, standard_member = { E : true, LN2 : true, LN10 : true, LOG2E : true, LOG10E : true, MAX_VALUE : true, MIN_VALUE : true, NEGATIVE_INFINITY : true, PI : true, POSITIVE_INFINITY : true, SQRT1_2 : true, SQRT2 : true }, directive, syntax = {}, tab, token, urls, useESNextSyntax, warnings, wsh = { ActiveXObject : true, Enumerator : true, GetObject : true, ScriptEngine : true, ScriptEngineBuildVersion : true, ScriptEngineMajorVersion : true, ScriptEngineMinorVersion : true, VBArray : true, WSH : true, WScript : true, XDomainRequest : true }; // Regular expressions. Some of these are stupidly long. var ax, cx, tx, nx, nxg, lx, ix, jx, ft; (function () { /*jshint maxlen:300 */ // unsafe comment or string ax = /@cc|<\/?|script|\]\s*\]|<\s*!|</i; // unsafe characters that are silently deleted by one or more browsers cx = /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/; // token tx = /^\s*([(){}\[.,:;'"~\?\]#@]|==?=?|\/(\*(jshint|jslint|members?|global)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|%=?|&[&=]?|\|[|=]?|>>?>?=?|<([\/=!]|\!(\[|--)?|<=?)?|\^=?|\!=?=?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+([xX][0-9a-fA-F]+|\.[0-9]*)?([eE][+\-]?[0-9]+)?)/; // characters in strings that need escapement nx = /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/; nxg = /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; // star slash lx = /\*\/|\/\*/; // identifier ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/; // javascript url jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i; // catches /* falls through */ comments ft = /^\s*\/\*\s*falls\sthrough\s*\*\/\s*$/; }()); function F() {} // Used by Object.create function is_own(object, name) { // The object.hasOwnProperty method fails when the property under consideration // is named 'hasOwnProperty'. So we have to use this more convoluted form. return Object.prototype.hasOwnProperty.call(object, name); } function checkOption(name, t) { if (valOptions[name] === undefined && boolOptions[name] === undefined) { warning("Bad option: '" + name + "'.", t); } } // Provide critical ES5 functions to ES3. if (typeof Array.isArray !== 'function') { Array.isArray = function (o) { return Object.prototype.toString.apply(o) === '[object Array]'; }; } if (typeof Object.create !== 'function') { Object.create = function (o) { F.prototype = o; return new F(); }; } if (typeof Object.keys !== 'function') { Object.keys = function (o) { var a = [], k; for (k in o) { if (is_own(o, k)) { a.push(k); } } return a; }; } // Non standard methods if (typeof String.prototype.entityify !== 'function') { String.prototype.entityify = function () { return this .replace(/&/g, '&') .replace(//g, '>'); }; } if (typeof String.prototype.isAlpha !== 'function') { String.prototype.isAlpha = function () { return (this >= 'a' && this <= 'z\uffff') || (this >= 'A' && this <= 'Z\uffff'); }; } if (typeof String.prototype.isDigit !== 'function') { String.prototype.isDigit = function () { return (this >= '0' && this <= '9'); }; } if (typeof String.prototype.supplant !== 'function') { String.prototype.supplant = function (o) { return this.replace(/\{([^{}]*)\}/g, function (a, b) { var r = o[b]; return typeof r === 'string' || typeof r === 'number' ? r : a; }); }; } if (typeof String.prototype.name !== 'function') { String.prototype.name = function () { // If the string looks like an identifier, then we can return it as is. // If the string contains no control characters, no quote characters, and no // backslash characters, then we can simply slap some quotes around it. // Otherwise we must also replace the offending characters with safe // sequences. if (ix.test(this)) { return this; } if (nx.test(this)) { return '"' + this.replace(nxg, function (a) { var c = escapes[a]; if (c) { return c; } return '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4); }) + '"'; } return '"' + this + '"'; }; } function combine(t, o) { var n; for (n in o) { if (is_own(o, n)) { t[n] = o[n]; } } } function assume() { if (option.couch) { combine(predefined, couch); } if (option.rhino) { combine(predefined, rhino); } if (option.prototypejs) { combine(predefined, prototypejs); } if (option.node) { combine(predefined, node); option.globalstrict = true; } if (option.devel) { combine(predefined, devel); } if (option.dojo) { combine(predefined, dojo); } if (option.browser) { combine(predefined, browser); } if (option.nonstandard) { combine(predefined, nonstandard); } if (option.jquery) { combine(predefined, jquery); } if (option.mootools) { combine(predefined, mootools); } if (option.wsh) { combine(predefined, wsh); } if (option.esnext) { useESNextSyntax(); } if (option.globalstrict && option.strict !== false) { option.strict = true; } } // Produce an error warning. function quit(message, line, chr) { var percentage = Math.floor((line / lines.length) * 100); throw { name: 'JSHintError', line: line, character: chr, message: message + " (" + percentage + "% scanned).", raw: message }; } function isundef(scope, m, t, a) { return JSHINT.undefs.push([scope, m, t, a]); } function warning(m, t, a, b, c, d) { var ch, l, w; t = t || nexttoken; if (t.id === '(end)') { // `~ t = token; } l = t.line || 0; ch = t.from || 0; w = { id: '(error)', raw: m, evidence: lines[l - 1] || '', line: l, character: ch, a: a, b: b, c: c, d: d }; w.reason = m.supplant(w); JSHINT.errors.push(w); if (option.passfail) { quit('Stopping. ', l, ch); } warnings += 1; if (warnings >= option.maxerr) { quit("Too many errors.", l, ch); } return w; } function warningAt(m, l, ch, a, b, c, d) { return warning(m, { line: l, from: ch }, a, b, c, d); } function error(m, t, a, b, c, d) { var w = warning(m, t, a, b, c, d); } function errorAt(m, l, ch, a, b, c, d) { return error(m, { line: l, from: ch }, a, b, c, d); } // lexical analysis and token construction var lex = (function lex() { var character, from, line, s; // Private lex methods function nextLine() { var at, tw; // trailing whitespace check if (line >= lines.length) return false; character = 1; s = lines[line]; line += 1; // If smarttabs option is used check for spaces followed by tabs only. // Otherwise check for any occurence of mixed tabs and spaces. if (option.smarttabs) at = s.search(/ \t/); else at = s.search(/ \t|\t /); if (at >= 0) warningAt("Mixed spaces and tabs.", line, at + 1); s = s.replace(/\t/g, tab); at = s.search(cx); if (at >= 0) warningAt("Unsafe character.", line, at); if (option.maxlen && option.maxlen < s.length) warningAt("Line too long.", line, s.length); // Check for trailing whitespaces tw = option.trailing && s.match(/^(.*?)\s+$/); if (tw && !/^\s+$/.test(s)) { warningAt("Trailing whitespace.", line, tw[1].length + 1); } return true; } // Produce a token object. The token inherits from a syntax symbol. function it(type, value) { var i, t; if (type === '(color)' || type === '(range)') { t = {type: type}; } else if (type === '(punctuator)' || (type === '(identifier)' && is_own(syntax, value))) { t = syntax[value] || syntax['(error)']; } else { t = syntax[type]; } t = Object.create(t); if (type === '(string)' || type === '(range)') { if (!option.scripturl && jx.test(value)) { warningAt("Script URL.", line, from); } } if (type === '(identifier)') { t.identifier = true; if (value === '__proto__' && !option.proto) { warningAt("The '{a}' property is deprecated.", line, from, value); } else if (value === '__iterator__' && !option.iterator) { warningAt("'{a}' is only available in JavaScript 1.7.", line, from, value); } else if (option.nomen && (value.charAt(0) === '_' || value.charAt(value.length - 1) === '_')) { if (!option.node || token.id === '.' || (value !== '__dirname' && value !== '__filename')) { warningAt("Unexpected {a} in '{b}'.", line, from, "dangling '_'", value); } } } t.value = value; t.line = line; t.character = character; t.from = from; i = t.id; if (i !== '(endline)') { prereg = i && (('(,=:[!&|?{};'.indexOf(i.charAt(i.length - 1)) >= 0) || i === 'return' || i === 'case'); } return t; } // Public lex methods return { init: function (source) { if (typeof source === 'string') { lines = source .replace(/\r\n/g, '\n') .replace(/\r/g, '\n') .split('\n'); } else { lines = source; } // If the first line is a shebang (#!), make it a blank and move on. // Shebangs are used by Node scripts. if (lines[0] && lines[0].substr(0, 2) === '#!') lines[0] = ''; line = 0; nextLine(); from = 1; }, range: function (begin, end) { var c, value = ''; from = character; if (s.charAt(0) !== begin) { errorAt("Expected '{a}' and instead saw '{b}'.", line, character, begin, s.charAt(0)); } for (;;) { s = s.slice(1); character += 1; c = s.charAt(0); switch (c) { case '': errorAt("Missing '{a}'.", line, character, c); break; case end: s = s.slice(1); character += 1; return it('(range)', value); case '\\': warningAt("Unexpected '{a}'.", line, character, c); } value += c; } }, // token -- this is called by advance to get the next token token: function () { var b, c, captures, d, depth, high, i, l, low, q, t, isLiteral, isInRange, n; function match(x) { var r = x.exec(s), r1; if (r) { l = r[0].length; r1 = r[1]; c = r1.charAt(0); s = s.substr(l); from = character + l - r1.length; character += l; return r1; } } function string(x) { var c, j, r = '', allowNewLine = false; if (jsonmode && x !== '"') { warningAt("Strings must use doublequote.", line, character); } function esc(n) { var i = parseInt(s.substr(j + 1, n), 16); j += n; if (i >= 32 && i <= 126 && i !== 34 && i !== 92 && i !== 39) { warningAt("Unnecessary escapement.", line, character); } character += n; c = String.fromCharCode(i); } j = 0; unclosedString: for (;;) { while (j >= s.length) { j = 0; var cl = line, cf = from; if (!nextLine()) { errorAt("Unclosed string.", cl, cf); break unclosedString; } if (allowNewLine) { allowNewLine = false; } else { warningAt("Unclosed string.", cl, cf); } } c = s.charAt(j); if (c === x) { character += 1; s = s.substr(j + 1); return it('(string)', r, x); } if (c < ' ') { if (c === '\n' || c === '\r') { break; } warningAt("Control character in string: {a}.", line, character + j, s.slice(0, j)); } else if (c === '\\') { j += 1; character += 1; c = s.charAt(j); n = s.charAt(j + 1); switch (c) { case '\\': case '"': case '/': break; case '\'': if (jsonmode) { warningAt("Avoid \\'.", line, character); } break; case 'b': c = '\b'; break; case 'f': c = '\f'; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case '0': c = '\0'; // Octal literals fail in strict mode // check if the number is between 00 and 07 // where 'n' is the token next to 'c' if (n >= 0 && n <= 7 && directive["use strict"]) { warningAt( "Octal literals are not allowed in strict mode.", line, character); } break; case 'u': esc(4); break; case 'v': if (jsonmode) { warningAt("Avoid \\v.", line, character); } c = '\v'; break; case 'x': if (jsonmode) { warningAt("Avoid \\x-.", line, character); } esc(2); break; case '': // last character is escape character // always allow new line if escaped, but show // warning if option is not set allowNewLine = true; if (option.multistr) { if (jsonmode) { warningAt("Avoid EOL escapement.", line, character); } c = ''; character -= 1; break; } warningAt("Bad escapement of EOL. Use option multistr if needed.", line, character); break; default: warningAt("Bad escapement.", line, character); } } r += c; character += 1; j += 1; } } for (;;) { if (!s) { return it(nextLine() ? '(endline)' : '(end)', ''); } t = match(tx); if (!t) { t = ''; c = ''; while (s && s < '!') { s = s.substr(1); } if (s) { errorAt("Unexpected '{a}'.", line, character, s.substr(0, 1)); s = ''; } } else { // identifier if (c.isAlpha() || c === '_' || c === '$') { return it('(identifier)', t); } // number if (c.isDigit()) { if (!isFinite(Number(t))) { warningAt("Bad number '{a}'.", line, character, t); } if (s.substr(0, 1).isAlpha()) { warningAt("Missing space after '{a}'.", line, character, t); } if (c === '0') { d = t.substr(1, 1); if (d.isDigit()) { if (token.id !== '.') { warningAt("Don't use extra leading zeros '{a}'.", line, character, t); } } else if (jsonmode && (d === 'x' || d === 'X')) { warningAt("Avoid 0x-. '{a}'.", line, character, t); } } if (t.substr(t.length - 1) === '.') { warningAt( "A trailing decimal point can be confused with a dot '{a}'.", line, character, t); } return it('(number)', t); } switch (t) { // string case '"': case "'": return string(t); // // comment case '//': s = ''; token.comment = true; break; // /* comment case '/*': for (;;) { i = s.search(lx); if (i >= 0) { break; } if (!nextLine()) { errorAt("Unclosed comment.", line, character); } } character += i + 2; if (s.substr(i, 1) === '/') { errorAt("Nested comment.", line, character); } s = s.substr(i + 2); token.comment = true; break; // /*members /*jshint /*global case '/*members': case '/*member': case '/*jshint': case '/*jslint': case '/*global': case '*/': return { value: t, type: 'special', line: line, character: character, from: from }; case '': break; // / case '/': if (token.id === '/=') { errorAt("A regular expression literal can be confused with '/='.", line, from); } if (prereg) { depth = 0; captures = 0; l = 0; for (;;) { b = true; c = s.charAt(l); l += 1; switch (c) { case '': errorAt("Unclosed regular expression.", line, from); return quit('Stopping.', line, from); case '/': if (depth > 0) { warningAt("{a} unterminated regular expression " + "group(s).", line, from + l, depth); } c = s.substr(0, l - 1); q = { g: true, i: true, m: true }; while (q[s.charAt(l)] === true) { q[s.charAt(l)] = false; l += 1; } character += l; s = s.substr(l); q = s.charAt(0); if (q === '/' || q === '*') { errorAt("Confusing regular expression.", line, from); } return it('(regexp)', c); case '\\': c = s.charAt(l); if (c < ' ') { warningAt( "Unexpected control character in regular expression.", line, from + l); } else if (c === '<') { warningAt( "Unexpected escaped character '{a}' in regular expression.", line, from + l, c); } l += 1; break; case '(': depth += 1; b = false; if (s.charAt(l) === '?') { l += 1; switch (s.charAt(l)) { case ':': case '=': case '!': l += 1; break; default: warningAt( "Expected '{a}' and instead saw '{b}'.", line, from + l, ':', s.charAt(l)); } } else { captures += 1; } break; case '|': b = false; break; case ')': if (depth === 0) { warningAt("Unescaped '{a}'.", line, from + l, ')'); } else { depth -= 1; } break; case ' ': q = 1; while (s.charAt(l) === ' ') { l += 1; q += 1; } if (q > 1) { warningAt( "Spaces are hard to count. Use {{a}}.", line, from + l, q); } break; case '[': c = s.charAt(l); if (c === '^') { l += 1; if (option.regexp) { warningAt("Insecure '{a}'.", line, from + l, c); } else if (s.charAt(l) === ']') { errorAt("Unescaped '{a}'.", line, from + l, '^'); } } if (c === ']') { warningAt("Empty class.", line, from + l - 1); } isLiteral = false; isInRange = false; klass: do { c = s.charAt(l); l += 1; switch (c) { case '[': case '^': warningAt("Unescaped '{a}'.", line, from + l, c); if (isInRange) { isInRange = false; } else { isLiteral = true; } break; case '-': if (isLiteral && !isInRange) { isLiteral = false; isInRange = true; } else if (isInRange) { isInRange = false; } else if (s.charAt(l) === ']') { isInRange = true; } else { if (option.regexdash !== (l === 2 || (l === 3 && s.charAt(1) === '^'))) { warningAt("Unescaped '{a}'.", line, from + l - 1, '-'); } isLiteral = true; } break; case ']': if (isInRange && !option.regexdash) { warningAt("Unescaped '{a}'.", line, from + l - 1, '-'); } break klass; case '\\': c = s.charAt(l); if (c < ' ') { warningAt( "Unexpected control character in regular expression.", line, from + l); } else if (c === '<') { warningAt( "Unexpected escaped character '{a}' in regular expression.", line, from + l, c); } l += 1; // \w, \s and \d are never part of a character range if (/[wsd]/i.test(c)) { if (isInRange) { warningAt("Unescaped '{a}'.", line, from + l, '-'); isInRange = false; } isLiteral = false; } else if (isInRange) { isInRange = false; } else { isLiteral = true; } break; case '/': warningAt("Unescaped '{a}'.", line, from + l - 1, '/'); if (isInRange) { isInRange = false; } else { isLiteral = true; } break; case '<': if (isInRange) { isInRange = false; } else { isLiteral = true; } break; default: if (isInRange) { isInRange = false; } else { isLiteral = true; } } } while (c); break; case '.': if (option.regexp) { warningAt("Insecure '{a}'.", line, from + l, c); } break; case ']': case '?': case '{': case '}': case '+': case '*': warningAt("Unescaped '{a}'.", line, from + l, c); } if (b) { switch (s.charAt(l)) { case '?': case '+': case '*': l += 1; if (s.charAt(l) === '?') { l += 1; } break; case '{': l += 1; c = s.charAt(l); if (c < '0' || c > '9') { warningAt( "Expected a number and instead saw '{a}'.", line, from + l, c); } l += 1; low = +c; for (;;) { c = s.charAt(l); if (c < '0' || c > '9') { break; } l += 1; low = +c + (low * 10); } high = low; if (c === ',') { l += 1; high = Infinity; c = s.charAt(l); if (c >= '0' && c <= '9') { l += 1; high = +c; for (;;) { c = s.charAt(l); if (c < '0' || c > '9') { break; } l += 1; high = +c + (high * 10); } } } if (s.charAt(l) !== '}') { warningAt( "Expected '{a}' and instead saw '{b}'.", line, from + l, '}', c); } else { l += 1; } if (s.charAt(l) === '?') { l += 1; } if (low > high) { warningAt( "'{a}' should not be greater than '{b}'.", line, from + l, low, high); } } } } c = s.substr(0, l - 1); character += l; s = s.substr(l); return it('(regexp)', c); } return it('(punctuator)', t); // punctuator case '#': return it('(punctuator)', t); default: return it('(punctuator)', t); } } } } }; }()); function addlabel(t, type) { if (t === 'hasOwnProperty') { warning("'hasOwnProperty' is a really bad name."); } // Define t in the current function in the current scope. if (is_own(funct, t) && !funct['(global)']) { if (funct[t] === true) { if (option.latedef) warning("'{a}' was used before it was defined.", nexttoken, t); } else { if (!option.shadow && type !== "exception") warning("'{a}' is already defined.", nexttoken, t); } } funct[t] = type; if (funct['(global)']) { global[t] = funct; if (is_own(implied, t)) { if (option.latedef) warning("'{a}' was used before it was defined.", nexttoken, t); delete implied[t]; } } else { scope[t] = funct; } } function doOption() { var b, obj, filter, o = nexttoken.value, t, tn, v; switch (o) { case '*/': error("Unbegun comment."); break; case '/*members': case '/*member': o = '/*members'; if (!membersOnly) { membersOnly = {}; } obj = membersOnly; break; case '/*jshint': case '/*jslint': obj = option; filter = boolOptions; break; case '/*global': obj = predefined; break; default: error("What?"); } t = lex.token(); loop: for (;;) { for (;;) { if (t.type === 'special' && t.value === '*/') { break loop; } if (t.id !== '(endline)' && t.id !== ',') { break; } t = lex.token(); } if (t.type !== '(string)' && t.type !== '(identifier)' && o !== '/*members') { error("Bad option.", t); } v = lex.token(); if (v.id === ':') { v = lex.token(); if (obj === membersOnly) { error("Expected '{a}' and instead saw '{b}'.", t, '*/', ':'); } if (o === '/*jshint') { checkOption(t.value, t); } if (t.value === 'indent' && (o === '/*jshint' || o === '/*jslint')) { b = +v.value; if (typeof b !== 'number' || !isFinite(b) || b <= 0 || Math.floor(b) !== b) { error("Expected a small integer and instead saw '{a}'.", v, v.value); } obj.white = true; obj.indent = b; } else if (t.value === 'maxerr' && (o === '/*jshint' || o === '/*jslint')) { b = +v.value; if (typeof b !== 'number' || !isFinite(b) || b <= 0 || Math.floor(b) !== b) { error("Expected a small integer and instead saw '{a}'.", v, v.value); } obj.maxerr = b; } else if (t.value === 'maxlen' && (o === '/*jshint' || o === '/*jslint')) { b = +v.value; if (typeof b !== 'number' || !isFinite(b) || b <= 0 || Math.floor(b) !== b) { error("Expected a small integer and instead saw '{a}'.", v, v.value); } obj.maxlen = b; } else if (t.value === 'validthis') { if (funct['(global)']) { error("Option 'validthis' can't be used in a global scope."); } else { if (v.value === 'true' || v.value === 'false') obj[t.value] = v.value === 'true'; else error("Bad option value.", v); } } else if (v.value === 'true' || v.value === 'false') { if (o === '/*jslint') { tn = renamedOptions[t.value] || t.value; obj[tn] = v.value === 'true'; if (invertedOptions[tn] !== undefined) { obj[tn] = !obj[tn]; } } else { obj[t.value] = v.value === 'true'; } } else { error("Bad option value.", v); } t = lex.token(); } else { if (o === '/*jshint' || o === '/*jslint') { error("Missing option value.", t); } obj[t.value] = false; t = v; } } if (filter) { assume(); } } // We need a peek function. If it has an argument, it peeks that much farther // ahead. It is used to distinguish // for ( var i in ... // from // for ( var i = ... function peek(p) { var i = p || 0, j = 0, t; while (j <= i) { t = lookahead[j]; if (!t) { t = lookahead[j] = lex.token(); } j += 1; } return t; } // Produce the next token. It looks for programming errors. function advance(id, t) { switch (token.id) { case '(number)': if (nexttoken.id === '.') { warning("A dot following a number can be confused with a decimal point.", token); } break; case '-': if (nexttoken.id === '-' || nexttoken.id === '--') { warning("Confusing minusses."); } break; case '+': if (nexttoken.id === '+' || nexttoken.id === '++') { warning("Confusing plusses."); } break; } if (token.type === '(string)' || token.identifier) { anonname = token.value; } if (id && nexttoken.id !== id) { if (t) { if (nexttoken.id === '(end)') { warning("Unmatched '{a}'.", t, t.id); } else { warning("Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.", nexttoken, id, t.id, t.line, nexttoken.value); } } else if (nexttoken.type !== '(identifier)' || nexttoken.value !== id) { warning("Expected '{a}' and instead saw '{b}'.", nexttoken, id, nexttoken.value); } } prevtoken = token; token = nexttoken; for (;;) { nexttoken = lookahead.shift() || lex.token(); if (nexttoken.id === '(end)' || nexttoken.id === '(error)') { return; } if (nexttoken.type === 'special') { doOption(); } else { if (nexttoken.id !== '(endline)') { break; } } } } // This is the heart of JSHINT, the Pratt parser. In addition to parsing, it // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is // like .nud except that it is only used on the first token of a statement. // Having .fud makes it much easier to define statement-oriented languages like // JavaScript. I retained Pratt's nomenclature. // .nud Null denotation // .fud First null denotation // .led Left denotation // lbp Left binding power // rbp Right binding power // They are elements of the parsing method called Top Down Operator Precedence. function expression(rbp, initial) { var left, isArray = false, isObject = false; if (nexttoken.id === '(end)') error("Unexpected early end of program.", token); advance(); if (initial) { anonname = 'anonymous'; funct['(verb)'] = token.value; } if (initial === true && token.fud) { left = token.fud(); } else { if (token.nud) { left = token.nud(); } else { if (nexttoken.type === '(number)' && token.id === '.') { warning("A leading decimal point can be confused with a dot: '.{a}'.", token, nexttoken.value); advance(); return token; } else { error("Expected an identifier and instead saw '{a}'.", token, token.id); } } while (rbp < nexttoken.lbp) { isArray = token.value === 'Array'; isObject = token.value === 'Object'; // #527, new Foo.Array(), Foo.Array(), new Foo.Object(), Foo.Object() // Line breaks in IfStatement heads exist to satisfy the checkJSHint // "Line too long." error. if (left && (left.value || (left.first && left.first.value))) { // If the left.value is not "new", or the left.first.value is a "." // then safely assume that this is not "new Array()" and possibly // not "new Object()"... if (left.value !== 'new' || (left.first && left.first.value && left.first.value === '.')) { isArray = false; // ...In the case of Object, if the left.value and token.value // are not equal, then safely assume that this not "new Object()" if (left.value !== token.value) { isObject = false; } } } advance(); if (isArray && token.id === '(' && nexttoken.id === ')') warning("Use the array literal notation [].", token); if (isObject && token.id === '(' && nexttoken.id === ')') warning("Use the object literal notation {}.", token); if (token.led) { left = token.led(left); } else { error("Expected an operator and instead saw '{a}'.", token, token.id); } } } return left; } // Functions for conformance of style. function adjacent(left, right) { left = left || token; right = right || nexttoken; if (option.white) { if (left.character !== right.from && left.line === right.line) { left.from += (left.character - left.from); warning("Unexpected space after '{a}'.", left, left.value); } } } function nobreak(left, right) { left = left || token; right = right || nexttoken; if (option.white && (left.character !== right.from || left.line !== right.line)) { warning("Unexpected space before '{a}'.", right, right.value); } } function nospace(left, right) { left = left || token; right = right || nexttoken; if (option.white && !left.comment) { if (left.line === right.line) { adjacent(left, right); } } } function nonadjacent(left, right) { if (option.white) { left = left || token; right = right || nexttoken; if (left.line === right.line && left.character === right.from) { left.from += (left.character - left.from); warning("Missing space after '{a}'.", left, left.value); } } } function nobreaknonadjacent(left, right) { left = left || token; right = right || nexttoken; if (!option.laxbreak && left.line !== right.line) { warning("Bad line breaking before '{a}'.", right, right.id); } else if (option.white) { left = left || token; right = right || nexttoken; if (left.character === right.from) { left.from += (left.character - left.from); warning("Missing space after '{a}'.", left, left.value); } } } function indentation(bias) { var i; if (option.white && nexttoken.id !== '(end)') { i = indent + (bias || 0); if (nexttoken.from !== i) { warning( "Expected '{a}' to have an indentation at {b} instead at {c}.", nexttoken, nexttoken.value, i, nexttoken.from); } } } function nolinebreak(t) { t = t || token; if (t.line !== nexttoken.line) { warning("Line breaking error '{a}'.", t, t.value); } } function comma() { if (token.line !== nexttoken.line) { if (!option.laxcomma) { if (comma.first) { warning("Comma warnings can be turned off with 'laxcomma'"); comma.first = false; } warning("Bad line breaking before '{a}'.", token, nexttoken.id); } } else if (!token.comment && token.character !== nexttoken.from && option.white) { token.from += (token.character - token.from); warning("Unexpected space after '{a}'.", token, token.value); } advance(','); nonadjacent(token, nexttoken); } // Functional constructors for making the symbols that will be inherited by // tokens. function symbol(s, p) { var x = syntax[s]; if (!x || typeof x !== 'object') { syntax[s] = x = { id: s, lbp: p, value: s }; } return x; } function delim(s) { return symbol(s, 0); } function stmt(s, f) { var x = delim(s); x.identifier = x.reserved = true; x.fud = f; return x; } function blockstmt(s, f) { var x = stmt(s, f); x.block = true; return x; } function reserveName(x) { var c = x.id.charAt(0); if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { x.identifier = x.reserved = true; } return x; } function prefix(s, f) { var x = symbol(s, 150); reserveName(x); x.nud = (typeof f === 'function') ? f : function () { this.right = expression(150); this.arity = 'unary'; if (this.id === '++' || this.id === '--') { if (option.plusplus) { warning("Unexpected use of '{a}'.", this, this.id); } else if ((!this.right.identifier || this.right.reserved) && this.right.id !== '.' && this.right.id !== '[') { warning("Bad operand.", this); } } return this; }; return x; } function type(s, f) { var x = delim(s); x.type = s; x.nud = f; return x; } function reserve(s, f) { var x = type(s, f); x.identifier = x.reserved = true; return x; } function reservevar(s, v) { return reserve(s, function () { if (typeof v === 'function') { v(this); } return this; }); } function infix(s, f, p, w) { var x = symbol(s, p); reserveName(x); x.led = function (left) { if (!w) { nobreaknonadjacent(prevtoken, token); nonadjacent(token, nexttoken); } if (s === "in" && left.id === "!") { warning("Confusing use of '{a}'.", left, '!'); } if (typeof f === 'function') { return f(left, this); } else { this.left = left; this.right = expression(p); return this; } }; return x; } function relation(s, f) { var x = symbol(s, 100); x.led = function (left) { nobreaknonadjacent(prevtoken, token); nonadjacent(token, nexttoken); var right = expression(100); if ((left && left.id === 'NaN') || (right && right.id === 'NaN')) { warning("Use the isNaN function to compare with NaN.", this); } else if (f) { f.apply(this, [left, right]); } if (left.id === '!') { warning("Confusing use of '{a}'.", left, '!'); } if (right.id === '!') { warning("Confusing use of '{a}'.", right, '!'); } this.left = left; this.right = right; return this; }; return x; } function isPoorRelation(node) { return node && ((node.type === '(number)' && +node.value === 0) || (node.type === '(string)' && node.value === '') || (node.type === 'null' && !option.eqnull) || node.type === 'true' || node.type === 'false' || node.type === 'undefined'); } function assignop(s, f) { symbol(s, 20).exps = true; return infix(s, function (left, that) { var l; that.left = left; if (predefined[left.value] === false && scope[left.value]['(global)'] === true) { warning("Read only.", left); } else if (left['function']) { warning("'{a}' is a function.", left, left.value); } if (left) { if (option.esnext && funct[left.value] === 'const') { warning("Attempting to override '{a}' which is a constant", left, left.value); } if (left.id === '.' || left.id === '[') { if (!left.left || left.left.value === 'arguments') { warning('Bad assignment.', that); } that.right = expression(19); return that; } else if (left.identifier && !left.reserved) { if (funct[left.value] === 'exception') { warning("Do not assign to the exception parameter.", left); } that.right = expression(19); return that; } if (left === syntax['function']) { warning( "Expected an identifier in an assignment and instead saw a function invocation.", token); } } error("Bad assignment.", that); }, 20); } function bitwise(s, f, p) { var x = symbol(s, p); reserveName(x); x.led = (typeof f === 'function') ? f : function (left) { if (option.bitwise) { warning("Unexpected use of '{a}'.", this, this.id); } this.left = left; this.right = expression(p); return this; }; return x; } function bitwiseassignop(s) { symbol(s, 20).exps = true; return infix(s, function (left, that) { if (option.bitwise) { warning("Unexpected use of '{a}'.", that, that.id); } nonadjacent(prevtoken, token); nonadjacent(token, nexttoken); if (left) { if (left.id === '.' || left.id === '[' || (left.identifier && !left.reserved)) { expression(19); return that; } if (left === syntax['function']) { warning( "Expected an identifier in an assignment, and instead saw a function invocation.", token); } return that; } error("Bad assignment.", that); }, 20); } function suffix(s, f) { var x = symbol(s, 150); x.led = function (left) { if (option.plusplus) { warning("Unexpected use of '{a}'.", this, this.id); } else if ((!left.identifier || left.reserved) && left.id !== '.' && left.id !== '[') { warning("Bad operand.", this); } this.left = left; return this; }; return x; } // fnparam means that this identifier is being defined as a function // argument (see identifier()) function optionalidentifier(fnparam) { if (nexttoken.identifier) { advance(); if (token.reserved && !option.es5) { // `undefined` as a function param is a common pattern to protect // against the case when somebody does `undefined = true` and // help with minification. More info: https://gist.github.com/315916 if (!fnparam || token.value !== 'undefined') { warning("Expected an identifier and instead saw '{a}' (a reserved word).", token, token.id); } } return token.value; } } // fnparam means that this identifier is being defined as a function // argument function identifier(fnparam) { var i = optionalidentifier(fnparam); if (i) { return i; } if (token.id === 'function' && nexttoken.id === '(') { warning("Missing name in function declaration."); } else { error("Expected an identifier and instead saw '{a}'.", nexttoken, nexttoken.value); } } function reachable(s) { var i = 0, t; if (nexttoken.id !== ';' || noreach) { return; } for (;;) { t = peek(i); if (t.reach) { return; } if (t.id !== '(endline)') { if (t.id === 'function') { if (!option.latedef) { break; } warning( "Inner functions should be listed at the top of the outer function.", t); break; } warning("Unreachable '{a}' after '{b}'.", t, t.value, s); break; } i += 1; } } function statement(noindent) { var i = indent, r, s = scope, t = nexttoken; if (t.id === ";") { advance(";"); return; } // Is this a labelled statement? if (t.identifier && !t.reserved && peek().id === ':') { advance(); advance(':'); scope = Object.create(s); addlabel(t.value, 'label'); if (!nexttoken.labelled) { warning("Label '{a}' on {b} statement.", nexttoken, t.value, nexttoken.value); } if (jx.test(t.value + ':')) { warning("Label '{a}' looks like a javascript url.", t, t.value); } nexttoken.label = t.value; t = nexttoken; } // Parse the statement. if (!noindent) { indentation(); } r = expression(0, true); // Look for the final semicolon. if (!t.block) { if (!option.expr && (!r || !r.exps)) { warning("Expected an assignment or function call and instead saw an expression.", token); } else if (option.nonew && r.id === '(' && r.left.id === 'new') { warning("Do not use 'new' for side effects."); } if (nexttoken.id === ',') { return comma(); } if (nexttoken.id !== ';') { if (!option.asi) { // If this is the last statement in a block that ends on // the same line *and* option lastsemic is on, ignore the warning. // Otherwise, complain about missing semicolon. if (!option.lastsemic || nexttoken.id !== '}' || nexttoken.line !== token.line) { warningAt("Missing semicolon.", token.line, token.character); } } } else { adjacent(token, nexttoken); advance(';'); nonadjacent(token, nexttoken); } } // Restore the indentation. indent = i; scope = s; return r; } function statements(startLine) { var a = [], f, p; while (!nexttoken.reach && nexttoken.id !== '(end)') { if (nexttoken.id === ';') { p = peek(); if (!p || p.id !== "(") { warning("Unnecessary semicolon."); } advance(';'); } else { a.push(statement(startLine === nexttoken.line)); } } return a; } /* * read all directives * recognizes a simple form of asi, but always * warns, if it is used */ function directives() { var i, p, pn; for (;;) { if (nexttoken.id === "(string)") { p = peek(0); if (p.id === "(endline)") { i = 1; do { pn = peek(i); i = i + 1; } while (pn.id === "(endline)"); if (pn.id !== ";") { if (pn.id !== "(string)" && pn.id !== "(number)" && pn.id !== "(regexp)" && pn.identifier !== true && pn.id !== "}") { break; } warning("Missing semicolon.", nexttoken); } else { p = pn; } } else if (p.id === "}") { // directive with no other statements, warn about missing semicolon warning("Missing semicolon.", p); } else if (p.id !== ";") { break; } indentation(); advance(); if (directive[token.value]) { warning("Unnecessary directive \"{a}\".", token, token.value); } if (token.value === "use strict") { option.newcap = true; option.undef = true; } // there's no directive negation, so always set to true directive[token.value] = true; if (p.id === ";") { advance(";"); } continue; } break; } } /* * Parses a single block. A block is a sequence of statements wrapped in * braces. * * ordinary - true for everything but function bodies and try blocks. * stmt - true if block can be a single statement (e.g. in if/for/while). * isfunc - true if block is a function body */ function block(ordinary, stmt, isfunc) { var a, b = inblock, old_indent = indent, m, s = scope, t, line, d; inblock = ordinary; if (!ordinary || !option.funcscope) scope = Object.create(scope); nonadjacent(token, nexttoken); t = nexttoken; if (nexttoken.id === '{') { advance('{'); line = token.line; if (nexttoken.id !== '}') { indent += option.indent; while (!ordinary && nexttoken.from > indent) { indent += option.indent; } if (isfunc) { m = {}; for (d in directive) { if (is_own(directive, d)) { m[d] = directive[d]; } } directives(); if (option.strict && funct['(context)']['(global)']) { if (!m["use strict"] && !directive["use strict"]) { warning("Missing \"use strict\" statement."); } } } a = statements(line); if (isfunc) { directive = m; } indent -= option.indent; if (line !== nexttoken.line) { indentation(); } } else if (line !== nexttoken.line) { indentation(); } advance('}', t); indent = old_indent; } else if (!ordinary) { error("Expected '{a}' and instead saw '{b}'.", nexttoken, '{', nexttoken.value); } else { if (!stmt || option.curly) warning("Expected '{a}' and instead saw '{b}'.", nexttoken, '{', nexttoken.value); noreach = true; indent += option.indent; // test indentation only if statement is in new line a = [statement(nexttoken.line === token.line)]; indent -= option.indent; noreach = false; } funct['(verb)'] = null; if (!ordinary || !option.funcscope) scope = s; inblock = b; if (ordinary && option.noempty && (!a || a.length === 0)) { warning("Empty block."); } return a; } function countMember(m) { if (membersOnly && typeof membersOnly[m] !== 'boolean') { warning("Unexpected /*member '{a}'.", token, m); } if (typeof member[m] === 'number') { member[m] += 1; } else { member[m] = 1; } } function note_implied(token) { var name = token.value, line = token.line, a = implied[name]; if (typeof a === 'function') { a = false; } if (!a) { a = [line]; implied[name] = a; } else if (a[a.length - 1] !== line) { a.push(line); } } // Build the syntax table by declaring the syntactic elements of the language. type('(number)', function () { return this; }); type('(string)', function () { return this; }); syntax['(identifier)'] = { type: '(identifier)', lbp: 0, identifier: true, nud: function () { var v = this.value, s = scope[v], f; if (typeof s === 'function') { // Protection against accidental inheritance. s = undefined; } else if (typeof s === 'boolean') { f = funct; funct = functions[0]; addlabel(v, 'var'); s = funct; funct = f; } // The name is in scope and defined in the current function. if (funct === s) { // Change 'unused' to 'var', and reject labels. switch (funct[v]) { case 'unused': funct[v] = 'var'; break; case 'unction': funct[v] = 'function'; this['function'] = true; break; case 'function': this['function'] = true; break; case 'label': warning("'{a}' is a statement label.", token, v); break; } } else if (funct['(global)']) { // The name is not defined in the function. If we are in the global // scope, then we have an undefined variable. // // Operators typeof and delete do not raise runtime errors even if // the base object of a reference is null so no need to display warning // if we're inside of typeof or delete. if (option.undef && typeof predefined[v] !== 'boolean') { // Attempting to subscript a null reference will throw an // error, even within the typeof and delete operators if (!(anonname === 'typeof' || anonname === 'delete') || (nexttoken && (nexttoken.value === '.' || nexttoken.value === '['))) { isundef(funct, "'{a}' is not defined.", token, v); } } note_implied(token); } else { // If the name is already defined in the current // function, but not as outer, then there is a scope error. switch (funct[v]) { case 'closure': case 'function': case 'var': case 'unused': warning("'{a}' used out of scope.", token, v); break; case 'label': warning("'{a}' is a statement label.", token, v); break; case 'outer': case 'global': break; default: // If the name is defined in an outer function, make an outer entry, // and if it was unused, make it var. if (s === true) { funct[v] = true; } else if (s === null) { warning("'{a}' is not allowed.", token, v); note_implied(token); } else if (typeof s !== 'object') { // Operators typeof and delete do not raise runtime errors even // if the base object of a reference is null so no need to // display warning if we're inside of typeof or delete. if (option.undef) { // Attempting to subscript a null reference will throw an // error, even within the typeof and delete operators if (!(anonname === 'typeof' || anonname === 'delete') || (nexttoken && (nexttoken.value === '.' || nexttoken.value === '['))) { isundef(funct, "'{a}' is not defined.", token, v); } } funct[v] = true; note_implied(token); } else { switch (s[v]) { case 'function': case 'unction': this['function'] = true; s[v] = 'closure'; funct[v] = s['(global)'] ? 'global' : 'outer'; break; case 'var': case 'unused': s[v] = 'closure'; funct[v] = s['(global)'] ? 'global' : 'outer'; break; case 'closure': case 'parameter': funct[v] = s['(global)'] ? 'global' : 'outer'; break; case 'label': warning("'{a}' is a statement label.", token, v); } } } } return this; }, led: function () { error("Expected an operator and instead saw '{a}'.", nexttoken, nexttoken.value); } }; type('(regexp)', function () { return this; }); // ECMAScript parser delim('(endline)'); delim('(begin)'); delim('(end)').reach = true; delim(''); delim('(error)').reach = true; delim('}').reach = true; delim(')'); delim(']'); delim('"').reach = true; delim("'").reach = true; delim(';'); delim(':').reach = true; delim(','); delim('#'); delim('@'); reserve('else'); reserve('case').reach = true; reserve('catch'); reserve('default').reach = true; reserve('finally'); reservevar('arguments', function (x) { if (directive['use strict'] && funct['(global)']) { warning("Strict violation.", x); } }); reservevar('eval'); reservevar('false'); reservevar('Infinity'); reservevar('NaN'); reservevar('null'); reservevar('this', function (x) { if (directive['use strict'] && !option.validthis && ((funct['(statement)'] && funct['(name)'].charAt(0) > 'Z') || funct['(global)'])) { warning("Possible strict violation.", x); } }); reservevar('true'); reservevar('undefined'); assignop('=', 'assign', 20); assignop('+=', 'assignadd', 20); assignop('-=', 'assignsub', 20); assignop('*=', 'assignmult', 20); assignop('/=', 'assigndiv', 20).nud = function () { error("A regular expression literal can be confused with '/='."); }; assignop('%=', 'assignmod', 20); bitwiseassignop('&=', 'assignbitand', 20); bitwiseassignop('|=', 'assignbitor', 20); bitwiseassignop('^=', 'assignbitxor', 20); bitwiseassignop('<<=', 'assignshiftleft', 20); bitwiseassignop('>>=', 'assignshiftright', 20); bitwiseassignop('>>>=', 'assignshiftrightunsigned', 20); infix('?', function (left, that) { that.left = left; that.right = expression(10); advance(':'); that['else'] = expression(10); return that; }, 30); infix('||', 'or', 40); infix('&&', 'and', 50); bitwise('|', 'bitor', 70); bitwise('^', 'bitxor', 80); bitwise('&', 'bitand', 90); relation('==', function (left, right) { var eqnull = option.eqnull && (left.value === 'null' || right.value === 'null'); if (!eqnull && option.eqeqeq) warning("Expected '{a}' and instead saw '{b}'.", this, '===', '=='); else if (isPoorRelation(left)) warning("Use '{a}' to compare with '{b}'.", this, '===', left.value); else if (isPoorRelation(right)) warning("Use '{a}' to compare with '{b}'.", this, '===', right.value); return this; }); relation('==='); relation('!=', function (left, right) { var eqnull = option.eqnull && (left.value === 'null' || right.value === 'null'); if (!eqnull && option.eqeqeq) { warning("Expected '{a}' and instead saw '{b}'.", this, '!==', '!='); } else if (isPoorRelation(left)) { warning("Use '{a}' to compare with '{b}'.", this, '!==', left.value); } else if (isPoorRelation(right)) { warning("Use '{a}' to compare with '{b}'.", this, '!==', right.value); } return this; }); relation('!=='); relation('<'); relation('>'); relation('<='); relation('>='); bitwise('<<', 'shiftleft', 120); bitwise('>>', 'shiftright', 120); bitwise('>>>', 'shiftrightunsigned', 120); infix('in', 'in', 120); infix('instanceof', 'instanceof', 120); infix('+', function (left, that) { var right = expression(130); if (left && right && left.id === '(string)' && right.id === '(string)') { left.value += right.value; left.character = right.character; if (!option.scripturl && jx.test(left.value)) { warning("JavaScript URL.", left); } return left; } that.left = left; that.right = right; return that; }, 130); prefix('+', 'num'); prefix('+++', function () { warning("Confusing pluses."); this.right = expression(150); this.arity = 'unary'; return this; }); infix('+++', function (left) { warning("Confusing pluses."); this.left = left; this.right = expression(130); return this; }, 130); infix('-', 'sub', 130); prefix('-', 'neg'); prefix('---', function () { warning("Confusing minuses."); this.right = expression(150); this.arity = 'unary'; return this; }); infix('---', function (left) { warning("Confusing minuses."); this.left = left; this.right = expression(130); return this; }, 130); infix('*', 'mult', 140); infix('/', 'div', 140); infix('%', 'mod', 140); suffix('++', 'postinc'); prefix('++', 'preinc'); syntax['++'].exps = true; suffix('--', 'postdec'); prefix('--', 'predec'); syntax['--'].exps = true; prefix('delete', function () { var p = expression(0); if (!p || (p.id !== '.' && p.id !== '[')) { warning("Variables should not be deleted."); } this.first = p; return this; }).exps = true; prefix('~', function () { if (option.bitwise) { warning("Unexpected '{a}'.", this, '~'); } expression(150); return this; }); prefix('!', function () { this.right = expression(150); this.arity = 'unary'; if (bang[this.right.id] === true) { warning("Confusing use of '{a}'.", this, '!'); } return this; }); prefix('typeof', 'typeof'); prefix('new', function () { var c = expression(155), i; if (c && c.id !== 'function') { if (c.identifier) { c['new'] = true; switch (c.value) { case 'Number': case 'String': case 'Boolean': case 'Math': case 'JSON': warning("Do not use {a} as a constructor.", token, c.value); break; case 'Function': if (!option.evil) { warning("The Function constructor is eval."); } break; case 'Date': case 'RegExp': break; default: if (c.id !== 'function') { i = c.value.substr(0, 1); if (option.newcap && (i < 'A' || i > 'Z')) { warning("A constructor name should start with an uppercase letter.", token); } } } } else { if (c.id !== '.' && c.id !== '[' && c.id !== '(') { warning("Bad constructor.", token); } } } else { if (!option.supernew) warning("Weird construction. Delete 'new'.", this); } adjacent(token, nexttoken); if (nexttoken.id !== '(' && !option.supernew) { warning("Missing '()' invoking a constructor."); } this.first = c; return this; }); syntax['new'].exps = true; prefix('void').exps = true; infix('.', function (left, that) { adjacent(prevtoken, token); nobreak(); var m = identifier(); if (typeof m === 'string') { countMember(m); } that.left = left; that.right = m; if (left && left.value === 'arguments' && (m === 'callee' || m === 'caller')) { if (option.noarg) warning("Avoid arguments.{a}.", left, m); else if (directive['use strict']) error('Strict violation.'); } else if (!option.evil && left && left.value === 'document' && (m === 'write' || m === 'writeln')) { warning("document.write can be a form of eval.", left); } if (!option.evil && (m === 'eval' || m === 'execScript')) { warning('eval is evil.'); } return that; }, 160, true); infix('(', function (left, that) { if (prevtoken.id !== '}' && prevtoken.id !== ')') { nobreak(prevtoken, token); } nospace(); if (option.immed && !left.immed && left.id === 'function') { warning("Wrap an immediate function invocation in parentheses " + "to assist the reader in understanding that the expression " + "is the result of a function, and not the function itself."); } var n = 0, p = []; if (left) { if (left.type === '(identifier)') { if (left.value.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) { if (left.value !== 'Number' && left.value !== 'String' && left.value !== 'Boolean' && left.value !== 'Date') { if (left.value === 'Math') { warning("Math is not a function.", left); } else if (option.newcap) { warning( "Missing 'new' prefix when invoking a constructor.", left); } } } } } if (nexttoken.id !== ')') { for (;;) { p[p.length] = expression(10); n += 1; if (nexttoken.id !== ',') { break; } comma(); } } advance(')'); nospace(prevtoken, token); if (typeof left === 'object') { if (left.value === 'parseInt' && n === 1) { warning("Missing radix parameter.", left); } if (!option.evil) { if (left.value === 'eval' || left.value === 'Function' || left.value === 'execScript') { warning("eval is evil.", left); } else if (p[0] && p[0].id === '(string)' && (left.value === 'setTimeout' || left.value === 'setInterval')) { warning( "Implied eval is evil. Pass a function instead of a string.", left); } } if (!left.identifier && left.id !== '.' && left.id !== '[' && left.id !== '(' && left.id !== '&&' && left.id !== '||' && left.id !== '?') { warning("Bad invocation.", left); } } that.left = left; return that; }, 155, true).exps = true; prefix('(', function () { nospace(); if (nexttoken.id === 'function') { nexttoken.immed = true; } var v = expression(0); advance(')', this); nospace(prevtoken, token); if (option.immed && v.id === 'function') { if (nexttoken.id === '(' || (nexttoken.id === '.' && (peek().value === 'call' || peek().value === 'apply'))) { warning( "Move the invocation into the parens that contain the function.", nexttoken); } else { warning( "Do not wrap function literals in parens unless they are to be immediately invoked.", this); } } return v; }); infix('[', function (left, that) { nobreak(prevtoken, token); nospace(); var e = expression(0), s; if (e && e.type === '(string)') { if (!option.evil && (e.value === 'eval' || e.value === 'execScript')) { warning("eval is evil.", that); } countMember(e.value); if (!option.sub && ix.test(e.value)) { s = syntax[e.value]; if (!s || !s.reserved) { warning("['{a}'] is better written in dot notation.", e, e.value); } } } advance(']', that); nospace(prevtoken, token); that.left = left; that.right = e; return that; }, 160, true); prefix('[', function () { var b = token.line !== nexttoken.line; this.first = []; if (b) { indent += option.indent; if (nexttoken.from === indent + option.indent) { indent += option.indent; } } while (nexttoken.id !== '(end)') { while (nexttoken.id === ',') { warning("Extra comma."); advance(','); } if (nexttoken.id === ']') { break; } if (b && token.line !== nexttoken.line) { indentation(); } this.first.push(expression(10)); if (nexttoken.id === ',') { comma(); if (nexttoken.id === ']' && !option.es5) { warning("Extra comma.", token); break; } } else { break; } } if (b) { indent -= option.indent; indentation(); } advance(']', this); return this; }, 160); function property_name() { var id = optionalidentifier(true); if (!id) { if (nexttoken.id === '(string)') { id = nexttoken.value; advance(); } else if (nexttoken.id === '(number)') { id = nexttoken.value.toString(); advance(); } } return id; } function functionparams() { var i, t = nexttoken, p = []; advance('('); nospace(); if (nexttoken.id === ')') { advance(')'); return; } for (;;) { i = identifier(true); p.push(i); addlabel(i, 'parameter'); if (nexttoken.id === ',') { comma(); } else { advance(')', t); nospace(prevtoken, token); return p; } } } function doFunction(i, statement) { var f, oldOption = option, oldScope = scope; option = Object.create(option); scope = Object.create(scope); funct = { '(name)' : i || '"' + anonname + '"', '(line)' : nexttoken.line, '(context)' : funct, '(breakage)' : 0, '(loopage)' : 0, '(scope)' : scope, '(statement)': statement }; f = funct; token.funct = funct; functions.push(funct); if (i) { addlabel(i, 'function'); } funct['(params)'] = functionparams(); block(false, false, true); scope = oldScope; option = oldOption; funct['(last)'] = token.line; funct = funct['(context)']; return f; } (function (x) { x.nud = function () { var b, f, i, j, p, t; var props = {}; // All properties, including accessors function saveProperty(name, token) { if (props[name] && is_own(props, name)) warning("Duplicate member '{a}'.", nexttoken, i); else props[name] = {}; props[name].basic = true; props[name].basicToken = token; } function saveSetter(name, token) { if (props[name] && is_own(props, name)) { if (props[name].basic || props[name].setter) warning("Duplicate member '{a}'.", nexttoken, i); } else { props[name] = {}; } props[name].setter = true; props[name].setterToken = token; } function saveGetter(name) { if (props[name] && is_own(props, name)) { if (props[name].basic || props[name].getter) warning("Duplicate member '{a}'.", nexttoken, i); } else { props[name] = {}; } props[name].getter = true; props[name].getterToken = token; } b = token.line !== nexttoken.line; if (b) { indent += option.indent; if (nexttoken.from === indent + option.indent) { indent += option.indent; } } for (;;) { if (nexttoken.id === '}') { break; } if (b) { indentation(); } if (nexttoken.value === 'get' && peek().id !== ':') { advance('get'); if (!option.es5) { error("get/set are ES5 features."); } i = property_name(); if (!i) { error("Missing property name."); } saveGetter(i); t = nexttoken; adjacent(token, nexttoken); f = doFunction(); p = f['(params)']; if (p) { warning("Unexpected parameter '{a}' in get {b} function.", t, p[0], i); } adjacent(token, nexttoken); } else if (nexttoken.value === 'set' && peek().id !== ':') { advance('set'); if (!option.es5) { error("get/set are ES5 features."); } i = property_name(); if (!i) { error("Missing property name."); } saveSetter(i, nexttoken); t = nexttoken; adjacent(token, nexttoken); f = doFunction(); p = f['(params)']; if (!p || p.length !== 1) { warning("Expected a single parameter in set {a} function.", t, i); } } else { i = property_name(); saveProperty(i, nexttoken); if (typeof i !== 'string') { break; } advance(':'); nonadjacent(token, nexttoken); expression(10); } countMember(i); if (nexttoken.id === ',') { comma(); if (nexttoken.id === ',') { warning("Extra comma.", token); } else if (nexttoken.id === '}' && !option.es5) { warning("Extra comma.", token); } } else { break; } } if (b) { indent -= option.indent; indentation(); } advance('}', this); // Check for lonely setters if in the ES5 mode. if (option.es5) { for (var name in props) { if (is_own(props, name) && props[name].setter && !props[name].getter) { warning("Setter is defined without getter.", props[name].setterToken); } } } return this; }; x.fud = function () { error("Expected to see a statement and instead saw a block.", token); }; }(delim('{'))); // This Function is called when esnext option is set to true // it adds the `const` statement to JSHINT useESNextSyntax = function () { var conststatement = stmt('const', function (prefix) { var id, name, value; this.first = []; for (;;) { nonadjacent(token, nexttoken); id = identifier(); if (funct[id] === "const") { warning("const '" + id + "' has already been declared"); } if (funct['(global)'] && predefined[id] === false) { warning("Redefinition of '{a}'.", token, id); } addlabel(id, 'const'); if (prefix) { break; } name = token; this.first.push(token); if (nexttoken.id !== "=") { warning("const " + "'{a}' is initialized to 'undefined'.", token, id); } if (nexttoken.id === '=') { nonadjacent(token, nexttoken); advance('='); nonadjacent(token, nexttoken); if (nexttoken.id === 'undefined') { warning("It is not necessary to initialize " + "'{a}' to 'undefined'.", token, id); } if (peek(0).id === '=' && nexttoken.identifier) { error("Constant {a} was not declared correctly.", nexttoken, nexttoken.value); } value = expression(0); name.first = value; } if (nexttoken.id !== ',') { break; } comma(); } return this; }); conststatement.exps = true; }; var varstatement = stmt('var', function (prefix) { // JavaScript does not have block scope. It only has function scope. So, // declaring a variable in a block can have unexpected consequences. var id, name, value; if (funct['(onevar)'] && option.onevar) { warning("Too many var statements."); } else if (!funct['(global)']) { funct['(onevar)'] = true; } this.first = []; for (;;) { nonadjacent(token, nexttoken); id = identifier(); if (option.esnext && funct[id] === "const") { warning("const '" + id + "' has already been declared"); } if (funct['(global)'] && predefined[id] === false) { warning("Redefinition of '{a}'.", token, id); } addlabel(id, 'unused'); if (prefix) { break; } name = token; this.first.push(token); if (nexttoken.id === '=') { nonadjacent(token, nexttoken); advance('='); nonadjacent(token, nexttoken); if (nexttoken.id === 'undefined') { warning("It is not necessary to initialize '{a}' to 'undefined'.", token, id); } if (peek(0).id === '=' && nexttoken.identifier) { error("Variable {a} was not declared correctly.", nexttoken, nexttoken.value); } value = expression(0); name.first = value; } if (nexttoken.id !== ',') { break; } comma(); } return this; }); varstatement.exps = true; blockstmt('function', function () { if (inblock) { warning("Function declarations should not be placed in blocks. " + "Use a function expression or move the statement to the top of " + "the outer function.", token); } var i = identifier(); if (option.esnext && funct[i] === "const") { warning("const '" + i + "' has already been declared"); } adjacent(token, nexttoken); addlabel(i, 'unction'); doFunction(i, true); if (nexttoken.id === '(' && nexttoken.line === token.line) { error( "Function declarations are not invocable. Wrap the whole function invocation in parens."); } return this; }); prefix('function', function () { var i = optionalidentifier(); if (i) { adjacent(token, nexttoken); } else { nonadjacent(token, nexttoken); } doFunction(i); if (!option.loopfunc && funct['(loopage)']) { warning("Don't make functions within a loop."); } return this; }); blockstmt('if', function () { var t = nexttoken; advance('('); nonadjacent(this, t); nospace(); expression(20); if (nexttoken.id === '=') { if (!option.boss) warning("Expected a conditional expression and instead saw an assignment."); advance('='); expression(20); } advance(')', t); nospace(prevtoken, token); block(true, true); if (nexttoken.id === 'else') { nonadjacent(token, nexttoken); advance('else'); if (nexttoken.id === 'if' || nexttoken.id === 'switch') { statement(true); } else { block(true, true); } } return this; }); blockstmt('try', function () { var b, e, s; block(false); if (nexttoken.id === 'catch') { advance('catch'); nonadjacent(token, nexttoken); advance('('); s = scope; scope = Object.create(s); e = nexttoken.value; if (nexttoken.type !== '(identifier)') { warning("Expected an identifier and instead saw '{a}'.", nexttoken, e); } else { addlabel(e, 'exception'); } advance(); advance(')'); block(false); b = true; scope = s; } if (nexttoken.id === 'finally') { advance('finally'); block(false); return; } else if (!b) { error("Expected '{a}' and instead saw '{b}'.", nexttoken, 'catch', nexttoken.value); } return this; }); blockstmt('while', function () { var t = nexttoken; funct['(breakage)'] += 1; funct['(loopage)'] += 1; advance('('); nonadjacent(this, t); nospace(); expression(20); if (nexttoken.id === '=') { if (!option.boss) warning("Expected a conditional expression and instead saw an assignment."); advance('='); expression(20); } advance(')', t); nospace(prevtoken, token); block(true, true); funct['(breakage)'] -= 1; funct['(loopage)'] -= 1; return this; }).labelled = true; blockstmt('with', function () { var t = nexttoken; if (directive['use strict']) { error("'with' is not allowed in strict mode.", token); } else if (!option.withstmt) { warning("Don't use 'with'.", token); } advance('('); nonadjacent(this, t); nospace(); expression(0); advance(')', t); nospace(prevtoken, token); block(true, true); return this; }); blockstmt('switch', function () { var t = nexttoken, g = false; funct['(breakage)'] += 1; advance('('); nonadjacent(this, t); nospace(); this.condition = expression(20); advance(')', t); nospace(prevtoken, token); nonadjacent(token, nexttoken); t = nexttoken; advance('{'); nonadjacent(token, nexttoken); indent += option.indent; this.cases = []; for (;;) { switch (nexttoken.id) { case 'case': switch (funct['(verb)']) { case 'break': case 'case': case 'continue': case 'return': case 'switch': case 'throw': break; default: // You can tell JSHint that you don't use break intentionally by // adding a comment /* falls through */ on a line just before // the next `case`. if (!ft.test(lines[nexttoken.line - 2])) { warning( "Expected a 'break' statement before 'case'.", token); } } indentation(-option.indent); advance('case'); this.cases.push(expression(20)); g = true; advance(':'); funct['(verb)'] = 'case'; break; case 'default': switch (funct['(verb)']) { case 'break': case 'continue': case 'return': case 'throw': break; default: if (!ft.test(lines[nexttoken.line - 2])) { warning( "Expected a 'break' statement before 'default'.", token); } } indentation(-option.indent); advance('default'); g = true; advance(':'); break; case '}': indent -= option.indent; indentation(); advance('}', t); if (this.cases.length === 1 || this.condition.id === 'true' || this.condition.id === 'false') { if (!option.onecase) warning("This 'switch' should be an 'if'.", this); } funct['(breakage)'] -= 1; funct['(verb)'] = undefined; return; case '(end)': error("Missing '{a}'.", nexttoken, '}'); return; default: if (g) { switch (token.id) { case ',': error("Each value should have its own case label."); return; case ':': g = false; statements(); break; default: error("Missing ':' on a case clause.", token); return; } } else { if (token.id === ':') { advance(':'); error("Unexpected '{a}'.", token, ':'); statements(); } else { error("Expected '{a}' and instead saw '{b}'.", nexttoken, 'case', nexttoken.value); return; } } } } }).labelled = true; stmt('debugger', function () { if (!option.debug) { warning("All 'debugger' statements should be removed."); } return this; }).exps = true; (function () { var x = stmt('do', function () { funct['(breakage)'] += 1; funct['(loopage)'] += 1; this.first = block(true); advance('while'); var t = nexttoken; nonadjacent(token, t); advance('('); nospace(); expression(20); if (nexttoken.id === '=') { if (!option.boss) warning("Expected a conditional expression and instead saw an assignment."); advance('='); expression(20); } advance(')', t); nospace(prevtoken, token); funct['(breakage)'] -= 1; funct['(loopage)'] -= 1; return this; }); x.labelled = true; x.exps = true; }()); blockstmt('for', function () { var s, t = nexttoken; funct['(breakage)'] += 1; funct['(loopage)'] += 1; advance('('); nonadjacent(this, t); nospace(); if (peek(nexttoken.id === 'var' ? 1 : 0).id === 'in') { if (nexttoken.id === 'var') { advance('var'); varstatement.fud.call(varstatement, true); } else { switch (funct[nexttoken.value]) { case 'unused': funct[nexttoken.value] = 'var'; break; case 'var': break; default: warning("Bad for in variable '{a}'.", nexttoken, nexttoken.value); } advance(); } advance('in'); expression(20); advance(')', t); s = block(true, true); if (option.forin && s && (s.length > 1 || typeof s[0] !== 'object' || s[0].value !== 'if')) { warning("The body of a for in should be wrapped in an if statement to filter " + "unwanted properties from the prototype.", this); } funct['(breakage)'] -= 1; funct['(loopage)'] -= 1; return this; } else { if (nexttoken.id !== ';') { if (nexttoken.id === 'var') { advance('var'); varstatement.fud.call(varstatement); } else { for (;;) { expression(0, 'for'); if (nexttoken.id !== ',') { break; } comma(); } } } nolinebreak(token); advance(';'); if (nexttoken.id !== ';') { expression(20); if (nexttoken.id === '=') { if (!option.boss) warning("Expected a conditional expression and instead saw an assignment."); advance('='); expression(20); } } nolinebreak(token); advance(';'); if (nexttoken.id === ';') { error("Expected '{a}' and instead saw '{b}'.", nexttoken, ')', ';'); } if (nexttoken.id !== ')') { for (;;) { expression(0, 'for'); if (nexttoken.id !== ',') { break; } comma(); } } advance(')', t); nospace(prevtoken, token); block(true, true); funct['(breakage)'] -= 1; funct['(loopage)'] -= 1; return this; } }).labelled = true; stmt('break', function () { var v = nexttoken.value; if (funct['(breakage)'] === 0) warning("Unexpected '{a}'.", nexttoken, this.value); if (!option.asi) nolinebreak(this); if (nexttoken.id !== ';') { if (token.line === nexttoken.line) { if (funct[v] !== 'label') { warning("'{a}' is not a statement label.", nexttoken, v); } else if (scope[v] !== funct) { warning("'{a}' is out of scope.", nexttoken, v); } this.first = nexttoken; advance(); } } reachable('break'); return this; }).exps = true; stmt('continue', function () { var v = nexttoken.value; if (funct['(breakage)'] === 0) warning("Unexpected '{a}'.", nexttoken, this.value); if (!option.asi) nolinebreak(this); if (nexttoken.id !== ';') { if (token.line === nexttoken.line) { if (funct[v] !== 'label') { warning("'{a}' is not a statement label.", nexttoken, v); } else if (scope[v] !== funct) { warning("'{a}' is out of scope.", nexttoken, v); } this.first = nexttoken; advance(); } } else if (!funct['(loopage)']) { warning("Unexpected '{a}'.", nexttoken, this.value); } reachable('continue'); return this; }).exps = true; stmt('return', function () { if (this.line === nexttoken.line) { if (nexttoken.id === '(regexp)') warning("Wrap the /regexp/ literal in parens to disambiguate the slash operator."); if (nexttoken.id !== ';' && !nexttoken.reach) { nonadjacent(token, nexttoken); if (peek().value === "=" && !option.boss) { warningAt("Did you mean to return a conditional instead of an assignment?", token.line, token.character + 1); } this.first = expression(0); } } else if (!option.asi) { nolinebreak(this); // always warn (Line breaking error) } reachable('return'); return this; }).exps = true; stmt('throw', function () { nolinebreak(this); nonadjacent(token, nexttoken); this.first = expression(20); reachable('throw'); return this; }).exps = true; // Superfluous reserved words reserve('class'); reserve('const'); reserve('enum'); reserve('export'); reserve('extends'); reserve('import'); reserve('super'); reserve('let'); reserve('yield'); reserve('implements'); reserve('interface'); reserve('package'); reserve('private'); reserve('protected'); reserve('public'); reserve('static'); // Parse JSON function jsonValue() { function jsonObject() { var o = {}, t = nexttoken; advance('{'); if (nexttoken.id !== '}') { for (;;) { if (nexttoken.id === '(end)') { error("Missing '}' to match '{' from line {a}.", nexttoken, t.line); } else if (nexttoken.id === '}') { warning("Unexpected comma.", token); break; } else if (nexttoken.id === ',') { error("Unexpected comma.", nexttoken); } else if (nexttoken.id !== '(string)') { warning("Expected a string and instead saw {a}.", nexttoken, nexttoken.value); } if (o[nexttoken.value] === true) { warning("Duplicate key '{a}'.", nexttoken, nexttoken.value); } else if ((nexttoken.value === '__proto__' && !option.proto) || (nexttoken.value === '__iterator__' && !option.iterator)) { warning("The '{a}' key may produce unexpected results.", nexttoken, nexttoken.value); } else { o[nexttoken.value] = true; } advance(); advance(':'); jsonValue(); if (nexttoken.id !== ',') { break; } advance(','); } } advance('}'); } function jsonArray() { var t = nexttoken; advance('['); if (nexttoken.id !== ']') { for (;;) { if (nexttoken.id === '(end)') { error("Missing ']' to match '[' from line {a}.", nexttoken, t.line); } else if (nexttoken.id === ']') { warning("Unexpected comma.", token); break; } else if (nexttoken.id === ',') { error("Unexpected comma.", nexttoken); } jsonValue(); if (nexttoken.id !== ',') { break; } advance(','); } } advance(']'); } switch (nexttoken.id) { case '{': jsonObject(); break; case '[': jsonArray(); break; case 'true': case 'false': case 'null': case '(number)': case '(string)': advance(); break; case '-': advance('-'); if (token.character !== nexttoken.from) { warning("Unexpected space after '-'.", token); } adjacent(token, nexttoken); advance('(number)'); break; default: error("Expected a JSON value.", nexttoken); } } // The actual JSHINT function itself. var itself = function (s, o, g) { var a, i, k, x, optionKeys, newOptionObj = {}; JSHINT.errors = []; JSHINT.undefs = []; predefined = Object.create(standard); combine(predefined, g || {}); if (o) { a = o.predef; if (a) { if (Array.isArray(a)) { for (i = 0; i < a.length; i += 1) { predefined[a[i]] = true; } } else if (typeof a === 'object') { k = Object.keys(a); for (i = 0; i < k.length; i += 1) { predefined[k[i]] = !!a[k[i]]; } } } optionKeys = Object.keys(o); for (x = 0; x < optionKeys.length; x++) { newOptionObj[optionKeys[x]] = o[optionKeys[x]]; } } option = newOptionObj; option.indent = option.indent || 4; option.maxerr = option.maxerr || 50; tab = ''; for (i = 0; i < option.indent; i += 1) { tab += ' '; } indent = 1; global = Object.create(predefined); scope = global; funct = { '(global)': true, '(name)': '(global)', '(scope)': scope, '(breakage)': 0, '(loopage)': 0 }; functions = [funct]; urls = []; stack = null; member = {}; membersOnly = null; implied = {}; inblock = false; lookahead = []; jsonmode = false; warnings = 0; lex.init(s); prereg = true; directive = {}; prevtoken = token = nexttoken = syntax['(begin)']; // Check options for (var name in o) { if (is_own(o, name)) { checkOption(name, token); } } assume(); // combine the passed globals after we've assumed all our options combine(predefined, g || {}); //reset values comma.first = true; try { advance(); switch (nexttoken.id) { case '{': case '[': option.laxbreak = true; jsonmode = true; jsonValue(); break; default: directives(); if (directive["use strict"] && !option.globalstrict) { warning("Use the function form of \"use strict\".", prevtoken); } statements(); } advance('(end)'); var markDefined = function (name, context) { do { if (typeof context[name] === 'string') { // JSHINT marks unused variables as 'unused' and // unused function declaration as 'unction'. This // code changes such instances back 'var' and // 'closure' so that the code in JSHINT.data() // doesn't think they're unused. if (context[name] === 'unused') context[name] = 'var'; else if (context[name] === 'unction') context[name] = 'closure'; return true; } context = context['(context)']; } while (context); return false; }; var clearImplied = function (name, line) { if (!implied[name]) return; var newImplied = []; for (var i = 0; i < implied[name].length; i += 1) { if (implied[name][i] !== line) newImplied.push(implied[name][i]); } if (newImplied.length === 0) delete implied[name]; else implied[name] = newImplied; }; // Check queued 'x is not defined' instances to see if they're still undefined. for (i = 0; i < JSHINT.undefs.length; i += 1) { k = JSHINT.undefs[i].slice(0); if (markDefined(k[2].value, k[0])) { clearImplied(k[2].value, k[2].line); } else { warning.apply(warning, k.slice(1)); } } } catch (e) { if (e) { var nt = nexttoken || {}; JSHINT.errors.push({ raw : e.raw, reason : e.message, line : e.line || nt.line, character : e.character || nt.from }, null); } } return JSHINT.errors.length === 0; }; // Data summary. itself.data = function () { var data = { functions: [], options: option }, fu, globals, implieds = [], f, i, j, members = [], n, unused = [], v; if (itself.errors.length) { data.errors = itself.errors; } if (jsonmode) { data.json = true; } for (n in implied) { if (is_own(implied, n)) { implieds.push({ name: n, line: implied[n] }); } } if (implieds.length > 0) { data.implieds = implieds; } if (urls.length > 0) { data.urls = urls; } globals = Object.keys(scope); if (globals.length > 0) { data.globals = globals; } for (i = 1; i < functions.length; i += 1) { f = functions[i]; fu = {}; for (j = 0; j < functionicity.length; j += 1) { fu[functionicity[j]] = []; } for (n in f) { if (is_own(f, n) && n.charAt(0) !== '(') { v = f[n]; if (v === 'unction') { v = 'unused'; } if (Array.isArray(fu[v])) { fu[v].push(n); if (v === 'unused') { unused.push({ name: n, line: f['(line)'], 'function': f['(name)'] }); } } } } for (j = 0; j < functionicity.length; j += 1) { if (fu[functionicity[j]].length === 0) { delete fu[functionicity[j]]; } } fu.name = f['(name)']; fu.param = f['(params)']; fu.line = f['(line)']; fu.last = f['(last)']; data.functions.push(fu); } if (unused.length > 0) { data.unused = unused; } members = []; for (n in member) { if (typeof member[n] === 'number') { data.member = member; break; } } return data; }; itself.report = function (option) { var data = itself.data(); var a = [], c, e, err, f, i, k, l, m = '', n, o = [], s; function detail(h, array) { var b, i, singularity; if (array) { o.push('
' + h + ' '); array = array.sort(); for (i = 0; i < array.length; i += 1) { if (array[i] !== singularity) { singularity = array[i]; o.push((b ? ', ' : '') + singularity); b = true; } } o.push('
'); } } if (data.errors || data.implieds || data.unused) { err = true; o.push('
Error:'); if (data.errors) { for (i = 0; i < data.errors.length; i += 1) { c = data.errors[i]; if (c) { e = c.evidence || ''; o.push('

Problem' + (isFinite(c.line) ? ' at line ' + c.line + ' character ' + c.character : '') + ': ' + c.reason.entityify() + '

' + (e && (e.length > 80 ? e.slice(0, 77) + '...' : e).entityify()) + '

'); } } } if (data.implieds) { s = []; for (i = 0; i < data.implieds.length; i += 1) { s[i] = '' + data.implieds[i].name + ' ' + data.implieds[i].line + ''; } o.push('

Implied global: ' + s.join(', ') + '

'); } if (data.unused) { s = []; for (i = 0; i < data.unused.length; i += 1) { s[i] = '' + data.unused[i].name + ' ' + data.unused[i].line + ' ' + data.unused[i]['function'] + ''; } o.push('

Unused variable: ' + s.join(', ') + '

'); } if (data.json) { o.push('

JSON: bad.

'); } o.push('
'); } if (!option) { o.push('
'); if (data.urls) { detail("URLs
", data.urls, '
'); } if (data.json && !err) { o.push('

JSON: good.

'); } else if (data.globals) { o.push('
Global ' + data.globals.sort().join(', ') + '
'); } else { o.push('
No new global variables introduced.
'); } for (i = 0; i < data.functions.length; i += 1) { f = data.functions[i]; o.push('
' + f.line + '-' + f.last + ' ' + (f.name || '') + '(' + (f.param ? f.param.join(', ') : '') + ')
'); detail('Unused', f.unused); detail('Closure', f.closure); detail('Variable', f['var']); detail('Exception', f.exception); detail('Outer', f.outer); detail('Global', f.global); detail('Label', f.label); } if (data.member) { a = Object.keys(data.member); if (a.length) { a = a.sort(); m = '
/*members ';
                    l = 10;
                    for (i = 0; i < a.length; i += 1) {
                        k = a[i];
                        n = k.name();
                        if (l + n.length > 72) {
                            o.push(m + '
');
                            m = '    ';
                            l = 1;
                        }
                        l += n.length + 2;
                        if (data.member[k] === 1) {
                            n = '' + n + '';
                        }
                        if (i < a.length - 1) {
                            n += ', ';
                        }
                        m += n;
                    }
                    o.push(m + '
*/
'); } o.push('
'); } } return o.join(''); }; itself.jshint = itself; return itself; }()); // Make JSHINT a Node module, if possible. if (typeof exports === 'object' && exports) exports.JSHINT = JSHINT; lets_code_javascript-episode2/todo.txt000066400000000000000000000006761177713054400205050ustar00rootroot00000000000000WeeWikiPaint Minimum Marketing Features: * marketing home page - collaborative painting page (very basic) - wiki-fy the pages - more complex painting? - more collaborative features? User Stories: * "hello world" server - "hello world" client (one browser) - support multiple browsers - marketing copy Engineering Tasks: - static code analysis (Lint) - Bring in all options - continuous integration - server-side testing - client-side testing