trans 0.5.10 → 0.5.13

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/node_modules/minimatch/test/brace-expand.js

@@ -1,33 +0,0 @@
-var tap = require("tap")
-  , minimatch = require("../")
-
-tap.test("brace expansion", function (t) {
-  // [ pattern, [expanded] ]
-  ; [ [ "a{b,c{d,e},{f,g}h}x{y,z}"
-      , [ "abxy"
-        , "abxz"
-        , "acdxy"
-        , "acdxz"
-        , "acexy"
-        , "acexz"
-        , "afhxy"
-        , "afhxz"
-        , "aghxy"
-        , "aghxz" ] ]
-    , [ "a{1..5}b"
-      , [ "a1b"
-        , "a2b"
-        , "a3b"
-        , "a4b"
-        , "a5b" ] ]
-    , [ "a{b}c", ["a{b}c"] ]
-  ].forEach(function (tc) {
-    var p = tc[0]
-      , expect = tc[1]
-    t.equivalent(minimatch.braceExpand(p), expect, p)
-  })
-  console.error("ending")
-  t.end()
-})
-
-

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/node_modules/minimatch/test/caching.js

@@ -1,14 +0,0 @@
-var Minimatch = require("../minimatch.js").Minimatch
-var tap = require("tap")
-tap.test("cache test", function (t) {
-  var mm1 = new Minimatch("a?b")
-  var mm2 = new Minimatch("a?b")
-  t.equal(mm1, mm2, "should get the same object")
-  // the lru should drop it after 100 entries
-  for (var i = 0; i < 100; i ++) {
-    new Minimatch("a"+i)
-  }
-  mm2 = new Minimatch("a?b")
-  t.notEqual(mm1, mm2, "cache should have dropped")
-  t.end()
-})

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/node_modules/minimatch/test/defaults.js

