complexity-reduction

Complexity reduction

Cyclomatic complexity counts linearly independent paths through a method: every if, else if, for, while, case, catch, &&, ||, and ?: adds one. High complexity means many paths to test and maintain. CodeFactor enforces a threshold on the PR diff; the local complexity:gate does the same before push.

When to use

• CodeFactor reports Complex Method on your PR.
• npm run complexity:gate fails (a changed method grew, or a new method exceeds the cap).
• You are about to add branching to an already-large method.

Diagnose first

Identify which methods are over the threshold and whether you introduced them:

npx eslint --rule '{"complexity": ["error", 15]}' <file>       # per-method complexity
git show <base>:<file> | npx eslint --stdin --stdin-filename <file> \
  --rule '{"complexity": ["error", 15]}'                       # baseline (was it already complex?)

If a flagged method is unchanged from the baseline it is pre-existing debt, but CodeFactor still requires it under the threshold when the file is in the diff — reduce it anyway (it is a reviewable improvement, not a no-op).

The four techniques (in order of value)

1. Guard clauses (fail fast, keep the main path linear)

Replace nested if trees with early returns. This is the single biggest win.

// Before — arrow anti-pattern (deep nesting)
function collect(exec, result) {
  const name = exec && exec.name
  if (name) {
    const fileIndex = ctx.get('fileIndex')
    if (fileIndex && typeof fileIndex.addScopePath === 'function') {
      // ... work
    }
  }
}

// After — linear flow
function collect(exec, result) {
  const name = exec && exec.name
  if (!name) return
  const fileIndex = ctx.get('fileIndex')
  if (!fileIndex || typeof fileIndex.addScopePath !== 'function') return
  // ... work at one nesting level
}

2. Composed functions (extract one thing per function)

If a function does multiple things — often signalled by comment blocks like // Step 2: ... — extract each into a small helper. The caller becomes orchestration; each helper has few branches.