@cookshack/eslint-config 3.0.0 → 5.0.0

package/formatter.js

@@ -1,5 +1,6 @@
 export default
-function (results) {
+function
+(results) {
   let str
 
   str = ''

package/index.js

@@ -7,6 +7,8 @@ import alwaysLetPlugin from './plugins/always-let.js'
 import initBeforeUsePlugin from './plugins/init-before-use.js'
 import varDeclBlockStartPlugin from './plugins/var-decl-block-start.js'
 import fnDeclBlockStartPlugin from './plugins/fn-decl-block-start.js'
+import fnArgsNlPlugin from './plugins/fn-args-nl.js'
+import indentStructPlugin from './plugins/indent-struct.js'
 
 export { getPrintBuffer }
 
@@ -18,75 +20,69 @@ plugins = { 'cookshack': { rules: { 'positive-vibes': positiveVibesPlugin,
                                     'always-let': alwaysLetPlugin,
                                     'init-before-use': initBeforeUsePlugin,
                                     'var-decl-block-start': varDeclBlockStartPlugin,
-                                    'fn-decl-block-start': fnDeclBlockStartPlugin } } }
+                                    'fn-decl-block-start': fnDeclBlockStartPlugin,
+                                    'fn-args-nl': fnArgsNlPlugin,
+                                    'indent-struct': indentStructPlugin } } }
 
-rules = {
-  'array-bracket-newline': [ 'error', 'never' ],
-  'array-bracket-spacing': [ 'error', 'always' ],
-  'arrow-parens': [ 'error', 'as-needed' ],
-  'brace-style': [ 'error', 'stroustrup' ],
-  'comma-dangle': 'error',
-  'curly': [ 'error', 'multi' ],
-  'eol-last': [ 'error', 'always' ],
-  'function-paren-newline': [ 'error', 'never' ],
-  'indent': [ 'error', 2, { ArrayExpression: 'first',
-                            CallExpression: { arguments: 'first' },
-                            //flatTernaryExpressions: true,
-                            //offsetTernaryExpressions: true,
-                            // ternary, because overhangs strangely (eg multiline in array def)
-                            'ignoredNodes': [ 'ConditionalExpression' ],
-                            FunctionDeclaration: { parameters: 'first', body: 1 },
-                            FunctionExpression: { parameters: 'first', body: 1 },
-                            ImportDeclaration: 'first',
-                            ObjectExpression: 'first',
-                            offsetTernaryExpressions: true,
-                            VariableDeclarator: 'first' } ],
-  'init-declarations': [ 'error', 'never', { 'ignoreForLoopInit': true } ],
-  'keyword-spacing': [ 'error', { before: true, after: true } ],
-  'linebreak-style': [ 'error', 'unix' ],
-  'padding-line-between-statements': [ 'error',
-                                       { blankLine: 'always', prev: 'let', next: '*' },
-                                       { blankLine: 'never', prev: 'let', next: 'let' } ],
-  'no-case-declarations': 'error',
-  'no-global-assign': 'error',
-  'cookshack/positive-vibes': 'error',
-  'cookshack/narrowest-scope': 'error',
-  'cookshack/use-risky-equal': 'error',
-  'cookshack/always-let': 'error',
-  // using the implicit inititialization to undefined fits better
-  //'cookshack/init-before-use': 'error',
-  'cookshack/var-decl-block-start': 'error',
-  'cookshack/fn-decl-block-start': 'error',
-  'no-mixed-operators': 'error',
-  'no-multi-spaces': 'error',
-  'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],
-  'no-negated-condition': 'error',
-  'no-redeclare': 'error',
-  'no-sequences': 'error',
-  'no-sparse-arrays': 'error',
-  'no-tabs': 'error',
-  'no-trailing-spaces': 'error',
-  'no-undef': 'error',
-  'no-unsafe-negation': 'error',
-  'no-unused-vars': 'error',
-  'no-var': 'error',
-  'object-curly-spacing': [ 'error', 'always' ],
-  'object-shorthand': [ 'error', 'always' ],
-  quotes: [ 'error', 'single', { avoidEscape: true } ],
-  semi: [ 'error', 'never' ]
-  //'vars-on-top': [ 'error' ], // want version for let
-  //'newline-before-function-paren': ['error', 'always'],
-}
+rules = { 'array-bracket-newline': [ 'error', 'never' ],
+          'array-bracket-spacing': [ 'error', 'always' ],
+          'arrow-parens': [ 'error', 'as-needed' ],
+          'brace-style': [ 'error', 'stroustrup' ],
+          'comma-dangle': 'error',
+          'curly': [ 'error', 'multi' ],
+          'eol-last': [ 'error', 'always' ],
+          'function-paren-newline': [ 'error', 'never' ],
+          'indent': [ 'error', 2, { ArrayExpression: 'first',
+                                    CallExpression: { arguments: 'first' },
+                                    //flatTernaryExpressions: true,
+                                    //offsetTernaryExpressions: true,
+                                    // ternary, because overhangs strangely (eg multiline in array def)
+                                    'ignoredNodes': [ 'ConditionalExpression', 'ObjectExpression *' ],
+                                    FunctionDeclaration: { parameters: 'first', body: 1 },
+                                    FunctionExpression: { parameters: 'first', body: 1 },
+                                    ImportDeclaration: 'first',
+                                    offsetTernaryExpressions: true,
+                                    VariableDeclarator: 'first' } ],
+          'init-declarations': [ 'error', 'never', { 'ignoreForLoopInit': true } ],
+          'keyword-spacing': [ 'error', { before: true, after: true } ],
+          'linebreak-style': [ 'error', 'unix' ],
+          'padding-line-between-statements': [ 'error',
+                                               { blankLine: 'always', prev: 'let', next: '*' },
+                                               { blankLine: 'never', prev: 'let', next: 'let' } ],
+          'no-case-declarations': 'error',
+          'no-global-assign': 'error',
+          'cookshack/positive-vibes': 'error',
+          'cookshack/narrowest-scope': 'error',
+          'cookshack/use-risky-equal': 'error',
+          'cookshack/always-let': 'error',
+          // using the implicit inititialization to undefined fits better
+          //'cookshack/init-before-use': 'error',
+          'cookshack/var-decl-block-start': 'error',
+          'cookshack/fn-decl-block-start': 'error',
+          'cookshack/fn-args-nl': 'error',
+          'cookshack/indent-struct': 'error',
+          'no-mixed-operators': 'error',
+          'no-multi-spaces': 'error',
+          'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],
+          'no-negated-condition': 'error',
+          'no-redeclare': 'error',
+          'no-sequences': 'error',
+          'no-shadow': [ 'error', { builtinGlobals: true } ],
+          'no-sparse-arrays': 'error',
+          'no-tabs': 'error',
+          'no-trailing-spaces': 'error',
+          'no-undef': 'error',
+          'no-unsafe-negation': 'error',
+          'no-unused-vars': 'error',
+          'no-var': 'error',
+          'object-curly-spacing': [ 'error', 'always' ],
+          'object-shorthand': [ 'error', 'always' ],
+          quotes: [ 'error', 'single', { avoidEscape: true } ],
+          semi: [ 'error', 'never' ] }
 