@@ -1,274 +0,0 @@
-// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test
-//
-// TODO: Some of these tests do very bad things with backslashes, and will
-// most likely fail badly on windows.  They should probably be skipped.
-
-var tap = require("tap")
-  , globalBefore = Object.keys(global)
-  , mm = require("../")
-  , files = [ "a", "b", "c", "d", "abc"
-            , "abd", "abe", "bb", "bcd"
-            , "ca", "cb", "dd", "de"
-            , "bdir/", "bdir/cfile"]
-  , next = files.concat([ "a-b", "aXb"
-                        , ".x", ".y" ])
-
-tap.test("basic tests", function (t) {
-  var start = Date.now()
-
-  // [ pattern, [matches], MM opts, files, TAP opts]
-  ; [ "http://www.bashcookbook.com/bashinfo" +
-      "/source/bash-1.14.7/tests/glob-test"
-    , ["a*", ["a", "abc", "abd", "abe"]]
-    , ["X*", ["X*"], {nonull: true}]
-
-    // allow null glob expansion
-    , ["X*", []]
-
-    // isaacs: Slightly different than bash/sh/ksh
-    // \\* is not un-escaped to literal "*" in a failed match,
-    // but it does make it get treated as a literal star
-    , ["\\*", ["\\*"], {nonull: true}]
-    , ["\\**", ["\\**"], {nonull: true}]
-    , ["\\*\\*", ["\\*\\*"], {nonull: true}]
-
-    , ["b*/", ["bdir/"]]
-    , ["c*", ["c", "ca", "cb"]]
-    , ["**", files]
-
-    , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}]
-    , ["s/\\..*//", ["s/\\..*//"], {nonull: true}]
-
-    , "legendary larry crashes bashes"
-    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"
-      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}]
-    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"
-      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}]
-
-    , "character classes"
-    , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]]
-    , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd",
-       "bdir/", "ca", "cb", "dd", "de"]]
-    , ["a*[^c]", ["abd", "abe"]]
-    , function () { files.push("a-b", "aXb") }
-    , ["a[X-]b", ["a-b", "aXb"]]
-    , function () { files.push(".x", ".y") }
-    , ["[^a-c]*", ["d", "dd", "de"]]
-    , function () { files.push("a*b/", "a*b/ooo") }
-    , ["a\\*b/*", ["a*b/ooo"]]
-    , ["a\\*?/*", ["a*b/ooo"]]
-    , ["*\\\\!*", [], {null: true}, ["echo !7"]]
-    , ["*\\!*", ["echo !7"], null, ["echo !7"]]
-    , ["*.\\*", ["r.*"], null, ["r.*"]]
-    , ["a[b]c", ["abc"]]
-    , ["a[\\b]c", ["abc"]]
-    , ["a?c", ["abc"]]
-    , ["a\\*c", [], {null: true}, ["abc"]]
-    , ["", [""], { null: true }, [""]]
-
-    , "http://www.opensource.apple.com/source/bash/bash-23/" +
-      "bash/tests/glob-test"
-    , function () { files.push("man/", "man/man1/", "man/man1/bash.1") }
-    , ["*/man*/bash.*", ["man/man1/bash.1"]]
-    , ["man/man1/bash.1", ["man/man1/bash.1"]]
-    , ["a***c", ["abc"], null, ["abc"]]
-    , ["a*****?c", ["abc"], null, ["abc"]]
-    , ["?*****??", ["abc"], null, ["abc"]]
-    , ["*****??", ["abc"], null, ["abc"]]
-    , ["?*****?c", ["abc"], null, ["abc"]]
-    , ["?***?****c", ["abc"], null, ["abc"]]
-    , ["?***?****?", ["abc"], null, ["abc"]]
-    , ["?***?****", ["abc"], null, ["abc"]]
-    , ["*******c", ["abc"], null, ["abc"]]
-    , ["*******?", ["abc"], null, ["abc"]]
-    , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["[-abc]", ["-"], null, ["-"]]
-    , ["[abc-]", ["-"], null, ["-"]]
-    , ["\\", ["\\"], null, ["\\"]]
-    , ["[\\\\]", ["\\"], null, ["\\"]]
-    , ["[[]", ["["], null, ["["]]
-    , ["[", ["["], null, ["["]]
-    , ["[*", ["[abc"], null, ["[abc"]]
-    , "a right bracket shall lose its special meaning and\n" +
-      "represent itself in a bracket expression if it occurs\n" +
-      "first in the list.  -- POSIX.2 2.8.3.2"
-    , ["[]]", ["]"], null, ["]"]]
-    , ["[]-]", ["]"], null, ["]"]]
-    , ["[a-\z]", ["p"], null, ["p"]]
-    , ["??**********?****?", [], { null: true }, ["abc"]]
-    , ["??**********?****c", [], { null: true }, ["abc"]]
-    , ["?************c****?****", [], { null: true }, ["abc"]]
-    , ["*c*?**", [], { null: true }, ["abc"]]
-    , ["a*****c*?**", [], { null: true }, ["abc"]]
-    , ["a********???*******", [], { null: true }, ["abc"]]
-    , ["[]", [], { null: true }, ["a"]]
-    , ["[abc", [], { null: true }, ["["]]
-
-    , "nocase tests"
-    , ["XYZ", ["xYz"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-    , ["ab*", ["ABC"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-    , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-
-    // [ pattern, [matches], MM opts, files, TAP opts]
-    , "onestar/twostar"
-    , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]]
-    , ["{/?,*}", ["/a", "bb"], {null: true}
-      , ["/a", "/b/b", "/a/b/c", "bb"]]
-
-    , "dots should not match unless requested"
-    , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]]
-
-    // .. and . can only match patterns starting with .,
-    // even when options.dot is set.
-    , function () {
-        files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"]
-      }
-    , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}]
-    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}]
-    , ["a/*/b", ["a/c/b"], {dot:false}]
-    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}]
-
-
-    // this also tests that changing the options needs
-    // to change the cache key, even if the pattern is
-    // the same!
-    , ["**", ["a/b","a/.d",".a/.d"], { dot: true }
-      , [ ".a/.d", "a/.d", "a/b"]]
-
-    , "paren sets cannot contain slashes"
-    , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]]
-
-    // brace sets trump all else.
-    //
-    // invalid glob pattern.  fails on bash4 and bsdglob.
-    // however, in this implementation, it's easier just
-    // to do the intuitive thing, and let brace-expansion
-    // actually come before parsing any extglob patterns,
-    // like the documentation seems to say.
-    //
-    // XXX: if anyone complains about this, either fix it
-    // or tell them to grow up and stop complaining.
-    //
-    // bash/bsdglob says this:
-    // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]]
-    // but we do this instead:
-    , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]]
-
-    // test partial parsing in the presence of comment/negation chars
-    , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]]
-    , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]]
-
-    // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped.
-    , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g"
-      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"]
-      , {}
-      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]]
-
-
-    // crazy nested {,,} and *(||) tests.
-    , function () {
-        files = [ "a", "b", "c", "d"
-                , "ab", "ac", "ad"
-                , "bc", "cb"
-                , "bc,d", "c,db", "c,d"
-                , "d)", "(b|c", "*(b|c"
-                , "b|c", "b|cc", "cb|c"
-                , "x(a|b|c)", "x(a|c)"
-                , "(a|b|c)", "(a|c)"]
-      }
-    , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]]
-    , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]]
-    // a
-    // *(b|c)
-    // *(b|d)
-    , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]]
-    , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]]
-
-
-    // test various flag settings.
-    , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"]
-      , { noext: true } ]
-    , ["a?b", ["x/y/acb", "acb/"], {matchBase: true}
-      , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ]
-    , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]]
-
-
-    // begin channelling Boole and deMorgan...
-    , "negation tests"
-    , function () {
-        files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"]
-      }
-
-    // anything that is NOT a* matches.
-    , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]]
-
-    // anything that IS !a* matches.
-    , ["!a*", ["!ab", "!abc"], {nonegate: true}]
-
-    // anything that IS a* matches
-    , ["!!a*", ["a!b"]]
-
-    // anything that is NOT !a* matches
-    , ["!\\!a*", ["a!b", "d", "e", "\\!a"]]
-
-    // negation nestled within a pattern
-    , function () {
-        files = [ "foo.js"
-                , "foo.bar"
-                // can't match this one without negative lookbehind.
-                , "foo.js.js"
-                , "blar.js"
-                , "foo."
-                , "boo.js.boo" ]
-      }
-    , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ]
-
-    ].forEach(function (c) {
-      if (typeof c === "function") return c()
-      if (typeof c === "string") return t.comment(c)
-
-      var pattern = c[0]
-        , expect = c[1].sort(alpha)
-        , options = c[2] || {}
-        , f = c[3] || files
-        , tapOpts = c[4] || {}
-
-      // options.debug = true
-      var Class = mm.defaults(options).Minimatch
-      var m = new Class(pattern, {})
-      var r = m.makeRe()
-      tapOpts.re = String(r) || JSON.stringify(r)
-      tapOpts.files = JSON.stringify(f)
-      tapOpts.pattern = pattern
-      tapOpts.set = m.set
-      tapOpts.negated = m.negate
-
-      var actual = mm.match(f, pattern, options)
-      actual.sort(alpha)
-
-      t.equivalent( actual, expect
-                  , JSON.stringify(pattern) + " " + JSON.stringify(expect)
-                  , tapOpts )
-    })
-
-  t.comment("time=" + (Date.now() - start) + "ms")
-  t.end()
-})
-
-tap.test("global leak test", function (t) {
-  var globalAfter = Object.keys(global)
-  t.equivalent(globalAfter, globalBefore, "no new globals, please")
-  t.end()
-})
-
-function alpha (a, b) {
-  return a > b ? 1 : -1
-}

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/node_modules/minimatch/test/extglob-ending-with-state-char.js

