refactor(lib): move utility functions into their own modules

Author: michael-ciniawsky

lib/backup.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const cloneDeep = require('fclone')
+
+/**
+ * @description Creates a backup of keys values
+ *
+ * @method makeLocalsBackup
+ *
+ * @param {Object} keys Keys
+ * @param {Object} locals Locals
+ *
+ * @return {Object} backup Backup Locals
+ */
+function makeLocalsBackup (keys, locals) {
+  let backup = {}
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+    if (locals.hasOwnProperty(key)) backup[key] = cloneDeep(locals[key])
+  }
+
+  return backup
+}
+
+/**
+ * @description Returns the original keys values
+ *
+ * @method revertBackupedLocals
+ *
+ * @param  {Object} keys   Keys
+ * @param  {Object} locals Locals
+ * @param  {Object} backup Backup
+ *
+ * @return {Object} locals Reverted Locals
+ */
+function revertBackupedLocals (keys, locals, backup) {
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+    // remove key from locals
+    delete locals[key]
+
+    // revert copied key value
+    if (backup.hasOwnProperty(key)) locals[key] = backup[key]
+  }
+
+  return locals
+}
+
+/**
+ * @module backup
+ *
+ * @requires fclone
+ *
+ * @type {Object}
+ *
+ * @prop {Function} make   Make Locals backup
+ * @prop {Function} revert Revert backuped Locals
+ */
+module.exports = { make: makeLocalsBackup, revert: revertBackupedLocals }

lib/escape.js

@@ -0,0 +1,22 @@
+/**
+ * @description Replace String based on RegExp
+ *
+ * @method escapeRegexpString
+ *
+ * @param  {String}   input Input
+ *
+ * @return {Function} input Replaced Input
+ */
+function escapeRegexpString (input) {
+  // match Operators
+  const match = /[|\\{}()[\]^$+*?.]/
+
+  return input.replace(match, '\\$&')
+}
+
+/**
+ * @module escape
+ *
+ * @type {Function}
+ */
+module.exports = escapeRegexpString

lib/index.js

@@ -1,27 +1,91 @@
 'use strict'
 
 const vm = require('vm')
-const cloneDeep = require('fclone')
+
+const getNextTag = require('./tags')
+const parseLoopStatement = require('./loops')
+const escapeRegexpString = require('./escape')
+const makeLocalsBackup = require('./backup').make
+const revertBackupedLocals = require('./backup').revert
 const placeholders = require('./placeholders')
 
 let delimitersSettings = []
 let conditionals, loops, scopes
 
