pax_global_header00006660000000000000000000000064127663435750014534gustar00rootroot0000000000000052 comment=4ea2dfbfe03e3ca70576aff5fe5e4a4235232591 loader-utils-0.2.16/000077500000000000000000000000001276634357500142265ustar00rootroot00000000000000loader-utils-0.2.16/.gitignore000066400000000000000000000000261276634357500162140ustar00rootroot00000000000000node_modules coverage loader-utils-0.2.16/.travis.yml000066400000000000000000000004311276634357500163350ustar00rootroot00000000000000sudo: false language: node_js node_js: - "0.10" - "0.12" - "iojs" script: npm run travis before_install: - '[ "${TRAVIS_NODE_VERSION}" != "0.10" ] || npm install -g npm' after_success: cat ./coverage/lcov.info | node_modules/.bin/coveralls --verbose && rm -rf ./coverage loader-utils-0.2.16/LICENSE000066400000000000000000000020741276634357500152360ustar00rootroot00000000000000(The MIT License) Copyright (c) 2012 - 2015 Tobias Koppers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. loader-utils-0.2.16/README.md000066400000000000000000000137321276634357500155130ustar00rootroot00000000000000# loader-utils ## Methods ### `getLoaderConfig` Recommended way to retrieve the loader config: ```javascript // inside your loader config = loaderUtils.getLoaderConfig(this, "myLoader"); ``` Tries to read the loader config from the `webpack.config.js` under the given property name (`"myLoader"` in this case) and merges the result with the loader query. For example, if your `webpack.config.js` had this property... ```javascript cheesecakeLoader: { type: "delicious", slices: 4 } ``` ...and your loader was called with `?slices=8`, `getLoaderConfig(this, "cheesecakeLoader")` would return ```javascript { type: "delicious", slices: 8 } ``` It is recommended that you use the camelCased loader name as your default config property name. ### `parseQuery` ``` javascript var query = loaderUtils.parseQuery(this.query); assert(typeof query == "object"); if(query.flag) // ... ``` ``` text null -> {} ? -> {} ?flag -> { flag: true } ?+flag -> { flag: true } ?-flag -> { flag: false } ?xyz=test -> { xyz: "test" } ?xyz[]=a -> { xyz: ["a"] } ?flag1&flag2 -> { flag1: true, flag2: true } ?+flag1,-flag2 -> { flag1: true, flag2: false } ?xyz[]=a,xyz[]=b -> { xyz: ["a", "b"] } ?a%2C%26b=c%2C%26d -> { "a,&b": "c,&d" } ?{json:5,data:{a:1}} -> { json: 5, data: { a: 1 } } ``` ### `stringifyRequest` Makes a request pretty and stringifies it. Absolute paths are replaced with relative ones. Use it instead of `JSON.stringify(...)` to build code of a `require(...)` call in a loader. ``` javascript loaderUtils.stringifyRequest(this, require.resolve("./test")); // = "../node_modules/some-loader/lib/test.js" ``` ### `urlToRequest` Converts some resource URL to a webpack module request. ```javascript var url = "path/to/module.js"; var request = loaderUtils.urlToRequest(url); // "./path/to/module.js" ``` #### Module URLs Any URL containing a `~` will be interpreted as a module request. Anything after the `~` will be considered the request path. ```javascript var url = "~path/to/module.js"; var request = loaderUtils.urlToRequest(url); // "path/to/module.js" ``` #### Root-relative URLs URLs that are root-relative (start with `/`) can be resolved relative to some arbitrary path by using the `root` parameter: ```javascript var url = "/path/to/module.js"; var root = "./root"; var request = loaderUtils.urlToRequest(url, root); // "./root/path/to/module.js" ``` To convert a root-relative URL into a module URL, specify a `root` value that starts with `~`: ```javascript var url = "/path/to/module.js"; var root = "~"; var request = loaderUtils.urlToRequest(url, root); // "path/to/module.js" ``` ### `interpolateName` Interpolates a filename template using multiple placeholders and/or a regular expression. The template and regular expression are set as query params called `name` and `regExp` on the current loader's context. ```javascript var interpolatedName = loaderUtils.interpolateName(loaderContext, name, options); ``` The following tokens are replaced in the `name` parameter: * `[ext]` the extension of the resource * `[name]` the basename of the resource * `[path]` the path of the resource relative to the `context` query parameter or option. * `[folder]` the folder of the resource is in. * `[emoji]` a random emoji representation of `options.content` * `[emoji:]` same as above, but with a customizable number of emojis * `[hash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the md5 hash) * `[:hash::]` optionally one can configure * other `hashType`s, i. e. `sha1`, `md5`, `sha256`, `sha512` * other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64` * and `length` the length in chars * `[N]` the N-th match obtained from matching the current file name against `options.regExp` Examples ``` javascript // loaderContext.resourcePath = "/app/js/javascript.js" loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext]", { content: ... }); // => js/9473fdd0d880a43c21b7778d34872157.script.js // loaderContext.resourcePath = "/app/page.html" loaderUtils.interpolateName(loaderContext, "html-[hash:6].html", { content: ... }); // => html-9473fd.html // loaderContext.resourcePath = "/app/flash.txt" loaderUtils.interpolateName(loaderContext, "[hash]", { content: ... }); // => c31e9820c001c9c4a86bce33ce43b679 // loaderContext.resourcePath = "/app/img/image.gif" loaderUtils.interpolateName(loaderContext, "[emoji]", { content: ... }); // => 👍 // loaderContext.resourcePath = "/app/img/image.gif" loaderUtils.interpolateName(loaderContext, "[emoji:4]", { content: ... }); // => 🙍🏢📤🐝 // loaderContext.resourcePath = "/app/img/image.png" loaderUtils.interpolateName(loaderContext, "[sha512:hash:base64:7].[ext]", { content: ... }); // => 2BKDTjl.png // use sha512 hash instead of md5 and with only 7 chars of base64 // loaderContext.resourcePath = "/app/img/myself.png" // loaderContext.query.name = loaderUtils.interpolateName(loaderContext, "picture.png"); // => picture.png // loaderContext.resourcePath = "/app/dir/file.png" loaderUtils.interpolateName(loaderContext, "[path][name].[ext]?[hash]", { content: ... }); // => /app/dir/file.png?9473fdd0d880a43c21b7778d34872157 // loaderContext.resourcePath = "/app/js/page-home.js" loaderUtils.interpolateName(loaderContext, "script-[1].[ext]", { regExp: "page-(.*)\\.js", content: ... }); // => script-home.js ``` ### `getHashDigest` ``` javascript var digestString = loaderUtils.getHashDigest(buffer, hashType, digestType, maxLength); ``` * `buffer` the content that should be hashed * `hashType` one of `sha1`, `md5`, `sha256`, `sha512` or any other node.js supported hash type * `digestType` one of `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64` * `maxLength` the maximum length in chars ## License MIT (http://www.opensource.org/licenses/mit-license.php) loader-utils-0.2.16/index.js000066400000000000000000000224331276634357500156770ustar00rootroot00000000000000var JSON5 = require("json5"); var path = require("path"); var assign = require("object-assign"); var emojiRegex = /[\uD800-\uDFFF]./; var emojiList = require("emojis-list").filter(function(emoji) { return emojiRegex.test(emoji) }); var baseEncodeTables = { 26: "abcdefghijklmnopqrstuvwxyz", 32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio 36: "0123456789abcdefghijklmnopqrstuvwxyz", 49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO 52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO 62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_" }; var emojiCache = {}; function encodeStringToEmoji(content, length) { if (emojiCache[content]) return emojiCache[content]; length = length || 1; var emojis = []; do { var index = Math.floor(Math.random() * emojiList.length); emojis.push(emojiList[index]); emojiList.splice(index, 1); } while (--length > 0); var emojiEncoding = emojis.join(''); emojiCache[content] = emojiEncoding; return emojiEncoding; } function encodeBufferToBase(buffer, base) { var encodeTable = baseEncodeTables[base]; if (!encodeTable) throw new Error("Unknown encoding base" + base); var readLength = buffer.length; var Big = require('big.js'); Big.RM = Big.DP = 0; var b = new Big(0); for (var i = readLength - 1; i >= 0; i--) { b = b.times(256).plus(buffer[i]); } var output = ""; while (b.gt(0)) { output = encodeTable[b.mod(base)] + output; b = b.div(base); } Big.DP = 20; Big.RM = 1; return output; } exports.parseQuery = function parseQuery(query) { var specialValues = { 'null': null, 'true': true, 'false': false }; if(!query) return {}; if(typeof query !== "string") return query; if(query.substr(0, 1) !== "?") throw new Error("a valid query string passed to parseQuery should begin with '?'"); query = query.substr(1); var queryLength = query.length; if(query.substr(0, 1) === "{" && query.substr(-1) === "}") { return JSON5.parse(query); } var queryArgs = query.split(/[,\&]/g); var result = {}; queryArgs.forEach(function(arg) { var idx = arg.indexOf("="); if(idx >= 0) { var name = arg.substr(0, idx); var value = decodeURIComponent(arg.substr(idx+1)); if (specialValues.hasOwnProperty(value)) { value = specialValues[value]; } if(name.substr(-2) === "[]") { name = decodeURIComponent(name.substr(0, name.length-2)); if(!Array.isArray(result[name])) result[name] = []; result[name].push(value); } else { name = decodeURIComponent(name); result[name] = value; } } else { if(arg.substr(0, 1) === "-") { result[decodeURIComponent(arg.substr(1))] = false; } else if(arg.substr(0, 1) === "+") { result[decodeURIComponent(arg.substr(1))] = true; } else { result[decodeURIComponent(arg)] = true; } } }); return result; }; exports.getLoaderConfig = function(loaderContext, defaultConfigKey) { var query = exports.parseQuery(loaderContext.query); var configKey = query.config || defaultConfigKey; if (configKey) { var config = loaderContext.options[configKey] || {}; delete query.config; return assign({}, config, query); } return query; }; exports.stringifyRequest = function(loaderContext, request) { var splitted = request.split("!"); var context = loaderContext.context || (loaderContext.options && loaderContext.options.context); return JSON.stringify(splitted.map(function(part) { if(/^\/|^[A-Z]:/i.test(part) && context) { part = path.relative(context, part); if(/^[A-Z]:/i.test(part)) { return part; } else { return "./" + part.replace(/\\/g, "/"); } } return part; }).join("!")); }; function dotRequest(obj) { return obj.request; } exports.getRemainingRequest = function(loaderContext) { if(loaderContext.remainingRequest) return loaderContext.remainingRequest; var request = loaderContext.loaders.slice(loaderContext.loaderIndex+1).map(dotRequest).concat([loaderContext.resource]); return request.join("!"); }; exports.getCurrentRequest = function(loaderContext) { if(loaderContext.currentRequest) return loaderContext.currentRequest; var request = loaderContext.loaders.slice(loaderContext.loaderIndex).map(dotRequest).concat([loaderContext.resource]); return request.join("!"); }; exports.isUrlRequest = function(url, root) { // An URL is not an request if // 1. it's a Data Url // 2. it's an absolute url or and protocol-relative // 3. it's some kind of url for a template if(/^data:|^chrome-extension:|^(https?:)?\/\/|^[\{\}\[\]#*;,'§\$%&\(=?`´\^°<>]/.test(url)) return false; // 4. It's also not an request if root isn't set and it's a root-relative url if((root === undefined || root === false) && /^\//.test(url)) return false; return true; }; exports.urlToRequest = function(url, root) { var moduleRequestRegex = /^[^?]*~/; var request; if(/^[a-zA-Z]:\\|^\\\\/.test(url)) { // absolute windows path, keep it request = url; } else if(root !== undefined && root !== false && /^\//.test(url)) { // if root is set and the url is root-relative switch(typeof root) { // 1. root is a string: root is prefixed to the url case "string": // special case: `~` roots convert to module request if (moduleRequestRegex.test(root)) { request = root.replace(/([^~\/])$/, "$1/") + url.slice(1); } else { request = root + url; } break; // 2. root is `true`: absolute paths are allowed // *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/` case "boolean": request = url; break; default: throw new Error("Unexpected parameters to loader-utils 'urlToRequest': url = " + url + ", root = " + root + "."); } } else if(/^\.\.?\//.test(url)) { // A relative url stays request = url; } else { // every other url is threaded like a relative url request = "./" + url; } // A `~` makes the url an module if (moduleRequestRegex.test(request)) { request = request.replace(moduleRequestRegex, ""); } return request; }; exports.parseString = function parseString(str) { try { if(str[0] === '"') return JSON.parse(str); if(str[0] === "'" && str.substr(str.length - 1) === "'") { return parseString(str.replace(/\\.|"/g, function(x) { if(x === '"') return '\\"'; return x; }).replace(/^'|'$/g, '"')); } return JSON.parse('"' + str + '"'); } catch(e) { return str; } }; exports.getHashDigest = function getHashDigest(buffer, hashType, digestType, maxLength) { hashType = hashType || "md5"; maxLength = maxLength || 9999; var hash = require("crypto").createHash(hashType); hash.update(buffer); if (digestType === "base26" || digestType === "base32" || digestType === "base36" || digestType === "base49" || digestType === "base52" || digestType === "base58" || digestType === "base62" || digestType === "base64") { return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(0, maxLength); } else { return hash.digest(digestType || "hex").substr(0, maxLength); } }; exports.interpolateName = function interpolateName(loaderContext, name, options) { var filename = name || "[hash].[ext]"; var context = options.context; var content = options.content; var regExp = options.regExp; var ext = "bin"; var basename = "file"; var directory = ""; var folder = ""; if(loaderContext.resourcePath) { var resourcePath = loaderContext.resourcePath; var idx = resourcePath.lastIndexOf("."); var i = resourcePath.lastIndexOf("\\"); var j = resourcePath.lastIndexOf("/"); var p = i < 0 ? j : j < 0 ? i : i < j ? i : j; if(idx >= 0) { ext = resourcePath.substr(idx+1); resourcePath = resourcePath.substr(0, idx); } if(p >= 0) { basename = resourcePath.substr(p+1); resourcePath = resourcePath.substr(0, p+1); } if (typeof context !== 'undefined') { directory = path.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1"); directory = directory.substr(0, directory.length-1); } else { directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1"); } if (directory.length === 1) { directory = ""; } else if (directory.length > 1) { folder = path.basename(directory); } } var url = filename; if(content) { // Match hash template url = url.replace(/\[(?:(\w+):)?hash(?::([a-z]+\d*))?(?::(\d+))?\]/ig, function() { return exports.getHashDigest(content, arguments[1], arguments[2], parseInt(arguments[3], 10)); }).replace(/\[emoji(?::(\d+))?\]/ig, function() { return encodeStringToEmoji(content, arguments[1]); }); } url = url.replace(/\[ext\]/ig, function() { return ext; }).replace(/\[name\]/ig, function() { return basename; }).replace(/\[path\]/ig, function() { return directory; }).replace(/\[folder\]/ig, function() { return folder; }); if(regExp && loaderContext.resourcePath) { var re = new RegExp(regExp); var match = loaderContext.resourcePath.match(re); if(match) { for (var i = 0; i < match.length; i++) { var re = new RegExp("\\[" + i + "\\]", "ig"); url = url.replace(re, match[i]); } } } if(typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") { url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options); } return url; }; loader-utils-0.2.16/package.json000066400000000000000000000014261276634357500165170ustar00rootroot00000000000000{ "name": "loader-utils", "version": "0.2.16", "author": "Tobias Koppers @sokra", "description": "utils for webpack loaders", "dependencies": { "big.js": "^3.1.3", "emojis-list": "^2.0.0", "json5": "^0.5.0", "object-assign": "^4.0.1" }, "scripts": { "test": "mocha", "travis": "npm run cover -- --report lcovonly", "cover": "istanbul cover -x *.runtime.js node_modules/mocha/bin/_mocha", "publish-patch": "mocha && npm version patch && git push && git push --tags && npm publish" }, "license": "MIT", "repository": { "type": "git", "url": "https://github.com/webpack/loader-utils.git" }, "devDependencies": { "coveralls": "^2.11.2", "istanbul": "^0.3.14", "mocha": "^1.21.4" }, "files": [ "index.js" ] } loader-utils-0.2.16/test/000077500000000000000000000000001276634357500152055ustar00rootroot00000000000000loader-utils-0.2.16/test/index.js000066400000000000000000000221111276634357500166470ustar00rootroot00000000000000var assert = require("assert"), loaderUtils = require("../"); function ExpectedError(regex) { this.regex = regex; } ExpectedError.prototype.matches = function (err) { return this.regex.test(err.message); }; describe("loader-utils", function() { describe("#urlToRequest()", function() { [ // without root [["path/to/thing"], "./path/to/thing", "should handle implicit relative urls"], [["./path/to/thing"], "./path/to/thing", "should handle explicit relative urls"], [["~path/to/thing"], "path/to/thing", "should handle module urls (with ~)"], [["some/other/stuff/and/then~path/to/thing"], "path/to/thing", "should handle module urls with path prefix"], [["./some/other/stuff/and/then~path/to/thing"], "path/to/thing", "should handle module urls with relative path prefix"], // with root (normal path) [["path/to/thing", "root/dir"], "./path/to/thing", "should do nothing with root if implicit relative url"], [["./path/to/thing", "root/dir"], "./path/to/thing", "should do nothing with root if explicit relative url"], [["/path/to/thing", "root/dir"], "root/dir/path/to/thing", "should include root if root-relative url"], // with root (boolean) [["/path/to/thing", true], "/path/to/thing", "should allow root-relative to exist as-is if root = `true`"], // with root (boolean) on Windows [["C:\\path\\to\\thing"], "C:\\path\\to\\thing", "should handle Windows absolute paths with drive letter"], [["\\\\?\\UNC\\ComputerName\\path\\to\\thing"], "\\\\?\\UNC\\ComputerName\\path\\to\\thing", "should handle Windows absolute UNC paths"], // with root (module) [["/path/to/thing", "~"], "path/to/thing", "should convert to module url if root = ~"], // with root (module path) [["/path/to/thing", "~module"], "module/path/to/thing", "should allow module prefixes when root starts with ~"], [["/path/to/thing", "~module/"], "module/path/to/thing", "should allow module prefixes (with trailing slash) when root starts with ~"], // error cases [["/path/to/thing", 1], new ExpectedError(/unexpected parameters/i), "should throw an error on invalid root"], // difficult cases [["a:b-not-\\window-path"], "./a:b-not-\\window-path", "should not incorrectly detect windows paths"] ].forEach(function(test) { it(test[2], function() { var expected = test[1]; try { var request = loaderUtils.urlToRequest.apply(loaderUtils, test[0]); assert.equal(request, expected); } catch (e) { if (expected instanceof ExpectedError) { assert.ok(expected.matches(e)); } else { assert.ok(false, "should not have thrown an error: " + e.message); } } }); }); }); describe("#interpolateName", function() { [ ["/app/js/javascript.js", "js/[hash].script.[ext]", "test content", "js/9473fdd0d880a43c21b7778d34872157.script.js"], ["/app/page.html", "html-[hash:6].html", "test content", "html-9473fd.html"], ["/app/flash.txt", "[hash]", "test content", "9473fdd0d880a43c21b7778d34872157"], ["/app/img/image.png", "[sha512:hash:base64:7].[ext]", "test content", "2BKDTjl.png"], ["/app/dir/file.png", "[path][name].[ext]?[hash]", "test content", "/app/dir/file.png?9473fdd0d880a43c21b7778d34872157"] ].forEach(function(test) { it("should interpolate " + test[0] + " " + test[1], function() { var interpolatedName = loaderUtils.interpolateName({ resourcePath: test[0] }, test[1], { content: test[2] }); assert.equal(interpolatedName, test[3]); }); }); }); describe("#parseString", function() { [ ["test string", "test string"], [JSON.stringify("!\"§$%&/()=?'*#+,.-;öäü:_test"), "!\"§$%&/()=?'*#+,.-;öäü:_test"], ["'escaped with single \"'", 'escaped with single "'], ["invalid \"' string", "invalid \"' string"], ["\'inconsistent start and end\"", "\'inconsistent start and end\""] ].forEach(function(test) { it("should parse " + test[0], function() { var parsed = loaderUtils.parseString(test[0]); assert.equal(parsed, test[1]); }); }); }); describe("#parseQuery", function() { [ [ "?sweet=true&name=cheesecake&slices=8&delicious&warm=false", {"sweet":true,"name":"cheesecake","slices":"8","delicious":true,"warm": false} ], [ "?%3d", {"=": true} ], [ "?+%3d", {"=": true} ], [ "?-%3d", {"=": false} ], [ "?%3d=%3D", {"=": "="} ], [ { obj: "test" }, { obj: "test" } ] ].forEach(function(test) { it("should parse " + test[0], function() { var parsed = loaderUtils.parseQuery(test[0]); assert.deepEqual(parsed, test[1]); }); }); }); describe("#getLoaderConfig", function() { it("should merge loaderContext.query and loaderContext.options.testLoader", function () { var config = loaderUtils.getLoaderConfig({query:"?name=cheesecake",options:{testLoader:{slices:8}}}, "testLoader"); assert.deepEqual(config, {name:"cheesecake",slices:8}); }); it("should allow to specify a config property name via loaderContext.query.config", function () { var config = loaderUtils.getLoaderConfig({query:"?name=cheesecake&config=otherConfig",options:{otherConfig:{slices:8}}}, "testLoader"); assert.deepEqual(config, {name:"cheesecake",slices:8}); }); it("should prefer loaderContext.query.slices over loaderContext.options.slices", function () { var config = loaderUtils.getLoaderConfig({query:"?slices=8",options:{testLoader:{slices:4}}}, "testLoader"); assert.deepEqual(config, {slices:8}); }); it("should allow no default key", function () { var config = loaderUtils.getLoaderConfig({query:"?slices=8",options:{}}); assert.deepEqual(config, {slices:8}); }); }); describe("#getHashDigest", function() { [ ["test string", "md5", "hex", undefined, "6f8db599de986fab7a21625b7916589c"], ["test string", "md5", "hex", 4, "6f8d"], ["test string", "md5", "base64", undefined, "2sm1pVmS8xuGJLCdWpJoRL"], ["test string", "md5", "base52", undefined, "dJnldHSAutqUacjgfBQGLQx"], ["test string", "md5", "base26", 6, "bhtsgu"], ["test string", "sha512", "base64", undefined, "2IS-kbfIPnVflXb9CzgoNESGCkvkb0urMmucPD9z8q6HuYz8RShY1-tzSUpm5-Ivx_u4H1MEzPgAhyhaZ7RKog"], ["test_string", "md5", "hex", undefined, "3474851a3410906697ec77337df7aae4"] ].forEach(function(test) { it("should getHashDigest " + test[0] + " " + test[1] + " " + test[2] + " " + test[3], function() { var hashDigest = loaderUtils.getHashDigest(test[0], test[1], test[2], test[3]); assert.equal(hashDigest, test[4]); }); }); }); describe("#interpolateName", function() { function run(tests) { tests.forEach(function(test) { var args = test[0]; var expected = test[1]; var message = test[2]; it(message, function() { var result = loaderUtils.interpolateName.apply(loaderUtils, args); if (typeof expected === "function") { expected(result); } else { assert.equal(result, expected); } }); }); } run([ [[{}, "", { content: "test string" }], "6f8db599de986fab7a21625b7916589c.bin", "should interpolate default tokens"], [[{}, "[hash:base64]", { content: "test string" }], "2sm1pVmS8xuGJLCdWpJoRL", "should interpolate [hash] token with options"], [[{}, "[unrecognized]", { content: "test string" }], "[unrecognized]", "should not interpolate unrecognized token"], ]); var emojiRegex = /[\uD800-\uDFFF]./; run([ [ [{}, "[emoji]", { content: "test" }], function(result) { assert.ok(emojiRegex.test(result), result); }, "should interpolate [emoji]" ], [ [{}, "[emoji:3]", { content: "string" }], function(result) { assert.ok(emojiRegex.test(result), result); assert.ok(result.length, 6); }, "should interpolate [emoji:3]" ], ]); it("should return the same emoji for the same string", function() { var args = [{}, "[emoji:5]", { content: "same_emoji" }]; var result1 = loaderUtils.interpolateName.apply(loaderUtils, args); var result2 = loaderUtils.interpolateName.apply(loaderUtils, args); assert.equal(result1, result2); }); context("no loader context", function() { var loaderContext = {}; run([ [[loaderContext, "[ext]", {}], "bin", "should interpolate [ext] token"], [[loaderContext, "[name]", {}], "file", "should interpolate [name] token"], [[loaderContext, "[path]", {}], "", "should interpolate [path] token"], [[loaderContext, "[folder]", {}], "", "should interpolate [folder] token"] ]); }); context("with loader context", function() { var loaderContext = { resourcePath: "/path/to/file.exe" }; run([ [[loaderContext, "[ext]", {}], "exe", "should interpolate [ext] token"], [[loaderContext, "[name]", {}], "file", "should interpolate [name] token"], [[loaderContext, "[path]", {}], "/path/to/", "should interpolate [path] token"], [[loaderContext, "[folder]", {}], "to", "should interpolate [folder] token"] ]); }); run([ [[{ resourcePath: "/xyz", options: { customInterpolateName: function(str, name, options) { return str + "-" + name + "-" + options.special; } } }, "[name]", { special: "special" }], "xyz-[name]-special", "should provide a custom interpolateName function in options"], ]); }); });