@@ -1,8 +0,0 @@
-var test = require('tap').test
-var minimatch = require('../')
-
-test('extglob ending with statechar', function(t) {
-  t.notOk(minimatch('ax', 'a?(b*)'))
-  t.ok(minimatch('ax', '?(a*|b)'))
-  t.end()
-})

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/package.json

@@ -1,74 +0,0 @@
-{
-  "name": "globule",
-  "description": "An easy-to-use wildcard globbing library.",
-  "version": "0.1.0",
-  "homepage": "https://github.com/cowboy/node-globule",
-  "author": {
-    "name": "\"Cowboy\" Ben Alman",
-    "url": "http://benalman.com/"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/cowboy/node-globule.git"
-  },
-  "bugs": {
-    "url": "https://github.com/cowboy/node-globule/issues"
-  },
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "https://github.com/cowboy/node-globule/blob/master/LICENSE-MIT"
-    }
-  ],
-  "main": "lib/globule",
-  "engines": {
-    "node": ">= 0.8.0"
-  },
-  "scripts": {
-    "test": "grunt nodeunit"
-  },
-  "devDependencies": {
-    "grunt-contrib-jshint": "~0.1.1",
-    "grunt-contrib-nodeunit": "~0.1.2",
-    "grunt-contrib-watch": "~0.2.0",
-    "grunt": "~0.4.1"
-  },
-  "keywords": [
-    "glob",
-    "file",
-    "match",
-    "mapping",
-    "expand",
-    "wildcard",
-    "pattern",
-    "sync",
-    "awesome"
-  ],
-  "dependencies": {
-    "lodash": "~1.0.1",
-    "glob": "~3.1.21",
-    "minimatch": "~0.2.11"
-  },
-  "readme": "# globule [![Build Status](https://secure.travis-ci.org/cowboy/node-globule.png?branch=master)](http://travis-ci.org/cowboy/node-globule)\n\nAn easy-to-use wildcard globbing library.\n\n## Getting Started\nInstall the module with: `npm install globule`\n\n```javascript\nvar globule = require('globule');\nvar filepaths = globule.find('**/*.js');\n```\n\n## Documentation\n\n### globule.find\nReturns a unique array of all file or directory paths that match the given globbing pattern(s). This method accepts either comma separated globbing patterns or an array of globbing patterns. Paths matching patterns that begin with `!` will be excluded from the returned array. Patterns are processed in order, so inclusion and exclusion order is significant.\n\n```js\nglobule.find(patterns [, options])\n```\n\nThe `options` object supports all [glob][] library options, along with a few extras. These are the most commonly used:\n\n* `filter` Either a valid [fs.Stats method name](http://nodejs.org/docs/latest/api/fs.html#fs_class_fs_stats) or a function that will be passed the matched `src` filepath and `options` object as arguments. This function should return a `Boolean` value.\n* `nonull` Retain globbing patterns in result set even if they fail to match files.\n* `matchBase` Patterns without slashes will match just the basename part. Eg. this makes `*.js` work like `**/*.js`.\n* `srcBase` Patterns will be matched relative to the specified path instead of the current working directory. This is a synonym for `cwd`.\n* `prefixBase` Any specified `srcBase` will be prefixed to all returned filepaths.\n\n[glob]: https://github.com/isaacs/node-glob\n\n### globule.match\nMatch one or more globbing patterns against one or more file paths. Returns a uniqued array of all file paths that match any of the specified globbing patterns. Both the `patterns` and `filepaths` arguments can be a single string or array of strings. Paths matching patterns that begin with `!` will be excluded from the returned array. Patterns are processed in order, so inclusion and exclusion order is significant.\n\n```js\ngrunt.file.match(patterns, filepaths [, options])\n```\n\n### globule.isMatch\nThis method contains the same signature and logic as the `globule.match` method, but returns `true` if any files were matched, otherwise `false`.\n\n```js\ngrunt.file.isMatch(patterns, filepaths [, options])\n```\n\n### globule.mapping\nGiven a set of source file paths, returns an array of src-dest file mapping objects. Both src and dest paths may be renamed, depending on the options specified.\n\n```js\nglobule.mapping(filepaths [, options])\n```\n\nIn addition to the options the `globule.find` method supports, the options object also supports these properties:\n\n* `srcBase` The directory from which patterns are matched. Any string specified as `srcBase` is effectively stripped from the beginning of all matched paths.\n* `destBase` The specified path is prefixed to all `dest` filepaths.\n* `ext` Remove anything after (and including) the first `.` in the destination path, then append this value.\n* `extDot` Change the behavior of `ext`, `\"first\"` and `\"last\"` will remove anything after the first or last `.` in the destination filename, respectively. Defaults to `\"first\"`.\n* `flatten` Remove the path component from all matched src files. The src file path is still joined to the specified destBase.\n* `rename` If specified, this function will be responsible for returning the final `dest` filepath. By default, it flattens paths (if specified), changes extensions (if specified) and joins the matched path to the `destBase`.\n\n### globule.findMapping\nThis method is a convenience wrapper around the `globule.find` and `globule.mapping` methods.\n\n```js\nglobule.findMapping(patterns [, options])\n```\n\n\n## Examples\n\nGiven the files `foo/a.js` and `foo/b.js`:\n\n### srcBase and destBase\n\n```js\nglobule.find(\"foo/*.js\")\n// [\"foo/a.js\", \"foo/b.js\"]\n\nglobule.find(\"*.js\", {srcBase: \"foo\"})\n// [\"a.js\", \"b.js\"]\n\nglobule.find(\"*.js\", {srcBase: \"foo\", prefixBase: true})\n// [\"foo/a.js\", \"foo/b.js\"]\n```\n\n```js\nglobule.findMapping(\"foo/*.js\")\n// [{src: \"foo/a.js\", dest: \"foo/a.js\"}, {src: \"foo/b.js\", dest: \"foo/b.js\"}]\n\nglobule.findMapping(\"foo/*.js\", {destBase: \"bar\"})\n// [{src: \"foo/a.js\", dest: \"bar/foo/a.js\"}, {src: \"foo/b.js\", dest: \"bar/foo/b.js\"}]\n\nglobule.findMapping(\"*.js\", {srcBase: \"foo\", destBase: \"bar\"})\n// [{src: \"foo/a.js\", dest: \"bar/a.js\"}, {src: \"foo/b.js\", dest: \"bar/b.js\"}]\n```\n\n```js\nglobule.mapping([\"foo/a.js\", \"foo/b.js\"])\n// [{src: \"foo/a.js\", dest: \"foo/a.js\"}, {src: \"foo/b.js\", dest: \"foo/b.js\"}]\n\nglobule.mapping([\"foo/a.js\", \"foo/b.js\"], {destBase: \"bar\"})\n// [{src: \"foo/a.js\", dest: \"bar/foo/a.js\"}, {src: \"foo/b.js\", dest: \"bar/foo/b.js\"}]\n\nglobule.mapping([\"a.js\", \"b.js\"], {srcBase: \"foo\", destBase: \"bar\"})\n// [{src: \"foo/a.js\", dest: \"bar/a.js\"}, {src: \"foo/b.js\", dest: \"bar/b.js\"}]\n```\n\n## Contributing\nIn lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).\n\n## Release History\n_(Nothing yet)_\n\n## License\nCopyright (c) 2013 \"Cowboy\" Ben Alman  \nLicensed under the MIT license.\n",
-  "readmeFilename": "README.md",
-  "_id": "globule@0.1.0",
-  "dist": {
-    "shasum": "d9c8edde1da79d125a151b79533b978676346ae5",
-    "tarball": "http://registry.npmjs.org/globule/-/globule-0.1.0.tgz"
-  },
-  "_npmVersion": "1.1.70",
-  "_npmUser": {
-    "name": "cowboy",
-    "email": "cowboy@rj3.net"
-  },
-  "maintainers": [
-    {
-      "name": "cowboy",
-      "email": "cowboy@rj3.net"
-    }
-  ],
-  "directories": {},
-  "_shasum": "d9c8edde1da79d125a151b79533b978676346ae5",
-  "_from": "globule@>=0.1.0-0 <0.2.0-0",
-  "_resolved": "https://registry.npmjs.org/globule/-/globule-0.1.0.tgz"
-}

