Merge 9f37565 into 8f28bb1

Readme.md

@@ -44,6 +44,29 @@ var text = format("{{0}}")
 
 ```
 
+## Attaching prefix/postfix strings to a variable
+`string-template` allows you to define optional strings within a variable using square brackets as delimiters (e.g. `{[optional string]var_name[another string]}`). Attached strings are included only if there is a value assigned to its variable, making your templates much more flexible. A (somewhat contrived) example:
+
+```js
+var greetingTemplate = "Hello{[, ]name}!{[ You have ]msg[ new messages.]}"
+
+greeting = format(greetingTemplate, {
+    name: "Robert",
+    msg: "15"
+})
+// greeting -> "Hello, Robert! You have 15 new messages."
+
+greeting = format(greetingTemplate, {
+    name: "Robert"
+})
+// greeting -> "Hello, Robert!"
+
+greeting = format(greetingTemplate, {
+    msg: "100"
+})
+// greeting -> "Hello! You have 100 new messages."
+```
+
 ## Compiling templates
 
 `string-template` exposes two template compiling options for when you need the
@@ -81,6 +104,7 @@ var greeting = greetingTemplate(["Robert", 12])
 ## Contributors
 
  - Matt-Esch
+ - Alfonso Gómez-Arzola
 
 ## MIT Licenced
 

compile.js

@@ -1,7 +1,8 @@
 var template = require("./index")
 var escape = require("js-string-escape")
 
-var nargs = /\{[0-9a-zA-Z]+\}/g
+var nargs = /\{(?:\[.+\])?[0-9a-zA-Z]+(?:\[.+\])?\}/g
+var nargsCap = /\{(\[.+\])?([0-9a-zA-Z]+)(\[.+\])?\}/g
 
 var replaceTemplate =
 "    var args\n" +
@@ -19,7 +20,7 @@ var replaceTemplate =
 var literalTemplate = "\"{0}\""
 var argTemplate = "(result = args.hasOwnProperty(\"{0}\") ? " +
     "args[\"{0}\"] : null, \n        " +
-    "(result === null || result === undefined) ? \"\" : result)"
+    "(result === null || result === undefined) ? \"\" : \"{1}\" + result + \"{2}\")"
 
 module.exports = compile
 
@@ -33,17 +34,34 @@ function compile(string, inline) {
         var replacement = replacements[i];
         var escapeLeft = current.charAt(current.length - 1)
         var escapeRight = (interleave[i + 1] || "").charAt(0)
+        var attachLeft = ""
+        var attachRight = ""
+        var fullReplacement = ""
+        var subReplacement = ""
 
         if (replacement) {
-            replacement = replacement.substring(1, replacement.length - 1)
+            fullReplacement = replacement.substring(1, replacement.length - 1)
+            subReplacement = replacement.replace(nargsCap, function (match, l, i, r, index) {
+                if (l !== null && l !== undefined) {
+                    attachLeft = l.replace(/\[|\]/g, "")
+                }
+                if (r !== null && r !== undefined) {
+                    attachRight = r.replace(/\[|\]/g, "")
+                }
+                return i
+            })
         }
 
         if (escapeLeft === "{" && escapeRight === "}") {
-            replace.push(current + replacement)
+            replace.push(current + fullReplacement)
         } else {
             replace.push(current);
-            if (replacement) {
-                replace.push({ name: replacement })
+            if (subReplacement) {
+                replace.push({
+                    name: subReplacement,
+                    attachLeft: attachLeft,
+                    attachRight: attachRight
+                })
             }
         }
     }
@@ -75,7 +93,11 @@ function compile(string, inline) {
             if (String(token) === token) {
                 replace[k] = template(literalTemplate, escape(token))
             } else {
-                replace[k] = template(argTemplate, escape(token.name))
+                replace[k] = template(argTemplate,
+                    escape(token.name),
+                    escape(token.attachLeft),
+                    escape(token.attachRight)
+                )
             }
         }
 
@@ -104,9 +126,11 @@ function compile(string, inline) {
                 result.push(replace[i])
             } else {
                 var argName = replace[i].name
+                var attachLeft = replace[i].attachLeft
+                var attachRight = replace[i].attachRight
                 var arg = args.hasOwnProperty(argName) ? args[argName] : null
-                if (arg !== null || arg !== undefined) {
-                    result.push(arg)
+                if (arg !== null && arg !== undefined) {
+                    result.push(attachLeft + arg + attachRight)
                 }
             }
         }

index.js

@@ -1,4 +1,4 @@
-var nargs = /\{([0-9a-zA-Z]+)\}/g
+var nargs = /\{(\[.+\])?([0-9a-zA-Z]+)(\[.+\])?\}/g
 var slice = Array.prototype.slice
 
 module.exports = template
@@ -16,7 +16,7 @@ function template(string) {
         args = {}
     }
 
-    return string.replace(nargs, function replaceArg(match, i, index) {
+    return string.replace(nargs, function replaceArg(match, l, i, r, index) {
         var result
 
         if (string[index - 1] === "{" &&
@@ -27,6 +27,14 @@ function template(string) {
             if (result === null || result === undefined) {
                 return ""
             }
+            if (l) {
+                l = l.replace(/\[|\]/g, "")
+                result = l + result
+            }
+            if (r) {
+                r = r.replace(/\[|\]/g, "")
+                result = result + r
+            }
 
             return result
         }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "string-template",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A simple string template function based on named or indexed arguments",
   "keywords": [
     "template",
@@ -16,6 +16,8 @@
   "contributors": [
     {
       "name": "Matt-Esch"
+    },{
+      "name": "Alfonso Gómez-Arzola"
     }
   ],
   "bugs": {

test/compile-strong.js

@@ -249,3 +249,71 @@ test("Allow multiple references", function (assert) {
     assert.equal(result3, "onetwothree\nonetwothree\nonetwothree")
     assert.end()
 })
+
+test("Attach strings to variables in template (with object)", function (assert) {
+    var template1 = compile("Hello{[, ]name}!", true)
+    var result1 = template1({
+        name: "Mark"
+    })
+
+    var template2 = compile("Hello, {name[ San]}!", true)
+    var result2 = template2({
+        name: "Mark"
+    })
+
+    var template3 = compile("Hello{[, my name is ]name[ and I like JavaScript]}!", true)
+    var result3 = template3({
+        name: "Mark"
+    })
+
+    var template4 = compile("Hello{[, ]name}!", true)
+    var result4 = template4({
+        someotherkey: "Mark"
+    })
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with array)", function (assert) {
+    var template1 = compile("Hello{[, ]0}!", true)
+    var result1 = template1(["Mark"])
+
+    var template2 = compile("Hello, {0[ San]}!", true)
+    var result2 = template2(["Mark"])
+
+    var template3 = compile("Hello{[, my name is ]0[ and I like JavaScript]}!", true)
+    var result3 = template3(["Mark"])
+
+    var template4 = compile("Hello{[, ]0}!", true)
+    var result4 = template4([])
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with list of arguments)", function (assert) {
+    var template1 = compile("Hello{[, ]0}!", true)
+    var result1 = template1("Mark")
+
+    var template2 = compile("Hello, {0[ San]}!", true)
+    var result2 = template2("Mark")
+
+    var template3 = compile("Hello{[, my name is ]0[ and I like JavaScript]}!", true)
+    var result3 = template3("Mark")
+
+    var template4 = compile("Hello{[, ]0}!", true)
+    var result4 = template4()
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})

test/compile-weak.js

@@ -150,7 +150,7 @@ test("Missing listed arguments become 0 characters", function (assert) {
 
 test("Listed arguments can be escaped", function (assert) {
     var template = compile("Hello {{0}}, how are you?")
-    var result = template( "Mark")
+    var result = template("Mark")
     assert.equal(result, "Hello {0}, how are you?")
     assert.end()
 })
@@ -249,3 +249,71 @@ test("Allow multiple references", function (assert) {
     assert.equal(result3, "onetwothree\nonetwothree\nonetwothree")
     assert.end()
 })
+
+test("Attach strings to variables in template (with object)", function (assert) {
+    var template1 = compile("Hello{[, ]name}!")
+    var result1 = template1({
+        name: "Mark"
+    })
+
+    var template2 = compile("Hello, {name[ San]}!")
+    var result2 = template2({
+        name: "Mark"
+    })
+
+    var template3 = compile("Hello{[, my name is ]name[ and I like JavaScript]}!")
+    var result3 = template3({
+        name: "Mark"
+    })
+
+    var template4 = compile("Hello{[, ]name}!")
+    var result4 = template4({
+        someotherkey: "Mark"
+    })
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with array)", function (assert) {
+    var template1 = compile("Hello{[, ]0}!")
+    var result1 = template1(["Mark"])
+
+    var template2 = compile("Hello, {0[ San]}!")
+    var result2 = template2(["Mark"])
+
+    var template3 = compile("Hello{[, my name is ]0[ and I like JavaScript]}!")
+    var result3 = template3(["Mark"])
+
+    var template4 = compile("Hello{[, ]0}!")
+    var result4 = template4([])
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with list of arguments)", function (assert) {
+    var template1 = compile("Hello{[, ]0}!")
+    var result1 = template1("Mark")
+
+    var template2 = compile("Hello, {0[ San]}!")
+    var result2 = template2("Mark")
+
+    var template3 = compile("Hello{[, my name is ]0[ and I like JavaScript]}!")
+    var result3 = template3("Mark")
+
+    var template4 = compile("Hello{[, ]0}!")
+    var result4 = template4()
+
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})

test/string-template.js

@@ -211,3 +211,47 @@ test("Allow multiple references", function (assert) {
     assert.equal(result3, "onetwothree\nonetwothree\nonetwothree")
     assert.end()
 })
+
+test("Attach strings to variables in template (with object)", function (assert) {
+    var result1 = format("Hello{[, ]name}!", {
+        name: "Mark"
+    })
+    var result2 = format("Hello, {name[ San]}!", {
+        name: "Mark"
+    })
+    var result3 = format("Hello{[, my name is ]name[ and I like JavaScript]}!", {
+        name: "Mark"
+    })
+    var result4 = format("Hello{[, ]name}!", {
+        someotherkey: "Mark"
+    })
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with array)", function (assert) {
+    var result1 = format("Hello{[, ]0}!", ["Mark"])
+    var result2 = format("Hello, {0[ San]}!", ["Mark"])
+    var result3 = format("Hello{[, my name is ]0[ and I like JavaScript]}!", ["Mark"])
+    var result4 = format("Hello{[, ]0}!", [])
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})
+
+test("Attach strings to variables in template (with list of arguments)", function (assert) {
+    var result1 = format("Hello{[, ]0}!", "Mark")
+    var result2 = format("Hello, {0[ San]}!", "Mark")
+    var result3 = format("Hello{[, my name is ]0[ and I like JavaScript]}!", "Mark")
+    var result4 = format("Hello{[, ]0}!")
+    assert.equal(result1, "Hello, Mark!")
+    assert.equal(result2, "Hello, Mark San!")
+    assert.equal(result3, "Hello, my name is Mark and I like JavaScript!")
+    assert.equal(result4, "Hello!")
+    assert.end()
+})