-const matchOperatorsRegexp = /[|\\{}()[\]^$+*?.]/g
+/**
+ * @description Creates a set of local variables within the loop, and evaluates all nodes within the loop, returning their contents
+ *
+ * @method executeLoop
+ *
+ * @param  {Array}  params  Parameters
+ * @param  {String} p1      Parameter 1
+ * @param  {String} p2      Parameter 2
+ * @param  {Object} locals  Locals
+ * @param  {String} tree    Tree
+ *
+ * @return {Function} walk  Walks the tree and parses all locals within the loop
+ */
+function executeLoop (params, p1, p2, locals, tree) {
+  // two loop locals are allowed
+  // - for arrays it's the current value and the index
+  // - for objects, it's the value and the key
+  const scopes = locals
+
+  scopes[params[0]] = p1
 
-function escapeRegexpString (input) {
-  return input.replace(matchOperatorsRegexp, '\\$&')
+  if (params[1]) scopes[params[1]] = p2
+
+  return walk({ locals: scopes }, JSON.parse(tree))
 }
 
-module.exports = function PostHTMLExpressions (options) {
+/**
+ * @description Runs walk function with arbitrary set of local variables
+ *
+ * @method executeScope
+ *
+ * @param  {Object} scope  Scoped Locals
+ * @param  {Object} locals Locals
+ * @param  {Object} node   Node
+ *
+ * @return {Function} walk Walks the tree and parses all locals in scope
+ */
+function executeScope (scope, locals, node) {
+  scope = Object.assign(locals, scope)
+
+  return walk({ locals: scope }, node.content)
+}
+
+/**
+ * @author Jeff Escalante Denis (@jescalan),
+ *         Malinochkin (mrmlnc),
+ *         Michael Ciniawsky (@michael-ciniawsky)
+ * @description Expressions Plugin for PostHTML
+ * @license MIT
+ *
+ * @module posthtml-expressions
+ * @version 1.0.0
+ *
+ * @requires vm
+ *
+ * @requires ./tags
+ * @requires ./loops
+ * @requires ./escape
+ * @requires ./backup
+ * @requires ./placeholders
+ *
+ * @param  {Object} options Options
+ *
+ * @return {Object} tree PostHTML Tree
+ */
+module.exports = function postHTMLExpressions (options) {
   // set default options
   options = Object.assign({
+    locals: {},
     delimiters: ['{{', '}}'],
     unescapeDelimiters: ['{{{', '}}}'],
     conditionalTags: ['if', 'elseif', 'else'],
     loopTags: ['each'],
-    scopeTags: ['scope'],
-    locals: {}
+    scopeTags: ['scope']
   }, options)
 
   // set tags
@@ -32,10 +96,12 @@ module.exports = function PostHTMLExpressions (options) {
   // make a RegExp's to search for placeholders
   let before = escapeRegexpString(options.delimiters[0])
   let after = escapeRegexpString(options.delimiters[1])
+
   const delimitersRegexp = new RegExp(`${before}(.+?)${after}`, 'g')
 
   before = escapeRegexpString(options.unescapeDelimiters[0])
   after = escapeRegexpString(options.unescapeDelimiters[1])
+
   const unescapeDelimitersRegexp = new RegExp(`${before}(.+?)${after}`, 'g')
 
   // make array of delimiters
@@ -75,7 +141,9 @@ function walk (opts, nodes) {
     // if we have a string, match and replace it
     if (typeof node === 'string') {
       node = placeholders(node, ctx, delimitersSettings)
+
       m.push(node)
+
       return m
     }
 
@@ -101,12 +169,15 @@ function walk (opts, nodes) {
 
       // сalculate the first path of condition expression
       let expressionIndex = 1
+
       let expression = `if (${node.attrs.condition}) { 0 } `
+
       const branches = [node.content]
 
       // move through the nodes and collect all others that are part of the same
       // conditional statement
       let computedNextTag = getNextTag(nodes, ++i)
+
       let current = computedNextTag[0]
       let nextTag = computedNextTag[1]
 
@@ -135,6 +206,7 @@ function walk (opts, nodes) {
         expression += statement + (condition ? ` (${condition})` : '') + ` { ${expressionIndex++} } `
 
         computedNextTag = getNextTag(nodes, ++current)
+
         current = computedNextTag[0]
         nextTag = computedNextTag[1]
       }
@@ -149,6 +221,7 @@ function walk (opts, nodes) {
 
       // recursive evaluate of condition branch
       if (branch) Array.prototype.push.apply(m, walk(opts, branch))
+
       return m
     }
 
@@ -216,7 +289,7 @@ function walk (opts, nodes) {
       // creates a copy of the keys that will be changed within the loop
       const localsBackup = makeLocalsBackup(keys, opts.locals)
 
-      m.push(executeScoped(target, opts.locals, node))
+      m.push(executeScope(target, opts.locals, node))
 
       // returns the original keys values that was changed within the loop
       opts.locals = revertBackupedLocals(keys, opts.locals, localsBackup)
@@ -227,100 +300,7 @@ function walk (opts, nodes) {
 
     // return the node
     m.push(node)
+
     return m
   }, [])
 }
-
-function getNextTag (nodes, i, nodeCount) {
-  // loop until we get the next tag (bypassing newlines etc)
-  while (i < nodes.length) {
-    const node = nodes[i]
-    if (typeof node === 'object') {
-      return [i, node]
-    } else {
-      i++
-    }
-  }
-  return [i, { tag: undefined }]
-}
-
-/**
- * Given a "loop" parameter from an "each" tag, parses out the param names and
- * expression to be looped.
- */
-function parseLoopStatement (input) {
-  // try to find ` in ` keyword
-  const inKeywordIndex = input.search(/\sin\s/)
-
-  // if we reach the end of the string without getting "in", it's an error
-  if (inKeywordIndex === -1) {
-    throw new Error("Loop statement lacking 'in' keyword")
-  }
-
-  // expression is always after `in` keyword
-  const expression = input.substr(inKeywordIndex + 4)
-
-  // keys is always before `in` keyword
-  const keys = input.substr(0, inKeywordIndex).split(',')
-  for (let i = 0; i < keys.length; i++) {
-    keys[i] = keys[i].trim()
-  }
-
-  return {
-    keys,
-    expression
-  }
-}
-
-/**
- * Creates a backup of keys values
- */
-function makeLocalsBackup (keys, locals) {
-  let backup = {}
-
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i]
-    if (locals.hasOwnProperty(key)) backup[key] = cloneDeep(locals[key])
-  }
-
-  return backup
-}
-
-/**
- * Returns the original keys values
- */
-function revertBackupedLocals (keys, locals, backup) {
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i]
-    // remove key from locals
-    delete locals[key]
-
-    // revert copied key value
-    if (backup.hasOwnProperty(key)) locals[key] = backup[key]
-  }
-
-  return locals
-}
-
-/**
- * Creates a set of local variables within the loop, and evaluates all nodes
- * within the loop, returning their contents
- */
-function executeLoop (loopParams, p1, p2, locals, treeString) {
-  // two loop locals are allowed
-  // - for arrays it's the current value and the index
-  // - for objects, it's the value and the key
-  const scopedLocals = locals
-  scopedLocals[loopParams[0]] = p1
-  if (loopParams[1]) scopedLocals[loopParams[1]] = p2
-
-  return walk({ locals: scopedLocals }, JSON.parse(treeString))
-}
-
-/**
- * Runs walk function with arbitrary set of local variables
- */
-function executeScoped (scopeLocals, locals, node) {
-  const scopedLocals = Object.assign(locals, scopeLocals)
-  return walk({ locals: scopedLocals }, node.content)
-}

lib/loops.js

@@ -0,0 +1,37 @@
+/**
+ * @description Given a "loop" parameter from an "each" tag, parses out the param names and expression to be looped.
+ *
+ * @method parseLoopStatement
+ *
+ * @param {String}  input Input
+ *
+ * @return {Object} {}    Keys && Expression
+ */
+function parseLoopStatement (input) {
+  // try to find ` in ` keyword
+  const inKeywordIndex = input.search(/\sin\s/)
+
+  // if we reach the end of the string without getting "in", it's an error
+  if (inKeywordIndex === -1) {
+    throw new Error("Loop statement lacking 'in' keyword")
+  }
+
+  // expression is always after `in` keyword
+  const expression = input.substr(inKeywordIndex + 4)
+
+  // keys is always before `in` keyword
+  const keys = input.substr(0, inKeywordIndex).split(',')
+
+  for (let i = 0; i < keys.length; i++) {
+    keys[i] = keys[i].trim()
+  }
+
+  return { keys, expression }
+}
+
+/**
+ * @module loops
+ *
+ * @type {Function}
+ */
+module.exports = parseLoopStatement