data/template/node_modules/gulp/node_modules/vinyl-fs/node_modules/glob-watcher/node_modules/gaze/node_modules/globule/test/globule_test.js

@@ -1,486 +0,0 @@
-'use strict';
-
-var path = require('path');
-
-var globule = require('../lib/globule.js');
-
-/*
-  ======== A Handy Little Nodeunit Reference ========
-  https://github.com/caolan/nodeunit
-
-  Test methods:
-    test.expect(numAssertions)
-    test.done()
-  Test assertions:
-    test.ok(value, [message])
-    test.equal(actual, expected, [message])
-    test.notEqual(actual, expected, [message])
-    test.deepEqual(actual, expected, [message])
-    test.notDeepEqual(actual, expected, [message])
-    test.strictEqual(actual, expected, [message])
-    test.notStrictEqual(actual, expected, [message])
-    test.throws(block, [error], [message])
-    test.doesNotThrow(block, [error], [message])
-    test.ifError(value)
-*/
-
-exports['match'] = {
-  'empty set': function(test) {
-    test.expect(6);
-    // Should return empty set if a required argument is missing or an empty set.
-    test.deepEqual(globule.match(null, 'foo.js'), [], 'should return empty set.');
-    test.deepEqual(globule.match('*.js', null), [], 'should return empty set.');
-    test.deepEqual(globule.match([], 'foo.js'), [], 'should return empty set.');
-    test.deepEqual(globule.match('*.js', []), [], 'should return empty set.');
-    test.deepEqual(globule.match(null, ['foo.js']), [], 'should return empty set.');
-    test.deepEqual(globule.match(['*.js'], null), [], 'should return empty set.');
-    test.done();
-  },
-  'basic matching': function(test) {
-    test.expect(6);
-    test.deepEqual(globule.match('*.js', 'foo.js'), ['foo.js'], 'should match correctly.');
-    test.deepEqual(globule.match('*.js', ['foo.js']), ['foo.js'], 'should match correctly.');
-    test.deepEqual(globule.match('*.js', ['foo.js', 'bar.css']), ['foo.js'], 'should match correctly.');
-    test.deepEqual(globule.match(['*.js', '*.css'], 'foo.js'), ['foo.js'], 'should match correctly.');
-    test.deepEqual(globule.match(['*.js', '*.css'], ['foo.js']), ['foo.js'], 'should match correctly.');
-    test.deepEqual(globule.match(['*.js', '*.css'], ['foo.js', 'bar.css']), ['foo.js', 'bar.css'], 'should match correctly.');
-    test.done();
-  },
-  'no matches': function(test) {
-    test.expect(2);
-    test.deepEqual(globule.match('*.js', 'foo.css'), [], 'should fail to match.');
-    test.deepEqual(globule.match('*.js', ['foo.css', 'bar.css']), [], 'should fail to match.');
-    test.done();
-  },
-  'unique': function(test) {
-    test.expect(2);
-    test.deepEqual(globule.match('*.js', ['foo.js', 'foo.js']), ['foo.js'], 'should return a uniqued set.');
-    test.deepEqual(globule.match(['*.js', '*.*'], ['foo.js', 'foo.js']), ['foo.js'], 'should return a uniqued set.');
-    test.done();
-  },
-  'flatten': function(test) {
-    test.expect(1);
-    test.deepEqual(globule.match([['*.js', '*.css'], ['*.*', '*.js']], ['foo.js', 'bar.css']),
-      ['foo.js', 'bar.css'],
-      'should process nested pattern arrays correctly.');
-    test.done();
-  },
-  'exclusion': function(test) {
-    test.expect(5);
-    test.deepEqual(globule.match(['!*.js'], ['foo.js', 'bar.js']), [], 'solitary exclusion should match nothing');
-    test.deepEqual(globule.match(['*.js', '!*.js'], ['foo.js', 'bar.js']), [], 'exclusion should cancel match');
-    test.deepEqual(globule.match(['*.js', '!f*.js'], ['foo.js', 'bar.js', 'baz.js']),
-      ['bar.js', 'baz.js'],
-      'partial exclusion should partially cancel match');
-    test.deepEqual(globule.match(['*.js', '!*.js', 'b*.js'], ['foo.js', 'bar.js', 'baz.js']),
-      ['bar.js', 'baz.js'],
-      'inclusion / exclusion order matters');
-    test.deepEqual(globule.match(['*.js', '!f*.js', '*.js'], ['foo.js', 'bar.js', 'baz.js']),
-      ['bar.js', 'baz.js', 'foo.js'],
-      'inclusion / exclusion order matters');
-    test.done();
-  },
-  'options.matchBase': function(test) {
-    test.expect(2);
-    test.deepEqual(globule.match('*.js', ['foo.js', 'bar', 'baz/xyz.js'], {matchBase: true}),
-      ['foo.js', 'baz/xyz.js'],
-      'should matchBase (minimatch) when specified.');
-    test.deepEqual(globule.match('*.js', ['foo.js', 'bar', 'baz/xyz.js']),
-      ['foo.js'],
-      'should not matchBase (minimatch) by default.');
-    test.done();
-  },
-};
-
-exports['isMatch'] = {
-  'basic matching': function(test) {
-    test.expect(6);
-    test.ok(globule.isMatch('*.js', 'foo.js'), 'should match correctly.');
-    test.ok(globule.isMatch('*.js', ['foo.js']), 'should match correctly.');
-    test.ok(globule.isMatch('*.js', ['foo.js', 'bar.css']), 'should match correctly.');
-    test.ok(globule.isMatch(['*.js', '*.css'], 'foo.js'), 'should match correctly.');
-    test.ok(globule.isMatch(['*.js', '*.css'], ['foo.js']), 'should match correctly.');
-    test.ok(globule.isMatch(['*.js', '*.css'], ['foo.js', 'bar.css']), 'should match correctly.');
-    test.done();
-  },
-  'no matches': function(test) {
-    test.expect(6);
-    test.ok(!globule.isMatch('*.js', 'foo.css'), 'should fail to match.');
-    test.ok(!globule.isMatch('*.js', ['foo.css', 'bar.css']), 'should fail to match.');
-    test.ok(!globule.isMatch(null, 'foo.css'), 'should fail to match.');
-    test.ok(!globule.isMatch('*.js', null), 'should fail to match.');
-    test.ok(!globule.isMatch([], 'foo.css'), 'should fail to match.');
-    test.ok(!globule.isMatch('*.js', []), 'should fail to match.');
-    test.done();
-  },
-  'options.matchBase': function(test) {
-    test.expect(2);
-    test.ok(globule.isMatch('*.js', ['baz/xyz.js'], {matchBase: true}), 'should matchBase (minimatch) when specified.');
-    test.ok(!globule.isMatch('*.js', ['baz/xyz.js']), 'should not matchBase (minimatch) by default.');
-    test.done();
-  },
-};
-
-exports['find'] = {
-  setUp: function(done) {
-    this.cwd = process.cwd();
-    process.chdir('test/fixtures/expand');
-    done();
-  },
-  tearDown: function(done) {
-    process.chdir(this.cwd);
-    done();
-  },
-  'basic matching': function(test) {
-    test.expect(5);
-    test.deepEqual(globule.find('**/*.js'), ['js/bar.js', 'js/foo.js'], 'single pattern argument should match.');
-    test.deepEqual(globule.find('**/*.js', '**/*.css'),
-      ['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css'],
-      'multiple pattern arguments should match.');
-    test.deepEqual(globule.find(['**/*.js', '**/*.css']),
-      ['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css'],
-      'array of patterns should match.');
-    test.deepEqual(globule.find([['**/*.js'], [['**/*.css', 'js/*.js']]]),
-      ['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css'],
-      'array of arrays of patterns should be flattened.');
-    test.deepEqual(globule.find('*.xyz'), [], 'bad pattern should fail to match.');
-    test.done();
-  },
-  'unique': function(test) {
-    test.expect(4);
-    test.deepEqual(globule.find('**/*.js', 'js/*.js'),
-      ['js/bar.js', 'js/foo.js'],
-      'file list should be uniqed.');
-    test.deepEqual(globule.find('**/*.js', '**/*.css', 'js/*.js'), ['js/bar.js', 'js/foo.js',
-      'css/baz.css', 'css/qux.css'],
-      'file list should be uniqed.');
-    test.deepEqual(globule.find('js', 'js/'),
-      ['js', 'js/'],
-      'mixed non-ending-/ and ending-/ dirs will not be uniqed by default.');
-    test.deepEqual(globule.find('js', 'js/', {mark: true}),
-      ['js/'],
-      'mixed non-ending-/ and ending-/ dirs will be uniqed when "mark" is specified.');
-    test.done();
-  },
-  'file order': function(test) {
-    test.expect(5);
-    var actual = globule.find('**/*.{js,css}');
-    var expected = ['css/baz.css', 'css/qux.css', 'js/bar.js', 'js/foo.js'];
-    test.deepEqual(actual, expected, 'should select 4 files in this order, by default.');
-
-    actual = globule.find('js/foo.js', 'js/bar.js', '**/*.{js,css}');
-    expected = ['js/foo.js', 'js/bar.js', 'css/baz.css', 'css/qux.css'];
-    test.deepEqual(actual, expected, 'specifically-specified-up-front file order should be maintained.');
-
-    actual = globule.find('js/bar.js', 'js/foo.js', '**/*.{js,css}');
-    expected = ['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css'];
-    test.deepEqual(actual, expected, 'specifically-specified-up-front file order should be maintained.');
-
-    actual = globule.find('**/*.{js,css}', '!css/qux.css', 'css/qux.css');
-    expected = ['css/baz.css', 'js/bar.js', 'js/foo.js', 'css/qux.css'];
-    test.deepEqual(actual, expected, 'if a file is excluded and then re-added, it should be added at the end.');
-
-    actual = globule.find('js/foo.js', '**/*.{js,css}', '!css/qux.css', 'css/qux.css');
-    expected = ['js/foo.js', 'css/baz.css', 'js/bar.js', 'css/qux.css'];
-    test.deepEqual(actual, expected, 'should be able to combine specified-up-front and excluded/added-at-end.');
-    test.done();
-  },
-  'exclusion': function(test) {
-    test.expect(8);
-    test.deepEqual(globule.find(['!js/*.js']), [], 'solitary exclusion should match nothing');
-    test.deepEqual(globule.find(['js/bar.js','!js/bar.js']), [], 'exclusion should negate match');
-    test.deepEqual(globule.find(['**/*.js', '!js/foo.js']),
-      ['js/bar.js'],
-      'should omit single file from matched set');
-    test.deepEqual(globule.find(['!js/foo.js', '**/*.js']),
-      ['js/bar.js', 'js/foo.js'],
-      'inclusion / exclusion order matters');
-    test.deepEqual(globule.find(['**/*.js', '**/*.css', '!js/bar.js', '!css/baz.css']),
-      ['js/foo.js','css/qux.css'],
-      'multiple exclusions should be removed from the set');
-    test.deepEqual(globule.find(['**/*.js', '**/*.css', '!**/*.css']),
-      ['js/bar.js', 'js/foo.js'],
-      'excluded wildcards should be removed from the matched set');
-    test.deepEqual(globule.find(['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css', '!**/b*.*']),
-      ['js/foo.js', 'css/qux.css'],
-      'different pattern for exclusion should still work');
-    test.deepEqual(globule.find(['js/bar.js', '!**/b*.*', 'js/foo.js', 'css/baz.css', 'css/qux.css']),
-      ['js/foo.js', 'css/baz.css', 'css/qux.css'],
-      'inclusion / exclusion order matters');
-    test.done();
-  },
-  'options.mark': function(test) {
-    test.expect(4);
-    test.deepEqual(globule.find('**d*/**'), [
-      'deep',
-      'deep/deep.txt',
-      'deep/deeper',
-      'deep/deeper/deeper.txt',
-      'deep/deeper/deepest',
-      'deep/deeper/deepest/deepest.txt'], 'should match files and directories.');
-    test.deepEqual(globule.find('**d*/**/'), [
-      'deep/',
-      'deep/deeper/',
-      'deep/deeper/deepest/'], 'trailing / in pattern should match directories only, matches end in /.');
-    test.deepEqual(globule.find('**d*/**', {mark: true}), [
-      'deep/',
-      'deep/deep.txt',
-      'deep/deeper/',
-      'deep/deeper/deeper.txt',
-      'deep/deeper/deepest/',
-      'deep/deeper/deepest/deepest.txt'], 'the minimatch "mark" option ensures directories end in /.');
-    test.deepEqual(globule.find('**d*/**/', {mark: true}), [
-      'deep/',
-      'deep/deeper/',
-      'deep/deeper/deepest/'], 'the minimatch "mark" option should not remove trailing / from matched paths.');
-    test.done();
-  },
-  'options.filter': function(test) {
-    test.expect(5);
-    test.deepEqual(globule.find('**d*/**', {filter: 'isFile'}), [
-      'deep/deep.txt',
-      'deep/deeper/deeper.txt',
-      'deep/deeper/deepest/deepest.txt'
-    ], 'should match files only.');
-    test.deepEqual(globule.find('**d*/**', {filter: 'isDirectory'}), [
-      'deep',
-      'deep/deeper',
-      'deep/deeper/deepest'
-    ], 'should match directories only.');
-    test.deepEqual(globule.find('**', {
-      arbitraryProp: /deepest/,
-      filter: function(filepath, options) {
-        return options.arbitraryProp.test(filepath);
-      }
-    }), [
-      'deep/deeper/deepest',
-      'deep/deeper/deepest/deepest.txt',
-    ], 'should filter arbitrarily.');
-    test.deepEqual(globule.find('js', 'css', {filter: 'isFile'}), [], 'should fail to match.');
-    test.deepEqual(globule.find('**/*.js', {filter: 'isDirectory'}), [], 'should fail to match.');
-    test.done();
-  },
-  'options.matchBase': function(test) {
-    test.expect(3);
-    test.deepEqual(globule.find('*.js'), [], 'should not matchBase (minimatch) by default.');
-    test.deepEqual(globule.find('*.js', {matchBase: true}),
-      ['js/bar.js', 'js/foo.js'],
-      'matchBase option should be passed through to minimatch.');
-    test.deepEqual(globule.find('*.js', '*.css', {matchBase: true}),
-      ['js/bar.js', 'js/foo.js', 'css/baz.css', 'css/qux.css'],
-      'matchBase option should be passed through to minimatch.');
-    test.done();
-  },
-  'options.srcBase': function(test) {
-    test.expect(5);
-    test.deepEqual(globule.find(['**/deep*.txt'], {srcBase: 'deep'}),
-      ['deep.txt', 'deeper/deeper.txt', 'deeper/deepest/deepest.txt'],
-      'should find paths matching pattern relative to srcBase.');
-    test.deepEqual(globule.find(['**/deep*.txt'], {cwd: 'deep'}),
-      ['deep.txt', 'deeper/deeper.txt', 'deeper/deepest/deepest.txt'],
-      'cwd and srcBase should do the same thing.');
-    test.deepEqual(globule.find(['**/deep*'], {srcBase: 'deep', filter: 'isFile'}),
-      ['deep.txt', 'deeper/deeper.txt', 'deeper/deepest/deepest.txt'],
-      'srcBase should not prevent filtering.');
-    test.deepEqual(globule.find(['**/deep*'], {srcBase: 'deep', filter: 'isDirectory'}),
-      ['deeper', 'deeper/deepest'],
-      'srcBase should not prevent filtering.');
-    test.deepEqual(globule.find(['**/deep*.txt', '!**/deeper**'], {srcBase: 'deep'}),
-      ['deep.txt', 'deeper/deepest/deepest.txt'],
-      'srcBase should not prevent exclusions.');
-    test.done();
-  },
-  'options.prefixBase': function(test) {
-    test.expect(2);
-    test.deepEqual(globule.find(['**/deep*.txt'], {srcBase: 'deep', prefixBase: false}),
-      ['deep.txt', 'deeper/deeper.txt', 'deeper/deepest/deepest.txt'],
-      'should not prefix srcBase to returned paths.');
-    test.deepEqual(globule.find(['**/deep*.txt'], {srcBase: 'deep', prefixBase: true}),
-      ['deep/deep.txt', 'deep/deeper/deeper.txt', 'deep/deeper/deepest/deepest.txt'],
-      'should prefix srcBase to returned paths.');
-    test.done();
-  },
-  'options.nonull': function(test) {
-    test.expect(3);
-    test.deepEqual(globule.find(['*omg*'], {nonull: true}),
-      ['*omg*'],
-      'non-matching patterns should be returned in result set.');
-    test.deepEqual(globule.find(['js/a*', 'js/b*', 'js/c*'], {nonull: true}),
-      ['js/a*', 'js/bar.js', 'js/c*'],
-      'non-matching patterns should be returned in result set.');
-    test.deepEqual(globule.find(['js/foo.js', 'js/bar.js', 'js/nonexistent.js'], {nonull: true}),
-      ['js/foo.js', 'js/bar.js', 'js/nonexistent.js'],
-      'non-matching filenames should be returned in result set.');
-    test.done();
-  },
-};
-
-exports['mapping'] = {
-  'basic mapping': function(test) {
-    test.expect(1);
-
-    var actual = globule.mapping(['a.txt', 'b.txt', 'c.txt']);
-    var expected = [
-      {dest: 'a.txt', src: ['a.txt']},
-      {dest: 'b.txt', src: ['b.txt']},
-      {dest: 'c.txt', src: ['c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'default options should create same-to-same src-dest mappings.');
-
-    test.done();
-  },
-  'options.srcBase': function(test) {
-    test.expect(2);
-    var actual, expected;
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {srcBase: 'foo'});
-    expected = [
-      {dest: 'a.txt', src: ['foo/a.txt']},
-      {dest: 'bar/b.txt', src: ['foo/bar/b.txt']},
-      {dest: 'bar/baz/c.txt', src: ['foo/bar/baz/c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'srcBase should be prefixed to src paths (no trailing /).');
-
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {srcBase: 'foo/'});
-    test.deepEqual(actual, expected, 'srcBase should be prefixed to src paths (trailing /).');
-
-    test.done();
-  },
-  'options.destBase': function(test) {
-    test.expect(2);
-    var actual, expected;
-
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {destBase: 'dest'});
-    expected = [
-      {dest: 'dest/a.txt', src: ['a.txt']},
-      {dest: 'dest/bar/b.txt', src: ['bar/b.txt']},
-      {dest: 'dest/bar/baz/c.txt', src: ['bar/baz/c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'destBase should be prefixed to dest paths (no trailing /).');
-
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {destBase: 'dest/'});
-    test.deepEqual(actual, expected, 'destBase should be prefixed to dest paths (trailing /).');
-
-    test.done();
-  },
-  'options.flatten': function(test) {
-    test.expect(1);
-    var actual, expected;
-
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {flatten: true});
-    expected = [
-      {dest: 'a.txt', src: ['a.txt']},
-      {dest: 'b.txt', src: ['bar/b.txt']},
-      {dest: 'c.txt', src: ['bar/baz/c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'flatten should remove all src path parts from dest.');
-
-    test.done();
-  },
-  'options.flatten + options.destBase': function(test) {
-    test.expect(1);
-    var actual, expected;
-
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {destBase: 'dest', flatten: true});
-    expected = [
-      {dest: 'dest/a.txt', src: ['a.txt']},
-      {dest: 'dest/b.txt', src: ['bar/b.txt']},
-      {dest: 'dest/c.txt', src: ['bar/baz/c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'flatten and destBase should work together.');
-
-    test.done();
-  },
-  'options.ext': function(test) {
-    test.expect(1);
-    var actual, expected;
-
-    actual = globule.mapping(['x/a.js', 'x.y/b.min.js', 'x.y/z.z/c'], {ext: '.foo'});
-    expected = [
-      {dest: 'x/a.foo', src: ['x/a.js']},
-      {dest: 'x.y/b.foo', src: ['x.y/b.min.js']},
-      {dest: 'x.y/z.z/c.foo', src: ['x.y/z.z/c']},
-    ];
-    test.deepEqual(actual, expected, 'by default, ext should replace everything after the first dot in the filename.');
-
-    test.done();
-  },
-  'options.extDot': function(test) {
-    test.expect(2);
-    var actual, expected;
-
-    actual = globule.mapping(['x/a.js', 'x.y/b.bbb.min.js', 'x.y/z.z/c'], {ext: '.foo', extDot: 'first'});
-    expected = [
-      {dest: 'x/a.foo', src: ['x/a.js']},
-      {dest: 'x.y/b.foo', src: ['x.y/b.bbb.min.js']},
-      {dest: 'x.y/z.z/c.foo', src: ['x.y/z.z/c']},
-    ];
-    test.deepEqual(actual, expected, 'extDot of "first" should replace everything after the first dot in the filename.');
-
-    actual = globule.mapping(['x/a.js', 'x.y/b.bbb.min.js', 'x.y/z.z/c'], {ext: '.foo', extDot: 'last'});
-    expected = [
-      {dest: 'x/a.foo', src: ['x/a.js']},
-      {dest: 'x.y/b.bbb.min.foo', src: ['x.y/b.bbb.min.js']},
-      {dest: 'x.y/z.z/c.foo', src: ['x.y/z.z/c']},
-    ];
-    test.deepEqual(actual, expected, 'extDot of "last" should replace everything after the last dot in the filename.');
-
-    test.done();
-  },
-  'options.rename': function(test) {
-    test.expect(1);
-    var actual, expected;
-    actual = globule.mapping(['a.txt', 'bar/b.txt', 'bar/baz/c.txt'], {
-      arbitraryProp: 'FOO',
-      rename: function(dest, options) {
-        return path.join(options.arbitraryProp, dest.toUpperCase());
-      }
-    });
-    expected = [
-      {dest: 'FOO/A.TXT', src: ['a.txt']},
-      {dest: 'FOO/BAR/B.TXT', src: ['bar/b.txt']},
-      {dest: 'FOO/BAR/BAZ/C.TXT', src: ['bar/baz/c.txt']},
-    ];
-    test.deepEqual(actual, expected, 'allow arbitrary renaming of files.');
-
-    test.done();
-  },
-};
-
-exports['findMapping'] = {
-  setUp: function(done) {
-    this.cwd = process.cwd();
-    process.chdir('test/fixtures');
-    done();
-  },
-  tearDown: function(done) {
-    process.chdir(this.cwd);
-    done();
-  },
-  'basic matching': function(test) {
-    test.expect(2);
-
-    var actual = globule.findMapping(['expand/**/*.txt']);
-    var expected = [
-      {dest: 'expand/deep/deep.txt', src: ['expand/deep/deep.txt']},
-      {dest: 'expand/deep/deeper/deeper.txt', src: ['expand/deep/deeper/deeper.txt']},
-      {dest: 'expand/deep/deeper/deepest/deepest.txt', src: ['expand/deep/deeper/deepest/deepest.txt']},
-    ];
-    test.deepEqual(actual, expected, 'default options');
-
-    expected = globule.mapping(globule.find(['expand/**/*.txt']));
-    test.deepEqual(actual, expected, 'this is what it\'s doing under the hood, anwyays.');
-
-    test.done();
-  },
-  'options.srcBase': function(test) {
-    test.expect(1);
-    var actual = globule.findMapping(['**/*.txt'], {destBase: 'dest', srcBase: 'expand/deep'});
-    var expected = [
-      {dest: 'dest/deep.txt', src: ['expand/deep/deep.txt']},
-      {dest: 'dest/deeper/deeper.txt', src: ['expand/deep/deeper/deeper.txt']},
-      {dest: 'dest/deeper/deepest/deepest.txt', src: ['expand/deep/deeper/deepest/deepest.txt']},
-    ];
-    test.deepEqual(actual, expected, 'srcBase should be stripped from front of destPath, pre-destBase+destPath join');
-    test.done();
-  },
-};