Add support for wikilink and external link using mediawiki style syntax

Tests included

src/ast.js

@@ -3,10 +3,9 @@
  * @param {string} message
  */
 export default function BananaMessage (message) {
-  let pipe, colon, backslash, anyCharacter, dollar, digits, regularLiteral,
-    regularLiteralWithoutBar, regularLiteralWithoutSpace, escapedOrLiteralWithoutBar,
-    escapedOrRegularLiteral, templateContents, templateName, openTemplate,
-    closeTemplate, expression, paramExpression, result
+  let escapedOrLiteralWithoutBar,
+    escapedOrRegularLiteral, templateContents, templateName,
+    expression, paramExpression, result
 
   let pos = 0
 
@@ -104,15 +103,16 @@ export default function BananaMessage (message) {
     }
   }
 
-  pipe = makeStringParser('|')
-  colon = makeStringParser(':')
-  backslash = makeStringParser('\\')
-  anyCharacter = makeRegexParser(/^./)
-  dollar = makeStringParser('$')
-  digits = makeRegexParser(/^\d+/)
-  regularLiteral = makeRegexParser(/^[^{}[\]$\\]/)
-  regularLiteralWithoutBar = makeRegexParser(/^[^{}[\]$\\|]/)
-  regularLiteralWithoutSpace = makeRegexParser(/^[^{}[\]$\s]/)
+  const whitespace = makeRegexParser(/^\s+/)
+  const pipe = makeStringParser('|')
+  const colon = makeStringParser(':')
+  const backslash = makeStringParser('\\')
+  const anyCharacter = makeRegexParser(/^./)
+  const dollar = makeStringParser('$')
+  const digits = makeRegexParser(/^\d+/)
+  const regularLiteral = makeRegexParser(/^[^{}[\]$\\]/)
+  const regularLiteralWithoutBar = makeRegexParser(/^[^{}[\]$\\|]/)
+  const regularLiteralWithoutSpace = makeRegexParser(/^[^{}[\]$\s]/)
 
   // There is a general pattern:
   // parse a thing;
@@ -137,9 +137,22 @@ export default function BananaMessage (message) {
     return result === null ? null : result.join('')
   }
 
+  // Used to define "literals" within template parameters.
+  // The pipe character is the parameter delimeter, so by default
+  // it is not a literal in the parameter
   function literal () {
-    let result = nOrMore(1, escapedOrRegularLiteral)()
+    const result = nOrMore(1, escapedOrRegularLiteral)()
+    return result === null ? null : result.join('')
+  }
 
+  const escapedOrLiteralWithoutSpace = choice([
+    escapedLiteral,
+    regularLiteralWithoutSpace
+  ])
+
+  // Used to define "literals" without spaces, in space-delimited situations
+  function literalWithoutSpace () {
+    const result = nOrMore(1, escapedOrLiteralWithoutSpace)()
     return result === null ? null : result.join('')
   }
 
@@ -223,16 +236,108 @@ export default function BananaMessage (message) {
     }
   ])
 
-  openTemplate = makeStringParser('{{')
-  closeTemplate = makeStringParser('}}')
+  const openTemplate = makeStringParser('{{')
+  const closeTemplate = makeStringParser('}}')
+  const openWikilink = makeStringParser('[[')
+  const closeWikilink = makeStringParser(']]')
+  const openExtlink = makeStringParser('[')
+  const closeExtlink = makeStringParser(']')
 
   function template () {
     let result = sequence([ openTemplate, templateContents, closeTemplate ])
 
     return result === null ? null : result[ 1 ]
   }
 
