├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── bin
    └── commonize
├── lib
    ├── cache.js
    ├── commoner.js
    ├── context.js
    ├── grep.js
    ├── output.js
    ├── reader.js
    ├── relative.js
    ├── util.js
    └── watcher.js
├── main.js
├── package.json
└── test
    ├── debug.conf
    ├── release.conf
    ├── run.js
    └── source
        ├── assert.js
        ├── core.js
        ├── home.js
        ├── login.js
        ├── roots.json
        ├── schema.json
        ├── settings.js
        ├── tests
            ├── home.js
            ├── login.js
            └── settings.js
        ├── third-party.js
        └── widget
            ├── .bogus.js
            ├── bogus.js~
            ├── common.js
            ├── follow.js
            ├── gallery.js
            └── share.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | test/output
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.11"
4 |   - "0.10"
5 |   - "0.8"
6 | before_install:
7 |   - npm install -g npm@2.1.10
8 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 Ben Newman <bn@cs.stanford.edu>
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | - - -
  2 | 
  3 | **_This project is not actively maintained. Proceed at your own risk!_**
  4 | 
  5 | - - - 
  6 | 
  7 | Commoner [![Build Status](https://travis-ci.org/reactjs/commoner.png?branch=master)](https://travis-ci.org/reactjs/commoner)
  8 | ---
  9 | 
 10 | Commoner makes it easy to write scripts that flexibly and efficiently
 11 | transpile any dialect of JavaScript into a directory structure of
 12 | Node-compatible CommonJS module files.
 13 | 
 14 | This task is made possible by
 15 | 
 16 |   1. a declarative syntax for defining how module source code should be
 17 |      found and processed,
 18 |   2. the use of [promises](https://github.com/kriskowal/q) to manage an
 19 |      asynchronous build pipeline, and
 20 |   3. never rebuilding modules that have already been built.
 21 | 
 22 | The output files can be required seamlessly by Node, or served by any
 23 | static file server, or bundled together using a tool such as
 24 | [Browserify](https://github.com/substack/node-browserify),
 25 | [WrapUp](https://github.com/kamicane/wrapup), or
 26 | [Stitch](https://github.com/sstephenson/stitch) for delivery to a web
 27 | browser.
 28 | 
 29 | If you pass the `--relativize` option, Commoner also takes care to rewrite
 30 | all `require` calls to use [relative module
 31 | identifiers](http://wiki.commonjs.org/wiki/Modules/1.1#Module_Identifiers),
 32 | so that the output files can be installed into any subdirectory of a
 33 | larger project, and external tools do not have to give special treatment
 34 | to top-level modules (or even know which modules are top-level and which
 35 | are nested).
 36 | 
 37 | Commoner was derived from an earlier, more opinionated tool called
 38 | [Brigade](https://github.com/benjamn/brigade) that provided additional
 39 | support for packaging modules together into multiple non-overlapping
 40 | bundles. Commoner grew out of the realization that many tools already
 41 | exist for bundling CommonJS modules, but that fewer tools focus on getting
 42 | to that point.
 43 | 
 44 | Installation
 45 | ---
 46 | 
 47 | From NPM:
 48 | 
 49 |     npm install commoner
 50 | 
 51 | From GitHub:
 52 | 
 53 |     cd path/to/node_modules
 54 |     git clone git://github.com/reactjs/commoner.git
 55 |     cd commoner
 56 |     npm install .
 57 | 
 58 | Usage
 59 | ---
 60 | 
 61 | Here's the output of `bin/commonize --help`:
 62 | ```
 63 | Usage: commonize [options] <source directory> <output directory> [<module ID> [<module ID> ...]]
 64 | 
 65 | Options:
 66 | 
 67 |   -h, --help                               output usage information
 68 |   -V, --version                            output the version number
 69 |   -c, --config [file]                      JSON configuration file (no file means STDIN)
 70 |   -w, --watch                              Continually rebuild
 71 |   -x, --extension <js | coffee | ...>      File extension to assume when resolving module identifiers
 72 |   --relativize                             Rewrite all module identifiers to be relative
 73 |   --follow-requires                        Scan modules for required dependencies
 74 |   --cache-dir <directory>                  Alternate directory to use for disk cache
 75 |   --no-cache-dir                           Disable the disk cache
 76 |   --source-charset <utf8 | win1252 | ...>  Charset of source (default: utf8)
 77 |   --output-charset <utf8 | win1252 | ...>  Charset of output (default: utf8)
 78 | ```
 79 | 
 80 | In a single sentence: the `commonize` command finds modules with the given
 81 | module identifiers in the source directory and places a processed copy of
 82 | each module into the output directory, along with processed copies of all
 83 | required modules.
 84 | 
 85 | If you do not provide any module identifiers, `commonize` will process all
 86 | files that it can find under the source directory that have the preferred
 87 | file extension (`.js` by default). If your source files have a file
 88 | extension other than `.js`, use the `-x` or `--extension` option to
 89 | specify it. For example, `--extension coffee` to find `.coffee` files.
 90 | 
 91 | Output
 92 | ---
 93 | 
 94 | Commoner prints various status messages to `STDERR`, so that you can see
 95 | what it's doing, or figure out why it's not doing what you thought it
 96 | would do.
 97 | 
 98 | The only information it prints to `STDOUT` is a JSON array of module
 99 | identifiers, which includes the identifiers passed on the command line and
100 | all their dependencies. This array contains no duplicates.
101 | 
102 | Internally, each module that Commoner generates has a hash computed from
103 | the module's identifier, source code, and processing steps. Since this
104 | hash can be computed before processing takes place, Commoner is able to
105 | avoid processing a module if it has ever previously processed the same
106 | module in the same way.
107 | 
108 | If you dig into [the
109 | code](https://github.com/reactjs/commoner/blob/5e7f65cab2/lib/context.js#L94),
110 | you'll find that Commoner maintains a cache directory (by default,
111 | `~/.commoner/module-cache/`) containing files with names like
112 | `9ffc5c853aac07bc106da1dc1b2486903ca688bf.js`.  When Commoner is about to
113 | process a module, it checks its hash against the file names in this
114 | directory. If no match is found, processing procedes and the resulting
115 | file is written to the cache directory with a new hash. If the appropriate
116 | hash file is already present in the cache directory, however, Commoner
117 | merely creates a hard link between the hash file and a file with a more
118 | meaningful name in the output directory.
119 | 
120 | When you pass the `--watch` flag to `bin/commonize`, Commoner avoids
121 | exiting after the first build and instead watches for changes to
122 | previously read files, printing a new JSON array of module identifiers to
123 | `STDOUT` each time rebuilding finishes. Thanks to the caching of processed
124 | modules, the time taken to rebuild is roughly proportional to the number
125 | of modified files.
126 | 
127 | Customization
128 | ---
129 | 
130 | The `bin/commonize` script is actually quite simple, and you can write
131 | similar scripts yourself. Let's have a look:
132 | ```js
133 | #!/usr/bin/env node
134 | 
135 | require("commoner").resolve(function(id) {
136 |     var context = this;
137 | 
138 |     return context.getProvidedP().then(function(idToPath) {
139 |         // If a module declares its own identifier using @providesModule
140 |         // then that identifier will be a key in the idToPath object.
141 |         if (idToPath.hasOwnProperty(id))
142 |             return context.readFileP(idToPath[id]);
143 |     });
144 | 
145 | }, function(id) {
146 |     // Otherwise assume the identifier maps directly to a filesystem path.
147 |     // The readModuleP method simply appends the preferred file extension
148 |     // (usually .js) to the given module identifier and opens that file.
149 |     return this.readModuleP(id);
150 | });
151 | ```
152 | The scriptable interface of the `commoner` module abstracts away many of
153 | the annoyances of writing a command-line script. In particular, you don't
154 | have to do any parsing of command-line arguments, and you don't have to
155 | worry about installing any dependencies other than `commoner` in your
156 | `$NODE_PATH`.
157 | 
158 | What you are responsible for, at a minimum, is telling Commoner how to
159 | find the source of a module given a module identifier, and you do this by
160 | passing callback functions to `require("commoner").resolve`. The script
161 | above uses two strategies that will be tried in sequence: first, it calls
162 | the helper function `this.getProvidedP` to retrieve an object mapping
163 | identifiers to file paths (more about this below); and, if that doesn't
164 | work, it falls back to interpreting the identifier as a path relative to
165 | the source directory.
166 | 
167 | Now, you might not care about `this.getProvidedP`. It's really just a
168 | proof of concept that Commoner can support modules that declare their own
169 | identifiers using the `// @providesModule <identifier>` syntax, and I
170 | included it by default because it doesn't make a difference unless you
171 | decide to use `@providesModule`. If you don't like it, you could write an
172 | even simpler script:
173 | ```js
174 | #!/usr/bin/env node
175 | 
176 | require("commoner").resolve(function(id) {
177 |     return this.readModuleP(id);
178 | });
179 | ```
180 | The point is, it's entirely up to you to define how module identifiers are
181 | interpreted. In fact, the source you return doesn't even have to be valid
182 | JavaScript. It could be [CoffeeScript](http://coffeescript.org/), or
183 | [LESS](http://lesscss.org/), or whatever language you prefer to write by
184 | hand. Commoner doesn't care what your source code looks like, because
185 | Commoner allows you to define arbitrary build steps to turn that source
186 | code into plain old CommonJS.
187 | 
188 | Let's consider the example of using LESS to write dynamic CSS
189 | modules. First, let's apply what we already know to give special meaning
190 | to `.less` files:
191 | ```js
192 | #!/usr/bin/env node
193 | 
194 | require("commoner").resolve(function(id) {
195 |     if (isLess(id))
196 |         return this.readFileP(id);
197 | }, function(id) {
198 |     return this.readModuleP(id);
199 | });
200 | 
201 | function isLess(id) {
202 |     return /\.less$/i.test(id);
203 | }
204 | ```
205 | All this really accomplishes is to avoid appending the `.js` file
206 | extension to identifiers that already have the `.less` extension.
207 | 
208 | Now we need to make sure the contents of `.less` files somehow get
209 | transformed into plain old CommonJS, and for that we need
210 | `require("commoner").process`:
211 | ```js
212 | require("commoner").resolve(function(id) {
213 |     if (isLess(id))
214 |         return this.readFileP(id);
215 | }, function(id) {
216 |     return this.readModuleP(id);
217 | }).process(function(id, source) {
218 |     if (isLess(id))
219 |         return compileLessToJs(source);
220 |     return source;
221 | });
222 | ```
223 | How should `compileLessToJs` be implemented? At a high level, I propose
224 | that we generate a CommonJS module that will append a new `<style>` tag to
225 | the `<head>` the first time the module is required. This suggests to me
226 | that we need to take the CSS generated by LESS and somehow embed it as a
227 | string in a CommonJS module with a small amount of boilerplate JS.
228 | 
229 | Here's a first attempt:
230 | ```js
231 | function compileLessToJs(less) {
232 |     var css = require("less").render(less);
233 |     return 'require("css").add(' + JSON.stringify(css) + ");";
234 | }
235 | ```
236 | Implementing a `css` module with an appropriate `add` method is an
237 | exercise that I will leave to the reader (hint: you may find [this
238 | StackOverflow answer](http://stackoverflow.com/a/524721/128454) useful).
239 | 
240 | This almost works, but there's one problem: `require("less").render` does
241 | not actually return a string! For better or worse, it passes the compiled
242 | CSS to a callback function, which would make our task extremely painful
243 | *if Commoner were not deeply committed to supporting asynchronous
244 | processing*.
245 | 
246 | Commoner uses promises for asynchronous control flow, so we need to return
247 | a promise if we can't return a string immediately. The easiest way to make
248 | a promise is to call `this.makePromise` in the following style:
249 | ```js
250 | #!/usr/bin/env node
251 | 
252 | require("commoner").resolve(function(id) {
253 |     if (isLess(id))
254 |         return this.readFileP(id);
255 | }, function(id) {
256 |     return this.readModuleP(id);
257 | }).process(function(id, source) {
258 |     if (isLess(id)) {
259 |         return this.makePromise(function(nodeStyleCallback) {
260 |             compileLessToJs(source, nodeStyleCallback);
261 |         });
262 |     }
263 |     return source;
264 | });
265 | 
266 | function compileLessToJs(less, callback) {
267 |     require("less").render(less, function(err, css) {
268 |         callback(err, 'require("css").add(' + JSON.stringify(css) + ");")
269 |     });
270 | }
271 | ```
272 | And we're done! This example was admittedly pretty involved, but if you
273 | followed it to the end you now have all the knowledge you need to write
274 | source files like `sidebar.less` and require them from other modules by
275 | invoking `require("sidebar.less")`. (And, by the way, embedding dynamic
276 | CSS modules in your JavaScript turns out to be an excellent idea.)
277 | 
278 | Generating multiple files from one source module
279 | ---
280 | 
281 | Commoner is not limited to generating just one output file from each
282 | source module. For example, if you want to follow best practices for
283 | producing source maps, you probably want to create a `.map.json` file
284 | corresponding to every `.js` file that you compile.
285 | 
286 | Recall that normally your `.process` callback returns a string (or a
287 | promise for a string) whose contents will be written as a `.js` file in
288 | the output directory. To write more than one file, just return an object
289 | whose keys are the file extensions of the files you want to write, and
290 | whose values are either strings or promises for strings representing the
291 | desired contents of those files.
292 | 
293 | Here's an example of generating two different files for every source
294 | module, one called `<id>.map.json` and the other called `<id>.js`:
295 | ```js
296 | require("commoner").resolve(function(id) {
297 |     return this.readModuleP(id);
298 | }).process(function(id, source) {
299 |     var result = compile(source);
300 |     return {
301 |         ".map.json": JSON.stringify(result.sourceMap),
302 |         ".js": [
303 |             result.code,
304 |             "//# sourceMappingURL=" + id + ".map.json"
305 |         ].join("\n")
306 |     };
307 | });
308 | ```
309 | 
310 | Note that
311 | ```js
312 | return {
313 |     ".js": source
314 | };
315 | ```
316 | would be equivalent to
317 | ```js
318 | return source;
319 | ```
320 | so you only have to return an object when you want to generate multiple
321 | files. However, the `.js` key is mandatory when returning an object.
322 | 
323 | For your convenience, if you have a sequence of multiple processing
324 | functions, the values of the object returned from each step will be
325 | resolved before the object is passed along to the next processing
326 | function, so you can be sure all the values are strings (instead of
327 | promises) at the beginning of the next processing function.
328 | 
329 | Configuration
330 | ---
331 | 
332 | Of course, not all customization requires modifying code. Most of the
333 | time, in fact, configuration has more to do with providing different
334 | dynamic values to the same code.
335 | 
336 | For that kind of configuration, you don't need to modify your Commoner
337 | script at all, because Commoner scripts accept a flag called `--config`
338 | that can either specify a JSON file or (if `--config` is given without a
339 | file name) read a string of JSON from `STDIN`.
340 | 
341 | Examples:
342 | 
343 |     bin/commonize source/ output/ main --config release.json
344 |     bin/commonize source/ output/ main --config debug.json
345 |     echo '{"debug":false}' | bin/commonize source/ output/ main --config
346 |     echo '{"debug":true}' | bin/commonize source/ output/ main --config /dev/stdin
347 | 
348 | This configuration object is exposed to the `.resolve` and `.process`
349 | callbacks as `this.config`. So, for example, if you wanted to implement
350 | minification as a processing step, you might do it like this:
351 | ```js
352 | require("commoner").resolve(function(id) {
353 |     return this.readModule(id);
354 | }).process(function(id, source) {
355 |     if (this.config.debug)
356 |         return source;
357 |     return minify(source);
358 | });
359 | ```
360 | Perhaps the coolest thing about the configuration object is that Commoner
361 | generates a recursive hash of all its properties and their values which is
362 | then incorporated into every module hash. This means that two modules with
363 | the same identifier and identical source code and processing steps will
364 | have distinct hashes if built using different configuration objects.
365 | 
366 | Custom Options
367 | ---
368 | 
369 | You can define custom options for your script by using the `option` function.
370 | 
371 | ```js
372 | require("commoner").resolve(function(id) {
373 |     return this.readModule(id);
374 | }).option(
375 |     '--custom-option',
376 |     'This is a custom option.'
377 | ).process(function(id, source) {
378 |     if (this.options.customOption) {
379 |         source = doCustomThing(source);
380 |     }
381 |     return source;
382 | });
383 | ```
384 | 
385 | For more information of the options object available inside the `process` function see [Commander](https://github.com/visionmedia/commander.js).
386 | 


--------------------------------------------------------------------------------
/bin/commonize:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | require("commoner").resolve(function(id) {
 4 |     var context = this;
 5 | 
 6 |     return context.getProvidedP().then(function(idToPath) {
 7 |         // If a module declares its own identifier using @providesModule
 8 |         // then that identifier will be a key in the idToPath object.
 9 |         if (idToPath.hasOwnProperty(id))
10 |             return context.readFileP(idToPath[id]);
11 |     });
12 | 
13 | }, function(id) {
14 |     // Otherwise assume the identifier maps directly to a filesystem path.
15 |     return this.readModuleP(id);
16 | 
17 | }).process(function(id, source) {
18 |     // As a simple example of a processing step, make sure the file ends
19 |     // with exactly one newline character.
20 |     return source.replace(/\s+$/m, "\n");
21 | });
22 | 


--------------------------------------------------------------------------------
/lib/cache.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var Q = require("q");
  3 | var fs = require("fs");
  4 | var path = require("path");
  5 | var util = require("./util");
  6 | var EventEmitter = require("events").EventEmitter;
  7 | var hasOwn = Object.prototype.hasOwnProperty;
  8 | 
  9 | /**
 10 |  * ReadFileCache is an EventEmitter subclass that caches file contents in
 11 |  * memory so that subsequent calls to readFileP return the same contents,
 12 |  * regardless of any changes in the underlying file.
 13 |  */
 14 | function ReadFileCache(sourceDir, charset) {
 15 |     assert.ok(this instanceof ReadFileCache);
 16 |     assert.strictEqual(typeof sourceDir, "string");
 17 | 
 18 |     this.charset = charset;
 19 | 
 20 |     EventEmitter.call(this);
 21 | 
 22 |     Object.defineProperties(this, {
 23 |         sourceDir: { value: sourceDir },
 24 |         sourceCache: { value: {} }
 25 |     });
 26 | }
 27 | 
 28 | util.inherits(ReadFileCache, EventEmitter);
 29 | var RFCp = ReadFileCache.prototype;
 30 | 
 31 | /**
 32 |  * Read a file from the cache if possible, else from disk.
 33 |  */
 34 | RFCp.readFileP = function(relativePath) {
 35 |     var cache = this.sourceCache;
 36 | 
 37 |     relativePath = path.normalize(relativePath);
 38 | 
 39 |     return hasOwn.call(cache, relativePath)
 40 |         ? cache[relativePath]
 41 |         : this.noCacheReadFileP(relativePath);
 42 | };
 43 | 
 44 | /**
 45 |  * Read (or re-read) a file without using the cache.
 46 |  *
 47 |  * The new contents are stored in the cache for any future calls to
 48 |  * readFileP.
 49 |  */
 50 | RFCp.noCacheReadFileP = function(relativePath) {
 51 |     relativePath = path.normalize(relativePath);
 52 | 
 53 |     var added = !hasOwn.call(this.sourceCache, relativePath);
 54 |     var promise = this.sourceCache[relativePath] = util.readFileP(
 55 |         path.join(this.sourceDir, relativePath), this.charset);
 56 | 
 57 |     if (added) {
 58 |         this.emit("added", relativePath);
 59 |     }
 60 | 
 61 |     return promise;
 62 | };
 63 | 
 64 | /**
 65 |  * If you have reason to believe the contents of a file have changed, call
 66 |  * this method to re-read the file and compare the new contents to the
 67 |  * cached contents.  If the new contents differ from the contents of the
 68 |  * cache, the "changed" event will be emitted.
 69 |  */
 70 | RFCp.reportPossiblyChanged = function(relativePath) {
 71 |     var self = this;
 72 |     var cached = self.readFileP(relativePath);
 73 |     var fresh = self.noCacheReadFileP(relativePath);
 74 | 
 75 |     Q.spread([
 76 |         cached.catch(orNull),
 77 |         fresh.catch(orNull)
 78 |     ], function(oldData, newData) {
 79 |         if (oldData !== newData) {
 80 |             self.emit("changed", relativePath);
 81 |         }
 82 |     }).done();
 83 | };
 84 | 
 85 | /**
 86 |  * Invoke the given callback for all files currently known to the
 87 |  * ReadFileCache, and invoke it in the future when any new files become
 88 |  * known to the cache.
 89 |  */
 90 | RFCp.subscribe = function(callback, context) {
 91 |     for (var relativePath in this.sourceCache) {
 92 |         if (hasOwn.call(this.sourceCache, relativePath)) {
 93 |             callback.call(context || null, relativePath);
 94 |         }
 95 |     }
 96 | 
 97 |     this.on("added", function(relativePath) {
 98 |         callback.call(context || null, relativePath);
 99 |     });
100 | };
101 | 
102 | /**
103 |  * Avoid memory leaks by removing listeners and emptying the cache.
104 |  */
105 | RFCp.clear = function() {
106 |     this.removeAllListeners();
107 | 
108 |     for (var relativePath in this.sourceCache) {
109 |         delete this.sourceCache[relativePath];
110 |     }
111 | };
112 | 
113 | function orNull(err) {
114 |     return null;
115 | }
116 | 
117 | exports.ReadFileCache = ReadFileCache;
118 | 


--------------------------------------------------------------------------------
/lib/commoner.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var path = require("path");
  3 | var fs = require("fs");
  4 | var Q = require("q");
  5 | var iconv = require("iconv-lite");
  6 | var ReadFileCache = require("./cache").ReadFileCache;
  7 | var Watcher = require("./watcher").Watcher;
  8 | var contextModule = require("./context");
  9 | var BuildContext = contextModule.BuildContext;
 10 | var PreferredFileExtension = contextModule.PreferredFileExtension;
 11 | var ModuleReader = require("./reader").ModuleReader;
 12 | var output = require("./output");
 13 | var DirOutput = output.DirOutput;
 14 | var StdOutput = output.StdOutput;
 15 | var util = require("./util");
 16 | var log = util.log;
 17 | var Ap = Array.prototype;
 18 | var each = Ap.forEach;
 19 | 
 20 | // Better stack traces for promises.
 21 | Q.longStackSupport = true;
 22 | 
 23 | function Commoner() {
 24 |     var self = this;
 25 |     assert.ok(self instanceof Commoner);
 26 | 
 27 |     Object.defineProperties(self, {
 28 |         customVersion: { value: null, writable: true },
 29 |         customOptions: { value: [] },
 30 |         resolvers: { value: [] },
 31 |         processors: { value: [] }
 32 |     });
 33 | }
 34 | 
 35 | var Cp = Commoner.prototype;
 36 | 
 37 | Cp.version = function(version) {
 38 |     this.customVersion = version;
 39 |     return this; // For chaining.
 40 | };
 41 | 
 42 | // Add custom command line options
 43 | Cp.option = function() {
 44 |     this.customOptions.push(Ap.slice.call(arguments));
 45 |     return this; // For chaining.
 46 | };
 47 | 
 48 | // A resolver is a function that takes a module identifier and returns
 49 | // the unmodified source of the corresponding module, either as a string
 50 | // or as a promise for a string.
 51 | Cp.resolve = function() {
 52 |     each.call(arguments, function(resolver) {
 53 |         assert.strictEqual(typeof resolver, "function");
 54 |         this.resolvers.push(resolver);
 55 |     }, this);
 56 | 
 57 |     return this; // For chaining.
 58 | };
 59 | 
 60 | // A processor is a function that takes a module identifier and a string
 61 | // representing the source of the module and returns a modified version of
 62 | // the source, either as a string or as a promise for a string.
 63 | Cp.process = function(processor) {
 64 |     each.call(arguments, function(processor) {
 65 |         assert.strictEqual(typeof processor, "function");
 66 |         this.processors.push(processor);
 67 |     }, this);
 68 | 
 69 |     return this; // For chaining.
 70 | };
 71 | 
 72 | Cp.buildP = function(options, roots) {
 73 |     var self = this;
 74 |     var sourceDir = options.sourceDir;
 75 |     var outputDir = options.outputDir;
 76 |     var readFileCache = new ReadFileCache(sourceDir, options.sourceCharset);
 77 |     var waiting = 0;
 78 |     var output = outputDir
 79 |         ? new DirOutput(outputDir)
 80 |         : new StdOutput;
 81 | 
 82 |     if (self.watch) {
 83 |         new Watcher(readFileCache).on("changed", function(file) {
 84 |             log.err(file + " changed; rebuilding...", "yellow");
 85 |             rebuild();
 86 |         });
 87 |     }
 88 | 
 89 |     function outputModules(modules) {
 90 |         // Note that output.outputModules comes pre-bound.
 91 |         modules.forEach(output.outputModule);
 92 |         return modules;
 93 |     }
 94 | 
 95 |     function finish(result) {
 96 |         rebuild.ing = false;
 97 | 
 98 |         if (waiting > 0) {
 99 |             waiting = 0;
100 |             process.nextTick(rebuild);
101 |         }
102 | 
103 |         return result;
104 |     }
105 | 
106 |     function rebuild() {
107 |         if (rebuild.ing) {
108 |             waiting += 1;
109 |             return;
110 |         }
111 | 
112 |         rebuild.ing = true;
113 | 
114 |         var context = new BuildContext(options, readFileCache);
115 | 
116 |         if (self.preferredFileExtension)
117 |             context.setPreferredFileExtension(
118 |                 self.preferredFileExtension);
119 | 
120 |         context.setCacheDirectory(self.cacheDir);
121 | 
122 |         context.setIgnoreDependencies(self.ignoreDependencies);
123 | 
124 |         context.setRelativize(self.relativize);
125 | 
126 |         context.setUseProvidesModule(self.useProvidesModule);
127 | 
128 |         return new ModuleReader(
129 |             context,
130 |             self.resolvers,
131 |             self.processors
132 |         ).readMultiP(context.expandIdsOrGlobsP(roots))
133 |             .then(context.ignoreDependencies ? pass : collectDepsP)
134 |             .then(outputModules)
135 |             .then(outputDir ? printModuleIds : pass)
136 |             .then(finish, function(err) {
137 |                 log.err(err.stack);
138 | 
139 |                 if (!self.watch) {
140 |                     // If we're not building with --watch, throw the error
141 |                     // so that cliBuildP can call process.exit(-1).
142 |                     throw err;
143 |                 }
144 | 
145 |                 finish();
146 |             });
147 |     }
148 | 
149 |     return (
150 |       // If outputDir is falsy, we can't (and don't need to) mkdirP it.
151 |       outputDir ? util.mkdirP : Q
152 |     )(outputDir).then(rebuild);
153 | };
154 | 
155 | function pass(modules) {
156 |     return modules;
157 | }
158 | 
159 | function collectDepsP(rootModules) {
160 |     var modules = [];
161 |     var seenIds = {};
162 | 
163 |     function traverse(module) {
164 |         if (seenIds.hasOwnProperty(module.id))
165 |             return Q(modules);
166 |         seenIds[module.id] = true;
167 | 
168 |         return module.getRequiredP().then(function(reqs) {
169 |             return Q.all(reqs.map(traverse));
170 |         }).then(function() {
171 |             modules.push(module);
172 |             return modules;
173 |         });
174 |     }
175 | 
176 |     return Q.all(rootModules.map(traverse)).then(
177 |         function() { return modules });
178 | }
179 | 
180 | function printModuleIds(modules) {
181 |     log.out(JSON.stringify(modules.map(function(module) {
182 |         return module.id;
183 |     })));
184 | 
185 |     return modules;
186 | }
187 | 
188 | Cp.forceResolve = function(forceId, source) {
189 |     this.resolvers.unshift(function(id) {
190 |         if (id === forceId)
191 |             return source;
192 |     });
193 | };
194 | 
195 | Cp.cliBuildP = function() {
196 |     var version = this.customVersion || require("../package.json").version;
197 |     return Q.spread([this, version], cliBuildP);
198 | };
199 | 
200 | function cliBuildP(commoner, version) {
201 |     var options = require("commander");
202 |     var workingDir = process.cwd();
203 |     var sourceDir = workingDir;
204 |     var outputDir = null;
205 |     var roots;
206 | 
207 |     options.version(version)
208 |         .usage("[options] <source directory> <output directory> [<module ID> [<module ID> ...]]")
209 |         .option("-c, --config [file]", "JSON configuration file (no file or - means STDIN)")
210 |         .option("-w, --watch", "Continually rebuild")
211 |         .option("-x, --extension <js | coffee | ...>",
212 |                 "File extension to assume when resolving module identifiers")
213 |         .option("--relativize", "Rewrite all module identifiers to be relative")
214 |         .option("--follow-requires", "Scan modules for required dependencies")
215 |         .option("--use-provides-module", "Respect @providesModules pragma in files")
216 |         .option("--cache-dir <directory>", "Alternate directory to use for disk cache")
217 |         .option("--no-cache-dir", "Disable the disk cache")
218 |         .option("--source-charset <utf8 | win1252 | ...>",
219 |                 "Charset of source (default: utf8)")
220 |         .option("--output-charset <utf8 | win1252 | ...>",
221 |                 "Charset of output (default: utf8)");
222 | 
223 |     commoner.customOptions.forEach(function(customOption) {
224 |         options.option.apply(options, customOption);
225 |     });
226 | 
227 |     options.parse(process.argv.slice(0));
228 | 
229 |     var pfe = new PreferredFileExtension(options.extension || "js");
230 | 
231 |     // TODO Decide whether passing options to buildP via instance
232 |     // variables is preferable to passing them as arguments.
233 |     commoner.preferredFileExtension = pfe;
234 |     commoner.watch = options.watch;
235 |     commoner.ignoreDependencies = !options.followRequires;
236 |     commoner.relativize = options.relativize;
237 |     commoner.useProvidesModule = options.useProvidesModule;
238 |     commoner.sourceCharset = normalizeCharset(options.sourceCharset);
239 |     commoner.outputCharset = normalizeCharset(options.outputCharset);
240 | 
241 |     function fileToId(file) {
242 |         file = absolutePath(workingDir, file);
243 |         assert.ok(fs.statSync(file).isFile(), file);
244 |         return pfe.trim(path.relative(sourceDir, file));
245 |     }
246 | 
247 |     var args = options.args.slice(0);
248 |     var argc = args.length;
249 |     if (argc === 0) {
250 |         if (options.config === true) {
251 |             log.err("Cannot read --config from STDIN when reading " +
252 |                     "source from STDIN");
253 |             process.exit(-1);
254 |         }
255 | 
256 |         sourceDir = workingDir;
257 |         outputDir = null;
258 |         roots = ["<stdin>"];
259 |         commoner.forceResolve("<stdin>", util.readFromStdinP());
260 | 
261 |         // Ignore dependencies because we wouldn't know how to find them.
262 |         commoner.ignoreDependencies = true;
263 | 
264 |     } else {
265 |         var first = absolutePath(workingDir, args[0]);
266 |         var stats = fs.statSync(first);
267 | 
268 |         if (argc === 1) {
269 |             var firstId = fileToId(first);
270 |             sourceDir = workingDir;
271 |             outputDir = null;
272 |             roots = [firstId];
273 |             commoner.forceResolve(
274 |                 firstId,
275 |                 util.readFileP(first, commoner.sourceCharset)
276 |             );
277 | 
278 |             // Ignore dependencies because we wouldn't know how to find them.
279 |             commoner.ignoreDependencies = true;
280 | 
281 |         } else if (stats.isDirectory(first)) {
282 |             sourceDir = first;
283 |             outputDir = absolutePath(workingDir, args[1]);
284 |             roots = args.slice(2);
285 |             if (roots.length === 0)
286 |                 roots.push(commoner.preferredFileExtension.glob());
287 | 
288 |         } else {
289 |             options.help();
290 |             process.exit(-1);
291 |         }
292 |     }
293 | 
294 |     commoner.cacheDir = null;
295 |     if (options.cacheDir === false) {
296 |         // Received the --no-cache-dir option, so disable the disk cache.
297 |     } else if (typeof options.cacheDir === "string") {
298 |         commoner.cacheDir = absolutePath(workingDir, options.cacheDir);
299 |     } else if (outputDir) {
300 |         // The default cache directory lives inside the output directory.
301 |         commoner.cacheDir = path.join(outputDir, ".module-cache");
302 |     }
303 | 
304 |     var promise = getConfigP(
305 |         workingDir,
306 |         options.config
307 |     ).then(function(config) {
308 |         var cleanOptions = {};
309 | 
310 |         options.options.forEach(function(option) {
311 |             var name = util.camelize(option.name());
312 |             if (options.hasOwnProperty(name)) {
313 |                 cleanOptions[name] = options[name];
314 |             }
315 |         });
316 | 
317 |         cleanOptions.version = version;
318 |         cleanOptions.config = config;
319 |         cleanOptions.sourceDir = sourceDir;
320 |         cleanOptions.outputDir = outputDir;
321 |         cleanOptions.sourceCharset = commoner.sourceCharset;
322 |         cleanOptions.outputCharset = commoner.outputCharset;
323 | 
324 |         return commoner.buildP(cleanOptions, roots);
325 |     });
326 | 
327 |     if (!commoner.watch) {
328 |         // If we're building from the command line without --watch, any
329 |         // build errors should immediately terminate the process with a
330 |         // non-zero error code.
331 |         promise = promise.catch(function(err) {
332 |             log.err(err.stack);
333 |             process.exit(-1);
334 |         });
335 |     }
336 | 
337 |     return promise;
338 | }
339 | 
340 | function normalizeCharset(charset) {
341 |     charset = charset
342 |         && charset.replace(/[- ]/g, "").toLowerCase()
343 |         || "utf8";
344 | 
345 |     assert.ok(
346 |         iconv.encodingExists(charset),
347 |         "Unrecognized charset: " + charset
348 |     );
349 | 
350 |     return charset;
351 | }
352 | 
353 | function absolutePath(workingDir, pathToJoin) {
354 |     if (pathToJoin) {
355 |         workingDir = path.normalize(workingDir);
356 |         pathToJoin = path.normalize(pathToJoin);
357 |         // TODO: use path.isAbsolute when Node < 0.10 is unsupported
358 |         if (path.resolve(pathToJoin) !== pathToJoin) {
359 |             pathToJoin = path.join(workingDir, pathToJoin);
360 |         }
361 |     }
362 |     return pathToJoin;
363 | }
364 | 
365 | function getConfigP(workingDir, configFile) {
366 |     if (typeof configFile === "undefined")
367 |         return Q({}); // Empty config.
368 | 
369 |     if (configFile === true || // --config is present but has no argument
370 |         configFile === "<stdin>" ||
371 |         configFile === "-" ||
372 |         configFile === path.sep + path.join("dev", "stdin")) {
373 |         return util.readJsonFromStdinP(
374 |             1000, // Time limit in milliseconds before warning displayed.
375 |             "Expecting configuration from STDIN (pass --config <file> " +
376 |                 "if stuck here)...",
377 |             "yellow"
378 |         );
379 |     }
380 | 
381 |     return util.readJsonFileP(absolutePath(workingDir, configFile));
382 | }
383 | 
384 | exports.Commoner = Commoner;
385 | 


--------------------------------------------------------------------------------
/lib/context.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var path = require("path");
  3 | var Q = require("q");
  4 | var util = require("./util");
  5 | var spawn = require("child_process").spawn;
  6 | var ReadFileCache = require("./cache").ReadFileCache;
  7 | var grepP = require("./grep");
  8 | var glob = require("glob");
  9 | var env = process.env;
 10 | 
 11 | function BuildContext(options, readFileCache) {
 12 |     var self = this;
 13 |     assert.ok(self instanceof BuildContext);
 14 |     assert.ok(readFileCache instanceof ReadFileCache);
 15 | 
 16 |     if (options) {
 17 |         assert.strictEqual(typeof options, "object");
 18 |     } else {
 19 |         options = {};
 20 |     }
 21 | 
 22 |     Object.freeze(options);
 23 | 
 24 |     Object.defineProperties(self, {
 25 |         readFileCache: { value: readFileCache },
 26 |         config: { value: options.config },
 27 |         options: { value: options },
 28 |         optionsHash: { value: util.deepHash(options) }
 29 |     });
 30 | }
 31 | 
 32 | var BCp = BuildContext.prototype;
 33 | 
 34 | BCp.makePromise = function(callback, context) {
 35 |     return util.makePromise(callback, context);
 36 | };
 37 | 
 38 | BCp.spawnP = function(command, args, kwargs) {
 39 |     args = args || [];
 40 |     kwargs = kwargs || {};
 41 | 
 42 |     var deferred = Q.defer();
 43 | 
 44 |     var outs = [];
 45 |     var errs = [];
 46 | 
 47 |     var options = {
 48 |         stdio: "pipe",
 49 |         env: env
 50 |     };
 51 | 
 52 |     if (kwargs.cwd) {
 53 |         options.cwd = kwargs.cwd;
 54 |     }
 55 | 
 56 |     var child = spawn(command, args, options);
 57 | 
 58 |     child.stdout.on("data", function(data) {
 59 |         outs.push(data);
 60 |     });
 61 | 
 62 |     child.stderr.on("data", function(data) {
 63 |         errs.push(data);
 64 |     });
 65 | 
 66 |     child.on("close", function(code) {
 67 |         if (errs.length > 0 || code !== 0) {
 68 |             var err = {
 69 |                 code: code,
 70 |                 text: errs.join("")
 71 |             };
 72 |         }
 73 | 
 74 |         deferred.resolve([err, outs.join("")]);
 75 |     });
 76 | 
 77 |     var stdin = kwargs && kwargs.stdin;
 78 |     if (stdin) {
 79 |         child.stdin.end(stdin);
 80 |     }
 81 | 
 82 |     return deferred.promise;
 83 | };
 84 | 
 85 | BCp.setIgnoreDependencies = function(value) {
 86 |     Object.defineProperty(this, "ignoreDependencies", {
 87 |         value: !!value
 88 |     });
 89 | };
 90 | 
 91 | // This default can be overridden by individual BuildContext instances.
 92 | BCp.setIgnoreDependencies(false);
 93 | 
 94 | BCp.setRelativize = function(value) {
 95 |     Object.defineProperty(this, "relativize", {
 96 |         value: !!value
 97 |     });
 98 | };
 99 | 
100 | // This default can be overridden by individual BuildContext instances.
101 | BCp.setRelativize(false);
102 | 
103 | BCp.setUseProvidesModule = function(value) {
104 |     Object.defineProperty(this, "useProvidesModule", {
105 |         value: !!value
106 |     });
107 | };
108 | 
109 | // This default can be overridden by individual BuildContext instances.
110 | BCp.setUseProvidesModule(false);
111 | 
112 | BCp.setCacheDirectory = function(dir) {
113 |     if (!dir) {
114 |         // Disable the cache directory.
115 |     } else {
116 |         assert.strictEqual(typeof dir, "string");
117 |     }
118 | 
119 |     Object.defineProperty(this, "cacheDir", {
120 |         value: dir || null
121 |     });
122 | };
123 | 
124 | // This default can be overridden by individual BuildContext instances.
125 | BCp.setCacheDirectory(null);
126 | 
127 | function PreferredFileExtension(ext) {
128 |     assert.strictEqual(typeof ext, "string");
129 |     assert.ok(this instanceof PreferredFileExtension);
130 |     Object.defineProperty(this, "extension", {
131 |         value: ext.toLowerCase()
132 |     });
133 | }
134 | 
135 | var PFEp = PreferredFileExtension.prototype;
136 | 
137 | PFEp.check = function(file) {
138 |     return file.split(".").pop().toLowerCase() === this.extension;
139 | };
140 | 
141 | PFEp.trim = function(file) {
142 |     if (this.check(file)) {
143 |         var len = file.length;
144 |         var extLen = 1 + this.extension.length;
145 |         file = file.slice(0, len - extLen);
146 |     }
147 |     return file;
148 | };
149 | 
150 | PFEp.glob = function() {
151 |     return "**/*." + this.extension;
152 | };
153 | 
154 | exports.PreferredFileExtension = PreferredFileExtension;
155 | 
156 | BCp.setPreferredFileExtension = function(pfe) {
157 |     assert.ok(pfe instanceof PreferredFileExtension);
158 |     Object.defineProperty(this, "preferredFileExtension", { value: pfe });
159 | };
160 | 
161 | BCp.setPreferredFileExtension(new PreferredFileExtension("js"));
162 | 
163 | BCp.expandIdsOrGlobsP = function(idsOrGlobs) {
164 |     var context = this;
165 | 
166 |     return Q.all(
167 |         idsOrGlobs.map(this.expandSingleIdOrGlobP, this)
168 |     ).then(function(listOfListsOfIDs) {
169 |         var result = [];
170 |         var seen = {};
171 | 
172 |         util.flatten(listOfListsOfIDs).forEach(function(id) {
173 |             if (!seen.hasOwnProperty(id)) {
174 |                 seen[id] = true;
175 |                 if (util.isValidModuleId(id))
176 |                     result.push(id);
177 |             }
178 |         });
179 | 
180 |         return result;
181 |     });
182 | };
183 | 
184 | BCp.expandSingleIdOrGlobP = function(idOrGlob) {
185 |     var context = this;
186 | 
187 |     return util.makePromise(function(callback) {
188 |         // If idOrGlob already looks like an acceptable identifier, don't
189 |         // try to expand it.
190 |         if (util.isValidModuleId(idOrGlob)) {
191 |             callback(null, [idOrGlob]);
192 |             return;
193 |         }
194 | 
195 |         glob(idOrGlob, {
196 |             cwd: context.readFileCache.sourceDir
197 |         }, function(err, files) {
198 |             if (err) {
199 |                 callback(err);
200 |             } else {
201 |                 callback(null, files.filter(function(file) {
202 |                     return !context.isHiddenFile(file);
203 |                 }).map(function(file) {
204 |                     return context.preferredFileExtension.trim(file);
205 |                 }));
206 |             }
207 |         });
208 |     });
209 | };
210 | 
211 | BCp.readModuleP = function(id) {
212 |     return this.readFileCache.readFileP(
213 |         id + "." + this.preferredFileExtension.extension
214 |     );
215 | };
216 | 
217 | BCp.readFileP = function(file) {
218 |     return this.readFileCache.readFileP(file);
219 | };
220 | 
221 | // Text editors such as VIM and Emacs often create temporary swap files
222 | // that should be ignored.
223 | var hiddenExp = /^\.|~$/;
224 | BCp.isHiddenFile = function(file) {
225 |     return hiddenExp.test(path.basename(file));
226 | };
227 | 
228 | BCp.getProvidedP = util.cachedMethod(function() {
229 |     var context = this;
230 |     var pattern = "@providesModule\\s+\\S+";
231 | 
232 |     return grepP(
233 |         pattern,
234 |         context.readFileCache.sourceDir
235 |     ).then(function(pathToMatch) {
236 |         var idToPath = {};
237 | 
238 |         Object.keys(pathToMatch).sort().forEach(function(path) {
239 |             if (context.isHiddenFile(path))
240 |                 return;
241 | 
242 |             var id = pathToMatch[path].split(/\s+/).pop();
243 | 
244 |             // If we're about to overwrite an existing module identifier,
245 |             // make sure the corresponding path ends with the preferred
246 |             // file extension. This allows @providesModule directives in
247 |             // .coffee files, for example, but prevents .js~ temporary
248 |             // files from taking precedence over actual .js files.
249 |             if (!idToPath.hasOwnProperty(id) ||
250 |                 context.preferredFileExtension.check(path))
251 |                 idToPath[id] = path;
252 |         });
253 | 
254 |         return idToPath;
255 |     });
256 | });
257 | 
258 | var providesExp = /@providesModule[ ]+(\S+)/;
259 | 
260 | BCp.getProvidedId = function(source) {
261 |     var match = providesExp.exec(source);
262 |     return match && match[1];
263 | };
264 | 
265 | exports.BuildContext = BuildContext;
266 | 


--------------------------------------------------------------------------------
/lib/grep.js:
--------------------------------------------------------------------------------
 1 | var assert = require("assert");
 2 | var path = require("path");
 3 | var Q = require("q");
 4 | var fs = require("graceful-fs");
 5 | var util = require("./util");
 6 | var readdir = Q.denodeify(fs.readdir);
 7 | var lstat = Q.denodeify(fs.lstat);
 8 | 
 9 | function processDirP(pattern, dir) {
10 |     return readdir(dir).then(function(files) {
11 |         return Q.all(files.map(function(file) {
12 |             file = path.join(dir, file);
13 |             return lstat(file).then(function(stat) {
14 |                 return stat.isDirectory()
15 |                     ? processDirP(pattern, file)
16 |                     : processFileP(pattern, file);
17 |             });
18 |         })).then(function(results) {
19 |             return util.flatten(results);
20 |         });
21 |     });
22 | }
23 | 
24 | function processFileP(pattern, file) {
25 |     return util.readFileP(file).then(function(contents) {
26 |         var result = new RegExp(pattern, 'g').exec(contents);
27 |         return result ? [{
28 |             path: file,
29 |             match: result[0]
30 |         }] : [];
31 |     });
32 | }
33 | 
34 | module.exports = function(pattern, sourceDir) {
35 |     assert.strictEqual(typeof pattern, "string");
36 | 
37 |     return processDirP(pattern, sourceDir).then(function(results) {
38 |         var pathToMatch = {};
39 | 
40 |         results.forEach(function(result) {
41 |             pathToMatch[path.relative(
42 |                 sourceDir,
43 |                 result.path
44 |             ).split("\\").join("/")] = result.match;
45 |         });
46 |         
47 |         return pathToMatch;
48 |     });
49 | };
50 | 


--------------------------------------------------------------------------------
/lib/output.js:
--------------------------------------------------------------------------------
 1 | var assert = require("assert");
 2 | var util = require("./util");
 3 | var log = util.log;
 4 | 
 5 | function AbstractOutput() {
 6 |     assert.ok(this instanceof AbstractOutput);
 7 |     Object.defineProperties(this, {
 8 |         outputModule: { value: this.outputModule.bind(this) }
 9 |     });
10 | }
11 | 
12 | var AOp = AbstractOutput.prototype;
13 | exports.AbstractOutput = AbstractOutput;
14 | 
15 | AOp.outputModule = function(module) {
16 |     throw new Error("not implemented");
17 | };
18 | 
19 | function StdOutput() {
20 |     assert.ok(this instanceof StdOutput);
21 |     AbstractOutput.call(this);
22 | }
23 | 
24 | var SOp = util.inherits(StdOutput, AbstractOutput);
25 | exports.StdOutput = StdOutput;
26 | 
27 | SOp.outputModule = function(module) {
28 |     log.out(module.source);
29 | };
30 | 
31 | function DirOutput(outputDir) {
32 |     assert.ok(this instanceof DirOutput);
33 |     assert.strictEqual(typeof outputDir, "string");
34 |     AbstractOutput.call(this);
35 | 
36 |     Object.defineProperties(this, {
37 |         outputDir: { value: outputDir }
38 |     });
39 | }
40 | 
41 | var DOp = util.inherits(DirOutput, AbstractOutput);
42 | exports.DirOutput = DirOutput;
43 | 
44 | DOp.outputModule = function(module) {
45 |     return module.writeVersionP(this.outputDir);
46 | };
47 | 
48 | function TestOutput() {
49 |     assert.ok(this instanceof TestOutput);
50 |     AbstractOutput.call(this);
51 | }
52 | 
53 | var TOp = util.inherits(TestOutput, AbstractOutput);
54 | exports.TestOutput = TestOutput;
55 | 
56 | TOp.outputModule = function(module) {
57 |     // Swallow any output.
58 | };
59 | 


--------------------------------------------------------------------------------
/lib/reader.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var path = require("path");
  3 | var fs = require("fs");
  4 | var Q = require("q");
  5 | var iconv = require("iconv-lite");
  6 | var createHash = require("crypto").createHash;
  7 | var detective = require("detective");
  8 | var util = require("./util");
  9 | var BuildContext = require("./context").BuildContext;
 10 | var slice = Array.prototype.slice;
 11 | 
 12 | function getRequiredIDs(id, source) {
 13 |     var ids = {};
 14 |     detective(source).forEach(function (dep) {
 15 |         ids[path.normalize(path.join(id, "..", dep))] = true;
 16 |     });
 17 |     return Object.keys(ids);
 18 | }
 19 | 
 20 | function ModuleReader(context, resolvers, processors) {
 21 |     var self = this;
 22 |     assert.ok(self instanceof ModuleReader);
 23 |     assert.ok(context instanceof BuildContext);
 24 |     assert.ok(resolvers instanceof Array);
 25 |     assert.ok(processors instanceof Array);
 26 | 
 27 |     var hash = createHash("sha1").update(context.optionsHash + "\0");
 28 | 
 29 |     function hashCallbacks(salt) {
 30 |         hash.update(salt + "\0");
 31 | 
 32 |         var cbs = util.flatten(slice.call(arguments, 1));
 33 | 
 34 |         cbs.forEach(function(cb) {
 35 |             assert.strictEqual(typeof cb, "function");
 36 |             hash.update(cb + "\0");
 37 |         });
 38 | 
 39 |         return cbs;
 40 |     }
 41 | 
 42 |     resolvers = hashCallbacks("resolvers", resolvers, warnMissingModule);
 43 | 
 44 |     var procArgs = [processors];
 45 |     if (context.relativize && !context.ignoreDependencies)
 46 |         procArgs.push(require("./relative").getProcessor(self));
 47 |     processors = hashCallbacks("processors", procArgs);
 48 | 
 49 |     Object.defineProperties(self, {
 50 |         context: { value: context },
 51 |         idToHash: { value: {} },
 52 |         resolvers: { value: resolvers },
 53 |         processors: { value: processors },
 54 |         salt: { value: hash.digest("hex") }
 55 |     });
 56 | }
 57 | 
 58 | ModuleReader.prototype = {
 59 |     getSourceP: util.cachedMethod(function(id) {
 60 |         var context = this.context;
 61 |         var copy = this.resolvers.slice(0).reverse();
 62 |         assert.ok(copy.length > 0, "no source resolvers registered");
 63 | 
 64 |         function tryNextResolverP() {
 65 |             var resolve = copy.pop();
 66 | 
 67 |             try {
 68 |                 var promise = Q(resolve && resolve.call(context, id));
 69 |             } catch (e) {
 70 |                 promise = Q.reject(e);
 71 |             }
 72 | 
 73 |             return resolve ? promise.then(function(result) {
 74 |                 if (typeof result === "string")
 75 |                     return result;
 76 |                 return tryNextResolverP();
 77 |             }, tryNextResolverP) : promise;
 78 |         }
 79 | 
 80 |         return tryNextResolverP();
 81 |     }),
 82 | 
 83 |     getCanonicalIdP: util.cachedMethod(function(id) {
 84 |         var reader = this;
 85 |         if (reader.context.useProvidesModule) {
 86 |             return reader.getSourceP(id).then(function(source) {
 87 |                 return reader.context.getProvidedId(source) || id;
 88 |             });
 89 |         } else {
 90 |           return Q(id);
 91 |         }
 92 |     }),
 93 | 
 94 |     readModuleP: util.cachedMethod(function(id) {
 95 |         var reader = this;
 96 | 
 97 |         return reader.getSourceP(id).then(function(source) {
 98 |             if (reader.context.useProvidesModule) {
 99 |                 // If the source contains a @providesModule declaration, treat
100 |                 // that declaration as canonical. Note that the Module object
101 |                 // returned by readModuleP might have an .id property whose
102 |                 // value differs from the original id parameter.
103 |                 id = reader.context.getProvidedId(source) || id;
104 |             }
105 | 
106 |             assert.strictEqual(typeof source, "string");
107 | 
108 |             var hash = createHash("sha1")
109 |                 .update("module\0")
110 |                 .update(id + "\0")
111 |                 .update(reader.salt + "\0")
112 |                 .update(source.length + "\0" + source)
113 |                 .digest("hex");
114 | 
115 |             if (reader.idToHash.hasOwnProperty(id)) {
116 |                 // Ensure that the same module identifier is not
117 |                 // provided by distinct modules.
118 |                 assert.strictEqual(
119 |                     reader.idToHash[id], hash,
120 |                     "more than one module named " +
121 |                         JSON.stringify(id));
122 |             } else {
123 |                 reader.idToHash[id] = hash;
124 |             }
125 | 
126 |             return reader.buildModuleP(id, hash, source);
127 |         });
128 |     }),
129 | 
130 |     buildModuleP: util.cachedMethod(function(id, hash, source) {
131 |         var reader = this;
132 |         return reader.processOutputP(
133 |             id, hash, source
134 |         ).then(function(output) {
135 |             return new Module(reader, id, hash, output);
136 |         });
137 |     }, function(id, hash, source) {
138 |         return hash;
139 |     }),
140 | 
141 |     processOutputP: function(id, hash, source) {
142 |         var reader = this;
143 |         var cacheDir = reader.context.cacheDir;
144 |         var manifestDir = cacheDir && path.join(cacheDir, "manifest");
145 |         var charset = reader.context.options.outputCharset;
146 | 
147 |         function buildP() {
148 |             var promise = Q(source);
149 | 
150 |             reader.processors.forEach(function(build) {
151 |                 promise = promise.then(function(input) {
152 |                     return util.waitForValuesP(
153 |                         build.call(reader.context, id, input)
154 |                     );
155 |                 });
156 |             });
157 | 
158 |             return promise.then(function(output) {
159 |                 if (typeof output === "string") {
160 |                     output = { ".js": output };
161 |                 } else {
162 |                     assert.strictEqual(typeof output, "object");
163 |                 }
164 | 
165 |                 return util.waitForValuesP(output);
166 | 
167 |             }).then(function(output) {
168 |                 util.log.err(
169 |                     "built Module(" + JSON.stringify(id) + ")",
170 |                     "cyan"
171 |                 );
172 | 
173 |                 return output;
174 | 
175 |             }).catch(function(err) {
176 |                 // Provide additional context for uncaught build errors.
177 |                 util.log.err("Error while reading module " + id + ":");
178 |                 throw err;
179 |             });
180 |         }
181 | 
182 |         if (manifestDir) {
183 |             return util.mkdirP(manifestDir).then(function(manifestDir) {
184 |                 var manifestFile = path.join(manifestDir, hash + ".json");
185 | 
186 |                 return util.readJsonFileP(manifestFile).then(function(manifest) {
187 |                     Object.keys(manifest).forEach(function(key) {
188 |                         var cacheFile = path.join(cacheDir, manifest[key]);
189 |                         manifest[key] = util.readFileP(cacheFile);
190 |                     });
191 | 
192 |                     return util.waitForValuesP(manifest, true);
193 | 
194 |                 }).catch(function(err) {
195 |                     return buildP().then(function(output) {
196 |                         var manifest = {};
197 | 
198 |                         Object.keys(output).forEach(function(key) {
199 |                             var cacheFile = manifest[key] = hash + key;
200 |                             var fullPath = path.join(cacheDir, cacheFile);
201 | 
202 |                             if (charset) {
203 |                                 fs.writeFileSync(fullPath, iconv.encode(output[key], charset))
204 |                             } else {
205 |                                 fs.writeFileSync(fullPath, output[key], "utf8");
206 |                             }
207 |                         });
208 | 
209 |                         fs.writeFileSync(
210 |                             manifestFile,
211 |                             JSON.stringify(manifest),
212 |                             "utf8"
213 |                         );
214 | 
215 |                         return output;
216 |                     });
217 |                 });
218 |             });
219 |         }
220 | 
221 |         return buildP();
222 |     },
223 | 
224 |     readMultiP: function(ids) {
225 |         var reader = this;
226 | 
227 |         return Q(ids).all().then(function(ids) {
228 |             if (ids.length === 0)
229 |                 return ids; // Shortcut.
230 | 
231 |             var modulePs = ids.map(reader.readModuleP, reader);
232 |             return Q(modulePs).all().then(function(modules) {
233 |                 var seen = {};
234 |                 var result = [];
235 | 
236 |                 modules.forEach(function(module) {
237 |                     if (!seen.hasOwnProperty(module.id)) {
238 |                         seen[module.id] = true;
239 |                         result.push(module);
240 |                     }
241 |                 });
242 | 
243 |                 return result;
244 |             });
245 |         });
246 |     }
247 | };
248 | 
249 | exports.ModuleReader = ModuleReader;
250 | 
251 | function warnMissingModule(id) {
252 |     // A missing module may be a false positive and therefore does not warrant
253 |     // a fatal error, but a warning is certainly in order.
254 |     util.log.err(
255 |         "unable to resolve module " + JSON.stringify(id) + "; false positive?",
256 |         "yellow");
257 | 
258 |     // Missing modules are installed as if they existed, but it's a run-time
259 |     // error if one is ever actually required.
260 |     var message = "nonexistent module required: " + id;
261 |     return "throw new Error(" + JSON.stringify(message) + ");";
262 | }
263 | 
264 | function Module(reader, id, hash, output) {
265 |     assert.ok(this instanceof Module);
266 |     assert.ok(reader instanceof ModuleReader);
267 |     assert.strictEqual(typeof output, "object");
268 | 
269 |     var source = output[".js"];
270 |     assert.strictEqual(typeof source, "string");
271 | 
272 |     Object.defineProperties(this, {
273 |         reader: { value: reader },
274 |         id: { value: id },
275 |         hash: { value: hash }, // TODO Remove?
276 |         deps: { value: getRequiredIDs(id, source) },
277 |         source: { value: source },
278 |         output: { value: output }
279 |     });
280 | }
281 | 
282 | Module.prototype = {
283 |     getRequiredP: function() {
284 |         return this.reader.readMultiP(this.deps);
285 |     },
286 | 
287 |     writeVersionP: function(outputDir) {
288 |         var id = this.id;
289 |         var hash = this.hash;
290 |         var output = this.output;
291 |         var cacheDir = this.reader.context.cacheDir;
292 |         var charset = this.reader.context.options.outputCharset;
293 | 
294 |         return Q.all(Object.keys(output).map(function(key) {
295 |             var outputFile = path.join(outputDir, id + key);
296 | 
297 |             function writeCopy() {
298 |                 if (charset) {
299 |                     fs.writeFileSync(outputFile, iconv.encode(output[key], charset));
300 |                 } else {
301 |                     fs.writeFileSync(outputFile, output[key], "utf8");
302 |                 }
303 |                 return outputFile;
304 |             }
305 | 
306 |             if (cacheDir) {
307 |                 var cacheFile = path.join(cacheDir, hash + key);
308 |                 return util.linkP(cacheFile, outputFile)
309 |                     // If the hard linking fails, the cache directory
310 |                     // might be on a different device, so fall back to
311 |                     // writing a copy of the file (slightly slower).
312 |                     .catch(writeCopy);
313 |             }
314 | 
315 |             return util.mkdirP(path.dirname(outputFile)).then(writeCopy);
316 |         }));
317 |     },
318 | 
319 |     toString: function() {
320 |         return "Module(" + JSON.stringify(this.id) + ")";
321 |     },
322 | 
323 |     resolveId: function(id) {
324 |         return util.absolutize(this.id, id);
325 |     }
326 | };
327 | 


--------------------------------------------------------------------------------
/lib/relative.js:
--------------------------------------------------------------------------------
 1 | var assert = require("assert");
 2 | var Q = require("q");
 3 | var path = require("path");
 4 | var util = require("./util");
 5 | var recast = require("recast");
 6 | var n = recast.types.namedTypes;
 7 | 
 8 | function Relativizer(reader) {
 9 |     assert.ok(this instanceof Relativizer);
10 |     assert.ok(reader === null ||
11 |               reader instanceof require("./reader").ModuleReader);
12 | 
13 |     Object.defineProperties(this, {
14 |         reader: { value: reader }
15 |     });
16 | }
17 | 
18 | var Rp = Relativizer.prototype;
19 | 
20 | exports.getProcessor = function(reader) {
21 |     var relativizer = new Relativizer(reader);
22 |     return function(id, input) {
23 |         return relativizer.processSourceP(id, input);
24 |     };
25 | };
26 | 
27 | Rp.processSourceP = function(id, input) {
28 |     var relativizer = this;
29 |     var output = typeof input === "string" ? {
30 |         ".js": input
31 |     } : input;
32 | 
33 |     return Q(output[".js"]).then(function(source) {
34 |         var promises = [];
35 |         var ast = recast.parse(source);
36 | 
37 |         function fixRequireP(literal) {
38 |             promises.push(relativizer.relativizeP(
39 |                 id, literal.value
40 |             ).then(function(newValue) {
41 |                 return literal.value = newValue;
42 |             }));
43 |         }
44 | 
45 |         recast.visit(ast, {
46 |             visitCallExpression: function(path) {
47 |                 var args = path.value.arguments;
48 |                 var callee = path.value.callee;
49 | 
50 |                 if (n.Identifier.check(callee) &&
51 |                     callee.name === "require" &&
52 |                     args.length === 1) {
53 |                     var arg = args[0];
54 |                     if (n.Literal.check(arg) &&
55 |                         typeof arg.value === "string") {
56 |                         fixRequireP(arg);
57 |                     }
58 |                 }
59 | 
60 |                 this.traverse(path);
61 |             }
62 |         });
63 | 
64 |         return Q.all(promises).then(function() {
65 |             output[".js"] = recast.print(ast).code;
66 |             return output;
67 |         });
68 |     });
69 | };
70 | 
71 | Rp.absolutizeP = function(moduleId, requiredId) {
72 |     requiredId = util.absolutize(moduleId, requiredId);
73 | 
74 |     if (this.reader)
75 |         return this.reader.getCanonicalIdP(requiredId);
76 | 
77 |     return Q(requiredId);
78 | };
79 | 
80 | Rp.relativizeP = function(moduleId, requiredId) {
81 |     return this.absolutizeP(
82 |         moduleId,
83 |         requiredId
84 |     ).then(function(absoluteId) {
85 |         return util.relativize(moduleId, absoluteId);
86 |     });
87 | };
88 | 


--------------------------------------------------------------------------------
/lib/util.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var path = require("path");
  3 | var fs = require("graceful-fs");
  4 | var Q = require("q");
  5 | var createHash = require("crypto").createHash;
  6 | var mkdirp = require("mkdirp");
  7 | var iconv = require("iconv-lite");
  8 | var Ap = Array.prototype;
  9 | var slice = Ap.slice;
 10 | var join = Ap.join;
 11 | 
 12 | // The graceful-fs module attempts to limit the total number of open files
 13 | // by queueing fs operations, but it doesn't know about all open files, so
 14 | // we set the limit somewhat lower than the default to provide a healthy
 15 | // buffer against EMFILE (too many open files) errors.
 16 | fs.MAX_OPEN = 512;
 17 | 
 18 | function makePromise(callback, context) {
 19 |     var deferred = Q.defer();
 20 | 
 21 |     function finish(err, result) {
 22 |         if (err) {
 23 |             deferred.reject(err);
 24 |         } else {
 25 |             deferred.resolve(result);
 26 |         }
 27 |     }
 28 | 
 29 |     process.nextTick(function() {
 30 |         try {
 31 |             callback.call(context || null, finish);
 32 |         } catch (err) {
 33 |             finish(err);
 34 |         }
 35 |     });
 36 | 
 37 |     return deferred.promise;
 38 | }
 39 | exports.makePromise = makePromise;
 40 | 
 41 | exports.cachedMethod = function(fn, keyFn) {
 42 |     var p = require("private").makeAccessor();
 43 | 
 44 |     function wrapper() {
 45 |         var priv = p(this);
 46 |         var cache = priv.cache || (priv.cache = {});
 47 |         var args = arguments;
 48 |         var key = keyFn
 49 |             ? keyFn.apply(this, args)
 50 |             : join.call(args, "\0");
 51 |         return cache.hasOwnProperty(key)
 52 |             ? cache[key]
 53 |             : cache[key] = fn.apply(this, args);
 54 |     }
 55 | 
 56 |     wrapper.originalFn = fn;
 57 | 
 58 |     return wrapper;
 59 | };
 60 | 
 61 | function readFileP(file, charset) {
 62 |     return makePromise(charset ? function(callback) {
 63 |         return fs.readFile(file, function(err, data) {
 64 |             if (err) {
 65 |                 callback(err);
 66 |             } else {
 67 |                 callback(null, iconv.decode(data, charset));
 68 |             }
 69 |         });
 70 |     } : function(callback) {
 71 |         return fs.readFile(file, "utf8", callback);
 72 |     });
 73 | }
 74 | exports.readFileP = readFileP;
 75 | 
 76 | exports.readJsonFileP = function(file) {
 77 |     return readFileP(file).then(function(json) {
 78 |         return JSON.parse(json);
 79 |     });
 80 | };
 81 | 
 82 | function mkdirP(dir) {
 83 |     return makePromise(function(callback) {
 84 |         mkdirp(dir, function(err) {
 85 |             callback(err, dir);
 86 |         });
 87 |     });
 88 | }
 89 | exports.mkdirP = mkdirP;
 90 | 
 91 | function readFromStdinP(timeLimit, message, color) {
 92 |     var deferred = Q.defer();
 93 |     var ins = [];
 94 | 
 95 |     timeLimit = timeLimit || 1000;
 96 |     var timeout = setTimeout(function() {
 97 |         log.err(
 98 |             message || ("Warning: still waiting for STDIN after " +
 99 |                         timeLimit + "ms"),
100 |             color || "yellow"
101 |         );
102 |     }, timeLimit);
103 | 
104 |     try {
105 |         // On Windows, just accessing process.stdin throws an exception
106 |         // when no standard input has been provided. For consistency with
107 |         // other platforms, log the error but continue waiting (until
108 |         // killed) for the nonexistent input.
109 |         var stdin = process.stdin;
110 |     } catch (err) {
111 |         log.err(err);
112 |     }
113 | 
114 |     if (stdin) {
115 |         stdin.resume();
116 |         stdin.setEncoding("utf8");
117 | 
118 |         stdin.on("data", function(data) {
119 |             ins.push(data);
120 |         }).on("end", function() {
121 |             clearTimeout(timeout);
122 |             deferred.resolve(ins.join(""));
123 |         });
124 |     }
125 | 
126 |     return deferred.promise;
127 | }
128 | exports.readFromStdinP = readFromStdinP;
129 | 
130 | exports.readJsonFromStdinP = function(timeLimit) {
131 |     return readFromStdinP(timeLimit).then(function(input) {
132 |         return JSON.parse(input);
133 |     });
134 | };
135 | 
136 | function deepHash(val) {
137 |     var hash = createHash("sha1");
138 |     var type = typeof val;
139 | 
140 |     if (val === null) {
141 |         type = "null";
142 |     }
143 | 
144 |     switch (type) {
145 |     case "object":
146 |         Object.keys(val).sort().forEach(function(key) {
147 |             if (typeof val[key] === "function") {
148 |                 // Silently ignore nested methods, but nevertheless
149 |                 // complain below if the root value is a function.
150 |                 return;
151 |             }
152 | 
153 |             hash.update(key + "\0")
154 |                 .update(deepHash(val[key]));
155 |         });
156 |         break;
157 | 
158 |     case "function":
159 |         assert.ok(false, "cannot hash function objects");
160 |         break;
161 | 
162 |     default:
163 |         hash.update(val + "");
164 |         break;
165 |     }
166 | 
167 |     return hash.digest("hex");
168 | }
169 | exports.deepHash = deepHash;
170 | 
171 | exports.existsP = function(fullPath) {
172 |     return makePromise(function(callback) {
173 |         fs.exists(fullPath, function(exists) {
174 |             callback(null, exists);
175 |         });
176 |     });
177 | };
178 | 
179 | function writeFdP(fd, content) {
180 |     return makePromise(function(callback) {
181 |         content += "";
182 |         var buffer = new Buffer(content, "utf8");
183 |         var length = fs.writeSync(fd, buffer, 0, buffer.length, null);
184 |         assert.strictEqual(length, buffer.length);
185 |         callback(null, content);
186 |     }).finally(function() {
187 |         fs.closeSync(fd);
188 |     });
189 | }
190 | exports.writeFdP = writeFdP;
191 | 
192 | function openFileP(file, mode) {
193 |     return makePromise(function(callback) {
194 |         fs.open(file, mode || "w+", callback);
195 |     });
196 | }
197 | exports.openFileP = openFileP;
198 | 
199 | function openExclusiveP(file) {
200 |     // The 'x' in "wx+" means the file must be newly created.
201 |     return openFileP(file, "wx+");
202 | }
203 | exports.openExclusiveP = openExclusiveP;
204 | 
205 | exports.copyP = function(srcFile, dstFile) {
206 |     return makePromise(function(callback) {
207 |         var reader = fs.createReadStream(srcFile);
208 | 
209 |         function onError(err) {
210 |             callback(err || new Error(
211 |                 "error in util.copyP(" +
212 |                     JSON.stringify(srcFile) + ", " +
213 |                     JSON.stringify(dstFile) + ")"
214 |             ));
215 |         }
216 | 
217 |         reader.on("error", onError).pipe(
218 |             fs.createWriteStream(dstFile)
219 |         ).on("finish", function() {
220 |             callback(null, dstFile);
221 |         }).on("error", onError);
222 |     });
223 | };
224 | 
225 | // Even though they use synchronous operations to avoid race conditions,
226 | // linkP and unlinkP have promise interfaces, for consistency. Note that
227 | // this means the operation will not happen until at least the next tick
228 | // of the event loop, but it will be atomic when it happens.
229 | exports.linkP = function(srcFile, dstFile) {
230 |     return mkdirP(path.dirname(dstFile)).then(function() {
231 |         if (fs.existsSync(dstFile))
232 |             fs.unlinkSync(dstFile);
233 |         fs.linkSync(srcFile, dstFile);
234 |         return dstFile;
235 |     });
236 | };
237 | 
238 | exports.unlinkP = function(file) {
239 |     return makePromise(function(callback) {
240 |         try {
241 |             if (fs.existsSync(file))
242 |                 fs.unlinkSync(file);
243 |             callback(null, file);
244 |         } catch (err) {
245 |             callback(err);
246 |         }
247 |     });
248 | };
249 | 
250 | var colors = {
251 |     bold: "\033[1m",
252 |     red: "\033[31m",
253 |     green: "\033[32m",
254 |     yellow: "\033[33m",
255 |     cyan: "\033[36m",
256 |     reset: "\033[0m"
257 | };
258 | 
259 | Object.keys(colors).forEach(function(key) {
260 |     if (key !== "reset") {
261 |         exports[key] = function(text) {
262 |             return colors[key] + text + colors.reset;
263 |         };
264 |     }
265 | });
266 | 
267 | var log = exports.log = {
268 |     out: function(text, color) {
269 |         text = (text + "").trim();
270 |         if (colors.hasOwnProperty(color))
271 |             text = colors[color] + text + colors.reset;
272 |         process.stdout.write(text + "\n");
273 |     },
274 | 
275 |     err: function(text, color) {
276 |         text = (text + "").trim();
277 |         if (!colors.hasOwnProperty(color))
278 |             color = "red";
279 |         text = colors[color] + text + colors.reset;
280 |         process.stderr.write(text + "\n");
281 |     }
282 | };
283 | 
284 | var slugExp = /[^a-z\-]/ig;
285 | exports.idToSlug = function(id) {
286 |     return id.replace(slugExp, "_");
287 | };
288 | 
289 | var moduleIdExp = /^[ a-z0-9\-_\/\.]+$/i;
290 | exports.isValidModuleId = function(id) {
291 |     return id === "<stdin>" || moduleIdExp.test(id);
292 | };
293 | 
294 | var objToStr = Object.prototype.toString;
295 | var arrStr = objToStr.call([]);
296 | 
297 | function flatten(value, into) {
298 |     if (objToStr.call(value) === arrStr) {
299 |         into = into || [];
300 |         for (var i = 0, len = value.length; i < len; ++i)
301 |             if (i in value) // Skip holes.
302 |                 flatten(value[i], into);
303 |     } else if (into) {
304 |         into.push(value);
305 |     } else {
306 |         return value;
307 |     }
308 | 
309 |     return into;
310 | };
311 | exports.flatten = flatten;
312 | 
313 | exports.inherits = function(ctor, base) {
314 |     return ctor.prototype = Object.create(base.prototype, {
315 |         constructor: { value: ctor }
316 |     });
317 | };
318 | 
319 | function absolutize(moduleId, requiredId) {
320 |     if (requiredId.charAt(0) === ".")
321 |         requiredId = path.join(moduleId, "..", requiredId);
322 |     return path.normalize(requiredId).replace(/\\/g, '/');
323 | }
324 | exports.absolutize = absolutize;
325 | 
326 | function relativize(moduleId, requiredId) {
327 |     requiredId = absolutize(moduleId, requiredId);
328 | 
329 |     if (requiredId.charAt(0) === ".") {
330 |         // Keep the required ID relative.
331 |     } else {
332 |         // Relativize the required ID.
333 |         requiredId = path.relative(
334 |             path.join(moduleId, ".."),
335 |             requiredId
336 |         );
337 |     }
338 | 
339 |     if (requiredId.charAt(0) !== ".")
340 |         requiredId = "./" + requiredId;
341 | 
342 |     return requiredId.replace(/\\/g, '/');
343 | }
344 | exports.relativize = relativize;
345 | 
346 | function waitForValuesP(obj, makeCopy) {
347 |     if (typeof obj !== "object")
348 |         return Q(obj);
349 | 
350 |     var result = makeCopy ? {} : obj;
351 |     var keys = Object.keys(obj);
352 |     if (keys.length === 0)
353 |         return Q(result);
354 | 
355 |     return Q.all(keys.map(function(key) {
356 |         return obj[key];
357 |     })).then(function(values) {
358 |         for (var i = values.length - 1; i >= 0; --i)
359 |             result[keys[i]] = values[i];
360 |         return result;
361 |     });
362 | }
363 | exports.waitForValuesP = waitForValuesP;
364 | 
365 | function camelize(hyphenated) {
366 |     return hyphenated.replace(/-(.)/g, function(_, ch) {
367 |         return ch.toUpperCase();
368 |     });
369 | }
370 | exports.camelize = camelize;
371 | 


--------------------------------------------------------------------------------
/lib/watcher.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var path = require("path");
  3 | var fs = require("graceful-fs");
  4 | var spawn = require("child_process").spawn;
  5 | var Q = require("q");
  6 | var EventEmitter = require("events").EventEmitter;
  7 | var ReadFileCache = require("./cache").ReadFileCache;
  8 | var util = require("./util");
  9 | var hasOwn = Object.prototype.hasOwnProperty;
 10 | 
 11 | function Watcher(readFileCache, persistent) {
 12 |     assert.ok(this instanceof Watcher);
 13 |     assert.ok(this instanceof EventEmitter);
 14 |     assert.ok(readFileCache instanceof ReadFileCache);
 15 | 
 16 |     // During tests (and only during tests), persistent === false so that
 17 |     // the test suite can actually finish and exit.
 18 |     if (typeof persistent === "undefined") {
 19 |         persistent = true;
 20 |     }
 21 | 
 22 |     EventEmitter.call(this);
 23 | 
 24 |     var self = this;
 25 |     var sourceDir = readFileCache.sourceDir;
 26 |     var dirWatcher = new DirWatcher(sourceDir, persistent);
 27 | 
 28 |     Object.defineProperties(self, {
 29 |         sourceDir: { value: sourceDir },
 30 |         readFileCache: { value: readFileCache },
 31 |         dirWatcher: { value: dirWatcher }
 32 |     });
 33 | 
 34 |     // Watch everything the readFileCache already knows about, and any new
 35 |     // files added in the future.
 36 |     readFileCache.subscribe(function(relativePath) {
 37 |         self.watch(relativePath);
 38 |     });
 39 | 
 40 |     readFileCache.on("changed", function(relativePath) {
 41 |         self.emit("changed", relativePath);
 42 |     });
 43 | 
 44 |     function handleDirEvent(event, relativePath) {
 45 |         if (self.dirWatcher.ready) {
 46 |             self.getFileHandler(relativePath)(event);
 47 |         }
 48 |     }
 49 | 
 50 |     dirWatcher.on("added", function(relativePath) {
 51 |         handleDirEvent("added", relativePath);
 52 |     }).on("deleted", function(relativePath) {
 53 |         handleDirEvent("deleted", relativePath);
 54 |     }).on("changed", function(relativePath) {
 55 |         handleDirEvent("changed", relativePath);
 56 |     });
 57 | }
 58 | 
 59 | util.inherits(Watcher, EventEmitter);
 60 | var Wp = Watcher.prototype;
 61 | 
 62 | Wp.watch = function(relativePath) {
 63 |     this.dirWatcher.add(path.dirname(path.join(
 64 |         this.sourceDir, relativePath)));
 65 | };
 66 | 
 67 | Wp.readFileP = function(relativePath) {
 68 |     return this.readFileCache.readFileP(relativePath);
 69 | };
 70 | 
 71 | Wp.noCacheReadFileP = function(relativePath) {
 72 |     return this.readFileCache.noCacheReadFileP(relativePath);
 73 | };
 74 | 
 75 | Wp.getFileHandler = util.cachedMethod(function(relativePath) {
 76 |     var self = this;
 77 |     return function handler(event) {
 78 |         self.readFileCache.reportPossiblyChanged(relativePath);
 79 |     };
 80 | });
 81 | 
 82 | function orNull(err) {
 83 |     return null;
 84 | }
 85 | 
 86 | Wp.close = function() {
 87 |     this.dirWatcher.close();
 88 | };
 89 | 
 90 | /**
 91 |  * DirWatcher code adapted from Jeffrey Lin's original implementation:
 92 |  * https://github.com/jeffreylin/jsx_transformer_fun/blob/master/dirWatcher.js
 93 |  *
 94 |  * Invariant: this only watches the dir inode, not the actual path.
 95 |  * That means the dir can't be renamed and swapped with another dir.
 96 |  */
 97 | function DirWatcher(inputPath, persistent) {
 98 |     assert.ok(this instanceof DirWatcher);
 99 | 
100 |     var self = this;
101 |     var absPath = path.resolve(inputPath);
102 | 
103 |     if (!fs.statSync(absPath).isDirectory()) {
104 |         throw new Error(inputPath + "is not a directory!");
105 |     }
106 | 
107 |     EventEmitter.call(self);
108 | 
109 |     self.ready = false;
110 |     self.on("ready", function(){
111 |         self.ready = true;
112 |     });
113 | 
114 |     Object.defineProperties(self, {
115 |         // Map of absDirPaths to fs.FSWatcher objects from fs.watch().
116 |         watchers: { value: {} },
117 |         dirContents: { value: {} },
118 |         rootPath: { value: absPath },
119 |         persistent: { value: !!persistent }
120 |     });
121 | 
122 |     process.nextTick(function() {
123 |         self.add(absPath);
124 |         self.emit("ready");
125 |     });
126 | }
127 | 
128 | util.inherits(DirWatcher, EventEmitter);
129 | var DWp = DirWatcher.prototype;
130 | 
131 | DWp.add = function(absDirPath) {
132 |     var self = this;
133 |     if (hasOwn.call(self.watchers, absDirPath)) {
134 |         return;
135 |     }
136 | 
137 |     self.watchers[absDirPath] = fs.watch(absDirPath, {
138 |         persistent: this.persistent
139 |     }).on("change", function(event, filename) {
140 |         self.updateDirContents(absDirPath, event, filename);
141 |     });
142 | 
143 |     // Update internal dir contents.
144 |     self.updateDirContents(absDirPath);
145 | 
146 |     // Since we've never seen this path before, recursively add child
147 |     // directories of this path.  TODO: Don't do fs.readdirSync on the
148 |     // same dir twice in a row.  We already do an fs.statSync in
149 |     // this.updateDirContents() and we're just going to do another one
150 |     // here...
151 |     fs.readdirSync(absDirPath).forEach(function(filename) {
152 |         var filepath = path.join(absDirPath, filename);
153 | 
154 |         // Look for directories.
155 |         if (fs.statSync(filepath).isDirectory()) {
156 |             self.add(filepath);
157 |         }
158 |     });
159 | };
160 | 
161 | DWp.updateDirContents = function(absDirPath, event, fsWatchReportedFilename) {
162 |     var self = this;
163 | 
164 |     if (!hasOwn.call(self.dirContents, absDirPath)) {
165 |         self.dirContents[absDirPath] = [];
166 |     }
167 | 
168 |     var oldContents = self.dirContents[absDirPath];
169 |     var newContents = fs.readdirSync(absDirPath);
170 | 
171 |     var deleted = {};
172 |     var added = {};
173 | 
174 |     oldContents.forEach(function(filename) {
175 |         deleted[filename] = true;
176 |     });
177 | 
178 |     newContents.forEach(function(filename) {
179 |         if (hasOwn.call(deleted, filename)) {
180 |             delete deleted[filename];
181 |         } else {
182 |             added[filename] = true;
183 |         }
184 |     });
185 | 
186 |     var deletedNames = Object.keys(deleted);
187 |     deletedNames.forEach(function(filename) {
188 |         self.emit(
189 |             "deleted",
190 |             path.relative(
191 |                 self.rootPath,
192 |                 path.join(absDirPath, filename)
193 |             )
194 |         );
195 |     });
196 | 
197 |     var addedNames = Object.keys(added);
198 |     addedNames.forEach(function(filename) {
199 |         self.emit(
200 |             "added",
201 |             path.relative(
202 |                 self.rootPath,
203 |                 path.join(absDirPath, filename)
204 |             )
205 |         );
206 |     });
207 | 
208 |     // So changed is not deleted or added?
209 |     if (fsWatchReportedFilename &&
210 |         !hasOwn.call(deleted, fsWatchReportedFilename) &&
211 |         !hasOwn.call(added, fsWatchReportedFilename))
212 |     {
213 |         self.emit(
214 |             "changed",
215 |             path.relative(
216 |                 self.rootPath,
217 |                 path.join(absDirPath, fsWatchReportedFilename)
218 |             )
219 |         );
220 |     }
221 | 
222 |     // If any of the things removed were directories, remove their watchers.
223 |     // If a dir was moved, hopefully two changed events fired?
224 |     //  1) event in dir where it was removed
225 |     //  2) event in dir where it was moved to (added)
226 |     deletedNames.forEach(function(filename) {
227 |         var filepath = path.join(absDirPath, filename);
228 |         delete self.dirContents[filepath];
229 |         delete self.watchers[filepath];
230 |     });
231 | 
232 |     // if any of the things added were directories, recursively deal with them
233 |     addedNames.forEach(function(filename) {
234 |         var filepath = path.join(absDirPath, filename);
235 |         if (fs.existsSync(filepath) &&
236 |             fs.statSync(filepath).isDirectory())
237 |         {
238 |             self.add(filepath);
239 |             // mighttttttt need a self.updateDirContents() here in case
240 |             // we're somehow adding a path that replaces another one...?
241 |         }
242 |     });
243 | 
244 |     // Update state of internal dir contents.
245 |     self.dirContents[absDirPath] = newContents;
246 | };
247 | 
248 | DWp.close = function() {
249 |     var watchers = this.watchers;
250 |     Object.keys(watchers).forEach(function(filename) {
251 |         watchers[filename].close();
252 |     });
253 | };
254 | 
255 | exports.Watcher = Watcher;
256 | 


--------------------------------------------------------------------------------
/main.js:
--------------------------------------------------------------------------------
 1 | var path = require("path");
 2 | var Commoner = require("./lib/commoner").Commoner;
 3 | exports.Commoner = Commoner;
 4 | 
 5 | function defCallback(name) {
 6 |     exports[name] = function() {
 7 |         var commoner = new Commoner;
 8 |         commoner[name].apply(commoner, arguments);
 9 |         commoner.cliBuildP();
10 |         return commoner;
11 |     };
12 | }
13 | 
14 | defCallback("version");
15 | defCallback("resolve");
16 | defCallback("process");
17 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": {
 3 |     "name": "Ben Newman",
 4 |     "email": "bn@cs.stanford.edu"
 5 |   },
 6 |   "name": "commoner",
 7 |   "description": "Flexible tool for translating any dialect of JavaScript into Node-readable CommonJS modules",
 8 |   "keywords": [
 9 |     "modules",
10 |     "require",
11 |     "commonjs",
12 |     "exports",
13 |     "commoner",
14 |     "browserify",
15 |     "stitch"
16 |   ],
17 |   "version": "0.10.4",
18 |   "license": "MIT",
19 |   "homepage": "http://github.com/reactjs/commoner",
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "git://github.com/reactjs/commoner.git"
23 |   },
24 |   "main": "main.js",
25 |   "files": [
26 |     "bin",
27 |     "lib",
28 |     "main.js"
29 |   ],
30 |   "bin": {
31 |     "commonize": "./bin/commonize"
32 |   },
33 |   "scripts": {
34 |     "test": "rm -rf test/output ; node ./node_modules/mocha/bin/mocha --reporter spec test/run.js"
35 |   },
36 |   "dependencies": {
37 |     "commander": "^2.5.0",
38 |     "detective": "^4.3.1",
39 |     "glob": "^5.0.15",
40 |     "graceful-fs": "^4.1.2",
41 |     "iconv-lite": "^0.4.5",
42 |     "mkdirp": "^0.5.0",
43 |     "private": "^0.1.6",
44 |     "q": "^1.1.2",
45 |     "recast": "^0.10.0"
46 |   },
47 |   "devDependencies": {
48 |     "mocha": "^2.3.3"
49 |   },
50 |   "engines": {
51 |     "node": ">= 0.8"
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/test/debug.conf:
--------------------------------------------------------------------------------
1 | {
2 |     "debug": true
3 | }
4 | 


--------------------------------------------------------------------------------
/test/release.conf:
--------------------------------------------------------------------------------
1 | {
2 |     "debug": false
3 | }
4 | 


--------------------------------------------------------------------------------
/test/run.js:
--------------------------------------------------------------------------------
  1 | var assert = require("assert");
  2 | var Watcher = require("../lib/watcher").Watcher;
  3 | var BuildContext = require("../lib/context").BuildContext;
  4 | var ModuleReader = require("../lib/reader").ModuleReader;
  5 | var ReadFileCache = require("../lib/cache").ReadFileCache;
  6 | var grepP = require("../lib/grep");
  7 | var util = require("../lib/util");
  8 | var fs = require("fs");
  9 | var Q = require("q");
 10 | 
 11 | var path = require("path");
 12 | var sourceDir = path.resolve(__dirname, "source");
 13 | var outputDir = path.resolve(__dirname, "output");
 14 | 
 15 | try {
 16 |     fs.mkdirSync(outputDir);
 17 | } catch (exists) {
 18 |     // pass
 19 | }
 20 | 
 21 | var watcher = new Watcher(new ReadFileCache(sourceDir), false);
 22 | 
 23 | // Get a new context. Defaults to setRelativize(true) and setUseProvidesModule(true)
 24 | function getNewContext(options) {
 25 |     var context = new BuildContext({
 26 |         config: { debug: options.debug },
 27 |         sourceDir: sourceDir
 28 |     }, new ReadFileCache(sourceDir));
 29 |     context.setCacheDirectory(path.join(outputDir, options.cacheDirectory));
 30 |     context.setRelativize(options.relative === undefined || options.relative);
 31 |     context.setUseProvidesModule(options.useProvidesModule === undefined || options.useProvidesModule );
 32 |     return context;
 33 | }
 34 | 
 35 | function getNewDebugContext(options) {
 36 |     options = options || {};
 37 |     options.debug = true;
 38 |     options.cacheDirectory = ".debug-module-cache";
 39 |     return getNewContext(options);
 40 | }
 41 | 
 42 | function getNewReleaseContext(options) {
 43 |     options = options || {};
 44 |     options.debug = false;
 45 |     options.cacheDirectory = ".release-module-cache";
 46 |     return getNewContext(options);
 47 | }
 48 | 
 49 | var debugContext = getNewDebugContext();
 50 | 
 51 | var releaseContext = getNewReleaseContext();
 52 | 
 53 | function getProvidedP(id) {
 54 |     var context = this;
 55 |     return context.getProvidedP().then(function(idToPath) {
 56 |         if (idToPath.hasOwnProperty(id))
 57 |             return context.readFileP(idToPath[id]);
 58 |     });
 59 | }
 60 | 
 61 | function getSourceP(id) {
 62 |     return this.readModuleP(id);
 63 | }
 64 | 
 65 | function waitForHelpers(done, helperP, contextOptions) {
 66 |     Q.all([
 67 |         helperP(getNewDebugContext(contextOptions)),
 68 |         helperP(getNewReleaseContext(contextOptions))
 69 |     ]).done(function() {
 70 |         done();
 71 |     });
 72 | }
 73 | 
 74 | function checkHome(assert, home) {
 75 |     return Q(home).then(function(home) {
 76 |         assert.strictEqual(home.id, "home");
 77 |         assert.strictEqual(typeof home.source, "string");
 78 |         assert.notEqual(home.source.indexOf("exports"), -1);
 79 |         assert.strictEqual(home.source.indexOf('require("./assert");'), 0);
 80 |         return home;
 81 |     }).invoke("getRequiredP").then(function(reqs) {
 82 |         assert.strictEqual(reqs.length, 1);
 83 |         assert.strictEqual(reqs[0].id, "assert");
 84 |     });
 85 | }
 86 | 
 87 | describe("ModuleReader", function() {
 88 |     it('should read "home" module correctly', function(done) {
 89 |         var reader = new ModuleReader(debugContext, [getSourceP], []);
 90 |         var homeP = reader.readModuleP("home");
 91 |         checkHome(assert, homeP).done(done);
 92 |     });
 93 | 
 94 |     it("should generate stubs for missing modules", function(done) {
 95 |         function helperP(context) {
 96 |             var reader = new ModuleReader(context, [getSourceP], []);
 97 |             var id = "this/module/should/not/exist";
 98 |             return reader.readModuleP(id).then(function(module) {
 99 |                 assert.strictEqual(module.id, id);
100 |                 assert.notEqual(module.source.indexOf("throw new Error"), -1);
101 |             });
102 |         }
103 | 
104 |         waitForHelpers(done, helperP);
105 |     });
106 | 
107 |     it("should skip failing resolvers", function(done) {
108 |         var reader = new ModuleReader(debugContext, [function(id) {
109 |             return this.makePromise(function(callback) {
110 |                 process.nextTick(function() {
111 |                     callback(new Error("bad thing happen"));
112 |                 });
113 |             });
114 |         }, function(id) {
115 |             throw new Error("superbad situation");
116 |         }, getSourceP], []);
117 | 
118 |         var homeP = reader.readModuleP("home");
119 |         checkHome(assert, homeP).done(done);
120 |     });
121 | 
122 |     it("should cache previously-read modules", function(done) {
123 |         var reader = new ModuleReader(debugContext, [getSourceP], []);
124 | 
125 |         var homes = [
126 |             reader.readModuleP("home"),
127 |             reader.readModuleP("home"),
128 |             reader.readModuleP.originalFn.call(reader, "home")
129 |         ];
130 | 
131 |         assert.strictEqual(homes[0], homes[1]);
132 |         assert.notStrictEqual(homes[0], homes[2]);
133 |         assert.notStrictEqual(homes[1], homes[2]);
134 | 
135 |         Q.spread(homes, function(h0, h1, h2) {
136 |             assert.strictEqual(h0, h1);
137 |             assert.strictEqual(h0, h2);
138 |             assert.strictEqual(h1, h2);
139 | 
140 |             assert.strictEqual(h0.hash, h1.hash);
141 |             assert.strictEqual(h1.hash, h2.hash);
142 |         }).done(done);
143 |     });
144 | 
145 |     it("should allow multiple file output", function(done) {
146 |         var mfSource = [
147 |             "function multiFile(foo) {",
148 |             "  console.log(foo);",
149 |             "}"
150 |         ].join("\n");
151 | 
152 |         var pkg = require("../package.json");
153 | 
154 |         function getSourceP(id) {
155 |             assert.strictEqual(id, "multi-file");
156 |             return Q(mfSource);
157 |         }
158 | 
159 |         function processP1(id, source) {
160 |             assert.strictEqual(source, mfSource);
161 |             return {
162 |                 ".js": source,
163 |                 ".json": util.readJsonFileP(
164 |                     path.join(__dirname, "..", "package.json")
165 |                 )
166 |             };
167 |         }
168 | 
169 |         function processP2(id, input) {
170 |             assert.strictEqual(input[".js"], mfSource);
171 | 
172 |             var json = input[".json"];
173 |             assert.deepEqual(json, pkg);
174 | 
175 |             input[".json"] = util.makePromise(function(callback) {
176 |                 process.nextTick(function() {
177 |                     callback(null, JSON.stringify(json));
178 |                 });
179 |             });
180 | 
181 |             return input;
182 |         }
183 | 
184 |         function processP3(id, input) {
185 |             assert.strictEqual(input[".js"], mfSource);
186 |             assert.strictEqual(typeof input[".json"], "string");
187 |             assert.deepEqual(JSON.parse(input[".json"]), pkg);
188 | 
189 |             return input;
190 |         }
191 | 
192 |         var reader = new ModuleReader(
193 |             debugContext,
194 |             [getSourceP],
195 |             [processP1, processP2, processP3]
196 |         );
197 | 
198 |         reader.readModuleP("multi-file").then(function(mf) {
199 |             assert.strictEqual(mf.id, "multi-file");
200 |             assert.strictEqual(mf.source, mfSource);
201 |             assert.deepEqual(JSON.parse(mf.output[".json"]), pkg);
202 |         }).done(done);
203 |     });
204 | });
205 | 
206 | describe("grepP", function() {
207 |     it("should find @providesModule identifiers", function(done) {
208 |         Q.spread([
209 |             grepP("@providesModule\\s+\\S+", sourceDir),
210 |             debugContext.getProvidedP()
211 |         ], function(pathToMatch, valueToPath) {
212 |             assert.deepEqual(pathToMatch, {
213 |                 "widget/share.js": "@providesModule WidgetShare",
214 |                 "widget/.bogus.js": "@providesModule WidgetShare",
215 |                 "widget/bogus.js~": "@providesModule WidgetShare"
216 |             });
217 |             assert.deepEqual(valueToPath, {
218 |                 "WidgetShare": "widget/share.js"
219 |             });
220 |         }).done(done);
221 |     });
222 | });
223 | 
224 | describe("@providesModule", function() {
225 |     it("should parse docblocks correctly", function(done) {
226 |         var code = arguments.callee.toString();
227 | 
228 |         /**
229 |          * Look, Ma! A test function that uses itself as input!
230 |          * @providesModule
231 |          * @providesModule foo/bar
232 |          */
233 | 
234 |         assert.strictEqual(
235 |             code.split("@provides" + "Module").length,
236 |             4);
237 | 
238 |         assert.strictEqual(
239 |             debugContext.getProvidedId(code),
240 |             "foo/bar");
241 | 
242 |         assert.strictEqual(
243 |             debugContext.getProvidedId(
244 |                 "no at-providesModule, here"),
245 |             null);
246 | 
247 |         /**
248 |          * Just to make sure we only pay attention to the first one.
249 |          * @providesModule ignored
250 |          */
251 | 
252 |         function helper(context) {
253 |             var reader = new ModuleReader(context, [
254 |                 getProvidedP,
255 |                 getSourceP
256 |             ], []);
257 | 
258 |             return Q.all([
259 |                 Q.spread([
260 |                     reader.readModuleP("widget/share"),
261 |                     reader.readModuleP("WidgetShare")
262 |                 ], function(ws1, ws2) {
263 |                     assert.strictEqual(ws1.id, ws2.id);
264 |                     assert.strictEqual(ws1.id, "WidgetShare");
265 |                     assert.strictEqual(ws1, ws2);
266 |                 }),
267 | 
268 |                 reader.readMultiP([
269 |                     "widget/share",
270 |                     "WidgetShare"
271 |                 ]).then(function(modules) {
272 |                     assert.strictEqual(modules.length, 1);
273 |                     assert.strictEqual(modules[0].id, "WidgetShare");
274 |                 }),
275 | 
276 |                 reader.readModuleP(
277 |                     "widget/gallery"
278 |                 ).then(function(gallery) {
279 |                     return gallery.getRequiredP();
280 |                 }).then(function(deps) {
281 |                     assert.strictEqual(deps.length, 1);
282 |                     assert.strictEqual(deps[0].id, "WidgetShare");
283 |                 }),
284 | 
285 |                 Q.spread([
286 |                     reader.getSourceP("widget/share"),
287 |                     reader.getSourceP("WidgetShare")
288 |                 ], function(source1, source2) {
289 |                     assert.strictEqual(source1, source2);
290 |                 })
291 |             ]);
292 |         }
293 | 
294 |         waitForHelpers(done, helper);
295 |     });
296 | });
297 | 
298 | describe("context.makePromise", function() {
299 |     it("should make goodly promises", function(done) {
300 |         var error = new Error("test");
301 | 
302 |         function helperP(context) {
303 |             return context.makePromise(function(callback) {
304 |                 process.nextTick(function() {
305 |                     callback(error, "asdf");
306 |                 });
307 |             }).then(function() {
308 |                 assert.ok(false, "should have thrown an error");
309 |             }, function(err) {
310 |                 assert.strictEqual(err, error);
311 | 
312 |                 return context.makePromise(function(callback) {
313 |                     process.nextTick(function() {
314 |                         callback(null, "success");
315 |                     });
316 |                 }).then(function(result) {
317 |                     assert.strictEqual(result, "success");
318 |                 });
319 |             })
320 |         }
321 | 
322 |         waitForHelpers(done, helperP);
323 |     });
324 | });
325 | 
326 | describe("util.relativize", function() {
327 |     it("should resolve correct relative module identifiers", function(done) {
328 |         var moduleId = "some/deeply/nested/module";
329 |         var processor = require("../lib/relative").getProcessor(null);
330 | 
331 |         function makeSource(id) {
332 |             var str = JSON.stringify(id);
333 |             return "require(" + str + ");\n" +
334 |                 "require(function(){require(" + str + ")}())";
335 |         }
336 | 
337 |         function helperP(requiredId, expected) {
338 |             assert.strictEqual(
339 |                 util.relativize(moduleId, requiredId),
340 |                 expected);
341 | 
342 |             return processor(
343 |                 moduleId,
344 |                 makeSource(requiredId)
345 |             ).then(function(output) {
346 |                 assert.deepEqual(output, {
347 |                     ".js": makeSource(expected)
348 |                 });
349 |             });
350 |         }
351 | 
352 |         Q.all([
353 |             helperP("another/nested/module",
354 |                     "../../../another/nested/module"),
355 |             helperP("../../buried/module/./file",
356 |                     "../../buried/module/file"),
357 |             helperP("../../buried/module/../file",
358 |                     "../../buried/file"),
359 |             helperP("./same/level",
360 |                     "./same/level"),
361 |             helperP("./same/./level",
362 |                     "./same/level"),
363 |             helperP("./same/../level",
364 |                     "./level"),
365 |             helperP("some/deeply/buried/treasure",
366 |                     "../buried/treasure"),
367 |             helperP("./file", "./file"),
368 |             helperP("./file/../../../module",
369 |                     "../../module"),
370 |             helperP("./file/../../module",
371 |                     "../module")
372 |         ]).done(function() {
373 |             done();
374 |         });
375 |     });
376 | });
377 | 
378 | describe("canonical module identifiers", function() {
379 |     it("should be returned by reader.getCanonicalIdP", function(done) {
380 |         function helperP(context) {
381 |             var reader = new ModuleReader(context, [
382 |                 getProvidedP,
383 |                 getSourceP
384 |             ], []);
385 | 
386 |             return Q.spread([
387 |                 reader.getCanonicalIdP("widget/share"),
388 |                 reader.getCanonicalIdP("WidgetShare"),
389 |                 reader.readModuleP("widget/share").get("id"),
390 |                 reader.readModuleP("WidgetShare").get("id")
391 |             ], function(ws1, ws2, ws3, ws4) {
392 |                 assert.strictEqual(ws1, "WidgetShare");
393 |                 assert.strictEqual(ws2, "WidgetShare");
394 |                 assert.strictEqual(ws3, "WidgetShare");
395 |                 assert.strictEqual(ws4, "WidgetShare");
396 |             });
397 |         }
398 | 
399 |         waitForHelpers(done, helperP);
400 |     });
401 | 
402 |     it("should replace non-canonical required identifiers", function(done) {
403 |         function helperP(context) {
404 |             assert.strictEqual(context.ignoreDependencies, false);
405 | 
406 |             var reader = new ModuleReader(context, [
407 |                 getProvidedP,
408 |                 getSourceP
409 |             ], []);
410 | 
411 |             return reader.readModuleP("widget/follow").then(function(follow) {
412 |                 assert.strictEqual(follow.source.indexOf("widget/share"), -1);
413 | 
414 |                 assert.strictEqual(strCount(
415 |                     'require("../WidgetShare")',
416 |                     follow.source
417 |                 ), 4);
418 | 
419 |                 assert.strictEqual(strCount(
420 |                     'require("./gallery")',
421 |                     follow.source
422 |                 ), 2);
423 | 
424 |                 assert.strictEqual(strCount(
425 |                     'require("../assert")',
426 |                     follow.source
427 |                 ), 2);
428 |             });
429 |         }
430 | 
431 |         waitForHelpers(done, helperP);
432 |     });
433 | 
434 |     function strCount(substring, string) {
435 |         return string.split(substring).length - 1;
436 |     }
437 | });
438 | 
439 | describe("canonical module identifiers without --use-provides-module", function() {
440 |     it("should not be returned by reader.getCanonicalIdP nor reader.readModuleP", function(done) {
441 |         function helperP(context) {
442 |             console.log(context.useProvidesModule);
443 |             var reader = new ModuleReader(context, [
444 |                 getProvidedP,
445 |                 getSourceP
446 |             ], []);
447 | 
448 |             return Q.spread([
449 |                 reader.getCanonicalIdP("widget/share"),
450 |                 reader.getCanonicalIdP("WidgetShare"),
451 |                 reader.readModuleP("widget/share").get("id"),
452 |                 reader.readModuleP("WidgetShare").get("id")
453 |             ], function(ws1, ws2, ws3, ws4) {
454 |                 assert.strictEqual(ws1, "widget/share");
455 |                 assert.strictEqual(ws2, "WidgetShare");
456 |                 assert.strictEqual(ws3, "widget/share");
457 |                 assert.strictEqual(ws4, "WidgetShare");
458 |             });
459 |         }
460 | 
461 |         waitForHelpers(done, helperP, {useProvidesModule: false});
462 |     });
463 | })
464 | 
465 | describe("util.flatten", function() {
466 |     it("should flatten deeply nested arrays", function() {
467 |         function check(input, expected) {
468 |             var flat = util.flatten(input);
469 |             assert.deepEqual(flat, expected);
470 |         }
471 | 
472 |         check(1, 1);
473 |         check([[],,[],1, 2], [1, 2]);
474 |         check([[[[[[]]]]]], []);
475 |         check([[1,[[[[2]]],3]]], [1, 2, 3]);
476 |         check([[1],[[2]],[[[3]]]], [1, 2, 3]);
477 |         check([,,,], []);
478 |     });
479 | });
480 | 
481 | describe("util.testWriteFd", function() {
482 |     it("should write non-ASCII file data", function(done) {
483 |         var file = path.join(outputDir, "writeFdP.test.txt");
484 | 
485 |         function check(content) {
486 |             function afterUnlink(err) {
487 |                 return util.openExclusiveP(file).then(function(fd) {
488 |                     return util.writeFdP(fd, content).then(function(written) {
489 |                         assert.strictEqual(content, written);
490 |                     });
491 |                 });
492 |             }
493 | 
494 |             return function() {
495 |                 return util.unlinkP(file).then(afterUnlink, afterUnlink);
496 |             };
497 |         }
498 | 
499 |         Q("ignored")
500 |             .then(check("x"))
501 |             .then(check("x\ny"))
502 |             .then(check("x\r\ny"))
503 |             .then(check("\t\nx\t"))
504 |             .then(check("\ufeff")) // zero-width non-breaking space
505 |             .then(check("\u2603")) // snowman
506 |             .then(check("\ud83d\udc19")) // octopus
507 |             .finally(function() {
508 |                 return util.unlinkP(file);
509 |             }).done(done);
510 |     });
511 | });
512 | 
513 | describe("Watcher", function() {
514 |     it("should basically work", function(done) {
515 |         var watcher = new Watcher(new ReadFileCache(sourceDir), false);
516 |         var dummy = "dummy.js";
517 |         var dummyFile = path.join(sourceDir, dummy);
518 | 
519 |         function waitForChangeP() {
520 |             return util.makePromise(function(callback) {
521 |                 watcher.on("changed", function(path) {
522 |                     callback(null, path);
523 |                 });
524 |             });
525 |         }
526 | 
527 |         util.unlinkP(dummyFile).then(function() {
528 |             return util.openExclusiveP(dummyFile).then(function(fd) {
529 |                 return util.writeFdP(fd, "dummy");
530 |             });
531 |         }).then(function() {
532 |             return Q.all([
533 |                 watcher.readFileP("home.js"),
534 |                 watcher.readFileP(dummy)
535 |             ]);
536 |         }).then(function() {
537 |             return Q.all([
538 |                 util.unlinkP(dummyFile),
539 |                 waitForChangeP()
540 |             ]);
541 |         }).done(function() {
542 |             watcher.close();
543 |             done();
544 |         });
545 |     });
546 | 
547 |     it("should be able to watch directories", function(done) {
548 |         var watcher = new Watcher(new ReadFileCache(sourceDir), false);
549 |         var watchMe = "watchMe.js";
550 |         var fullPath = path.join(sourceDir, watchMe);
551 | 
552 |         function waitForChangeP() {
553 |             return util.makePromise(function(callback) {
554 |                 watcher.once("changed", function(path) {
555 |                     callback(null, path);
556 |                 });
557 |             });
558 |         }
559 | 
560 |         function write(content) {
561 |             return util.openFileP(fullPath).then(function(fd) {
562 |                 var promise = waitForChangeP();
563 |                 util.writeFdP(fd, content);
564 |                 return promise;
565 |             });
566 |         }
567 | 
568 |         util.unlinkP(fullPath).then(function() {
569 |             return watcher.readFileP(watchMe).then(function(source) {
570 |                 assert.ok(false, "readFileP should have failed");
571 |             }, function(err) {
572 |                 assert.strictEqual(err.code, "ENOENT");
573 |             });
574 |         }).then(function() {
575 |             return write("first");
576 |         }).then(function() {
577 |             return write("second");
578 |         }).then(function() {
579 |             var promise = waitForChangeP();
580 |             util.unlinkP(fullPath);
581 |             return promise;
582 |         }).then(function() {
583 |             return write("third");
584 |         }).finally(function() {
585 |             return util.unlinkP(fullPath);
586 |         }).done(function() {
587 |             watcher.close();
588 |             done();
589 |         });
590 |     });
591 | });
592 | 


--------------------------------------------------------------------------------
/test/source/assert.js:
--------------------------------------------------------------------------------
1 | function assert(test, msg) {
2 |     if (!test) {
3 |         throw new Error(msg);
4 |     }
5 | }
6 | 
7 | module.exports = assert.ok = assert;
8 | 


--------------------------------------------------------------------------------
/test/source/core.js:
--------------------------------------------------------------------------------
1 | exports.name = "core";
2 | 


--------------------------------------------------------------------------------
/test/source/home.js:
--------------------------------------------------------------------------------
1 | require("assert");
2 | require("./assert");
3 | require("./tests/../assert");
4 | 
5 | exports.name = "home";
6 | 


--------------------------------------------------------------------------------
/test/source/login.js:
--------------------------------------------------------------------------------
1 | exports.name = "login";
2 | 


--------------------------------------------------------------------------------
/test/source/roots.json:
--------------------------------------------------------------------------------
1 | ["core", "third-party", "home", "login", "settings"]
2 | 


--------------------------------------------------------------------------------
/test/source/schema.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "core": {
 3 |         "third-party": {
 4 |             "login": {
 5 |                 "tests/login": {}
 6 |             },
 7 |             "home": {
 8 |                 "tests/home": {}
 9 |             },
10 |             "settings": {
11 |                 "tests/settings": {}
12 |             }
13 |         }
14 |     },
15 |     "widget/common": {
16 |         "widget/follow": {},
17 |         "widget/gallery": {},
18 |         "widget/share": {}
19 |     },
20 |     "WidgetShare": {}
21 | }
22 | 


--------------------------------------------------------------------------------
/test/source/settings.js:
--------------------------------------------------------------------------------
1 | exports.name = "settings";
2 | 


--------------------------------------------------------------------------------
/test/source/tests/home.js:
--------------------------------------------------------------------------------
1 | exports.name = "tests/home";
2 | 


--------------------------------------------------------------------------------
/test/source/tests/login.js:
--------------------------------------------------------------------------------
1 | exports.name = "tests/login";
2 | 


--------------------------------------------------------------------------------
/test/source/tests/settings.js:
--------------------------------------------------------------------------------
1 | exports.name = "tests/settings";
2 | 


--------------------------------------------------------------------------------
/test/source/third-party.js:
--------------------------------------------------------------------------------
1 | exports.name = "third-party";
2 | 


--------------------------------------------------------------------------------
/test/source/widget/.bogus.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * This is a temporary file such as VIM is wont to create.
3 |  * @providesModule WidgetShare
4 |  */
5 | 


--------------------------------------------------------------------------------
/test/source/widget/bogus.js~:
--------------------------------------------------------------------------------
1 | /**
2 |  * This is a temporary file such as Emacs is wont to create.
3 |  * @providesModule WidgetShare
4 |  */
5 | 


--------------------------------------------------------------------------------
/test/source/widget/common.js:
--------------------------------------------------------------------------------
1 | exports.name = "widget/common";
2 | 


--------------------------------------------------------------------------------
/test/source/widget/follow.js:
--------------------------------------------------------------------------------
 1 | // All these ways of requiring WidgetShare should get normalized to the
 2 | // same relative identifier: "../WidgetShare".
 3 | require("./share");
 4 | require("../widget/share");
 5 | require("WidgetShare");
 6 | require("../WidgetShare");
 7 | 
 8 | // These identifiers will both become "./gallery".
 9 | require("../widget/gallery");
10 | require("./gallery");
11 | 
12 | // These both become "../assert".
13 | require("assert");
14 | require("../assert");
15 | 
16 | // These circular references should both become "./follow".
17 | require("./follow");
18 | require("../widget/follow");
19 | 
20 | exports.name = "widget/follow";
21 | 


--------------------------------------------------------------------------------
/test/source/widget/gallery.js:
--------------------------------------------------------------------------------
1 | require("../widget/share");
2 | require("./share");
3 | require("WidgetShare");
4 | 
5 | exports.name = "widget/gallery";
6 | 


--------------------------------------------------------------------------------
/test/source/widget/share.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * @providesModule WidgetShare
3 |  */
4 | 
5 | // @providesModule ignore this
6 | exports.name = "widget/share";
7 | 


--------------------------------------------------------------------------------