configorama 0.4.10 → 0.5.0

package/lib/main.js

@@ -3,26 +3,8 @@ const path = require('path')
 const fs = require('fs')
 const promiseFinallyShim = require('promise.prototype.finally').shim()
 // @TODO only import lodash we need
-const isArray = require('lodash.isarray')
-const isString = require('lodash.isstring')
-const isNumber = require('lodash.isnumber')
-const isObject = require('lodash.isobject')
-const isDate = require('lodash.isdate')
-const isRegExp = require('lodash.isregexp')
-const isFunction = require('lodash.isfunction')
-const isEmpty = require('lodash.isempty')
-const trim = require('lodash.trim')
-const camelCase = require('lodash.camelcase')
-const kebabCase = require('lodash.kebabcase')
-const capitalize = require('lodash.capitalize')
-const split = require('lodash.split')
-const map = require('lodash.map')
-const mapValues = require('lodash.mapvalues')
-const assign = require('lodash.assign')
-const set = require('lodash.set')
-const cloneDeep = require('lodash.clonedeep')
+
 const findUp = require('find-up')
-const replaceAll = require('replaceall')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
 /* Default Value resolvers */
@@ -38,16 +20,29 @@ const TOML = require('./parsers/toml')
 const md5Function = require('./functions/md5')
 
 /* Utility/helpers */
-const splitByComma = require('./utils/splitByComma')
 const cleanVariable = require('./utils/cleanVariable')
 const appendDeepVariable = require('./utils/appendDeepVariable')
 const isValidValue = require('./utils/isValidValue')
 const PromiseTracker = require('./utils/PromiseTracker')
 const handleSignalEvents = require('./utils/handleSignalEvents')
 const formatFunctionArgs = require('./utils/formatFunctionArgs')
-const cloudFormationSchema = require('./utils/cloudformationSchema')
 const trimSurroundingQuotes = require('./utils/trimSurroundingQuotes')
 const deepLog = require('./utils/deep-log')
+const { splitByComma } = require('./utils/splitByComma')
+const {
+  isArray, isString, isNumber, isObject, isDate, isRegExp, isFunction,
+  isEmpty, trim, camelCase, kebabCase, capitalize, split, map, mapValues,
+  assign, set, cloneDeep
+} = require('./utils/lodash')
+const { parseFileContents } = require('./utils/parse')
+const { splitCsv } = require('./utils/splitCsv')
+const { replaceAll } = require('./utils/replaceAll')
+const { getTextAfterOccurance, findNestedVariable } = require('./utils/textUtils')
+const { getFallbackString, verifyVariable } = require('./utils/variableUtils')
+const { encodeUnknown, decodeUnknown } = require('./utils/unknownValues')
+const { mergeByKeys } = require('./utils/mergeByKeys')
+const { arrayToJsonPath } = require('./utils/arrayToJsonPath')
+
 /**
  * Maintainer's notes:
  *
@@ -62,8 +57,10 @@ const deepLog = require('./utils/deep-log')
  *   pause population, noting the continued depth to traverse.  This motivated "deep" variables.
  *   Original issue #4687
  */
-
 const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
