@cookshack/eslint-config 2.0.5 → 4.0.0

package/test/rules/fn-decl-block-start.js

@@ -0,0 +1,48 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'fnDeclBlockStart' })
+    count--
+  }
+
+  invalidCases.push({ code, errors })
+}
+
+pass('function f() { let x; function g() {} }')
+
+pass('{ function f() {} }')
+
+pass('{ let x; function f() {} }')
+
+pass('{ let x; let y; function f() {}; function g() {} }')
+
+pass('{ function f() {}; function g() {}; code() }')
+
+fail(1, 'function main2 () { let a; a = 0; function f() { return 1 } let b }')
+
+fail(1, '{ x; function f() {} }')
+
+fail(1, '{ let x; code(); function f() {} }')
+
+globalThis.describe('fn-decl-block-start',
+                    () => ruleTester.run('fn-decl-block-start',
+                                         plugins.cookshack.rules['fn-decl-block-start'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/indent-struct.js

@@ -0,0 +1,198 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  if (code == undefined) {
+    code = count
+    count = 1
+  }
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'indentStruct' })
+    count--
+  }
+  invalidCases.push({ code, errors })
+}
+
+pass('let x = { a: 1, b: 2 }')
+
+pass(`
+let x = {
+          a: 1,
+          b: 2
+        }`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }`)
+
+pass(`
+let x = {
+          a
+          () {}
+        }`)
+
+pass(`
+let x = {
+          a
+          () {},
+          b
+          () {}
+        }`)
+
+pass(`
+function f
+() {
+  return { a: 1,
+           b: 2 }
+}`)
+
+pass(`
+function f1
+() {
+  return { f1
+           () {
+             return 1
+           },
+           b: 2 }
+}`)
+
+pass(`
+function f2
+() {
+  return { a: 1,
+           f2
+           () {
+             return 2
+           } }
+}`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }  
+`)
+
+pass(`
+let x = { a: 1,
+          b: 2 } /*stuff  {, } */
+`)
+
+pass(`
+let x = { a: 1,
+          b: 2 }   /*stuff*/
+`)
+
+pass(`
+let x = { a: { a: 1,
+               b: 2 } }
+`)
+
+pass(`
+let x = { a: { a: 1,
+               b: 2 } }   ; function f(){ return 1}
+`)
+
+pass(`function create
+(context) {
+  return { VariableDeclaration
+           (node) {
+             if (node.kind == 'const' || node.kind == 'var')
+               context.report({ node, messageId: 'useLet' })
+           } }
+}`)
+
+pass(`function two
+() {
+  return { 'Program:exit'
+           () {
+             // do
+           } }
+}`)
+
+pass(`
+let x = { get a
+          () {
+            return 1
+          },
+          get b
+          () {
+            return 2
+          } }`)
+
+pass(`
+let x = { async f
+          () {
+            return 1
+          },
+          async g
+          () {
+            return 2
+          } }`)
+
+fail(2, `
+let x = {
+  a: 1,
+  b: 2
+}`)
+
+fail(1, `
+let x = {
+          a: 1,
+           b: 2
+        }`)
+
+fail(1, `
+let x = { a: 1,
+         b: 2 }`)
+
+fail(1, `
+let x = { a: 1,
+  b: 2 }`)
+
+fail(1, `
+let x = { a: 1,
+b: 2 }`)
+
+fail(2, `
+let x = { a: 1,
+  b: 2,
+  c: 3 }`)
+
+fail(1, `
+let aHasArgsOnNextLine = { a
+  () {} }`)
+
+fail(1, `
+let x = { a: 1,
+          b: 2}
+`)
+
+fail(1, `
+let x = { a: 1,
+          b: 2  }
+`)
+
+fail(1, `
+let x = { a: { a: 1,
+               b: 2  } }
+`)
+
+globalThis.describe('indent-struct',
+                    () => ruleTester.run('indent-struct',
+                                         plugins.cookshack.rules['indent-struct'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/init-before-use.js

@@ -0,0 +1,196 @@
+import { Linter } from 'eslint'
+import { plugins } from '../../index.js'
+import { lastOst, ostString } from '../../plugins/init-before-use.js'
+
+let linter, validCases, invalidCases, config
+
+linter = new Linter()
+validCases = []
+invalidCases = []
+
+config = [ { languageOptions: { ecmaVersion: 2025,
+                                sourceType: 'module' },
+             plugins,
+             rules: { 'cookshack/init-before-use': 'error' } } ]
+
+function tree
+() {
+  let out
+
+  out = ostString(lastOst())
+  if (out.length)
+    return '=== Ordered Syntax Tree ===\n' + out
+  return ''
+}
+
+function _pass
+(tc) {
+  let messages
+
+  messages = linter.verify(tc.code, config)
+  if (messages.length > 0)
+    throw new Error('unexpected errors: ' + JSON.stringify(messages, null, 2) + '\n' + tree())
+}
+
+function _fail
+(tc) {
+  let messages
+
+  messages = linter.verify(tc.code, config)
+  if (messages.length == tc.errors.length)
+    return
+  throw new Error('expected ' + tc.errors.length + ' errors, got ' + messages.length + '\n' + JSON.stringify(messages, null, 2) + '\n' + tree())
+}
+
+function fail
+(message, code) {
+  let errors
+
+  if (Array.isArray(message))
+    errors = message.map(m => ({ messageId: m }))
+  else
+    errors = [ { messageId: message } ]
+
+  invalidCases.push({ code, errors })
+}
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+pass('let x; x = 1')
+
+pass('let x = 1; x')
+
+pass('function f() { let x = 1; return x }')
+
+pass('let x; function shadow() { let x = 2; return x } function shadow2() { let x = 3; return x } x = 1')
+
+pass('for (let x in [1,2,3]) {}; let x = 1')
+
+pass(`for (let tc of validCases)
+    globalThis.it(tc.code, () => _valid(tc))
+`)
+
+pass(`for (let tc of validCases)
+    globalThis.it(tc.code, () => _valid(tc))
+  for (let tc of invalidCases)
+    globalThis.it(tc.code, () => _invalid(tc))
+`)
+
+pass('let x; let y = { x: 1 }; x = 2')
+
+pass('function x() { }')
+
+pass(`function a1
+() {
+  let p
+
+  function a2
+  () {
+    return p[p.length - 1]
+  }
+
+  p = []
+  return a2(0)
+}`)
+
+pass('let x = 1; --x')
+
+pass('let x = 1; x++')
+
+pass('let x = 1; x += 2')
+
+pass("import globals from 'globals'")
+
+pass('let x, y; y = () => { return x }; x = 1')
+
+// it's actually an err, but we'd have to track assignments
+pass('let x, y; y = () => { return x }; y(); x = 1')
+
+pass('let i; for (i = addr; i < end; i++) {}')
+
+pass('for (let i = 0; i < 16; i++) { }')
+
+pass(`
+  for (let count = 0, i = 0; i < Ed.ctags.length; i++)
+    if (Ed.ctags[i].name.startsWith(word.text)) {
+      options.push({ label: Ed.ctags[i].name, type: Ed.ctags[i].kind })
+      if (count++ > 10)
+        break
+    }
+`)
+
+pass(`
+function equal
+() {
+  let two
+
+  function run
+  () {
+    console.log(two)
+  }
+
+  function open
+  () {
+    // the point is to test if this will accidentally be first write of two
+    two = 0
+  }
+
+  if (globalThis.x) {
+    two = 1
+    run()
+  }
+}`)
+
+fail('mustInit', 'let x')
+
+fail('initBeforeUse', 'x; let x = 1')
+
+fail('initBeforeUse', 'f(); let f = () => {}')
+
+fail('mustInit', 'console.log(x); let x')
+
+fail([ 'initBeforeUse', 'initBeforeUse' ], 'x; y; let x = 1; let y = 2')
+
+fail('initBeforeUse', 'for (x in [1,2,3]) {}; let x = 1')
+
+fail('mustInit', 'for (x in [1,2,3]) {}; let x')
+
+fail('initBeforeUse', 'let x = f(); function f() { return x }')
+
+fail('initBeforeUse', `function outer
+(arg) {
+  let p
+
+  function inner
+  () {
+    p.focus()
+  }
+
+  if (arg) {
+    inner()
+    return
+  }
+
+  p = get()
+  inner()
+}`)
+
+fail('initBeforeUse', 'let x; x = f(x)')
+
+fail('initBeforeUse', 'let x = 0; function shadow(y) { let x; x = shadow2(x) + y; return x } function shadow2(y) { let x = 3 + y; return x } shadow(x)')
+
+fail('initBeforeUse', 'let x; --x')
+
+fail('initBeforeUse', 'let x; x++')
+
+fail('initBeforeUse', 'let x; x += 2')
+
+globalThis.describe('init-before-use', () => {
+  for (let tc of validCases)
+    globalThis.it(tc.code, () => _pass(tc))
+  for (let tc of invalidCases)
+    globalThis.it(tc.code, () => _fail(tc))
+})

package/test/rules/narrowest-scope.js

@@ -13,16 +13,19 @@ config = [ { languageOptions: { ecmaVersion: 2025,
              plugins,
              rules: { 'cookshack/narrowest-scope': 'error' } } ]
 
-function pass(code, expected) {
+function pass
+(code, expected) {
   validCases.push({ code, expected })
 }
 
-function patch(expected, output) {
+function patch
+(expected, output) {
   return diffLines(expected.trim(), output.trim()).flatMap(p => p.value.split('\n').filter(l => l).map(l => ({ ...p, line: l })))
     .map(p => (p.removed ? '- ' : p.added ? '+ ' : '  ') + p.line).join('\n')
 }
 
-function _pass(tc) {
+function _pass
+(tc) {
   let messages, output
 
   messages = linter.verify(tc.code, config)
@@ -34,7 +37,8 @@ function _pass(tc) {
   throw new Error('output mismatch:\n' + patch(tc.expected, output))
 }
 
-function _fail(tc) {
+function _fail
+(tc) {
   let messages, output
 
   messages = linter.verify(tc.code, config)
@@ -47,7 +51,8 @@ function _fail(tc) {
   throw new Error('expected ' + tc.errors.length + ' errors, got ' + messages.length + '\n' + JSON.stringify(messages, null, 2))
 }
 
-function fail(count, code, expected) {
+function fail
+(count, code, expected) {
   let errors
 
   errors = []
@@ -472,6 +477,30 @@ function add
       READ  Map     pos 75
       WRITE classCache     pos 80.4`)
 
+pass(`function a1
+() {
+  let p
+
+  function a2
+  () {
+    return p[p.length - 1]
+  }
+
+  p = []
+  return a2(0)
+}`,
+     `SCOPE 1 GLOBAL pos 0
+  SCOPE 1.1 MODULE pos 0
+    LET   a1     pos 9
+    SCOPE 1.1.1 FUNCTION pos 11 name a1
+      LET   p     pos 23
+      LET   a2     pos 37
+      SCOPE 1.1.1.1 FUNCTION pos 39 name a2
+        READ  p     pos 58
+        READ  p     pos 60
+      WRITE p     pos 87.4
+      READ  a2     pos 97`)
+
 fail(1, 'let x = 1; function foo() { return x }',
      `SCOPE 1 GLOBAL pos 0
   SCOPE 1.1 MODULE pos 0
@@ -538,12 +567,14 @@ function f
         READ  b     pos 115
         SCOPE 1.1.1.1.1 FUNCTION pos 125
           LET   d     pos 125
+          READ  c1     pos 138
           READ  d     pos 144
           WRITE c1     pos 145.4
         READ  c1     pos 164
       SCOPE 1.1.1.2 BLOCK pos 174
         READ  ok     pos 185
         WRITE c2     pos 187.4
+        READ  c2     pos 192
         READ  ok     pos 198
         READ  ok     pos 203
         WRITE c2     pos 205.4

package/test/rules/use-risky-equal.js

@@ -0,0 +1,42 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'risky' })
+    count--
+  }
+
+  invalidCases.push({ code, errors })
+}
+
+pass('if (x == y) { }')
+
+pass('if (x != y) { }')
+
+pass('if (x !== y) { }')
+
+fail(1, 'if (x === y) { }')
+
+fail(2, 'if (x === y || a === y || a > 4) { }')
+
+globalThis.describe('use-risky-equal',
+                    () => ruleTester.run('use-risky-equal',
+                                         plugins.cookshack.rules['use-risky-equal'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/var-decl-block-start.js

@@ -0,0 +1,108 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'varDeclBlockStart' })
+    count--
+  }
+
+  invalidCases.push({ code, errors })
+}
+
+pass('let x = 1')
+
+pass('var x = 1')
+
+pass('const x = 1')
+
+pass('{ let x = 1 }')
+
+pass('{ var x = 1 }')
+
+pass('{ const x = 1 }')
+
+pass('{ let x = 1; let y = 2 }')
+
+pass('{ let x, y }')
+
+pass('{ let x; let y }')
+
+pass('for (let i = 0; i < 10; i++) { }')
+
+pass('for (var i = 0; i < 10; i++) { }')
+
+pass('for (const i = 0; i < 10; i++) { }')
+
+pass('for (let x of arr) { }')
+
+pass('for (let x in obj) { }')
+
+pass('for (var x in obj) { }')
+
+pass('try { } catch (err) { }')
+
+pass('function f() { let x }')
+
+pass('function f() { var x }')
+
+pass('function f() { const x = 1 }')
+
+pass('{ { let x } }')
+
+pass('{ { let x; let y } }')
+
+fail(1, 'if (1) { x = 1; let y = 2 }')
+
+fail(1, 'if (1) { x = 1; var y = 2 }')
+
+fail(1, 'if (1) { x = 1; const y = 2 }')
+
+fail(2, 'if (1) { x = 1; let y = 2; let z = 3 }')
+
+fail(1, '{ x = 1; let y = 2 }')
+
+fail(1, '{ x = 1; var y = 2 }')
+
+fail(1, '{ x = 1; const y = 2 }')
+
+fail(1, 'function f() { x = 1; let y = 2 }')
+
+fail(1, 'function f() { x = 1; var y = 2 }')
+
+fail(1, 'function f() { x = 1; const y = 2 }')
+
+fail(1, '{ { x = 1; let y = 2 } }')
+
+fail(1, 'if (1) { if (2) { x = 1; let y = 2 } }')
+
+fail(1, 'while (1) { x = 1; let y = 2 }')
+
+fail(1, 'for (let i = 0; i < 10; i++) { x = 1; let y = 2 }')
+
+fail(1, '{ function f() {}; let x }')
+
+fail(2, '{ function f() {}; let x; let y }')
+
+fail(1, '{ function f() {}; function g() {}; let x }')
+
+globalThis.describe('var-decl-block-start',
+                    () => ruleTester.run('var-decl-block-start',
+                                         plugins.cookshack.rules['var-decl-block-start'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))