configorama 0.6.11 → 0.6.13

package/src/utils/parsing/preProcess.js

@@ -0,0 +1,165 @@
+/**
+ * Preprocesses config to fix malformed fallback references
+ * and escape variables inside help() filter arguments
+ */
+const { splitByComma } = require('../strings/splitByComma')
+
+/**
+ * Preprocess config to fix malformed fallback references
+ * @param {Object} configObject - The parsed configuration object
+ * @param {RegExp} variableSyntax - The variable syntax regex to use
+ * @returns {Object} The preprocessed configuration object
+ */
+function preProcess(configObject, variableSyntax) {
+  // Known reference prefixes that should be wrapped in ${}
+  const refPrefixes = ['self:', 'opt:', 'env:', 'file:', 'text:', 'deep:']
+
+  /**
+   * Escape variables inside help() filter arguments so main resolver skips them
+   * Uses base64 encoding to preserve exact original syntax (supports custom variable syntax)
+   * @param {string} str - String potentially containing help() with variables
+   * @returns {string} String with help() variables escaped
+   */
+  function escapeHelpVariables(str) {
+    if (typeof str !== 'string') return str
+    if (!variableSyntax) return str
+
+    // Match help('...') or help("...") containing variables
+    const helpPattern = /help\(['"]([^'"]+)['"]\)/g
+
+    return str.replace(helpPattern, (match, helpContent) => {
+      // Check if help content contains variables
+      if (!helpContent.match(variableSyntax)) return match
+
+      // Replace each variable match with base64-encoded placeholder
+      const escaped = helpContent.replace(variableSyntax, (varMatch) => {
+        const encoded = Buffer.from(varMatch).toString('base64')
+        return `__CONFIGVAR:${encoded}__`
+      })
+      return `help('${escaped}')`
+    })
+  }
+
+  /**
+   * Fix malformed fallback references in a string
+   * @param {string} str - String potentially containing variables
+   * @returns {string} String with fixed fallback references
+   */
+  function fixFallbacksInString(str) {
+    if (typeof str !== 'string') return str
+
+    let result = str
+    let changed = true
+
+    // Keep iterating until no more changes (to handle nested variables)
+    while (changed) {
+      changed = false
+
+      // Find innermost ${...} blocks (ones that don't contain other ${)
+      let i = 0
+      while (i < result.length) {
+        if (result[i] === '$' && result[i + 1] === '{') {
+          const start = i
+          let braceCount = 1
+          let j = i + 2
+
+          // Find the matching closing brace by counting { and }
+          while (j < result.length && braceCount > 0) {
+            if (result[j] === '{') {
+              braceCount++
+            } else if (result[j] === '}') {
+              braceCount--
+            }
+            j++
+          }
+
+          if (braceCount === 0) {
+            const end = j
+            const match = result.substring(start, end)
+            const content = result.substring(start + 2, end - 1)
+
+            // Only process if there's a comma (indicating fallback syntax)
+            if (content.includes(',')) {
+              // Split by comma
+              const parts = splitByComma(content, variableSyntax)
+
+              if (parts.length > 1) {
+                // Check if the first part has nested ${} - if so, skip this (process inner ones first)
+                const firstPart = parts[0]
+                if (firstPart.includes('${')) {
+                  i = start + 2 // Move past ${ to find inner variables
+                  continue
+                }
+
+                // Check each part after the first (these are fallback values)
+                const fixed = parts.map((part, index) => {
+                  if (index === 0) {
+                    return part // Keep the main reference as-is
+                  }
+
+                  const trimmed = part.trim()
+
+                  // Check if this looks like a reference but is not wrapped
+                  const looksLikeRef = refPrefixes.some(prefix => trimmed.startsWith(prefix))
+                  const alreadyWrapped = trimmed.startsWith('${') && trimmed.endsWith('}')
+
+                  if (looksLikeRef && !alreadyWrapped) {
+                    return ` \${${trimmed}}`
+                  }
+
+                  return ` ${trimmed}`
+                })
+
+                const replacement = `\${${fixed.join(',')}}`
+                if (replacement !== match) {
+                  result = result.substring(0, start) + replacement + result.substring(end)
+                  changed = true
+                  break // Restart search from beginning
+                }
+              }
+            }
+
+            i = start + 2 // Move past ${ to continue searching for nested variables
+          } else {
+            i++
+          }
+        } else {
+          i++
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Recursively traverse and fix the config object
+   */
+  function traverseAndFix(obj) {
+    if (typeof obj === 'string') {
+      // First escape help() variables, then fix fallbacks
+      const withHelpEscaped = escapeHelpVariables(obj)
+      return fixFallbacksInString(withHelpEscaped)
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => traverseAndFix(item))
+    }
+
+    if (obj !== null && typeof obj === 'object') {
+      const result = {}
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          result[key] = traverseAndFix(obj[key])
+        }
+      }
+      return result
+    }
+
+    return obj
+  }
+
+  return traverseAndFix(configObject)
+}
+
+module.exports = preProcess

package/src/utils/paths/filePathUtils.js

@@ -0,0 +1,136 @@
+// Utilities for parsing and normalizing file paths in variable references
+
+const { splitCsv } = require('../strings/splitCsv')
+
+/**
+ * Normalize a file path (add ./ prefix, fix .//, skip deep refs)
+ * @param {string} filePath - The file path to normalize
+ * @returns {string|null} Normalized path, or null if should be skipped
+ */
+function normalizePath(filePath) {
+  // Skip deep references
+  if (filePath.includes('deep:')) {
+    return null
+  }
+
+  let normalized = filePath
+
+  // Add ./ prefix for relative paths
+  if (
+    !filePath.startsWith('./') &&
+    !filePath.startsWith('../') &&
+    !filePath.startsWith('/') &&
+    !filePath.startsWith('~')
+  ) {
+    normalized = './' + filePath
+  }
+
+  // Fix double slashes
+  if (normalized.startsWith('.//')) {
+    normalized = normalized.replace('.//', './')
+  }
+
+  return normalized
+}
+
+/**
+ * Extract file path from a file() or text() variable string
+ * @param {string} variableString - The variable string (with or without ${} wrapper)
+ * @returns {object|null} Object with filePath, or null if no match
+ */
+function extractFilePath(variableString) {
+  // Match both ${file(...)} and file(...) formats
+  const fileMatch = variableString.match(/^(?:\$\{)?(?:file|text)\((.*?)\)/)
+  if (!fileMatch || !fileMatch[1]) {
+    return null
+  }
+
+  const { trimSurroundingQuotes } = require('../strings/quoteUtils')
+  const fileContent = fileMatch[1].trim()
+  const parts = splitCsv(fileContent)
+  let filePath = parts[0].trim()
+
+  // Remove quotes if present
+  filePath = trimSurroundingQuotes(filePath, false)
+
+  return { filePath }
+}
+
+/**
+ * Normalize a file() or text() variable string
+ * Strips key accessors and normalizes the path inside
+ * @param {string} variableString - e.g. "file('./config.json'):key" or "file(config.json)"
+ * @returns {string} Normalized variable string, e.g. "file(./config.json)"
+ */
+function normalizeFileVariable(variableString) {
+  if (!variableString.match(/^(?:file|text)\(/)) {
+    return variableString
+  }
+
+  // Strip sub-key accessors like :topLevel, :nested.value, etc.
+  let normalized = variableString.replace(/:[\w.[\]]+$/, '')
+
+  // Normalize the path inside
+  normalized = normalized.replace(/^(file|text)\((.+?)\)/, (match, funcName, filePath) => {
+    let cleanPath = filePath.trim().replace(/^["']|["']$/g, '')
+    const normalizedPath = normalizePath(cleanPath)
+    return normalizedPath ? `${funcName}(${normalizedPath})` : match
+  })
+
+  return normalized
+}
+
+/**
+ * Resolve inner variables in a string from config values
+ * @param {string} str - String containing variables like ${self:stage}
+ * @param {RegExp} variableSyntax - Regex to match variable syntax
+ * @param {object} config - Config object to look up values
+ * @param {function} getProp - Function to get nested property (e.g. dotProp.get)
+ * @returns {{resolved: string, didResolve: boolean}} Resolved string and whether resolution happened
+ */
+function resolveInnerVariables(str, variableSyntax, config, getProp) {
+  const varMatches = str.match(variableSyntax)
+  if (!varMatches) {
+    return { resolved: str, didResolve: false }
+  }
+
+  let canResolve = true
+  let resolved = str
+  for (const varMatch of varMatches) {
+    const innerVar = varMatch.slice(2, -1) // Remove ${ and }
+    let configPath = null
+
+    // Handle self: prefix
+    if (innerVar.startsWith('self:')) {
+      configPath = innerVar.slice(5)
+    } else if (!innerVar.includes(':')) {
+      // dot.prop style
+      configPath = innerVar
+    }
+
+    if (configPath) {
+      const configValue = getProp(config, configPath)
+      // Only use if it's a static value (not another variable)
+      if (configValue !== undefined &&
+          typeof configValue === 'string' &&
+          !configValue.match(variableSyntax)) {
+        resolved = resolved.replace(varMatch, configValue)
+      } else {
+        canResolve = false
+        break
+      }
+    } else {
+      canResolve = false
+      break
+    }
+  }
+
+  return { resolved: canResolve ? resolved : str, didResolve: canResolve }
+}
+
+module.exports = {
+  normalizePath,
+  extractFilePath,
+  normalizeFileVariable,
+  resolveInnerVariables,
+}

package/src/utils/paths/filePathUtils.test.js

@@ -0,0 +1,214 @@
+// Tests for file path parsing and normalization utilities
+
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { normalizePath, extractFilePath, normalizeFileVariable, resolveInnerVariables } = require('./filePathUtils')
+
+// normalizePath tests
+
+test('normalizePath - returns null for deep: references', () => {
+  assert.is(normalizePath('deep:1'), null)
+  assert.is(normalizePath('some/deep:path'), null)
+})
+
+test('normalizePath - adds ./ prefix to bare paths', () => {
+  assert.is(normalizePath('config.json'), './config.json')
+  assert.is(normalizePath('path/to/file.yml'), './path/to/file.yml')
+})
+
+test('normalizePath - keeps ./ paths unchanged', () => {
+  assert.is(normalizePath('./config.json'), './config.json')
+  assert.is(normalizePath('./path/to/file.yml'), './path/to/file.yml')
+})
+
+test('normalizePath - keeps ../ paths unchanged', () => {
+  assert.is(normalizePath('../config.json'), '../config.json')
+  assert.is(normalizePath('../../path/to/file.yml'), '../../path/to/file.yml')
+})
+
+test('normalizePath - keeps absolute paths unchanged', () => {
+  assert.is(normalizePath('/etc/config.json'), '/etc/config.json')
+  assert.is(normalizePath('/home/user/file.yml'), '/home/user/file.yml')
+})
+
+test('normalizePath - keeps ~ paths unchanged', () => {
+  assert.is(normalizePath('~/config.json'), '~/config.json')
+  assert.is(normalizePath('~/.config/file.yml'), '~/.config/file.yml')
+})
+
+test('normalizePath - fixes .// to ./', () => {
+  assert.is(normalizePath('.//config.json'), './config.json')
+  assert.is(normalizePath('.//path/to/file.yml'), './path/to/file.yml')
+})
+
+// extractFilePath tests
+
+test('extractFilePath - extracts path from file(...) format', () => {
+  const result = extractFilePath('file(./config.json)')
+  assert.is(result.filePath, './config.json')
+})
+
+test('extractFilePath - extracts path from ${file(...)} format', () => {
+  const result = extractFilePath('${file(./config.json)}')
+  assert.is(result.filePath, './config.json')
+})
+
+test('extractFilePath - extracts path from text(...) format', () => {
+  const result = extractFilePath('text(./readme.txt)')
+  assert.is(result.filePath, './readme.txt')
+})
+
+test('extractFilePath - extracts path from ${text(...)} format', () => {
+  const result = extractFilePath('${text(./readme.txt)}')
+  assert.is(result.filePath, './readme.txt')
+})
+
+test('extractFilePath - handles single-quoted paths', () => {
+  const result = extractFilePath("file('./config.json')")
+  assert.is(result.filePath, './config.json')
+})
+
+test('extractFilePath - handles double-quoted paths', () => {
+  const result = extractFilePath('file("./config.json")')
+  assert.is(result.filePath, './config.json')
+})
+
+test('extractFilePath - extracts first path when fallback present', () => {
+  const result = extractFilePath("file(./env.yml, 'default')")
+  assert.is(result.filePath, './env.yml')
+})
+
+test('extractFilePath - handles path with key accessor', () => {
+  const result = extractFilePath('file(./env.yml):FOO')
+  assert.is(result.filePath, './env.yml')
+})
+
+test('extractFilePath - handles complex fallback with key accessor', () => {
+  const result = extractFilePath("file(./env.yml):SECRET, 'default-value'")
+  assert.is(result.filePath, './env.yml')
+})
+
+test('extractFilePath - returns null for non-file patterns', () => {
+  assert.is(extractFilePath('opt:stage'), null)
+  assert.is(extractFilePath('${self:provider.stage}'), null)
+  assert.is(extractFilePath('env:FOO'), null)
+})
+
+test('extractFilePath - returns null for empty input', () => {
+  assert.is(extractFilePath(''), null)
+})
+
+test('extractFilePath - handles bare filename', () => {
+  const result = extractFilePath('file(config.json)')
+  assert.is(result.filePath, 'config.json')
+})
+
+// normalizeFileVariable tests
+
+test('normalizeFileVariable - returns non-file strings unchanged', () => {
+  assert.is(normalizeFileVariable('opt:stage'), 'opt:stage')
+  assert.is(normalizeFileVariable('self:provider.stage'), 'self:provider.stage')
+})
+
+test('normalizeFileVariable - normalizes bare path in file()', () => {
+  assert.is(normalizeFileVariable('file(config.json)'), 'file(./config.json)')
+})
+
+test('normalizeFileVariable - normalizes bare path in text()', () => {
+  assert.is(normalizeFileVariable('text(readme.txt)'), 'text(./readme.txt)')
+})
+
+test('normalizeFileVariable - strips key accessor', () => {
+  assert.is(normalizeFileVariable('file(./env.yml):FOO'), 'file(./env.yml)')
+  assert.is(normalizeFileVariable('file(./config.json):nested.value'), 'file(./config.json)')
+})
+
+test('normalizeFileVariable - strips key accessor with array notation', () => {
+  assert.is(normalizeFileVariable('file(./data.json):items[0]'), 'file(./data.json)')
+})
+
+test('normalizeFileVariable - removes quotes from path', () => {
+  assert.is(normalizeFileVariable("file('./config.json')"), 'file(./config.json)')
+  assert.is(normalizeFileVariable('file("./config.json")'), 'file(./config.json)')
+})
+
+test('normalizeFileVariable - handles combined normalization', () => {
+  assert.is(normalizeFileVariable("file('config.json'):key"), 'file(./config.json)')
+})
+
+test('normalizeFileVariable - keeps ./ paths unchanged', () => {
+  assert.is(normalizeFileVariable('file(./already-normalized.yml)'), 'file(./already-normalized.yml)')
+})
+
+test('normalizeFileVariable - keeps ../ paths unchanged', () => {
+  assert.is(normalizeFileVariable('file(../parent/config.yml)'), 'file(../parent/config.yml)')
+})
+
+// resolveInnerVariables tests
+
+const variableSyntax = /\$\{([^}]+)\}/g
+const getProp = (obj, path) => path.split('.').reduce((o, k) => o && o[k], obj)
+
+test('resolveInnerVariables - returns unchanged when no variables', () => {
+  const result = resolveInnerVariables('./config.json', variableSyntax, {}, getProp)
+  assert.is(result.resolved, './config.json')
+  assert.is(result.didResolve, false)
+})
+
+test('resolveInnerVariables - resolves self: variables from config', () => {
+  const config = { stage: 'prod' }
+  const result = resolveInnerVariables('./database-${self:stage}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './database-prod.json')
+  assert.is(result.didResolve, true)
+})
+
+test('resolveInnerVariables - resolves dot.prop style variables', () => {
+  const config = { stage: 'dev' }
+  const result = resolveInnerVariables('./database-${stage}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './database-dev.json')
+  assert.is(result.didResolve, true)
+})
+
+test('resolveInnerVariables - resolves nested config paths', () => {
+  const config = { provider: { stage: 'test' } }
+  const result = resolveInnerVariables('./db-${self:provider.stage}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './db-test.json')
+  assert.is(result.didResolve, true)
+})
+
+test('resolveInnerVariables - resolves multiple variables', () => {
+  const config = { stage: 'prod', region: 'us-east-1' }
+  const result = resolveInnerVariables('./config-${self:stage}-${self:region}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './config-prod-us-east-1.json')
+  assert.is(result.didResolve, true)
+})
+
+test('resolveInnerVariables - does not resolve if config value is a variable', () => {
+  const config = { stage: '${opt:stage}' }
+  const result = resolveInnerVariables('./database-${self:stage}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './database-${self:stage}.json')
+  assert.is(result.didResolve, false)
+})
+
+test('resolveInnerVariables - does not resolve if config value is undefined', () => {
+  const config = {}
+  const result = resolveInnerVariables('./database-${self:stage}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './database-${self:stage}.json')
+  assert.is(result.didResolve, false)
+})
+
+test('resolveInnerVariables - does not resolve env: or opt: variables', () => {
+  const config = { stage: 'prod' }
+  const result = resolveInnerVariables('./database-${env:STAGE}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './database-${env:STAGE}.json')
+  assert.is(result.didResolve, false)
+})
+
+test('resolveInnerVariables - partial resolution fails completely', () => {
+  const config = { stage: 'prod' }
+  const result = resolveInnerVariables('./config-${self:stage}-${env:REGION}.json', variableSyntax, config, getProp)
+  assert.is(result.resolved, './config-${self:stage}-${env:REGION}.json')
+  assert.is(result.didResolve, false)
+})
+
+test.run()

package/src/utils/paths/findLineForKey.js

@@ -0,0 +1,47 @@
+/**
+ * Finds the line number for a given key in config file contents
+ */
+
+/**
+ * Find the line number where a key is defined in config file contents
+ * @param {string} keyToFind - The key to search for
+ * @param {string[]} lines - Array of file lines
+ * @param {string} fileType - File extension (e.g., '.yml', '.json', '.toml')
+ * @returns {number} Line number (1-indexed) or 0 if not found
+ */
+function findLineForKey(keyToFind, lines, fileType) {
+  if (!keyToFind || !lines || !lines.length) return 0
+
+  const escapedKey = keyToFind.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+  const lineIdx = lines.findIndex((line) => {
+    // YAML: key: or key :
+    if (fileType === '.yml' || fileType === '.yaml') {
+      return new RegExp(`^\\s*${escapedKey}\\s*:`).test(line)
+    }
+    // TOML: key = or key=
+    if (fileType === '.toml') {
+      return new RegExp(`^\\s*${escapedKey}\\s*=`).test(line)
+    }
+    // JSON: "key": or "key" :
+    if (fileType === '.json' || fileType === '.json5') {
+      return new RegExp(`"${escapedKey}"\\s*:`).test(line)
+    }
+    // INI: key = or key=
+    if (fileType === '.ini') {
+      return new RegExp(`^\\s*${escapedKey}\\s*=`).test(line)
+    }
+    // JS/TS/ESM: key: or "key": or 'key': or `key`: or [`key`]:
+    if (['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].includes(fileType)) {
+      return new RegExp(`(?:${escapedKey}|"${escapedKey}"|'${escapedKey}'|\`${escapedKey}\`|\\[\`${escapedKey}\`\\])\\s*:`).test(line)
+    }
+    // Default fallback: try YAML-style
+    return line.includes(`${keyToFind}:`)
+  })
+
+  return lineIdx !== -1 ? lineIdx + 1 : 0
+}
+
+module.exports = {
+  findLineForKey
+}

package/src/utils/paths/findLineForKey.test.js

@@ -0,0 +1,126 @@
+/**
+ * Tests for findLineForKey utility
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { findLineForKey } = require('./findLineForKey')
+
+// YAML tests
+test('YAML - finds key at start of line', () => {
+  const lines = ['foo: bar', 'baz: qux']
+  assert.equal(findLineForKey('foo', lines, '.yml'), 1)
+  assert.equal(findLineForKey('baz', lines, '.yml'), 2)
+})
+
+test('YAML - finds key with indentation', () => {
+  const lines = ['root:', '  nested: value', '  other: thing']
+  assert.equal(findLineForKey('nested', lines, '.yaml'), 2)
+  assert.equal(findLineForKey('other', lines, '.yaml'), 3)
+})
+
+test('YAML - finds key with space before colon', () => {
+  const lines = ['foo : bar']
+  assert.equal(findLineForKey('foo', lines, '.yml'), 1)
+})
+
+test('YAML - returns 0 for missing key', () => {
+  const lines = ['foo: bar']
+  assert.equal(findLineForKey('missing', lines, '.yml'), 0)
+})
+
+// JSON tests
+test('JSON - finds quoted key', () => {
+  const lines = ['{', '  "foo": "bar",', '  "baz": 123', '}']
+  assert.equal(findLineForKey('foo', lines, '.json'), 2)
+  assert.equal(findLineForKey('baz', lines, '.json'), 3)
+})
+
+test('JSON - finds key with space before colon', () => {
+  const lines = ['{ "foo" : "bar" }']
+  assert.equal(findLineForKey('foo', lines, '.json'), 1)
+})
+
+test('JSON5 - works same as JSON', () => {
+  const lines = ['{', '  "foo": "bar"', '}']
+  assert.equal(findLineForKey('foo', lines, '.json5'), 2)
+})
+
+// TOML tests
+test('TOML - finds key with equals', () => {
+  const lines = ['foo = "bar"', 'baz = 123']
+  assert.equal(findLineForKey('foo', lines, '.toml'), 1)
+  assert.equal(findLineForKey('baz', lines, '.toml'), 2)
+})
+
+test('TOML - finds key without spaces around equals', () => {
+  const lines = ['foo="bar"']
+  assert.equal(findLineForKey('foo', lines, '.toml'), 1)
+})
+
+// INI tests
+test('INI - finds key with equals', () => {
+  const lines = ['[section]', 'foo = bar', 'baz = qux']
+  assert.equal(findLineForKey('foo', lines, '.ini'), 2)
+  assert.equal(findLineForKey('baz', lines, '.ini'), 3)
+})
+
+// JS/TS tests
+test('JS - finds unquoted key', () => {
+  const lines = ['module.exports = {', '  foo: "bar",', '  baz: 123', '}']
+  assert.equal(findLineForKey('foo', lines, '.js'), 2)
+  assert.equal(findLineForKey('baz', lines, '.js'), 3)
+})
+
+test('JS - finds double-quoted key', () => {
+  const lines = ['module.exports = {', '  "foo": "bar"', '}']
+  assert.equal(findLineForKey('foo', lines, '.js'), 2)
+})
+
+test('JS - finds single-quoted key', () => {
+  const lines = ["module.exports = {", "  'foo': 'bar'", "}"]
+  assert.equal(findLineForKey('foo', lines, '.js'), 2)
+})
+
+test('JS - finds backtick-quoted key', () => {
+  const lines = ['module.exports = {', '  `foo`: "bar"', '}']
+  assert.equal(findLineForKey('foo', lines, '.js'), 2)
+})
+
+test('TS - works same as JS', () => {
+  const lines = ['export default {', '  foo: "bar"', '}']
+  assert.equal(findLineForKey('foo', lines, '.ts'), 2)
+})
+
+test('MJS - works same as JS', () => {
+  const lines = ['export default {', '  foo: "bar"', '}']
+  assert.equal(findLineForKey('foo', lines, '.mjs'), 2)
+})
+
+// Edge cases
+test('returns 0 for empty lines array', () => {
+  assert.equal(findLineForKey('foo', [], '.yml'), 0)
+})
+
+test('returns 0 for null/undefined key', () => {
+  const lines = ['foo: bar']
+  assert.equal(findLineForKey(null, lines, '.yml'), 0)
+  assert.equal(findLineForKey(undefined, lines, '.yml'), 0)
+})
+
+test('returns 0 for null/undefined lines', () => {
+  assert.equal(findLineForKey('foo', null, '.yml'), 0)
+  assert.equal(findLineForKey('foo', undefined, '.yml'), 0)
+})
+
+test('escapes special regex characters in key', () => {
+  const lines = ['foo.bar: value', 'baz[0]: thing']
+  assert.equal(findLineForKey('foo.bar', lines, '.yml'), 1)
+  assert.equal(findLineForKey('baz[0]', lines, '.yml'), 2)
+})
+
+test('unknown file type falls back to YAML-style', () => {
+  const lines = ['foo: bar']
+  assert.equal(findLineForKey('foo', lines, '.unknown'), 1)
+})
+
+test.run()