+const deepIndexReplacePattern = new RegExp(/^deep:|(\.[^}]+)*$/g)
+const deepIndexPattern = /deep\:(\d*)/
+const deepPrefixReplacePattern = /(?:^deep:)\d+\.?/g
 const fileRefSyntax = RegExp(/^file\((~?[a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
@@ -75,7 +72,9 @@ const funcStartOfLineRegex = /^(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
 const subFunctionRegex = /(\w+):(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
 const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
 const logLines = '─────────────────────────────────────────────────'
-const DEBUG = false
+
+let DEBUG = process.argv.includes('--debug') ? true : false
+// DEBUG = true
 
 const ENABLE_FUNCTIONS = true
 
@@ -94,17 +93,18 @@ class Configorama {
       allowUndefinedValues: false,
     }, options)
 
-    
+    this.filterCache = {}
+
     const defaultSyntax = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
+  
     const variableSyntax = options.syntax || defaultSyntax
     let varRegex
     if (typeof variableSyntax === 'string') {
-      varRegex = RegExp(variableSyntax, 'g')
+      varRegex = new RegExp(variableSyntax, 'g')
       // this.variableSyntax = /\${((?!AWS)([ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?|(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*))}/
     } else if (variableSyntax instanceof RegExp) {
       varRegex = variableSyntax
     }
-    // console.log('varRegex', varRegex)
     this.variableSyntax = varRegex
 
     // Set initial config object to populate
@@ -121,47 +121,15 @@ class Configorama {
       const fileDirectory = path.dirname(path.resolve(fileOrObject))
       const fileType = path.extname(fileOrObject)
 
-      let configObject
-      if (fileType.match(/\.(yml|yaml)/)) {
-        try {
-          const ymlText = YAML.preProcess(fileContents, varRegex)
-          // console.log('ymlText', ymlText)
-          configObject = YAML.parse(ymlText)
-        } catch (err) {
-          // Attempt to fix cloudformation refs
-          if (err.message.match(/YAMLException/)) {
-            const ymlText = YAML.preProcess(fileContents, varRegex)
-            const result = YAML.load(ymlText, {
-              filename: fileOrObject,
-              schema: cloudFormationSchema.schema
-            })
-            if (result.error) {
-              throw result.error
-            }
-            configObject = result.data
-          }
-        }
-      } else if (fileType.match(/\.(toml)/)) {
-        configObject = TOML.parse(fileContents)
-      } else if (fileType.match(/\.(json)/)) {
-        configObject = JSON.parse(fileContents)
-      } else if (fileType.match(/\.(js)/)) {
-        let jsFile
-        try {
-          jsFile = require(fileOrObject)
-          if (typeof jsFile !== 'function') {
-            configObject = jsFile
-          } else {
-            let jsArgs = opts.dynamicArgs || {}
-            if (jsArgs && typeof jsArgs === 'function') {
-              jsArgs = jsArgs()
-            }
-            configObject = jsFile(jsArgs)
-          }
-        } catch (err) {
-          throw new Error(err)
-        }
-      }
+      // Parse file contents using extracted function
+      const configObject = parseFileContents(
+        fileContents, 
+        fileType, 
+        fileOrObject, 
+        varRegex, 
+        this.opts
+      )
+
       // set config objects
       this.config = configObject
       // Keep a copy
@@ -200,7 +168,7 @@ class Configorama {
         match: selfRefSyntax,
         resolver: (varString, o, x, pathValue) => {
           return this.getValueFromSelf(varString, o, x, pathValue)
-        }
+        },
       },
       /**
        * File references
@@ -213,7 +181,7 @@ class Configorama {
         resolver: (varString, o, x, pathValue) => {
           // console.log('pathValue getValueFromFile', pathValue)
           return this.getValueFromFile(varString)
-        }
+        },
       },
 
       // Git refs
@@ -225,20 +193,14 @@ class Configorama {
       //     return this.getValueFromFunction(varString)
       //   }
       // },
-      // getValueFromString,
-      {
-        match: RegExp(/(?:('|").*?\1)/g),
-        resolver: (varString, o, x, pathValue) => {
-          // console.log('pathValue getValueFromString', pathValue)
-          return this.getValueFromString(varString)
-        }
-      },
-      // Deep references
+      /* Resolve string references */
+      getValueFromString,
+      /* Resolve deep references */
       {
         match: deepRefSyntax,
         resolver: (varString) => {
           return this.getValueFromDeep(varString)
-        }
+        },
       },
       // Numbers
       getValueFromNumber,
@@ -269,7 +231,7 @@ class Configorama {
       },
       resolver: (varString, o, x, pathValue) => {
         return this.getValueFromSelf(varString, o, x, pathValue)
-      }
+      },
     }
 
     /* Apply user defined variable sources */
@@ -282,6 +244,9 @@ class Configorama {
 
     // Additional filters on values. ${thing | filterFunction}
     this.filters = {
+      capitalize: (val) => {
+        return capitalize(val)
+      },
       toUpperCase: (val) => {
         if (typeof val === 'string') {
           return val.toUpperCase()
@@ -306,9 +271,23 @@ class Configorama {
       toKebabCase: (val) => {
         return kebabCase(val)
       },
-      capitalize: (val) => {
-        return capitalize(val)
-      }
+      /* Type filters */
+      toNumber: (val, from) => {
+        const newVal = Number(val)
+        return newVal
+      },
+      toString: (val) => {
+        return String(val)
+      },
+      toBoolean: (val) => {
+        return Boolean(val)
+      },
+      toJson: (val) => {
+        return JSON.stringify(val)
+      },
+      toObject: (val) => {
+        return JSON.parse(val)
+      },
     }
 
     // Apply user defined filters
@@ -316,6 +295,10 @@ class Configorama {
       this.filters = Object.assign({}, this.filters, options.filters)
     }
 
+    // (\|\s*(toUpperCase|toLowerCase|toCamelCase|toKebabCase|capitalize)\s*)+$
+    this.filterMatch = new RegExp(`(\\|\\s*(${Object.keys(this.filters).join('|')})\\s*)+}?$`)
+    // console.log('this.filterMatch', this.filterMatch)
+
     this.functions = {
       split: (value, delimiter, limit) => {
         const delimit = delimiter || ','
@@ -359,9 +342,9 @@ class Configorama {
       },
       math: () => {},
       upperKeys: (o) => {
-        return Object.keys(o).reduce((c, k) => (c[k.toUpperCase()] = o[k], c), {}) // eslint-disable-line
+        return Object.keys(o).reduce((c, k) => ((c[k.toUpperCase()] = o[k]), c), {}) // eslint-disable-line
       },
-      md5: md5Function
+      md5: md5Function,
     }
 
     // Apply user defined functions
@@ -393,66 +376,72 @@ class Configorama {
     const configoramaOpts = this.opts
     const originalConfig = this.originalConfig
     return this.initialCall(() => {
-      return Promise.resolve().then(() => {
-        return this.populateObjectImpl(this.config).finally(() => {
-          // TODO populate function values here?
-          // console.log('Final Config', this.config)
-          const transform = this.runFunction.bind(this)
-          const varSyntax = this.variableSyntax
-          // Traverse resolved object and run functions
-          // console.log('this.config', this.config)
-          traverse(this.config).forEach(function (rawValue) {
-            /* Pass through unknown variables */
-            if (!configoramaOpts.allowUndefinedValues && typeof rawValue === 'undefined') {
-              const configValuePath = this.path.join('.')
-              const ogValue = dotProp.get(originalConfig, configValuePath)
-              const varDisplay = (ogValue) ? `"${ogValue}" variable` : 'variable'
-              const errorMessage = `
+      return Promise.resolve()
+        .then(() => {
+          return this.populateObjectImpl(this.config).finally(() => {
+            // TODO populate function values here?
+            // console.log('Final Config', this.config)
+            const transform = this.runFunction.bind(this)
+            const varSyntax = this.variableSyntax
+            // Traverse resolved object and run functions
+            // console.log('this.config', this.config)
+            traverse(this.config).forEach(function (rawValue) {
+              /* Pass through unknown variables */
+              if (!configoramaOpts.allowUndefinedValues && typeof rawValue === 'undefined') {
+                const configValuePath = this.path.join('.')
+                const ogValue = dotProp.get(originalConfig, configValuePath)
+                const varDisplay = ogValue ? `"${ogValue}" variable` : 'variable'
+                const errorMessage = `
  Config error:
  "${configValuePath}" resolved to "undefined"
  Verify the ${varDisplay} in config at "${configValuePath}"`
-              throw new Error(errorMessage)
-            }
-            if (typeof rawValue === 'string') {
-              /* Process inline functions like merge() */
-              if (ENABLE_FUNCTIONS && rawValue.match(/> function /)) {
-                // console.log('RAW FUNCTION', rawFunction)
-                const funcString = rawValue.replace(/> function /g, '')
-                // console.log('funcString', funcString)
-                const func = cleanVariable(funcString, varSyntax, true)
-                const funcVal = transform(func)
-                const hasObjectRef = rawValue.match(/\.\S*$/)
-                if (hasObjectRef && typeof funcVal === 'object') {
-                  const objectPath = hasObjectRef[0].replace(/^\./, '')
-                  // console.log('objectPath', objectPath)
-                  /* get value from object and update  */
-                  const valueFromObject = dotProp.get(funcVal, objectPath)
-                  // console.log('valueFromObject', valueFromObject)
-                  this.update(valueFromObject)
-                } else {
-                  this.update(funcVal)
-                }
+                throw new Error(errorMessage)
               }
-            
-              
-              /* Allow for unknown variables to pass through */
-              if (rawValue.match(/>passthrough/)) {
-                const newValues = decodeUnknown(rawValue)
-                // console.log('>>>> newValues', newValues)
-                this.update(newValues)
+              if (typeof rawValue === 'string') {
+                /* Process inline functions like merge() */
+                if (ENABLE_FUNCTIONS && rawValue.match(/> function /)) {
+                  // console.log('RAW FUNCTION', rawFunction)
+                  const funcString = rawValue.replace(/> function /g, '')
+                  // console.log('funcString', funcString)
+                  const func = cleanVariable(funcString, varSyntax, true)
+                  const funcVal = transform(func)
+                  const hasObjectRef = rawValue.match(/\.\S*$/)
+                  if (hasObjectRef && typeof funcVal === 'object') {
+                    const objectPath = hasObjectRef[0].replace(/^\./, '')
+                    // console.log('objectPath', objectPath)
+                    /* get value from object and update  */
+                    const valueFromObject = dotProp.get(funcVal, objectPath)
+                    // console.log('valueFromObject', valueFromObject)
+                    this.update(valueFromObject)
+                  } else {
+                    this.update(funcVal)
+                  }
+                }
+
+                /* Allow for unknown variables to pass through */
+                if (rawValue.match(/>passthrough/)) {
+                  const newValues = decodeUnknown(rawValue)
+                  // console.log('>>>> newValues', newValues)
+                  this.update(newValues)
+                }
               }
+            })
+
+            if (DEBUG) {
+              console.log(`Variable process ran ${this.callCount} times`)
+              // console.log('FINAL Value', this.config)
+              // console.log(this.deep)
             }
           })
-
-          if (DEBUG) {
-            console.log(`Variable process ran ${this.callCount} times`)
-            // console.log('FINAL Value', this.config)
-            // console.log(this.deep)
+        })
+        .then(() => {
+          // console.log('this.config', this.config)
+          /* Final post-processing here */
+          if (this.mergeKeys && this.config) {
+            this.config = mergeByKeys(this.config, '', this.mergeKeys)
           }
+          return this.config
         })
-      }).then(() => {
-        return this.config
-      })
     })
   }
   runFunction(variableString) {
@@ -470,7 +459,6 @@ class Configorama {
     // test for object
     const functionName = hasFunc[1]
     const rawArgs = hasFunc[2]
-
     // TODO @DWELLS. Loop through all raw args and parse to correct datatype
     // argument is object
     let argsToPass
@@ -488,9 +476,7 @@ class Configorama {
     // TODO check for camelCase version. | toUpperCase messes with function name
     const theFunction = this.functions[functionName] || this.functions[functionName.toLowerCase()]
 
-    if (!theFunction) {
-      throw new Error(`Function "${functionName}" not found`)
-    }
+    if (!theFunction) throw new Error(`Function "${functionName}" not found`)
 
     const funcValue = theFunction(...argsToPass)
     // console.log('funcValue', funcValue)
@@ -545,13 +531,10 @@ class Configorama {
    */
   getProperties(root, atRoot, current, _context, _results) {
     let context = _context
-    if (!context) {
-      context = []
-    }
+    if (!context) context = []
     let results = _results
-    if (!results) {
-      results = []
-    }
+    if (!results) results = []
+  
     const addContext = (value, key) => {
       return this.getProperties(root, false, value, context.concat(key), results)
     }
@@ -567,13 +550,12 @@ class Configorama {
         path: context,
         value: current,
       }
-
-      const thePath = (leaf.path.length > 1) ? leaf.path.join('.') : leaf.path[0]
+      const thePath = leaf.path.length > 1 ? leaf.path.join('.') : leaf.path[0]
       let originalValue = dotProp.get(this.originalConfig, thePath)
       // TODO @DWELLS make recursive
       if (!originalValue) {
         const parentArray = leaf.path.slice(0, -1)
-        const parentPath = (parentArray > 1) ? parentArray.join('.') : parentArray[0]
+        const parentPath = parentArray > 1 ? parentArray.join('.') : parentArray[0]
         originalValue = dotProp.get(this.originalConfig, parentPath)
       }
       leaf.originalSource = originalValue
@@ -583,7 +565,7 @@ class Configorama {
           leaf.isFileRef = true
         }
       }
-      //  dotProp.get(this.originalConfig, thePath)
+      // dotProp.get(this.originalConfig, thePath)
       results.push(leaf)
     }
     return results
@@ -605,12 +587,12 @@ class Configorama {
       // Initial check if value has variable string in it
       return isString(property.value) && property.value.match(this.variableSyntax)
     })
+    // console.log('variables', variables)
     return map(variables, (valueObject) => {
       // console.log('valueObject', valueObject)
-      return this.populateValue(valueObject, false)
-        .then((populated) => {
-          return assign({}, valueObject, { populated: populated.value })
-        })
+      return this.populateValue(valueObject, false, '_populateVariables').then((populated) => {
+        return assign({}, valueObject, { populated: populated.value })
+      })
     })
   }
   /**
@@ -620,13 +602,15 @@ class Configorama {
    * @returns {Promise<number>} resolving with the number of changes that were applied to the given
    * target
    */
-  assignProperties(target, populations) { // eslint-disable-line class-methods-use-this
-    return Promise.all(populations)
-      .then((results) => results.forEach((result) => {
+  assignProperties(target, populations) {
+    // eslint-disable-line class-methods-use-this
+    return Promise.all(populations).then((results) => {
+      return results.forEach((result) => {
         if (result.value !== result.populated) {
           set(target, result.path, result.populated)
         }
-      }))
+      })
+    })
   }
   /**
    * Populate the variables in the given object.
@@ -638,20 +622,19 @@ class Configorama {
   }
   populateObjectImpl(objectToPopulate) {
     this.callCount = this.callCount + 1
-    
+
     if (DEBUG) {
-      deepLog(`objectToPopulate ${this.callCount}`, objectToPopulate)
+      deepLog(`objectToPopulate called ${this.callCount} times`, objectToPopulate)
+      // process.exit(0)
     }
 
     const leaves = this.getProperties(objectToPopulate, true, objectToPopulate)
+    // console.log('leaves', leaves)
     const populations = this.populateVariables(leaves)
-
     // console.log("FILL LEAVES", populations)
 
     if (populations.length === 0) {
-      if (DEBUG) {
-        console.log('Config Population Finished')
-      }
+      if (DEBUG) console.log('Config Population Finished')
       return Promise.resolve(objectToPopulate)
     }
 
@@ -674,20 +657,15 @@ class Configorama {
    * @returns {Object|String|MatchResult[]} The given property or the identified matches
    */
   getMatches(property) {
-    if (typeof property !== 'string') {
-      return property
-    }
+    if (typeof property !== 'string') return property
     const matches = property.match(this.variableSyntax)
-
-    if (!matches || !matches.length) {
-      return property
-    }
-    return map(matches, match => {
+    if (!matches || !matches.length) return property
+    return map(matches, (match) => {
       // console.log('match', match)
-      return ({
+      return {
         match: match,
         variable: cleanVariable(match, this.variableSyntax),
-      })
+      }
     })
   }
   /**
@@ -723,7 +701,6 @@ class Configorama {
       if (results[i] && typeof results[i] === 'object' && results[i].__internal_only_flag) {
         valueToPop = results[i].value
       }
-    
       result = this.populateVariable(valueObject, matches[i].match, valueToPop)
       /*
       console.log('> valueToPop', valueToPop)
@@ -742,30 +719,27 @@ class Configorama {
    * @returns {PromiseLike<T>} A promise that resolves to the populated value, recursively if root
    * is true
    */
-  populateValue(valueObject, root) {
+  populateValue(valueObject, root, caller) {
     if (DEBUG) {
       console.log('─────────────────────────────────────────────▶')
-      console.log('>>>>>>>> populateValue')
+      console.log('>>>>>>>> populateValue', caller)
       console.log(valueObject)
     }
     const property = valueObject.value
     const matches = this.getMatches(property)
     /*
-    console.log('matchesmatches', matches)
+    console.log('populateValue matches', matches)
     /** */
     if (!isArray(matches)) {
       return Promise.resolve(property)
     }
     const populations = this.populateMatches(matches, valueObject, root)
     return Promise.all(populations)
-      .then(results => this.renderMatches(valueObject, matches, results))
+      .then((results) => this.renderMatches(valueObject, matches, results))
       .then((result) => {
-        /*
-        console.log('renderMatches result', result)
-        /** */
-
+        // console.log('renderMatches result', result)
         if (root && isArray(matches)) {
-          return this.populateValue({ value: result.value }, root)
+          return this.populateValue({ value: result.value }, root, 'self populateValue')
         }
         return result
       })
@@ -794,29 +768,26 @@ class Configorama {
       console.log('valueObject', valueObject)
       console.log('root', root)
     }
-
     /* requires node 8.11+
     if (valueObject.value.match(/(?<!^)> function /)) {
       // valueObject.value = valueObject.value.replace(/(?<!^)> function /, '')
       // valueObject.value = valueObject.value.replace(/^> function /, '')
       // valueObject.value = `> function ${valueObject.value}`
-    }
-    */
+    }*/
 
     const parts = splitByComma(variable)
-
-    if (parts.length > 1) {
-      if (DEBUG) {
-        console.log('parts', parts)
-        console.log('parts variable:', variable)
-        console.log('parts property:', valueObject.value)
-        console.log('All parts:', parts)
-        console.log('-----')
-      }
-      return this.overwrite(parts, valueObject)
+    if (DEBUG) {
+      console.log('parts', parts)
+      console.log('parts variable:', variable)
+      console.log('parts property:', valueObject.value)
+      console.log('All parts:', parts)
+      console.log('-----')
     }
-
-    return this.getValueFromSource(parts[0], valueObject, 'splitAndGet')
+    if (parts.length <= 1) {
+      return this.getValueFromSource(parts[0], valueObject, 'splitAndGet')
+    }
+    // More than 2 parts, so we need to overwrite
+    return this.overwrite(parts, valueObject)
   }
   /**
    * Populate a given property, given the matched string to replace and the value to replace the
@@ -829,35 +800,54 @@ class Configorama {
    */
   populateVariable(valueObject, matchedString, valueToPopulate) {
     let property = valueObject.value
+    // console.log('init property', property)
+    let DEBUG_TYPE = false
     if (DEBUG) {
-      console.log('────────START populateVariable──────────────')
-      console.log('populateVariable: valueToPopulate', valueToPopulate)
-      console.log('populateVariable: valueObject', valueObject)
-      console.log('populateVariable: property', property)
-      console.log('populateVariable: matchedString', matchedString)
+      console.log('────────START populateVar──────────────')
+      console.log('populateVar: valueToPopulate', valueToPopulate)
+      console.log('populateVar: typeof valueToPopulate', typeof valueToPopulate)
+      console.log(`populateVar: path "${valueObject.path}"`)
+      console.log(`populateVar: value \`${valueObject.value}\``)
+      console.log(`populateVar: originalSource \`${valueObject.originalSource}\``)
+      console.log('populateVar: property', property)
+      console.log('populateVar: matchedString', matchedString)
+    }
+
+    const originalSrc = valueObject.originalSource || ''
+    const hasFilters = originalSrc.match(this.filterMatch)
+    let foundFilters = []
+    if (hasFilters) {
+      foundFilters = hasFilters[1]
+        .split('|')
+        .map((filter) => filter.trim())
+        .filter(Boolean)
     }
+    // console.log('foundFilters', foundFilters)
 
     // total replacement
     if (property === matchedString) {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE total replacement')
       const v = valueObject.value || ''
-      const originalSrc = valueObject.originalSource || ''
       property = valueToPopulate
+
       /* Handle ${self:custom.ref, ''} with deep values */
       if (v.match(deepRefSyntax) && originalSrc.match(this.variableSyntax) && !v.match(/deep\:(\d*)\..*}$/)) {
         // console.log('deep var', this.deep)
         // console.log('originalSrc', originalSrc)
         // console.log('value', v)
-        let deepIndex = Number(v.match(/deep\:(\d*)/)[1])
+        let deepIndex = Number(v.match(deepIndexPattern)[1])
         let item = this.deep[deepIndex]
-        
+
         if (item.match(deepRefSyntax)) {
-          deepIndex = Number(item.match(/deep\:(\d*)/)[1])
+          deepIndex = Number(item.match(deepIndexPattern)[1])
           item = this.deep[deepIndex]
         }
         property = this.deep[deepIndex]
+        // console.log('NEW PROPERTY after deep ref', property)
       }
     // partial replacement, string
     } else if (isString(valueToPopulate)) {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE isString')
       // if (property.match(/^> function /g)) {
       //
       //   const innerFunc = /> function (\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
@@ -867,7 +857,6 @@ class Configorama {
       //   console.log('xxxx', rep)
       //   console.log('valueToPopulate', valueToPopulate)
       // }
-  
 
       let currentMatchedString = matchedString
       /* Address fall through values if found */
@@ -877,7 +866,6 @@ class Configorama {
           currentMatchedString = valueObject.value
         }
       }
-
       /*
       console.log('>------')
       console.log('isString og matchedString', matchedString)
@@ -888,28 +876,56 @@ class Configorama {
       console.log('isString currentMatchedString', currentMatchedString)
       console.log('>------')
       /** */
-   
-      // (replaceThis, withThis, inThis)
+      // Handle comma ${opt:stage, dev} and remove extra }
+      if (
+        currentMatchedString.match(this.variableSyntax) &&
+        !valueToPopulate.match(this.variableSyntax) &&
+        valueToPopulate.match(/}$/)
+      ) {
+        valueToPopulate = valueToPopulate.replace(/}$/, '')
+      }
+
       property = replaceAll(currentMatchedString, valueToPopulate, property)
-      // console.log('property', property)
+      // console.log('property replaceAll', property)
 
       // if (property.match(/^> function /g)) {
       //   console.log('REPLACE after', property)
       // }
-    
+
     // partial replacement, number
     } else if (isNumber(valueToPopulate)) {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE isNumber')
       property = replaceAll(matchedString, String(valueToPopulate), property)
-    // TODO This was temp fix for array value mismatch from filters. This fixes filterInner: ${commas | split(${self:inner}, 2) }
-    // } else if (isArray(valueToPopulate) && valueToPopulate.length === 1) {
-    //  property = replaceAll(matchedString, String(valueToPopulate[0]), property)
+      // TODO This was temp fix for array value mismatch from filters. This fixes filterInner: ${commas | split(${self:inner}, 2) }
+      // } else if (isArray(valueToPopulate) && valueToPopulate.length === 1) {
+      //  property = replaceAll(matchedString, String(valueToPopulate[0]), property)
     } else if (isObject(valueToPopulate)) {
-      // console.log('OBJECT MATCH', valueToPopulate)
-      property = replaceAll(matchedString, JSON.stringify(valueToPopulate), property)// .replace(/}$/, '').replace(/^\$\{/, '')
+      if (DEBUG_TYPE) console.log('DEBUG_TYPEisObject')
+
+      const objStr = JSON.stringify(valueToPopulate)
+      /* Check if variable inside another variable. E.g. ${env:${self:someObject}} that resolves to ${env:{...}} */
+      if (
+        property.trim() !== matchedString.trim() &&
+        property.indexOf(matchedString) !== -1 &&
+        matchedString.match(this.variableSyntax) &&
+        property.match(this.variableSyntax)
+      ) {
+        const isVar = /^\${[a-zA-Z0-9_]+:/.test(property)
+        if (isVar) {
+          // console.log('INSIDE', property, matchedString)
+          // console.log('isVar', isVar)
+          throw new Error(
+            `Invalid variable syntax "${property}" resolves to "${replaceAll(matchedString, objStr, property)}"`,
+          )
+        }
+      }
+      // console.log('OBJECT MATCH', `"${objStr}"`)
+      property = replaceAll(matchedString, objStr, property) // .replace(/}$/, '').replace(/^\$\{/, '')
       // console.log('property', property)
       // TODO run functions here
       // console.log('other new prop', property)
     } else {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE else')
       let missingValue = matchedString
 
       if (matchedString.match(deepRefSyntax)) {
@@ -935,18 +951,15 @@ class Configorama {
           originalSource: valueObject.originalSource,
           // set __internal_only_flag to note this is object we make not a resolved value
           __internal_only_flag: true,
-          caller: 'nestedVar'
+          caller: 'nestedVar',
         }
       }
 
       const errorMessage = `
 Missing Value ${missingValue} - ${matchedString}
-
-Make sure the property is being passed in correctly
-
-For variable:
-
-${valueObject.path}: ${valueObject.originalSource}
+\nMake sure the property is being passed in correctly
+\nFor variable:
+\n${valueObject.path}: ${valueObject.originalSource}
 `
       throw new Error(errorMessage)
     }
@@ -964,10 +977,10 @@ ${valueObject.path}: ${valueObject.originalSource}
       if (func && property.match(/^> function /g)) {
         /* IMPORTANT fix `finalProp` for nested function reference
           nestedOne: 'hi'
-          nestedTwo: ${merge('haha', 'wowowow')}
+          nestedTwo: ${merge('nice', 'wow')}
           mergeNested: ${merge('lol', ${nestedTwo})}
         */
-        const finalProp = (property.match(/(?<!^)> function /)) ? prop : property
+        const finalProp = property.match(/(?<!^)> function /) ? prop : property
 
         return {
           value: finalProp, // prop to fix nested ¯\_(ツ)_/¯
@@ -1007,17 +1020,44 @@ ${valueObject.path}: ${valueObject.originalSource}
       //   property = newer
       // }
     }
-    // console.log('XXXX property', property)
+
+    // console.log('foundFilters', foundFilters)
+
+    /* Apply filters if found */
+    //console.log('> property', property)
+    if (
+      foundFilters.length > 0 &&
+      typeof valueToPopulate === 'string' &&
+      !valueToPopulate.match(deepRefSyntax) &&
+      !property.match(this.variableSyntax)
+    ) {
+      // If filter cache exists we need to remove filter that have already been run
+      if (this.filterCache[valueObject.path]) {
+        foundFilters = foundFilters.filter((filter) => {
+          return !this.filterCache[valueObject.path].includes(filter)
+        })
+      }
+      property = foundFilters.reduce((acc, filter) => {
+        const newVal = this.filters[filter](acc, 'from populateVariable')
+        // console.log('PROPERTY', newVal)
+        return newVal
+      }, property)
+      this.filterCache[valueObject.path] = (this.filterCache[valueObject.path] || []).concat(foundFilters)
+      // console.log('NEW PROPERTY', property)
+      // console.log('typeof property', typeof property)
+    }
+    // console.log('filterCache', this.filterCache)
+    // console.log('XXXX property', typeof property)
     // console.log('XXXX path', valueObject.path)
     // console.log('XXXX originalSource', valueObject.originalSource)
+    // console.log('end property', property)
     return {
       value: property,
       path: valueObject.path,
       originalSource: valueObject.originalSource,
-      // set __internal_only_flag to note this is object we make not a resolved value
-      __internal_only_flag: true,
+      __internal_only_flag: true, // set __internal_only_flag to note this is object we make not a resolved value
       caller: 'end',
-      count: this.callCount
+      count: this.callCount,
     }
   }
   // ###############
@@ -1033,16 +1073,13 @@ ${valueObject.path}: ${valueObject.originalSource}
   overwrite(variableStrings, valueObject) {
     const propertyString = valueObject.value
     // console.log('variableStrings', variableStrings)
-
     // console.log('propertyString', typeof propertyString)
     const variableValues = variableStrings.map((variableString) => {
       // This runs on nested variable resolution
       return this.getValueFromSource(variableString, valueObject, 'overwrite')
     })
-
     // console.log('variableValues', variableValues)
-
-    return Promise.all(variableValues).then(values => {
+    return Promise.all(variableValues).then((values) => {
       let deepPropertyStr = propertyString
       let deepProperties = 0
       values.forEach((value, index) => {
@@ -1059,19 +1096,20 @@ ${valueObject.path}: ${valueObject.originalSource}
       })
       return deepProperties > 0
         ? Promise.resolve(deepPropertyStr) // return deep variable replacement of original
-        : Promise.resolve(values.find(isValidValue))// resolve first valid value, else undefined
+        : Promise.resolve(values.find(isValidValue)) // resolve first valid value, else undefined
     })
   }
-
   /**
    * Given any variable string, return the value it should be populated with.
    * @param variableString The variable string to retrieve a value for.
    * @returns {Promise.<TResult>|*} A promise resolving to the given variables value.
    */
   getValueFromSource(variableString, valueObject, caller) {
+    // console.log('getValueFromSource caller', caller)
     const propertyString = valueObject.value
     const pathValue = valueObject.path
-    // return resolved value
+    // console.log('getValueFromSource propertyString', propertyString)
+    // console.log(`tracker contains ${variableString}`, this.tracker.contains(variableString))
     if (this.tracker.contains(variableString)) {
       // console.log('try to get', variableString)
       return this.tracker.get(variableString, propertyString)
@@ -1089,28 +1127,38 @@ ${valueObject.path}: ${valueObject.originalSource}
     }
 
     const filters = propertyString.match(/\s\|/)
+    let promiseKey
     // TODO match () or pipes |
     if (filters) {
+      const string = cleanVariable(propertyString, this.variableSyntax, true)
+      // console.log('string', string)
+      const deeperValue = getTextAfterOccurance(string, variableString)
+      // console.log('deeperValue', deeperValue)
+      // console.log('filters', filters)
       // console.log('variableString', variableString)
+      promiseKey = deeperValue.match(/\s\|/) ? deeperValue : undefined
 
       // TODO clean this up
       const t = variableString.split('|')
+      // console.log('variableString', variableString)
+      // console.log('valueObject', valueObject)
+      // console.log('t', t)
+      const _filter = string
+        .split('|')
+        .filter((value, index, arr) => {
+          return index > 0
+        })
+        .map((f) => {
+          return trim(f)
+        })
+      // console.log('filters to run', _filter)
 
-      const string = cleanVariable(propertyString, this.variableSyntax, true)
-      const filterz = string.split('|').filter((value, index, arr) => {
-        return index > 0
-      }).map((f) => {
-        return trim(f)
-      })
-      // console.log('filters to run', filterz)
-
-      newHasFilter = filterz
+      newHasFilter = _filter
       // If current variable string has no pipes, it has no filters
       if (!variableString.match(/\|/)) {
         newHasFilter = null
       }
-      // console.log('HAS FILTERS', filters)
-      // console.log('t', t)
+      // console.log('newHasFilter', newHasFilter)
       variableString = trim(t[0])
     }
 
@@ -1131,19 +1179,15 @@ ${valueObject.path}: ${valueObject.originalSource}
       }
       return false
     })
-
     // console.log('found', found)
 
     if (found && resolverFunction) {
       // TODO finalize resolverFunction API
-      const valuePromise = resolverFunction(
-        variableString,
-        this.options,
-        this.config,
-        valueObject
-      ).then((val) => {
+      const valuePromise = resolverFunction(variableString, this.options, this.config, valueObject).then((val) => {
         // console.log('VALUE', val)
-        if (val === null || typeof val === 'undefined' ||
+        if (
+          val === null ||
+          typeof val === 'undefined' ||
           /* match deep refs as empty {}, they need resolving via functions */
           (typeof val === 'object' && isEmpty(val) && variableString.match(/deep\:/))
         ) {
@@ -1153,9 +1197,8 @@ ${valueObject.path}: ${valueObject.originalSource}
 
           if (variableString.match(/deep\:/)) {
             // return Promise.resolve(this.getValueFromDeep(variableString))
-            const deepIndex = variableString.match(/deep\:(\d*)/)
-            const deepPrefixReplace = RegExp(/(?:^deep:)\d+\.?/g)
-            const deepRef = variableString.replace(deepPrefixReplace, '')
+            const deepIndex = variableString.match(deepIndexPattern)
+            const deepRef = variableString.replace(deepPrefixReplacePattern, '')
             // console.log('deepRef', deepRef)
             // console.log('deepIndexMatch', deepIndex)
             if (deepIndex[1] && this.deep.length) {
@@ -1170,22 +1213,21 @@ ${valueObject.path}: ${valueObject.originalSource}
           // TODO throw on empty values?
           // No fallback value found AND this is undefined, throw error
           if (valueCount.length === 1) {
-            throw new Error(`Error: Variable not found.
-Variable: "${variableString}" from ${propertyString}
-Value Path: ${(valueObject.path) ? valueObject.path.join('.') : 'na'}
-Original Value: ${valueObject.originalSource}
-Please fix this reference or provide a valid fallback value.
-Like so: \${${variableString}, "fallbackValue"\}.`)
+            throw new Error(`
+Unable to resolve variable ${propertyString} from "${valueObject.originalSource}" at path ${valueObject.path ? `"${arrayToJsonPath(valueObject.path)}"` : 'na'}
+\nFix this reference, your inputs and/or provide a valid fallback value.
+\nExample of setting a fallback value: \${${variableString}, "fallbackValue"\}\n`)
           }
-
           // no value resolved but fallback value exists, keep moving on
           return Promise.resolve(val)
         }
+        /*
         // console.log('------')
         // console.log('propertyString', propertyString)
         // console.log('resolved val', val)
         // console.log('------')
         // console.log('newHasFilter', newHasFilter)
+        /** */
         // No filters found. return value
         if (!newHasFilter) {
           return Promise.resolve(val)
@@ -1197,47 +1239,50 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
           }
           return acc.concat({
             filter: this.filters[currentFilter],
+            filterName: currentFilter,
             // args: argsToPass
           })
         }, [])
+        // console.log('newUse', newUse)
 
         if (typeof val === 'string' && val.match(/deep:/)) {
           // TODO refactor the deep filter logic here. match | filter | filter..
-          const allFilters = propertyString.replace(/}$/, '').split('|').reduce((acc, currentFilter, i) => {
-            if (i === 0) {
+          const allFilters = propertyString
+            .replace(/}$/, '')
+            .split('|')
+            .reduce((acc, currentFilter, i) => {
+              if (i === 0) {
+                return acc
+              }
+              acc += `| ${trim(currentFilter)}`
               return acc
-            }
-            acc += `| ${trim(currentFilter)}`
-            return acc
-          }, '')
-
+            }, '')
           // add filters to deep references if filter is used
-          const deepValueWithFilters = (newHasFilter[1]) ? val.replace(/}$/, ` ${allFilters}}`) : val
+          const deepValueWithFilters = newHasFilter[1] ? val.replace(/}$/, ` ${allFilters}}`) : val
           // console.log('deepValueWithFilters', deepValueWithFilters)
           return Promise.resolve(deepValueWithFilters)
         }
-
-        // console.log('newUse', newUse)
         /* Loop over filters used and produce new value */
         const newValue = newUse.reduce((a, c) => {
           // Fix for async value resolution. That code file refs returns object with .value
-          const theValue = (typeof a === 'object' && a.__internal_only_flag) ? a.value : a
-
-          if (typeof c.filter === 'function') {
-            if (c.args) {
-              return c.filter(theValue, ...c.args)
-            }
-            return c.filter(theValue)
+          const theValue = typeof a === 'object' && a.__internal_only_flag ? a.value : a
+          if (typeof c.filter !== 'function') {
+            return theValue
           }
-          return theValue
+          if (c.args) {
+            this.filterCache[pathValue] = (this.filterCache[pathValue] || []).concat(c.filterName)
+            return c.filter(theValue, ...c.args, 'from getValueFromSource with args')
+          }
+          this.filterCache[pathValue] = (this.filterCache[pathValue] || []).concat(c.filterName)
+          return c.filter(theValue, 'from getValueFromSource')
         }, val)
+        // console.log('newValue', newValue)
 
         return Promise.resolve(newValue)
       })
-
+      // console.log('newHasFilter', newHasFilter)
       // TODO do something with func here?
-
-      return this.tracker.add(variableString, valuePromise, propertyString, newHasFilter)
+      return this.tracker.add(variableString, valuePromise, propertyString, newHasFilter, promiseKey)
     }
 
     /* fall through case with self refs */
@@ -1271,7 +1316,7 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
         }
         const fallbackStr = getFallbackString(split, nestedVar)
         return this.getValueFromSource(variableString, {
-          value: fallbackStr
+          value: fallbackStr,
         }, 'nestedVar')
       }
 
@@ -1283,7 +1328,7 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
         if (fallbackValue) {
           // recurse on fallback and check again
           return this.getValueFromSource(`${variableString})`, {
-            value: propertyString
+            value: propertyString,
           }, 'cleanClean.match(fileRefSyntax)')
         }
       }
@@ -1299,20 +1344,23 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
 
       // has fallback but needs deeper lookup. Call getValueFromSource again
       if (fallbackValue) {
-        if (DEBUG) {
-          console.log('fallbackValue', fallbackValue)
-        }
+        if (DEBUG) console.log('fallbackValue', fallbackValue)
+        // console.log('fallbackValue', fallbackValue)
         // recurse on fallback and check again
-        return this.getValueFromSource(fallbackValue, {
-          value: propertyString
-        }, 'fallbackValue')
+        return this.getValueFromSource(
+          fallbackValue,
+          {
+            value: propertyString,
+          },
+          'fallbackValue',
+        )
       }
     }
 
     // Variable NOT FOUND. Warn user
     const errorMessage = [
       `Invalid variable reference syntax`,
-      `Key: "${(valueObject.path) ? valueObject.path.join('.') : 'na'}"`,
+      `Key: "${valueObject.path ? valueObject.path.join('.') : 'na'}"`,
       `Variable: "${variableString}" from ${propertyString} not found`,
     ]
 
@@ -1343,28 +1391,21 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
 
     return this.tracker.add(variableString, notFoundPromise, propertyString, newHasFilter)
   }
-  getValueFromString(variableString) {
-    const valueToPopulate = variableString.replace(/^['"]|['"]$/g, '')
-    return Promise.resolve(valueToPopulate)
-  }
-
   getValueFromSelf(variableString, o, x, data) {
     /*
     console.log('getValueFromSelf variableString', variableString)
     /** */
-
     // console.log('self data', data)
-
     const split = variableString.split(':')
-    const variable = (split.length && split[1]) ? split[1] : variableString
+    const variable = split.length && split[1] ? split[1] : variableString
     const valueToPopulate = this.config
-    let deepProperties = variable.split('.').filter(property => property)
+    let deepProperties = variable.split('.').filter((property) => property)
     // console.log('self deep', deepProperties)
     // console.log('self valueToPopulate', valueToPopulate)
 
     /* its file ref so we need to shift lookup for self in nested files */
     if (data.isFileRef) {
-      const dotPropPath = (deepProperties.length > 1) ? deepProperties.join('.') : deepProperties[0]
+      const dotPropPath = deepProperties.length > 1 ? deepProperties.join('.') : deepProperties[0]
       const exists = dotProp.get(valueToPopulate, dotPropPath)
       // console.log('self exists', exists)
       if (!exists) {
@@ -1373,7 +1414,6 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
         // console.log('self fixed deepProperties', deepProperties)
       }
     }
-
     return this.getDeeperValue(deepProperties, valueToPopulate).then((res) => {
       /*
       console.log('self getDeeperValue variableString', variableString)
@@ -1382,7 +1422,6 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
       return res
     })
   }
-
   getValueFromFile(variableString) {
     // console.log('From file', `"${variableString}"`)
     let matchedFileString = variableString.match(fileRefSyntax)[0]
@@ -1410,12 +1449,11 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
     }
     // console.log('argsToPass', argsToPass)
 
-    const relativePath = trimSurroundingQuotes(matchedFileString
-      .replace(fileRefSyntax, (match, varName) => varName.trim())
-      .replace('~', os.homedir()))
-      
+    const relativePath = trimSurroundingQuotes(
+      matchedFileString.replace(fileRefSyntax, (match, varName) => varName.trim()).replace('~', os.homedir()),
+    )
 
-    let fullFilePath = (path.isAbsolute(relativePath) ? relativePath : path.join(this.configPath, relativePath))
+    let fullFilePath = path.isAbsolute(relativePath) ? relativePath : path.join(this.configPath, relativePath)
 
     // console.log('fullFilePath', fullFilePath)
 
@@ -1423,7 +1461,7 @@ Like so: \${${variableString}, "fallbackValue"\}.`)
       // Get real path to handle potential symlinks (but don't fatal error)
       fullFilePath = fs.realpathSync(fullFilePath)
 
-    // Only match files that are relative
+      // Only match files that are relative
     } else if (relativePath.match(/\.\//)) {
       // TODO test higher parent refs
       const cleanName = path.basename(relativePath)
@@ -1491,15 +1529,14 @@ Check if your javascript is exporting a function that returns a value.`
         deepProperties = deepProperties.map((prop) => {
           return trim(prop)
         })
-        return this.getDeeperValue(deepProperties, valueToPopulateResolved)
-          .then((deepValueToPopulateResolved) => {
-            if (typeof deepValueToPopulateResolved === 'undefined') {
-              const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
+        return this.getDeeperValue(deepProperties, valueToPopulateResolved).then((deepValueToPopulateResolved) => {
+          if (typeof deepValueToPopulateResolved === 'undefined') {
+            const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
 Check if your javascript is returning the correct data.`
-              return Promise.reject(new Error(errorMessage))
-            }
-            return Promise.resolve(deepValueToPopulateResolved)
-          })
+            return Promise.reject(new Error(errorMessage))
+          }
+          return Promise.resolve(deepValueToPopulateResolved)
+        })
       })
     }
 
@@ -1545,13 +1582,9 @@ Please use ":" to reference sub properties`
     }
     return Promise.resolve(valueToPopulate)
   }
-
-  getDeepIndex(variableString) {
-    const deepIndexReplace = RegExp(/^deep:|(\.[^}]+)*$/g)
-    return variableString.replace(deepIndexReplace, '')
-  }
   getVariableFromDeep(variableString) {
-    const index = this.getDeepIndex(variableString)
+    const index = variableString.replace(deepIndexReplacePattern, '')
+    // const index = this.getDeepIndex(variableString)
     /*
     console.log('FIND INDEX', index)
     console.log(this.deep)
@@ -1559,17 +1592,17 @@ Please use ":" to reference sub properties`
     return this.deep[index]
   }
   getValueFromDeep(variableString) {
-    const deepPrefixReplace = RegExp(/(?:^deep:)\d+\.?/g)
     const variable = this.getVariableFromDeep(variableString)
-    const deepRef = variableString.replace(deepPrefixReplace, '')
+    const deepRef = variableString.replace(deepPrefixReplacePattern, '')
     /*
     console.log("GET getValueFromDeep", variableString)
     console.log('deepRef', deepRef)
     console.log('getValueFromDeep variable', variable)
     /** */
-    let ret = this.populateValue({ value: variable })
+    let ret = this.populateValue({ value: variable }, undefined, 'getValueFromDeep')
     // console.log('variable ret', ret)
-    if (deepRef.length) { // if there is a deep reference remaining
+    if (deepRef.length) {
+      // if there is a deep reference remaining
       ret = ret.then((result) => {
         // console.log('DEEP RESULT', result)
         if (isString(result.value) && result.value.match(this.variableSyntax)) {
@@ -1582,7 +1615,6 @@ Please use ":" to reference sub properties`
     }
     return ret
   }
-
   makeDeepVariable(variable) {
     // console.log('MAKE DEEP', variable)
     let index = this.deep.findIndex((item) => variable === item)
@@ -1599,7 +1631,6 @@ Please use ":" to reference sub properties`
 
     return deepVar
   }
-
   /**
    * Get a value that is within the given valueToPopulate.  The deepProperties specify what value
    * to retrieve from the given valueToPopulate.  The trouble is that anywhere along this chain a
@@ -1619,16 +1650,17 @@ Please use ":" to reference sub properties`
     console.log('deepProperties', deepProperties)
     console.log('valueToPopulate', valueToPopulate)
     /** */
-
     const veryDeep = deepProperties.reduce(async (reducedValueParam, subProperty) => {
       let reducedValue = await reducedValueParam
       // console.log('reducedValue', reducedValue)
       // console.log(typeof reducedValue)
       // console.log('subProperty', `"${subProperty}"`)
 
-      if (isString(reducedValue) && reducedValue.match(deepRefSyntax)) { // build mode
+      if (isString(reducedValue) && reducedValue.match(deepRefSyntax)) {
+        // build mode
         reducedValue = appendDeepVariable(reducedValue, subProperty)
-      } else { // get mode
+      } else {
+        // get mode
         if (typeof reducedValue === 'undefined') {
           // was reducedValue = {}
           // Adding internal flag signals this value is unknown
@@ -1684,126 +1716,14 @@ Please use ":" to reference sub properties`
       // console.log("MISSING", variableString)
       // console.log(this.deep)
       // console.log(valueToPopulate)
-
       const notFoundMsg = `No ${varType} found to satisfy the '\${${variableString}}' variable. Attempting fallback value`
       if (DEBUG) {
         console.log(notFoundMsg)
       }
-
       // errors make fallbacks not function. throw new Error(errorMsg)
     }
     return valueToPopulate
   }
 }
 
-function findNestedVariable(split, originalSource) {
-  return split.find((thing) => {
-    if (originalSource && typeof originalSource === 'string') {
-      return originalSource.indexOf(`\${${thing}}`) > -1
-    }
-    return false
-  })
-}
-
-/**
- * Get fallback variable string
- * @param  {array} split  - array from split at comma
- * @param  {string} nestedVar - fallback variable to reconstruct variable string from
- * @return {string} - returns new ${variable, string}
- */
-function getFallbackString(split, nestedVar) {
-  let isSet = false
-  const newVar = split.reduce((acc, curr) => {
-    if (curr === nestedVar || isSet) {
-      acc = acc.concat(curr)
-      isSet = true
-    }
-    return acc
-  }, []).join(', ')
-  const cleanC = `\${${newVar.replace(/^\${/, '').replace(/}$/, '')}}`
-  return cleanC
-}
-
-function verifyVariable(variableString, valueObject, variableTypes, config) {
-  const isRealVariable = variableTypes.some((r, i) => {
-    if (r.match instanceof RegExp && variableString.match(r.match)) {
-      return true
-    } else if (typeof r.match === 'function') {
-      if (r.match(variableString, config, valueObject)) {
-        return true
-      }
-    }
-    return false
-  })
-  // If not found in variable resolvers and is missing a colon throw
-  if (!isRealVariable && variableString.match(/:/)) {
-    // console.log('variableString', variableString)
-    throw new Error(`
-Variable \${${variableString}} is invalid variable syntax.
-Value Path: ${(valueObject.path) ? valueObject.path.join('.') : 'na'}
-Original Value: ${valueObject.originalSource}
-
-Remove or update the \${${variableString}} to fix
-`)
-  }
-  return isRealVariable
-}
-
-function encodeUnknown(v) {
-  return `>passthrough[_[${Buffer.from(v).toString('base64')}]_]`
-}
-
-function decodeUnknown(rawValue) {
-  const x = findUnknownValues(rawValue)
-  let val = rawValue.replace(/>passthrough/g, '')
-  if (x.length) {
-    x.forEach(({ match, value }) => {
-      // console.log('match', match)
-      const decodedValue = Buffer.from(value, 'base64').toString('ascii')
-      // console.log('decodedValue', decodedValue)
-      val = val.replace(match, decodedValue)
-    })
-  }
-  return val
-}
-
-function findUnknownValues(text) {
-  let matches
-  let links = []
-  while ((matches = base64WrapperRegex.exec(text)) !== null) {
-    if (matches.index === base64WrapperRegex.lastIndex) {
-      base64WrapperRegex.lastIndex++ // avoid infinite loops with zero-width matches
-    }
-    links.push({
-      match: matches[0], 
-      value: matches[1] 
-    })
-  }
-  return links
-}
-
-function isPromise(obj) { // eslint-disable-line
-  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'
-}
-
-// TODO fix argument parsing to handle commas
-function splitCsv(str, splitter) {
-  const splitSyntax = splitter || ','
-  // Split at comma SPACE ", "
-  return str.split(splitSyntax).reduce((accum, curr) => {
-    if (accum.isConcatting) {
-      accum.soFar[accum.soFar.length - 1] += ',' + curr
-    } else {
-      accum.soFar.push(curr)
-    }
-    if (curr.split('"').length % 2 == 0) { // eslint-disable-line
-      accum.isConcatting = !accum.isConcatting
-    }
-    return accum
-  }, {
-    soFar: [],
-    isConcatting: false
-  }).soFar
-}
-
 module.exports = Configorama