configorama 0.6.12 → 0.6.13

package/src/utils/strings/bracketMatcher.test.js

@@ -0,0 +1,135 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const {
+  findOutermostBraces,
+  findOutermostBracesDepthFirst,
+  findOutermostVariables
+} = require('./bracketMatcher')
+
+// Tests for findOutermostBraces
+test('findOutermostBraces - should find simple braces', () => {
+  const result = findOutermostBraces('text {content} more')
+  assert.equal(result, ['{content}'])
+})
+
+test('findOutermostBraces - should find multiple brace pairs', () => {
+  const result = findOutermostBraces('{first} and {second}')
+  assert.equal(result, ['{first}', '{second}'])
+})
+
+test('findOutermostBraces - should handle nested braces', () => {
+  const result = findOutermostBraces('{outer {inner} content}')
+  assert.equal(result, ['{outer {inner} content}'])
+})
+
+test('findOutermostBraces - should find with prefix', () => {
+  const result = findOutermostBraces('text ${variable} more', '{', '}', '$')
+  assert.equal(result, ['${variable}'])
+})
+
+test('findOutermostBraces - should handle multiple nested levels with prefix', () => {
+  const result = findOutermostBraces('${outer ${inner ${deepest}}}', '{', '}', '$')
+  assert.equal(result, ['${outer ${inner ${deepest}}}'])
+})
+
+test('findOutermostBraces - should return empty array when no matches', () => {
+  const result = findOutermostBraces('no braces here')
+  assert.equal(result, [])
+})
+
+test('findOutermostBraces - should handle custom delimiters', () => {
+  const result = findOutermostBraces('text [content] more', '[', ']')
+  assert.equal(result, ['[content]'])
+})
+
+test('findOutermostBraces - should not match without prefix when prefix is specified', () => {
+  const result = findOutermostBraces('{no prefix} ${with prefix}', '{', '}', '$')
+  assert.equal(result, ['${with prefix}'])
+})
+
+// Tests for findOutermostBracesDepthFirst
+test('findOutermostBracesDepthFirst - should find simple braces', () => {
+  const result = findOutermostBracesDepthFirst('text {content} more')
+  assert.equal(result, ['{content}'])
+})
+
+test('findOutermostBracesDepthFirst - should find multiple brace pairs', () => {
+  const result = findOutermostBracesDepthFirst('{first} and {second}')
+  assert.equal(result, ['{first}', '{second}'])
+})
+
+test('findOutermostBracesDepthFirst - should handle nested braces', () => {
+  const result = findOutermostBracesDepthFirst('{outer {inner} content}')
+  assert.equal(result, ['{outer {inner} content}'])
+})
+
+test('findOutermostBracesDepthFirst - should return empty array when no matches', () => {
+  const result = findOutermostBracesDepthFirst('no braces here')
+  assert.equal(result, [])
+})
+
+test('findOutermostBracesDepthFirst - should handle custom delimiters', () => {
+  const result = findOutermostBracesDepthFirst('text [content] more', '[', ']')
+  assert.equal(result, ['[content]'])
+})
+
+test('findOutermostBracesDepthFirst - should handle unmatched braces gracefully', () => {
+  const result = findOutermostBracesDepthFirst('{opened but not closed')
+  assert.equal(result, [])
+})
+
+test('findOutermostBracesDepthFirst - should handle complex nested structures', () => {
+  const result = findOutermostBracesDepthFirst('{a {b {c}}} {d {e}}')
+  assert.equal(result, ['{a {b {c}}}', '{d {e}}'])
+})
+
+// Tests for findOutermostVariables
+test('findOutermostVariables - should find simple variable', () => {
+  const result = findOutermostVariables('text ${variable} more')
+  assert.equal(result, ['${variable}'])
+})
+
+test('findOutermostVariables - should find multiple variables', () => {
+  const result = findOutermostVariables('${first} and ${second}')
+  assert.equal(result, ['${first}', '${second}'])
+})
+
+test('findOutermostVariables - should handle nested variables', () => {
+  const result = findOutermostVariables('${outer ${inner}}')
+  assert.equal(result, ['${outer ${inner}}'])
+})
+
+test('findOutermostVariables - should return empty array when no variables', () => {
+  const result = findOutermostVariables('no variables here')
+  assert.equal(result, [])
+})
+
+test('findOutermostVariables - should ignore plain braces without dollar sign', () => {
+  const result = findOutermostVariables('{not a variable} ${is a variable}')
+  assert.equal(result, ['${is a variable}'])
+})
+
+test('findOutermostVariables - should handle real-world serverless variables', () => {
+  const result = findOutermostVariables('${param:xyz}')
+  assert.equal(result, ['${param:xyz}'])
+})
+
+test('findOutermostVariables - should handle deeply nested serverless variables', () => {
+  const result = findOutermostVariables('${opt:stage, ${env:foo}}')
+  assert.equal(result, ['${opt:stage, ${env:foo}}'])
+})
+
+test('findOutermostVariables - should find multiple variables in array context', () => {
+  const text = "y: !Not [!Equals [!Join ['', ${param:xyz}]]]"
+  const result = findOutermostVariables(text)
+  assert.equal(result, ['${param:xyz}'])
+})
+
+test('findOutermostVariables - should handle variables in YAML object context', () => {
+  const text = 'key: { value: ${self:config}, other: ${env:var} }'
+  const result = findOutermostVariables(text)
+  assert.equal(result, ['${self:config}', '${env:var}'])
+})
+
+// Run all tests
+test.run()

