configorama 0.4.10 → 0.5.0

package/lib/utils/splitCsv.js

@@ -0,0 +1,29 @@
+/**
+ * Split a string by comma while preserving quoted content
+ * @param {string} str - String to split
+ * @param {string} splitter - Optional custom splitter (defaults to ',')
+ * @returns {string[]} Array of split strings
+ */
+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) {
+        accum.isConcatting = !accum.isConcatting
+      }
+      return accum
+    },
+    {
+      soFar: [],
+      isConcatting: false,
+    },
+  ).soFar
+}
+
+module.exports = { splitCsv } 

package/lib/utils/textUtils.js

@@ -0,0 +1,31 @@
+/**
+ * Get text after first occurrence of search string
+ * @param {string} str - Source string
+ * @param {string} search - String to search for
+ * @returns {string} Text after search string or empty string if not found
+ */
+function getTextAfterOccurance(str, search) {
+  const index = str.indexOf(search)
+  if (index === -1) return ''
+  return str.substring(index)
+}
+
+/**
+ * Find nested variable in split array that exists in original source
+ * @param {string[]} split - Array of potential variables
+ * @param {string} originalSource - Original source string
+ * @returns {string|undefined} Found nested variable or undefined
+ */
+function findNestedVariable(split, originalSource) {
+  return split.find((thing) => {
+    if (originalSource && typeof originalSource === 'string') {
+      return originalSource.indexOf(`\${${thing}}`) > -1
+    }
+    return false
+  })
+}
+
+module.exports = {
+  getTextAfterOccurance,
+  findNestedVariable
+} 

package/lib/utils/unknownValues.js

@@ -0,0 +1,46 @@
+/**
+ * Encode unknown variable for passthrough
+ */
+function encodeUnknown(v) {
+  return `>passthrough[_[${Buffer.from(v).toString('base64')}]_]`
+}
+
+/**
+ * Decode unknown variable from passthrough
+ */
+function decodeUnknown(rawValue) {
+  const x = findUnknownValues(rawValue)
+  let val = rawValue.replace(/>passthrough/g, '')
+  if (x.length) {
+    x.forEach(({ match, value }) => {
+      const decodedValue = Buffer.from(value, 'base64').toString('ascii')
+      val = val.replace(match, decodedValue)
+    })
+  }
+  return val
+}
+
+/**
+ * Find base64 encoded unknown values in text
+ */
+function findUnknownValues(text) {
+  const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
+  let matches
+  const links = []
+  while ((matches = base64WrapperRegex.exec(text)) !== null) {
+    if (matches.index === base64WrapperRegex.lastIndex) {
+      base64WrapperRegex.lastIndex++
+    }
+    links.push({
+      match: matches[0],
+      value: matches[1],
+    })
+  }
+  return links
+}
+
+module.exports = {
+  encodeUnknown,
+  decodeUnknown,
+  findUnknownValues
+} 

package/lib/utils/variableUtils.js

@@ -0,0 +1,52 @@
+/**
+ * Get fallback variable string
+ * @param {string[]} split - Array from split at comma
+ * @param {string} nestedVar - Fallback variable to reconstruct variable string from
+ * @returns {string} 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
+}
+
+/**
+ * Verify if variable string is valid
+ */
+function verifyVariable(variableString, valueObject, variableTypes, config) {
+  const isRealVariable = variableTypes.some((r) => {
+    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 (!isRealVariable && variableString.match(/:/)) {
+    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
+}
+
+module.exports = {
+  getFallbackString,
+  verifyVariable
+} 

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "configorama",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "description": "Variable support for configuration files",
   "main": "lib/index.js",
   "files": [
+    "cli.js",
     "lib",
     "package.json",
     "package-lock.json",
     "README.md"
   ],
+  "bin": {
+    "configorama": "./cli.js"
+  },
   "scripts": {
     "docs": "node ./scripts/docs.js",
-    "test": "uvu tests \".*\\.test.js$\"",
+    "test": "npm run testlib && uvu tests \".*\\.test.js$\" ",
     "test:api": "uvu tests/api api.test.js",
+    "testlib": "uvu lib \".*\\.test.js$\"",
     "watch": "watchlist tests -- npm test",
     "publish": "git push origin && git push origin --tags",
     "release:patch": "npm version patch && npm publish",
@@ -41,7 +46,6 @@
     "lodash.isregexp": "^4.0.1",
     "lodash.isfunction": "^3.0.9",
     "lodash.isempty": "^4.4.0",
-    "lodash.trim": "^4.5.1",
     "lodash.camelcase": "^4.3.0",
     "lodash.kebabcase": "^4.1.1",
     "lodash.capitalize": "^4.2.1",
@@ -49,12 +53,10 @@
     "lodash.map": "^4.6.0",
     "lodash.mapvalues": "^4.6.0",
     "lodash.assign": "^4.2.0",
-    "lodash.set": "^4.3.2",
     "lodash.clonedeep": "^4.5.0",
     "lodash.includes": "^4.3.0",
     "lodash.flatten": "^4.4.0",
     "promise.prototype.finally": "^3.1.8",
-    "replaceall": "^0.1.6",
     "sync-rpc": "^1.3.6",
     "traverse": "^0.6.8"
   },