-  expression = choice([ template, replacement, literal ])
+  function pipedWikilink () {
+    var result = sequence([
+      nOrMore(1, paramExpression),
+      pipe,
+      nOrMore(1, expression)
+    ])
+    return result === null ? null : [
+      [ 'CONCAT' ].concat(result[ 0 ]),
+      [ 'CONCAT' ].concat(result[ 2 ])
+    ]
+  }
+
+  function unpipedWikilink () {
+    var result = sequence([
+      nOrMore(1, paramExpression)
+    ])
+    return result === null ? null : [
+      [ 'CONCAT' ].concat(result[ 0 ])
+    ]
+  }
+
+  const wikilinkContents = choice([
+    pipedWikilink,
+    unpipedWikilink
+  ])
+
+  function wikilink () {
+    let result = null
+
+    const parsedResult = sequence([
+      openWikilink,
+      wikilinkContents,
+      closeWikilink
+    ])
+
+    if (parsedResult !== null) {
+      const parsedLinkContents = parsedResult[ 1 ]
+      result = [ 'WIKILINK' ].concat(parsedLinkContents)
+    }
+
+    return result
+  }
+
+  // this extlink MUST have inner contents, e.g. [foo] not allowed; [foo bar] [foo <i>bar</i>], etc. are allowed
+  function extlink () {
+    let result = null
+
+    const parsedResult = sequence([
+      openExtlink,
+      nOrMore(1, nonWhitespaceExpression),
+      whitespace,
+      nOrMore(1, expression),
+      closeExtlink
+    ])
+
+    if (parsedResult !== null) {
+      // When the entire link target is a single parameter, we can't use CONCAT, as we allow
+      // passing fancy parameters (like a whole jQuery object or a function) to use for the
+      // link. Check only if it's a single match, since we can either do CONCAT or not for
+      // singles with the same effect.
+      const target = parsedResult[ 1 ].length === 1
+        ? parsedResult[ 1 ][ 0 ]
+        : [ 'CONCAT' ].concat(parsedResult[ 1 ])
+      result = [
+        'EXTLINK',
+        target,
+        [ 'CONCAT' ].concat(parsedResult[ 3 ])
+      ]
+    }
+
+    return result
+  }
+
+  const nonWhitespaceExpression = choice([
+    template,
+    replacement,
+    wikilink,
+    extlink,
+    literalWithoutSpace
+  ])
+
+  expression = choice([
+    template,
+    replacement,
+    wikilink,
+    extlink,
+    literal
+  ])
+
   paramExpression = choice([ template, replacement, literalWithoutBar ])
 
   function start () {

src/emitter.js

@@ -161,6 +161,46 @@ class BananaEmitter {
     return word && form && this.language.convertGrammar(word, form)
   }
 
+  /**
+   * Transform wiki-link
+   *
+   * @param {String[]} nodes
+   * @return {String}
+   */
+  wikilink (nodes) {
+    let anchor
+    let page = nodes[0]
+    // Strip leading ':', which is used to suppress special behavior in wikitext links,
+    // e.g. [[:Category:Foo]] or [[:File:Foo.jpg]]
+    if (page.charAt(0) === ':') {
+      page = page.slice(1)
+    }
+    const url = `./${page}`
+
+    if (nodes.length === 1) {
+      // [[Some Page]] or [[Namespace:Some Page]]
+      anchor = page
+    } else {
+      // [[Some Page|anchor text]] or [[Namespace:Some Page|anchor]]
+      anchor = nodes[1]
+    }
+
+    return `<a href="${url}" title="${page}">${anchor}</a>`
+  }
+
+  /**
+   * Transform parsed structure into external link.
+   *
+   * @param {String[]} nodes
+   * @return {String}
+   */
+  extlink (nodes) {
+    if (nodes.length !== 2) {
+      throw Error('Expected two items in the node')
+    }
+    return `<a href="${nodes[0]}">${nodes[1]}</a>`
+  }
+
   /**
    * Wraps argument with unicode control characters for directionality safety
    *

src/parser.js

@@ -8,7 +8,7 @@ export default class BananaParser {
   }
 
   parse (message, params) {
-    if (message.includes('{{')) {
+    if (message.includes('{{') || message.includes('[')) {
       let ast = new BananaMessage(message)
       return this.emitter.emit(ast, params)
     } else {

test/banana.test.js

@@ -597,6 +597,30 @@ describe('Banana', function () {
     )
   })
 
+  it('should localize the messages with wiki liinks', () => {
+    const banana = new Banana('en')
+    banana.load({
+      'msg-with-extlink': 'This is a link to [https://wikipedia.org wikipedia]',
+      'msg-with-wikilink': 'This is a link to [[Apple|Apple Page]]',
+      'msg-with-wikilink-no-anchor': 'This is a link to [[Apple]]'
+    }, 'en')
+    assert.strictEqual(
+      banana.i18n('msg-with-extlink'),
+      'This is a link to <a href="https://wikipedia.org">wikipedia</a>',
+      'External link'
+    )
+    assert.strictEqual(
+      banana.i18n('msg-with-wikilink'),
+      'This is a link to <a href="./Apple" title="Apple">Apple Page</a>',
+      'Internal Wiki style link with link and title being different'
+    )
+    assert.strictEqual(
+      banana.i18n('msg-with-wikilink-no-anchor'),
+      'This is a link to <a href="./Apple" title="Apple">Apple</a>',
+      'Internal Wiki style link with link and title being same'
+    )
+  })
+
   for (var langCode in grammarTests) {
     grammarTest(langCode, grammarTests[langCode])
   }