package/src/utils/{formatFunctionArgs.js → strings/formatFunctionArgs.js}

@@ -1,7 +1,8 @@
-const { trim } = require('./lodash')
+const { trim } = require('../lodash')
+const { trimSurroundingQuotes } = require('./quoteUtils')
 
 function formatArg(arg) {
-  const cleanArg = trim(arg).replace(/^('|")/, '').replace(/('|")$/, '')
+  const cleanArg = trimSurroundingQuotes(trim(arg), false)
   if (cleanArg.match(/^{([^}]+)}$/)) {
     return JSON.parse(cleanArg)
   }

package/src/utils/strings/formatFunctionArgs.test.js

@@ -0,0 +1,77 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const formatFunctionArgs = require('./formatFunctionArgs')
+
+test('formatFunctionArgs - should handle single string argument', () => {
+  const result = formatFunctionArgs('simpleString')
+  assert.equal(result, 'simpleString')
+})
+
+test('formatFunctionArgs - should trim and remove quotes from string', () => {
+  const result = formatFunctionArgs('  "quoted"  ')
+  assert.equal(result, 'quoted')
+})
+
+test('formatFunctionArgs - should parse JSON object', () => {
+  const result = formatFunctionArgs('{"key":"value"}')
+  assert.is(typeof result, 'object')
+  assert.equal(result.key, 'value')
+})
+
+test('formatFunctionArgs - should parse JSON array', () => {
+  const result = formatFunctionArgs('[1,2,3]')
+  assert.is(Array.isArray(result), true)
+  assert.equal(result, [1, 2, 3])
+})
+
+test('formatFunctionArgs - should handle array of arguments', () => {
+  const result = formatFunctionArgs(['arg1', '"arg2"', '  arg3  '])
+  assert.is(Array.isArray(result), true)
+  assert.equal(result, ['arg1', 'arg2', 'arg3'])
+})
+
+test('formatFunctionArgs - should parse JSON objects in array', () => {
+  const result = formatFunctionArgs(['{"x":1}', '{"y":2}'])
+  assert.is(Array.isArray(result), true)
+  assert.equal(result[0].x, 1)
+  assert.equal(result[1].y, 2)
+})
+
+test('formatFunctionArgs - should parse JSON arrays in array', () => {
+  const result = formatFunctionArgs(['[1,2]', '[3,4]'])
+  assert.is(Array.isArray(result), true)
+  assert.equal(result[0], [1, 2])
+  assert.equal(result[1], [3, 4])
+})
+
+test('formatFunctionArgs - should handle mixed array', () => {
+  const result = formatFunctionArgs(['simple', '{"obj":"val"}', '[1,2]'])
+  assert.equal(result[0], 'simple')
+  assert.equal(result[1].obj, 'val')
+  assert.equal(result[2], [1, 2])
+})
+
+test('formatFunctionArgs - should handle single quotes', () => {
+  const result = formatFunctionArgs("'singleQuoted'")
+  assert.equal(result, 'singleQuoted')
+})
+
+test('formatFunctionArgs - should handle empty object', () => {
+  const result = formatFunctionArgs('{}')
+  assert.is(typeof result, 'object')
+  assert.equal(Object.keys(result).length, 0)
+})
+
+test('formatFunctionArgs - should handle empty array', () => {
+  const result = formatFunctionArgs('[]')
+  // Empty array regex pattern doesn't match /^\[([^}]+)\]$/ so returns the string as-is
+  assert.equal(result, '[]')
+})
+
+test('formatFunctionArgs - should preserve unquoted strings', () => {
+  const result = formatFunctionArgs('unquoted')
+  assert.equal(result, 'unquoted')
+})
+
+// Run all tests
+test.run()

package/src/utils/strings/quoteUtils.js

@@ -0,0 +1,89 @@
+/**
+ * Quote manipulation utilities for string handling
+ */
+
+/**
+ * Removes surrounding quotes (single, double, or backtick) from a string
+ * @param {string} str - The string to trim
+ * @param {boolean} includeBackticks - Whether to also trim backticks (default: true)
+ * @returns {string} The trimmed string
+ */
+function trimSurroundingQuotes(str = '', includeBackticks = true) {
+  let result = str
+    .replace(/^(")([^"\n]*?)(\1)$/, "$2")
+    .replace(/^(')([^'\n]*?)(\1)$/, "$2")
+
+  if (includeBackticks) {
+    result = result.replace(/^(`)([^`\n]*?)(\1)$/, "$2")
+  }
+
+  return result
+}
+
+/**
+ * Checks if a string starts with the given character
+ * @param {string} str - The string to check
+ * @param {string} char - The character to check for
+ * @returns {string} Empty string if starts with char, otherwise the char
+ */
+function startChar(str, char) {
+  return (str[0] === char) ? '' : char
+}
+
+/**
+ * Checks if a string ends with the given character
+ * @param {string} str - The string to check
+ * @param {string} char - The character to check for
+ * @returns {string} Empty string if ends with char, otherwise the char
+ */
+function endChar(str, char) {
+  return (str[str.length - 1] === char) ? '' : char
+}
+
+/**
+ * Ensures a value (string or array of strings) has quotes around it
+ * @param {string|string[]} value - The value to quote
+ * @param {string} open - Opening quote character (default: '"')
+ * @param {string} close - Closing quote character (default: same as open)
+ * @returns {string|string[]} The quoted value(s)
+ */
+function ensureQuote(value, open = '"', close) {
+  let i = -1
+  const result = []
+  const end = close || open
+  if (typeof value === 'string') {
+    return startChar(value, open) + value + endChar(value, end)
+  }
+  while (++i < value.length) {
+    result[i] = startChar(value[i], open) + value[i] + endChar(value[i], end)
+  }
+  return result
+}
+
+/**
+ * Checks if a string is surrounded by matching quotes (single or double)
+ * @param {string} str - The string to check
+ * @returns {boolean} True if surrounded by matching quotes
+ */
+function isSurroundedByQuotes(str) {
+  if (!str || str.length < 2) return false
+  const firstChar = str[0]
+  const lastChar = str[str.length - 1]
+  return (firstChar === "'" && lastChar === "'") || (firstChar === '"' && lastChar === '"')
+}
+
+/**
+ * Checks if a string starts with a quoted value followed by a pipe
+ * @param {string} str - The string to check
+ * @returns {boolean} True if matches pattern like 'xyz' | or "xyz" |
+ */
+function startsWithQuotedPipe(str) {
+  return /^(['"])(.*?)\1\s*\|/.test(str)
+}
+
+module.exports = {
+  trimSurroundingQuotes,
+  ensureQuote,
+  isSurroundedByQuotes,
+  startsWithQuotedPipe
+}

package/src/utils/strings/quoteUtils.test.js

@@ -0,0 +1,217 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { trimSurroundingQuotes: trimQuotes, ensureQuote, isSurroundedByQuotes, startsWithQuotedPipe } = require('./quoteUtils')
+
+// Tests for double quotes
+test('trimQuotes - should remove surrounding double quotes', () => {
+  const result = trimQuotes('"hello"')
+  assert.equal(result, 'hello')
+})
+
+test('trimQuotes - should not remove non-surrounding double quotes', () => {
+  const result = trimQuotes('say "hello" there')
+  assert.equal(result, 'say "hello" there')
+})
+
+test('trimQuotes - should preserve internal double quotes', () => {
+  const result = trimQuotes('"has "nested" quotes"')
+  assert.equal(result, '"has "nested" quotes"')
+})
+
+// Tests for single quotes
+test('trimQuotes - should remove surrounding single quotes', () => {
+  const result = trimQuotes("'hello'")
+  assert.equal(result, 'hello')
+})
+
+test('trimQuotes - should not remove non-surrounding single quotes', () => {
+  const result = trimQuotes("say 'hello' there")
+  assert.equal(result, "say 'hello' there")
+})
+
+test('trimQuotes - should preserve internal single quotes', () => {
+  const result = trimQuotes("'has 'nested' quotes'")
+  assert.equal(result, "'has 'nested' quotes'")
+})
+
+// Tests for backticks
+test('trimQuotes - should remove surrounding backticks by default', () => {
+  const result = trimQuotes('`hello`')
+  assert.equal(result, 'hello')
+})
+
+test('trimQuotes - should not remove backticks when includeBackticks is false', () => {
+  const result = trimQuotes('`hello`', false)
+  assert.equal(result, '`hello`')
+})
+
+test('trimQuotes - should preserve internal backticks', () => {
+  const result = trimQuotes('`has `nested` ticks`')
+  assert.equal(result, '`has `nested` ticks`')
+})
+
+// Tests for mixed quotes
+test('trimQuotes - should not remove mismatched quotes', () => {
+  const result = trimQuotes('"hello\'')
+  assert.equal(result, '"hello\'')
+})
+
+test('trimQuotes - should handle empty quotes', () => {
+  const result = trimQuotes('""')
+  assert.equal(result, '')
+})
+
+test('trimQuotes - should handle empty single quotes', () => {
+  const result = trimQuotes("''")
+  assert.equal(result, '')
+})
+
+test('trimQuotes - should handle empty backticks', () => {
+  const result = trimQuotes('``')
+  assert.equal(result, '')
+})
+
+// Tests for edge cases
+test('trimQuotes - should handle empty string', () => {
+  const result = trimQuotes('')
+  assert.equal(result, '')
+})
+
+test('trimQuotes - should handle undefined', () => {
+  const result = trimQuotes()
+  assert.equal(result, '')
+})
+
+test('trimQuotes - should handle strings without quotes', () => {
+  const result = trimQuotes('hello world')
+  assert.equal(result, 'hello world')
+})
+
+test('trimQuotes - should handle strings with only opening quote', () => {
+  const result = trimQuotes('"hello')
+  assert.equal(result, '"hello')
+})
+
+test('trimQuotes - should handle strings with only closing quote', () => {
+  const result = trimQuotes('hello"')
+  assert.equal(result, 'hello"')
+})
+
+test('trimQuotes - should not remove quotes from multi-line strings', () => {
+  const result = trimQuotes('"hello\nworld"')
+  assert.equal(result, '"hello\nworld"')
+})
+
+test('trimQuotes - should handle spaces inside quotes', () => {
+  const result = trimQuotes('"  hello  "')
+  assert.equal(result, '  hello  ')
+})
+
+test('trimQuotes - should handle special characters inside quotes', () => {
+  const result = trimQuotes('"hello@#$%world"')
+  assert.equal(result, 'hello@#$%world')
+})
+
+test('trimQuotes - should handle numbers as strings', () => {
+  const result = trimQuotes('"12345"')
+  assert.equal(result, '12345')
+})
+
+test('trimQuotes - should handle JSON-like strings', () => {
+  const result = trimQuotes('"{key: value}"')
+  assert.equal(result, '{key: value}')
+})
+
+// Tests for backtick parameter
+test('trimQuotes - should process all quote types when includeBackticks is true', () => {
+  assert.equal(trimQuotes('"test"', true), 'test')
+  assert.equal(trimQuotes("'test'", true), 'test')
+  assert.equal(trimQuotes('`test`', true), 'test')
+})
+
+test('trimQuotes - should not process backticks when includeBackticks is false', () => {
+  assert.equal(trimQuotes('"test"', false), 'test')
+  assert.equal(trimQuotes("'test'", false), 'test')
+  assert.equal(trimQuotes('`test`', false), '`test`')
+})
+
+// Tests for ensureQuote
+test('ensureQuote - should add double quotes to unquoted string', () => {
+  assert.equal(ensureQuote('hello'), '"hello"')
+})
+
+test('ensureQuote - should not double-quote already quoted string', () => {
+  assert.equal(ensureQuote('"hello"'), '"hello"')
+})
+
+test('ensureQuote - should use custom open/close characters', () => {
+  assert.equal(ensureQuote('hello', "'"), "'hello'")
+})
+
+test('ensureQuote - should handle different open and close characters', () => {
+  assert.equal(ensureQuote('hello', '[', ']'), '[hello]')
+})
+
+test('ensureQuote - should handle array of strings', () => {
+  const result = ensureQuote(['a', 'b', 'c'])
+  assert.equal(result, ['"a"', '"b"', '"c"'])
+})
+
+test('ensureQuote - should not re-quote already quoted items in array', () => {
+  const result = ensureQuote(['"a"', 'b'])
+  assert.equal(result, ['"a"', '"b"'])
+})
+
+// Tests for isSurroundedByQuotes
+test('isSurroundedByQuotes - should return true for double-quoted string', () => {
+  assert.equal(isSurroundedByQuotes('"hello"'), true)
+})
+
+test('isSurroundedByQuotes - should return true for single-quoted string', () => {
+  assert.equal(isSurroundedByQuotes("'hello'"), true)
+})
+
+test('isSurroundedByQuotes - should return false for unquoted string', () => {
+  assert.equal(isSurroundedByQuotes('hello'), false)
+})
+
+test('isSurroundedByQuotes - should return false for mismatched quotes', () => {
+  assert.equal(isSurroundedByQuotes('"hello\''), false)
+})
+
+test('isSurroundedByQuotes - should return false for empty string', () => {
+  assert.equal(isSurroundedByQuotes(''), false)
+})
+
+test('isSurroundedByQuotes - should return false for null/undefined', () => {
+  assert.equal(isSurroundedByQuotes(null), false)
+  assert.equal(isSurroundedByQuotes(undefined), false)
+})
+
+test('isSurroundedByQuotes - should return false for single character', () => {
+  assert.equal(isSurroundedByQuotes('"'), false)
+})
+
+// Tests for startsWithQuotedPipe
+test('startsWithQuotedPipe - should match single-quoted value with pipe', () => {
+  assert.equal(startsWithQuotedPipe("'value' | filter"), true)
+})
+
+test('startsWithQuotedPipe - should match double-quoted value with pipe', () => {
+  assert.equal(startsWithQuotedPipe('"value" | filter'), true)
+})
+
+test('startsWithQuotedPipe - should not match unquoted value with pipe', () => {
+  assert.equal(startsWithQuotedPipe('value | filter'), false)
+})
+
+test('startsWithQuotedPipe - should not match quoted value without pipe', () => {
+  assert.equal(startsWithQuotedPipe('"value"'), false)
+})
+
+test('startsWithQuotedPipe - should handle spaces around pipe', () => {
+  assert.equal(startsWithQuotedPipe("'xyz'   |  something"), true)
+})
+
+// Run all tests
+test.run()

package/src/utils/strings/replaceAll.test.js

@@ -0,0 +1,82 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { replaceAll } = require('./replaceAll')
+
+test('replaceAll - should replace simple string', () => {
+  const result = replaceAll('foo', 'bar', 'foo is foo')
+  assert.equal(result, 'bar is bar')
+})
+
+test('replaceAll - should replace all occurrences', () => {
+  const result = replaceAll('a', 'x', 'aaa bbb aaa')
+  assert.equal(result, 'xxx bbb xxx')
+})
+
+test('replaceAll - should handle regex special characters in search string', () => {
+  const result = replaceAll('.', 'X', 'a.b.c')
+  assert.equal(result, 'aXbXc')
+})
+
+test('replaceAll - should handle $ in replacement string', () => {
+  const result = replaceAll('foo', '$bar', 'foo is foo')
+  assert.equal(result, '$bar is $bar')
+})
+
+test('replaceAll - should handle parentheses in search string', () => {
+  const result = replaceAll('(test)', 'result', 'this (test) is a (test)')
+  assert.equal(result, 'this result is a result')
+})
+
+test('replaceAll - should handle square brackets in search string', () => {
+  const result = replaceAll('[item]', 'value', 'get [item] and [item]')
+  assert.equal(result, 'get value and value')
+})
+
+test('replaceAll - should handle forward slashes', () => {
+  const result = replaceAll('/', '-', 'path/to/file')
+  assert.equal(result, 'path-to-file')
+})
+
+test('replaceAll - should handle backslashes', () => {
+  const result = replaceAll('\\', '/', 'path\\to\\file')
+  assert.equal(result, 'path/to/file')
+})
+
+test('replaceAll - should handle curly braces', () => {
+  const result = replaceAll('{var}', 'value', 'get {var} and {var}')
+  assert.equal(result, 'get value and value')
+})
+
+test('replaceAll - should handle asterisks', () => {
+  const result = replaceAll('*', 'star', '* is *')
+  assert.equal(result, 'star is star')
+})
+
+test('replaceAll - should handle plus signs', () => {
+  const result = replaceAll('+', 'plus', 'a+b+c')
+  console.log('result', result)
+  assert.equal(result, 'aplusbplusc')
+})
+
+test('replaceAll - should handle question marks', () => {
+  const result = replaceAll('?', 'Q', 'what? why?')
+  assert.equal(result, 'whatQ whyQ')
+})
+
+test('replaceAll - should handle empty replacement', () => {
+  const result = replaceAll('foo', '', 'foo bar foo')
+  assert.equal(result, ' bar ')
+})
+
+test('replaceAll - should handle no matches', () => {
+  const result = replaceAll('xyz', 'abc', 'hello world')
+  assert.equal(result, 'hello world')
+})
+
+test('replaceAll - should handle complex regex special characters', () => {
+  const result = replaceAll('${var}', 'value', 'get ${var} and ${var}')
+  assert.equal(result, 'get value and value')
+})
+
+// Run all tests
+test.run()

package/src/utils/{splitByComma.js → strings/splitByComma.js}

@@ -1,4 +1,4 @@
-const stringResolver = require('../resolvers/valueFromString')
+const stringResolver = require('../../resolvers/valueFromString')
 const overwriteSyntax = RegExp(/\s*(?:,\s*)+/g) // /\s*(?:,\s*)+/g
 const stringRefSyntax = stringResolver.match
 /**

package/src/utils/strings/splitCsv.js

@@ -0,0 +1,38 @@
+const { splitByComma } = require('./splitByComma')
+
+/**
+ * Split a string by comma while preserving quoted content
+ * NOTE: This is a simpler version that delegates to splitByComma for consistency.
+ * For advanced use cases with bracket depth tracking and regex protection, use splitByComma directly.
+ * @param {string} str - String to split
+ * @param {string} splitter - Optional custom splitter (defaults to ',')
+ * @returns {string[]} Array of split strings
+ */
+function splitCsv(str, splitter) {
+  // If custom splitter is provided, fall back to original simple implementation
+  if (splitter && splitter !== ',') {
+    const splitSyntax = splitter
+    return str.split(splitSyntax).reduce(
+      (acc, curr) => {
+        if (acc.isConcatting) {
+          acc.soFar[acc.soFar.length - 1] += splitter + curr
+        } else {
+          acc.soFar.push(curr)
+        }
+        if (curr.split('"').length % 2 == 0) {
+          acc.isConcatting = !acc.isConcatting
+        }
+        return acc
+      },
+      {
+        soFar: [],
+        isConcatting: false,
+      },
+    ).soFar
+  }
+
+  // For standard comma splitting, use the more robust splitByComma
+  return splitByComma(str)
+}
+
+module.exports = { splitCsv }