pax_global_header00006660000000000000000000000064126435407220014517gustar00rootroot0000000000000052 comment=1a936280d4c9569035f9ac6a9808df564d413b30 string-template-1.0.0/000077500000000000000000000000001264354072200146345ustar00rootroot00000000000000string-template-1.0.0/.gitignore000066400000000000000000000002351264354072200166240ustar00rootroot00000000000000.DS_Store .monitor .*.swp .nodemonignore releases *.log *.err fleet.json public/browserify bin/*.json .bin build compile .lock-wscript node_modules coverage string-template-1.0.0/.npmignore000066400000000000000000000000351264354072200166310ustar00rootroot00000000000000support test examples *.sock string-template-1.0.0/.travis.yml000066400000000000000000000002021264354072200167370ustar00rootroot00000000000000language: node_js node_js: - "0.10" before_script: - npm install - npm install istanbul coveralls script: npm run travis-test string-template-1.0.0/LICENCE000066400000000000000000000020361264354072200156220ustar00rootroot00000000000000Copyright (c) 2013 Matt Esch. 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. string-template-1.0.0/Readme.md000066400000000000000000000060201264354072200163510ustar00rootroot00000000000000# string-template [![build status][1]][2] [![dependency status][3]][4] [![coverage report][9]][10] [![stability index][15]][16] [![npm stats][13]][14] [![browser support][5]][6] A simple string template function based on named or indexed arguments ## Example ```js var format = require("string-template") var greeting // Format using an object hash with keys matching [0-9a-zA-Z]+ greeting = format("Hello {name}, you have {count} unread messages", { name: "Robert", count: 12 }) // greeting -> "Hello Robert, you have 12 unread messages" // Format using a number indexed array greeting = format("Hello {0}, you have {1} unread messages", ["Robert", 12]) // greeting -> "Hello Robert, you have 12 unread messages" // Format using optional arguments greeting = format("Hello {0}, you have {1} unread messages", "Robert", 12) // greeting -> "Hello Robert, you have 12 unread messages" // Escape {} pairs by using double {{}} var text = format("{{0}}") // text -> "{0}" ``` ## Compiling templates `string-template` exposes two template compiling options for when you need the additional performance. Arguments passed to the compiled template are of the same structure as the main `string-template` function, so either a single object/array or a list of arguments. ```js var compile = require("string-template/compile") var greetingTemplate = compile("Hello {0}, you have {1} unread messages") var greeting = greetingTemplate("Robert", 12) // -> "Hello Robert, you have 12 unread messages" ``` Passing a truthy second argument to `compile` will opt into using `new Function` to generate a function. The function returned contains a literal string concatenation statement, interleaving the correct arguments you have passed in. ```js var compile = require("string-template/compile") var greetingTemplate = compile("Hello {0}, you have {1} unread messages", true) // -> greetingTemplate generated using new Function var greeting = greetingTemplate(["Robert", 12]) // -> "Hello Robert, you have 12 unread messages" ``` ## Installation `npm install string-template` ## Contributors - Matt-Esch ## MIT Licenced [1]: https://secure.travis-ci.org/Matt-Esch/string-template.png [2]: https://travis-ci.org/Matt-Esch/string-template [3]: https://david-dm.org/Matt-Esch/string-template.png [4]: https://david-dm.org/Matt-Esch/string-template [5]: https://ci.testling.com/Matt-Esch/string-template.png [6]: https://ci.testling.com/Matt-Esch/string-template [9]: https://coveralls.io/repos/Matt-Esch/string-template/badge.png [10]: https://coveralls.io/r/Matt-Esch/string-template [13]: https://nodei.co/npm/string-template.png?downloads=true&stars=true [14]: https://nodei.co/npm/string-template [15]: http://hughsk.github.io/stability-badges/dist/unstable.svg [16]: http://github.com/hughsk/stability-badges [7]: https://badge.fury.io/js/string-template.png [8]: https://badge.fury.io/js/string-template [11]: https://gemnasium.com/Matt-Esch/string-template.png [12]: https://gemnasium.com/Matt-Esch/string-template string-template-1.0.0/compile.js000066400000000000000000000074471264354072200166360ustar00rootroot00000000000000var template = require("./index") var whitespaceRegex = /["'\\\n\r\u2028\u2029]/g var nargs = /\{[0-9a-zA-Z]+\}/g var replaceTemplate = " var args\n" + " var result\n" + " if (arguments.length === 1 && typeof arguments[0] === \"object\") {\n" + " args = arguments[0]\n" + " } else {\n" + " args = arguments" + " }\n\n" + " if (!args || !(\"hasOwnProperty\" in args)) {\n" + " args = {}\n" + " }\n\n" + " return {0}" var literalTemplate = "\"{0}\"" var argTemplate = "(result = args.hasOwnProperty(\"{0}\") ? " + "args[\"{0}\"] : null, \n " + "(result === null || result === undefined) ? \"\" : result)" module.exports = compile function compile(string, inline) { var replacements = string.match(nargs) || [] var interleave = string.split(nargs) var replace = [] for (var i = 0; i < interleave.length; i++) { var current = interleave[i] var replacement = replacements[i] var escapeLeft = current.charAt(current.length - 1) var escapeRight = (interleave[i + 1] || "").charAt(0) if (replacement) { replacement = replacement.substring(1, replacement.length - 1) } if (escapeLeft === "{" && escapeRight === "}") { replace.push(current + replacement) } else { replace.push(current) if (replacement) { replace.push({ name: replacement }) } } } var prev = [""] for (var j = 0; j < replace.length; j++) { var curr = replace[j] if (String(curr) === curr) { var top = prev[prev.length - 1] if (String(top) === top) { prev[prev.length - 1] = top + curr } else { prev.push(curr) } } else { prev.push(curr) } } replace = prev if (inline) { for (var k = 0; k < replace.length; k++) { var token = replace[k] if (String(token) === token) { replace[k] = template(literalTemplate, escape(token)) } else { replace[k] = template(argTemplate, escape(token.name)) } } var replaceCode = replace.join(" +\n ") var compiledSource = template(replaceTemplate, replaceCode) return new Function(compiledSource) } return function template() { var args if (arguments.length === 1 && typeof arguments[0] === "object") { args = arguments[0] } else { args = arguments } if (!args || !("hasOwnProperty" in args)) { args = {} } var result = [] for (var i = 0; i < replace.length; i++) { if (i % 2 === 0) { result.push(replace[i]) } else { var argName = replace[i].name var arg = args.hasOwnProperty(argName) ? args[argName] : null if (arg !== null || arg !== undefined) { result.push(arg) } } } return result.join("") } } function escape(string) { string = '' + string return string.replace(whitespaceRegex, escapedWhitespace) } function escapedWhitespace(character) { // Escape all characters not included in SingleStringCharacters and // DoubleStringCharacters on // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4 switch (character) { case '"': case "'": case '\\': return '\\' + character // Four possible LineTerminator characters need to be escaped: case '\n': return '\\n' case '\r': return '\\r' case '\u2028': return '\\u2028' case '\u2029': return '\\u2029' } } string-template-1.0.0/index.js000066400000000000000000000015431264354072200163040ustar00rootroot00000000000000var nargs = /\{([0-9a-zA-Z_]+)\}/g module.exports = template function template(string) { var args if (arguments.length === 2 && typeof arguments[1] === "object") { args = arguments[1] } else { args = new Array(arguments.length - 1) for (var i = 1; i < arguments.length; ++i) { args[i - 1] = arguments[i] } } if (!args || !args.hasOwnProperty) { args = {} } return string.replace(nargs, function replaceArg(match, i, index) { var result if (string[index - 1] === "{" && string[index + match.length] === "}") { return i } else { result = args.hasOwnProperty(i) ? args[i] : null if (result === null || result === undefined) { return "" } return result } }) } string-template-1.0.0/package.json000066400000000000000000000026301264354072200171230ustar00rootroot00000000000000{ "name": "string-template", "version": "1.0.0", "description": "A simple string template function based on named or indexed arguments", "keywords": [ "template", "string", "format", "replace", "arguments" ], "author": "Matt-Esch ", "repository": "git://github.com/Matt-Esch/string-template.git", "main": "index", "homepage": "https://github.com/Matt-Esch/string-template", "contributors": [ { "name": "Matt-Esch" } ], "bugs": { "url": "https://github.com/Matt-Esch/string-template/issues", "email": "matt@mattesch.info" }, "dependencies": {}, "devDependencies": { "istanbul": "^0.4.1", "opn": "^3.0.3", "tape": "~1.1.1" }, "license": "MIT", "scripts": { "test": "node ./test/index.js", "travis-test": "istanbul cover ./test/index.js && ((cat coverage/lcov.info | coveralls) || exit 0)", "cover": "istanbul cover --report none --print detail ./test/index.js", "view-cover": "istanbul report html && opn --no-wait ./coverage/index.html" }, "testling": { "files": "test/index.js", "browsers": [ "ie/8..latest", "firefox/16..latest", "firefox/nightly", "chrome/22..latest", "chrome/canary", "opera/12..latest", "opera/next", "safari/5.1..latest", "ipad/6.0..latest", "iphone/6.0..latest", "android-browser/4.2..latest" ] } } string-template-1.0.0/test/000077500000000000000000000000001264354072200156135ustar00rootroot00000000000000string-template-1.0.0/test/compile-strong.js000066400000000000000000000207661264354072200211260ustar00rootroot00000000000000var test = require("tape") var compile = require("../compile.js") test("Named arguments are replaced", function (assert) { var template = compile("Hello {name}, how are you?", true) var result = template({ name: "Mark" }) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Named arguments at the start of strings are replaced", function (assert) { var template = compile("{likes} people have liked this", true) var result = template({ likes: 123 }) assert.equal(result, "123 people have liked this") assert.end() }) test("Named arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {date}", true) var result = template({ date: "01/01/2015" }) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple named arguments are replaced", function (assert) { var template = compile("Hello {name}, you have {emails} new messages", true) var result = template( { name: "Anna", emails: 5 }) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing named arguments become 0 characters", function (assert) { var template = compile("Hello{name}, how are you?", true) var result = template({}) assert.equal(result, "Hello, how are you?") assert.end() }) test("Named arguments can be escaped", function (assert) { var template = compile("Hello {{name}}, how are you?", true) var result = template({ name: "Mark" }) assert.equal(result, "Hello {name}, how are you?") assert.end() }) test("Array arguments are replaced", function (assert) { var template = compile("Hello {0}, how are you?", true) var result = template(["Mark"]) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Array arguments at the start of strings are replaced", function (assert) { var template = compile("{0} people have liked this", true) var result = template([123]) assert.equal(result, "123 people have liked this") assert.end() }) test("Array arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {0}", true) var result = template(["01/01/2015"]) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple array arguments are replaced", function (assert) { var template = compile("Hello {0}, you have {1} new messages", true) var result = template([ "Anna", 5 ]) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing array arguments become 0 characters", function (assert) { var template = compile("Hello{0}, how are you?", true) var result = template([]) assert.equal(result, "Hello, how are you?") assert.end() }) test("Array arguments can be escaped", function (assert) { var template = compile("Hello {{0}}, how are you?", true) var result = template(["Mark"]) assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Array keys are not accessible", function (assert) { var template = compile("Function{splice}", true) var result = template([]) assert.equal(result, "Function") assert.end() }) test("Listed arguments are replaced", function (assert) { var template = compile("Hello {0}, how are you?", true) var result = template("Mark") assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Supports quotes", function (assert) { var template = compile("Hello \"{0}, how are you?", true) var result = template("Mark") assert.equal(result, "Hello \"Mark, how are you?") assert.end() }) test("Supports \r", function (assert) { var template = compile("Hello \r{0}, how are you?", true) var result = template("Mark") assert.equal(result, "Hello \rMark, how are you?") assert.end() }) test("Supports \u2028", function (assert) { var template = compile("Hello \u2028{0}, how are you?", true) var result = template("Mark") assert.equal(result, "Hello \u2028Mark, how are you?") assert.end() }) test("Supports \u2029", function (assert) { var template = compile("Hello \u2029{0}, how are you?", true) var result = template("Mark") assert.equal(result, "Hello \u2029Mark, how are you?") assert.end() }) test("Listed arguments at the start of strings are replaced", function (assert) { var template = compile("{0} people have liked this", true) var result = template(123) assert.equal(result, "123 people have liked this") assert.end() }) test("Listed arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {0}", true) var result = template("01/01/2015") assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple listed arguments are replaced", function (assert) { var template = compile("Hello {0}, you have {1} new messages", true) var result = template("Anna", 5) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing listed arguments become 0 characters", function (assert) { var template = compile("Hello{1}, how are you?", true) var result = template("no") assert.equal(result, "Hello, how are you?") assert.end() }) test("Listed arguments can be escaped", function (assert) { var template = compile("Hello {{0}}, how are you?", true) var result = template( "Mark") assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Allow null data", function (assert) { var template = compile("Hello{0}", true) var result = template(null) assert.equal(result, "Hello") assert.end() }) test("Allow undefined data", function (assert) { var template = compile("Hello{0}", true) var result1 = template() var result2 = template(undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.end() }) test("Null keys become 0 characters", function (assert) { var template1 = compile("Hello{name}", true) var result1 = template1({ name: null }) var template2 = compile("Hello{0}", true) var result2 = template2([null]) var template3 = compile("Hello{0}{1}{2}", true) var result3 = template3(null, null, null) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Undefined keys become 0 characters", function (assert) { var template1 = compile("Hello{firstName}{lastName}", true) var result1 = template1({ name: undefined }) var template2 = compile("Hello{0}{1}", true) var result2 = template2([undefined]) var template3 = compile("Hello{0}{1}{2}", true) var result3 = template3(undefined, undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Works across multline strings", function (assert) { var template1 = compile("{zero}\n{one}\n{two}", true) var result1 = template1({ zero: "A", one: "B", two: "C" }) var template2 = compile("{0}\n{1}\n{2}", true) var result2 = template2(["A", "B", "C"]) var template3 = compile("{0}\n{1}\n{2}", true) var result3 = template3("A", "B", "C") assert.equal(result1, "A\nB\nC") assert.equal(result2, "A\nB\nC") assert.equal(result3, "A\nB\nC") assert.end() }) test("Allow multiple references", function (assert) { var template1 = compile("{a}{b}{c}\n{a}{b}{c}\n{a}{b}{c}", true) var result1 = template1({ a: "one", b: "two", c: "three" }) var template2 = compile("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}", true) var result2 = template2([ "one", "two", "three" ]) var template3 = compile("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}", true) var result3 = template3( "one", "two", "three") assert.equal(result1, "onetwothree\nonetwothree\nonetwothree") assert.equal(result2, "onetwothree\nonetwothree\nonetwothree") assert.equal(result3, "onetwothree\nonetwothree\nonetwothree") assert.end() }) test("Template string without arguments", function (assert) { var template = compile("Hello, how are you?", true) var result = template() assert.equal(result, "Hello, how are you?") assert.end() }) string-template-1.0.0/test/compile-weak.js000066400000000000000000000204221264354072200205260ustar00rootroot00000000000000var test = require("tape") var compile = require("../compile.js") test("Named arguments are replaced", function (assert) { var template = compile("Hello {name}, how are you?") var result = template({ name: "Mark" }) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Named arguments at the start of strings are replaced", function (assert) { var template = compile("{likes} people have liked this") var result = template({ likes: 123 }) assert.equal(result, "123 people have liked this") assert.end() }) test("Named arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {date}") var result = template({ date: "01/01/2015" }) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple named arguments are replaced", function (assert) { var template = compile("Hello {name}, you have {emails} new messages") var result = template( { name: "Anna", emails: 5 }) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing named arguments become 0 characters", function (assert) { var template = compile("Hello{name}, how are you?") var result = template({}) assert.equal(result, "Hello, how are you?") assert.end() }) test("Named arguments can be escaped", function (assert) { var template = compile("Hello {{name}}, how are you?") var result = template({ name: "Mark" }) assert.equal(result, "Hello {name}, how are you?") assert.end() }) test("Array arguments are replaced", function (assert) { var template = compile("Hello {0}, how are you?") var result = template(["Mark"]) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Array arguments at the start of strings are replaced", function (assert) { var template = compile("{0} people have liked this") var result = template([123]) assert.equal(result, "123 people have liked this") assert.end() }) test("Array arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {0}") var result = template(["01/01/2015"]) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple array arguments are replaced", function (assert) { var template = compile("Hello {0}, you have {1} new messages") var result = template([ "Anna", 5 ]) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing array arguments become 0 characters", function (assert) { var template = compile("Hello{0}, how are you?") var result = template([]) assert.equal(result, "Hello, how are you?") assert.end() }) test("Array arguments can be escaped", function (assert) { var template = compile("Hello {{0}}, how are you?") var result = template(["Mark"]) assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Array keys are not accessible", function (assert) { var template = compile("Function{splice}") var result = template([]) assert.equal(result, "Function") assert.end() }) test("Listed arguments are replaced", function (assert) { var template = compile("Hello {0}, how are you?") var result = template("Mark") assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Supports quotes", function (assert) { var template = compile("Hello {0}, how are you?") var result = template("\"Mark") assert.equal(result, "Hello \"Mark, how are you?") assert.end() }) test("Supports \r", function (assert) { var template = compile("Hello {0}, how are you?") var result = template("\rMark") assert.equal(result, "Hello \rMark, how are you?") assert.end() }) test("Supports \u2028", function (assert) { var template = compile("Hello {0}, how are you?") var result = template("\u2028Mark") assert.equal(result, "Hello \u2028Mark, how are you?") assert.end() }) test("Supports \u2029", function (assert) { var template = compile("Hello {0}, how are you?") var result = template("\u2029Mark") assert.equal(result, "Hello \u2029Mark, how are you?") assert.end() }) test("Listed arguments at the start of strings are replaced", function (assert) { var template = compile("{0} people have liked this") var result = template(123) assert.equal(result, "123 people have liked this") assert.end() }) test("Listed arguments at the end of string are replaced", function (assert) { var template = compile("Please respond by {0}") var result = template("01/01/2015") assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple listed arguments are replaced", function (assert) { var template = compile("Hello {0}, you have {1} new messages") var result = template("Anna", 5) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing listed arguments become 0 characters", function (assert) { var template = compile("Hello{1}, how are you?") var result = template("no") assert.equal(result, "Hello, how are you?") assert.end() }) test("Listed arguments can be escaped", function (assert) { var template = compile("Hello {{0}}, how are you?") var result = template( "Mark") assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Allow null data", function (assert) { var template = compile("Hello{0}") var result = template(null) assert.equal(result, "Hello") assert.end() }) test("Allow undefined data", function (assert) { var template = compile("Hello{0}") var result1 = template() var result2 = template(undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.end() }) test("Null keys become 0 characters", function (assert) { var template1 = compile("Hello{name}") var result1 = template1({ name: null }) var template2 = compile("Hello{0}") var result2 = template2([null]) var template3 = compile("Hello{0}{1}{2}") var result3 = template3(null, null, null) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Undefined keys become 0 characters", function (assert) { var template1 = compile("Hello{firstName}{lastName}") var result1 = template1({ name: undefined }) var template2 = compile("Hello{0}{1}") var result2 = template2([undefined]) var template3 = compile("Hello{0}{1}{2}") var result3 = template3(undefined, undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Works across multline strings", function (assert) { var template1 = compile("{zero}\n{one}\n{two}") var result1 = template1({ zero: "A", one: "B", two: "C" }) var template2 = compile("{0}\n{1}\n{2}") var result2 = template2(["A", "B", "C"]) var template3 = compile("{0}\n{1}\n{2}") var result3 = template3("A", "B", "C") assert.equal(result1, "A\nB\nC") assert.equal(result2, "A\nB\nC") assert.equal(result3, "A\nB\nC") assert.end() }) test("Allow multiple references", function (assert) { var template1 = compile("{a}{b}{c}\n{a}{b}{c}\n{a}{b}{c}") var result1 = template1({ a: "one", b: "two", c: "three" }) var template2 = compile("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}") var result2 = template2([ "one", "two", "three" ]) var template3 = compile("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}") var result3 = template3( "one", "two", "three") assert.equal(result1, "onetwothree\nonetwothree\nonetwothree") assert.equal(result2, "onetwothree\nonetwothree\nonetwothree") assert.equal(result3, "onetwothree\nonetwothree\nonetwothree") assert.end() }) test("Template string without arguments", function (assert) { var template = compile("Hello, how are you?") var result = template() assert.equal(result, "Hello, how are you?") assert.end() }) string-template-1.0.0/test/index.js000066400000000000000000000001231264354072200172540ustar00rootroot00000000000000require("./string-template") require("./compile-weak") require("./compile-strong") string-template-1.0.0/test/string-template.js000066400000000000000000000152561264354072200213010ustar00rootroot00000000000000var test = require("tape") var format = require("../index.js") test("Named arguments are replaced", function (assert) { var result = format("Hello {name}, how are you?", { name: "Mark" }) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Named arguments at the start of strings are replaced", function (assert) { var result = format("{likes} people have liked this", { likes: 123 }) assert.equal(result, "123 people have liked this") assert.end() }) test("Named arguments at the end of string are replaced", function (assert) { var result = format("Please respond by {date}", { date: "01/01/2015" }) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple named arguments are replaced", function (assert) { var result = format("Hello {name}, you have {emails} new messages", { name: "Anna", emails: 5 }) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing named arguments become 0 characters", function (assert) { var result = format("Hello{name}, how are you?", {}) assert.equal(result, "Hello, how are you?") assert.end() }) test("Named arguments can be escaped", function (assert) { var result = format("Hello {{name}}, how are you?", { name: "Mark" }) assert.equal(result, "Hello {name}, how are you?") assert.end() }) test("Array arguments are replaced", function (assert) { var result = format("Hello {0}, how are you?", ["Mark"]) assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Array arguments at the start of strings are replaced", function (assert) { var result = format("{0} people have liked this", [123]) assert.equal(result, "123 people have liked this") assert.end() }) test("Array arguments at the end of string are replaced", function (assert) { var result = format("Please respond by {0}", ["01/01/2015"]) assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple array arguments are replaced", function (assert) { var result = format("Hello {0}, you have {1} new messages", [ "Anna", 5 ]) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing array arguments become 0 characters", function (assert) { var result = format("Hello{0}, how are you?", []) assert.equal(result, "Hello, how are you?") assert.end() }) test("Array arguments can be escaped", function (assert) { var result = format("Hello {{0}}, how are you?", ["Mark"]) assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Array keys are not accessible", function (assert) { var result = format("Function{splice}", []) assert.equal(result, "Function") assert.end() }) test("Listed arguments are replaced", function (assert) { var result = format("Hello {0}, how are you?", "Mark") assert.equal(result, "Hello Mark, how are you?") assert.end() }) test("Listed arguments at the start of strings are replaced", function (assert) { var result = format("{0} people have liked this", 123) assert.equal(result, "123 people have liked this") assert.end() }) test("Listed arguments at the end of string are replaced", function (assert) { var result = format("Please respond by {0}", "01/01/2015") assert.equal(result, "Please respond by 01/01/2015") assert.end() }) test("Multiple listed arguments are replaced", function (assert) { var result = format("Hello {0}, you have {1} new messages", "Anna", 5) assert.equal(result, "Hello Anna, you have 5 new messages") assert.end() }) test("Missing listed arguments become 0 characters", function (assert) { var result = format("Hello{1}, how are you?", "no") assert.equal(result, "Hello, how are you?") assert.end() }) test("Listed arguments can be escaped", function (assert) { var result = format("Hello {{0}}, how are you?", "Mark") assert.equal(result, "Hello {0}, how are you?") assert.end() }) test("Allow null data", function (assert) { var result = format("Hello{0}", null) assert.equal(result, "Hello") assert.end() }) test("Allow undefined data", function (assert) { var result1 = format("Hello{0}") var result2 = format("Hello{0}", undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.end() }) test("Null keys become 0 characters", function (assert) { var result1 = format("Hello{name}", { name: null }) var result2 = format("Hello{0}", [null]) var result3 = format("Hello{0}{1}{2}", null, null, null) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Undefined keys become 0 characters", function (assert) { var result1 = format("Hello{firstName}{lastName}", { name: undefined }) var result2 = format("Hello{0}{1}", [undefined]) var result3 = format("Hello{0}{1}{2}", undefined, undefined) assert.equal(result1, "Hello") assert.equal(result2, "Hello") assert.equal(result3, "Hello") assert.end() }) test("Works across multline strings", function (assert) { var result1 = format("{zero}\n{one}\n{two}", { zero: "A", one: "B", two: "C" }) var result2 = format("{0}\n{1}\n{2}", ["A", "B", "C"]) var result3 = format("{0}\n{1}\n{2}", "A", "B", "C") assert.equal(result1, "A\nB\nC") assert.equal(result2, "A\nB\nC") assert.equal(result3, "A\nB\nC") assert.end() }) test("Allow multiple references", function (assert) { var result1 = format("{a}{b}{c}\n{a}{b}{c}\n{a}{b}{c}", { a: "one", b: "two", c: "three" }) var result2 = format("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}", [ "one", "two", "three" ]) var result3 = format("{0}{1}{2}\n{0}{1}{2}\n{0}{1}{2}", "one", "two", "three") assert.equal(result1, "onetwothree\nonetwothree\nonetwothree") assert.equal(result2, "onetwothree\nonetwothree\nonetwothree") assert.equal(result3, "onetwothree\nonetwothree\nonetwothree") assert.end() }) test("Template string without arguments", function (assert) { var result = format("Hello, how are you?") assert.equal(result, "Hello, how are you?") assert.end() }) test("Template string with underscores", function (assert) { var result = format("Hello {FULL_NAME}, how are you?", { FULL_NAME: "James Bond" }) assert.equal(result, "Hello James Bond, how are you?") assert.end() })