-languageOptions = {
-  globals: {
-    ...globals.node
-  },
-  parserOptions: {
-    ecmaVersion: 2025,
-    sourceType: 'module'
-  }
-}
+languageOptions = { globals: { ...globals.node },
+                    parserOptions: { ecmaVersion: 2025,
+                                     sourceType: 'module' } }
 
 export
 default [ { ignores: [ 'TAGS.mjs' ] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cookshack/eslint-config",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "description": "ESLint config for Cookshack projects",
   "homepage": "https://git.sr.ht/~mattmundell/eslint-config",
   "type": "module",

package/plugins/always-let.js

@@ -1,9 +1,10 @@
 function create
 (context) {
-  return { VariableDeclaration(node) {
-    if (node.kind == 'const' || node.kind == 'var')
-      context.report({ node, messageId: 'useLet' })
-  } }
+  return { VariableDeclaration
+           (node) {
+             if (node.kind == 'const' || node.kind == 'var')
+               context.report({ node, messageId: 'useLet' })
+           } }
 }
 
 export

package/plugins/fn-args-nl.js

@@ -0,0 +1,47 @@
+function FnArgsNl
+(node, context) {
+  let nameLine, parenLine, nameEnd, i, newlines, parent
+
+  parent = node.parent
+
+  if (parent?.type == 'Property' && (parent.method || parent.kind == 'get' || parent.kind == 'set')) {
+    nameLine = parent.key.loc.start.line
+    nameEnd = parent.key.range[1]
+  }
+  else if (parent?.type == 'MethodDefinition') {
+    nameLine = parent.key.loc.start.line
+    nameEnd = parent.key.range[1]
+  }
+  else {
+    nameLine = node.loc.start.line
+    nameEnd = node.range[0]
+  }
+
+  i = nameEnd
+  newlines = 0
+  while (i < context.sourceCode.text.length) {
+    if (context.sourceCode.text[i] == '(')
+      break
+    if (context.sourceCode.text[i] == '\n')
+      newlines++
+    i++
+  }
+
+  parenLine = nameLine + newlines
+
+  if (parenLine - nameLine == 1)
+    return
+  context.report({ node, messageId: 'fnArgsNl' })
+}
+
+function create
+(context) {
+  return { FunctionDeclaration: node => FnArgsNl(node, context),
+           FunctionExpression: node => FnArgsNl(node, context) }
+}
+
+export default { meta: { type: 'suggestion',
+                         docs: { description: 'Require function args on the line immediately after the function name.' },
+                         messages: { fnArgsNl: 'Fn args must be on the line immediately after the function name.' },
+                         schema: [] },
+                 create }

package/plugins/fn-decl-block-start.js

@@ -1,5 +1,4 @@
-function
-FunctionDeclaration
+function FunctionDeclaration
 (context, node) {
   let parent
 

package/plugins/indent-struct.js

@@ -0,0 +1,145 @@
+function trace
+(...args) {
+  if (0)
+    console.log(...args)
+}
+
+function unit
+(context) {
+  return context.options[0] ?? 2
+}
+
+function checkObjectExpressionProperties
+(properties, node, context) {
+  let firstProp, sourceCode, lastProp, lastPropEnd, closingBrace, firstPropLine, firstPropCol, afterLastProp, closingLine, lastPropValueEndLine
+
+  sourceCode = context.sourceCode.text
+  firstProp = properties[0]
+  lastProp = properties[properties.length - 1]
+  firstPropLine = firstProp.loc.start.line
+  firstPropCol = firstProp.loc.start.column
+  lastPropEnd = lastProp.range[1]
+  closingBrace = sourceCode.indexOf('}', lastPropEnd)
+  closingLine = sourceCode.slice(0, closingBrace).split('\n').length
+  afterLastProp = sourceCode.slice(lastPropEnd, closingBrace)
+  lastPropValueEndLine = sourceCode.slice(0, lastPropEnd).split('\n').length
+
+  trace('ALGORITHM 1: Single-line objects: always valid (no check needed)')
+  trace('CHECK POINT 1: is single-line? firstPropLine=%d, braceLine=%d, closingLine=%d', firstPropLine, node.loc.start.line, closingLine)
+  if (firstPropLine == node.loc.start.line && closingLine == firstPropLine)
+    return
+
+  trace('ALGORITHM 2: When first property is on a line after {: must use 1 indent unit from the column where { appears')
+  trace('CHECK POINT 2: is firstPropLine (%d) != braceLine (%d)?', firstPropLine, node.loc.start.line)
+  if (firstPropLine == node.loc.start.line) {
+    // first property is on brace line
+  }
+  else if (firstPropCol == node.loc.start.column + unit(context)) {
+    // ok
+  }
+  else {
+    trace('CHECK 2 FAIL')
+    context.report({ node: firstProp, messageId: 'indentStruct' })
+  }
+
+  trace('ALGORITHM 3: Multi-line: all properties must align to first propertys column')
+  trace('CHECK POINT 3: checking property alignment, firstPropCol=%d', firstPropCol)
+  for (let i = 1; i < properties.length; i++) {
+    let prop
+
+    prop = properties[i]
+    if (prop.loc.start.column == firstPropCol) {
+      // ok
+    }
+    else {
+      trace('CHECK 3 FAIL')
+      context.report({ node: prop, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 4: } on a line following the last prop value must align with {')
+  trace('CHECK POINT 4: is closing on a line following last prop value? closingLine=%d, lastPropValueEndLine=%d', closingLine, lastPropValueEndLine)
+  if (closingLine > lastPropValueEndLine) {
+    let braceCol, closingCol
+
+    braceCol = node.loc.start.column
+    closingCol = node.loc.end.column - 1
+    trace('CHECK 4: braceCol=%d, closingCol=%d', braceCol, closingCol)
+    if (closingCol == braceCol) {
+      // ok
+    }
+    else {
+      trace('CHECK 4 FAIL')
+      context.report({ node, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 5: } on same line as last prop value must have a space before it')
+  trace('CHECK POINT 5: is closing on same line as last prop value? closingLine=%d, lastPropValueEndLine=%d', closingLine, lastPropValueEndLine)
+  if (closingLine == lastPropValueEndLine) {
+    trace('CHECK 5: lastPropEnd=%d, closingBrace=%d, afterLastProp=%j', lastPropEnd, closingBrace, afterLastProp)
+    if (afterLastProp == ' ') {
+      // ok
+    }
+    else {
+      trace('CHECK 5 FAIL')
+      context.report({ node, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 6: When a param list is on a line after the field name, it must align with the field name')
+  trace('CHECK POINT 6: checking method param alignment')
+  for (let prop of properties)
+    if (prop.method) {
+      let keyLine, keyEnd, i, newlines, parenLine
+
+      keyLine = prop.key.loc.start.line
+      keyEnd = prop.key.range[1]
+      i = keyEnd
+      newlines = 0
+
+      while (i < sourceCode.length) {
+        if (sourceCode[i] == '(')
+          break
+        if (sourceCode[i] == '\n')
+          newlines++
+        i++
+      }
+      parenLine = keyLine + newlines
+      if (parenLine > keyLine) {
+        let parenCol
+
+        parenCol = i - sourceCode.lastIndexOf('\n', i)
+        if (prop.value.type == 'FunctionExpression' && prop.value.async) {
+          // async methods can have whitespace between key and paren
+        }
+        else if (parenCol - 1 == prop.key.loc.start.column) {
+          // ok
+        }
+        else {
+          trace('CHECK 6 FAIL')
+          context.report({ node: prop, messageId: 'indentStruct' })
+        }
+      }
+    }
+}
+
+function checkObjectExpression
+(node, context) {
+  let properties
+
+  properties = node.properties
+  if (properties.length)
+    checkObjectExpressionProperties(properties, node, context)
+}
+
+function create
+(context) {
+  return { ObjectExpression: node => checkObjectExpression(node, context) }
+}
+
+export default { meta: { type: 'suggestion',
+                         docs: { description: 'Struct alignment rules.' },
+                         messages: { indentStruct: 'Indent structure' },
+                         schema: [] },
+                 create }

package/plugins/init-before-use.js

@@ -1,10 +1,10 @@
 import { buildScopeTree } from './narrowest-scope.js'
 
-let ostIdCounter, errorCount, ost
+let ostIdCounter, errorCount, $lastOst
 
 ostIdCounter = 0
 errorCount = 0
-ost = 0
+$lastOst = 0
 
 function trace
 (...args) {
@@ -15,34 +15,34 @@ function trace
 export
 function lastOst
 () {
-  return ost
+  return $lastOst
 }
 
-function createInitBeforeUse(context) {
+function createInitBeforeUse
+(context) {
   let scopeManager
 
   scopeManager = context.sourceCode.scopeManager
   if (scopeManager)
-    return {
-      'Program:exit'() {
-        let scopeToNode, astToTree, astToOst
+    return { 'Program:exit'
+             () {
+               let scopeToNode, astToTree, astToOst
 
-        errorCount = 0
-        scopeToNode = new Map
-        astToTree = new Map
-        astToOst = new Map
-        buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree)
+               errorCount = 0
+               scopeToNode = new Map
+               astToTree = new Map
+               astToOst = new Map
+               buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree)
 
-        ostIdCounter = 0
-        ost = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set())
+               ostIdCounter = 0
+               $lastOst = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set())
 
-        ostAnnotate(ost, astToOst, context)
+               ostAnnotate($lastOst, astToOst, context)
 
-        ostCheck(ost, context)
+               ostCheck($lastOst, context)
 
-        trace('ERRORS: ' + errorCount)
-      }
-    }
+               trace('ERRORS: ' + errorCount)
+             } }
 }
 
 function isRegularDeclaration
@@ -55,7 +55,8 @@ function isRegularDeclaration
   return 0
 }
 
-function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
+function processAst
+(astNode, parentOst, astToTree, astToOst, indent, visited) {
   if (astNode) {
     let treeNode, scopeName, lets, reads, writes, ost, children
 
@@ -96,17 +97,15 @@ function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
             trace(`${indent}  | WRITE ${item.name}:${item.varId}`)
           }
 
-    ost = {
-      id: ostIdCounter++,
-      astNode,
-      treeNode,
-      scopeItems: treeNode?.items ?? [],
-      lets,
-      reads,
-      writes,
-      children: [],
-      fnDefOst: null
-    }
+    ost = { id: ostIdCounter++,
+            astNode,
+            treeNode,
+            scopeItems: treeNode?.items ?? [],
+            lets,
+            reads,
+            writes,
+            children: [],
+            fnDefOst: null }
 
     astToOst.set(astNode, ost)
 
@@ -192,7 +191,8 @@ function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
   }
 }
 
-function ostAnnotate(ost, astToOst, context) {
+function ostAnnotate
+(ost, astToOst, context) {
   if (ost) {
     for (let letInfo of ost.lets) {
       let writeOst
@@ -204,11 +204,9 @@ function ostAnnotate(ost, astToOst, context) {
       if (letInfo.item.defType == 'ImportBinding')
         continue
       errorCount++
-      context.report({
-        node: letInfo.item.identifier,
-        messageId: 'mustInit',
-        data: { name: letInfo.item.name }
-      })
+      context.report({ node: letInfo.item.identifier,
+                       messageId: 'mustInit',
+                       data: { name: letInfo.item.name } })
     }
 
     if (ost.astNode.type == 'CallExpression' && ost.astNode.callee?.type == 'Identifier')
@@ -239,7 +237,8 @@ function ostAnnotate(ost, astToOst, context) {
   }
 }
 
-function findFirstWrite(ost, letInfo) {
+function findFirstWrite
+(ost, letInfo) {
   if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
     for (let child of ost.children)
       if (child.astNode.type == 'BlockStatement')
@@ -247,7 +246,8 @@ function findFirstWrite(ost, letInfo) {
   return findFirstWriteInSubtree(ost, letInfo)
 }
 
-function findFirstWriteInSubtree(ost, letInfo) {
+function findFirstWriteInSubtree
+(ost, letInfo) {
   if (ost) {
     if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
       return null
@@ -272,7 +272,8 @@ function findFirstWriteInSubtree(ost, letInfo) {
   return null
 }
 
-function ostCheck(ost, context) {
+function ostCheck
+(ost, context) {
   if (ost) {
     for (let letInfo of ost.lets)
       if (letInfo.firstWrite)
@@ -283,7 +284,8 @@ function ostCheck(ost, context) {
   }
 }
 
-function walk2Start(node, letInfo, context) {
+function walk2Start
+(node, letInfo, context) {
   if (node.astNode.type == 'FunctionDeclaration')
     for (let child of node.children)
       if (child.astNode.type == 'BlockStatement')
@@ -291,7 +293,8 @@ function walk2Start(node, letInfo, context) {
   return walk2(node, letInfo, context, new Set())
 }
 
-function walk2(node, letInfo, context, visited) {
+function walk2
+(node, letInfo, context, visited) {
   if (node) {
     if (node.astNode.type == 'FunctionDeclaration' || node.astNode.type == 'ArrowFunctionExpression' || node.astNode.type == 'FunctionExpression')
       return false
@@ -300,11 +303,9 @@ function walk2(node, letInfo, context, visited) {
       for (let readInfo of node.reads)
         if (readInfo.item.ref.resolved == letInfo.item.variable) {
           errorCount++
-          context.report({
-            node: readInfo.item.ref.identifier,
-            messageId: 'initBeforeUse',
-            data: { name: letInfo.item.name }
-          })
+          context.report({ node: readInfo.item.ref.identifier,
+                           messageId: 'initBeforeUse',
+                           data: { name: letInfo.item.name } })
         }
       return true
     }
@@ -332,11 +333,9 @@ function walk2(node, letInfo, context, visited) {
     for (let readInfo of node.reads)
       if (readInfo.item.ref.resolved == letInfo.item.variable) {
         errorCount++
-        context.report({
-          node: readInfo.item.ref.identifier,
-          messageId: 'initBeforeUse',
-          data: { name: letInfo.item.name }
-        })
+        context.report({ node: readInfo.item.ref.identifier,
+                         messageId: 'initBeforeUse',
+                         data: { name: letInfo.item.name } })
       }
 
     for (let child of node.children)
@@ -375,13 +374,9 @@ function ostString
   return ''
 }
 
-export default {
-  meta: {
-    type: 'problem',
-    docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
-    messages: { initBeforeUse: "'{{name}}' used before initialization.",
-                mustInit: "'{{name}}' must be initialized." },
-    schema: []
-  },
-  create: createInitBeforeUse
-}
+export default { meta: { type: 'problem',
+                         docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
+                         messages: { initBeforeUse: "'{{name}}' used before initialization.",
+                                     mustInit: "'{{name}}' must be initialized." },
+                         schema: [] },
+                 create: createInitBeforeUse }