@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-dupe-else-if.md

@@ -0,0 +1,113 @@
+---
+id: js/no-dupe-else-if
+title: "No two conditions in an if/else-if chain are the same"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the second condition should have been is a decision"
+stability: preview
+ported_from: [eslint/no-dupe-else-if]
+since: 0.1.0
+---
+
+Each condition in an `if … else if …` chain is different from the ones before it.
+
+**Why:** A repeated condition's branch can never run, because the earlier one already took it.
+
+```codelaw
+native: js/no-dupe-else-if
+```
+
+## How to fix
+
+1. Find the repeated condition.
+2. Correct it to the case it was meant to handle, or remove the dead branch.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```js
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```jsx
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```ts
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```tsx
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```

package/rules/js/no-dupe-keys.md

@@ -0,0 +1,66 @@
+---
+id: js/no-dupe-keys
+title: "No two keys in an object literal are the same"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "which value should win can't be known from the code"
+stability: preview
+ported_from: [eslint/no-dupe-keys]
+since: 0.1.0
+---
+
+An object literal names each key once; `a`, `'a'` and `["a"]` are the same key, as are `1` and
+`0x1`.
+
+**Why:** The later value silently replaces the earlier one.
+
+```codelaw
+native: js/no-dupe-keys
+```
+
+## How to fix
+
+1. Decide which value the key should have.
+2. Remove the other entry, or give it its own key.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const user = {
+  name: "Ada",
+  name: "Grace",
+};
+```
+
+#### Do
+
+```js
+const user = {
+  name: "Ada",
+  nickname: "Grace",
+};
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const user = {
+  name: "Ada",
+  name: "Grace",
+};
+```
+
+#### Do
+
+```jsx
+const user = {
+  name: "Ada",
+  nickname: "Grace",
+};
+```

package/rules/js/no-duplicate-case.md

@@ -0,0 +1,137 @@
+---
+id: js/no-duplicate-case
+title: "No two case labels in a switch are the same"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which label was meant is a decision"
+stability: preview
+ported_from: [eslint/no-duplicate-case]
+since: 0.1.0
+---
+
+Each `case` in a `switch` tests a different expression.
+
+**Why:** A repeated case can never match: the first one always wins.
+
+```codelaw
+native: js/no-duplicate-case
+```
+
+## How to fix
+
+1. Find the label that was meant to test something else.
+2. Correct it, or merge the two bodies.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```js
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```jsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```ts
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```tsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```

package/rules/js/no-empty-character-class.md

@@ -0,0 +1,98 @@
+---
+id: js/no-empty-character-class
+title: "No empty character classes in regular expressions"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which characters the class should hold needs the author"
+stability: preview
+ported_from: [eslint/no-empty-character-class]
+since: 0.1.0
+---
+
+A regular expression contains no empty character class `[]`; `[^]`, which matches any character, is
+fine.
+
+**Why:** `[]` matches no character at all, so the whole pattern can never match.
+
+```codelaw
+native: js/no-empty-character-class
+```
+
+## How to fix
+
+1. Put the characters the class should match inside it.
+2. If `[]` was meant literally, escape it: `\[\]`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /^abc[]/;
+```
+
+#### Do
+
+```js
+const re = /^abc[a-z]/;
+```
+
+```js
+const brackets = /^\s*[{[]/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /^abc[]/;
+```
+
+#### Do
+
+```jsx
+const re = /^abc[a-z]/;
+```
+
+```jsx
+const brackets = /^\s*[{[]/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /^abc[]/;
+```
+
+#### Do
+
+```ts
+const re = /^abc[a-z]/;
+```
+
+```ts
+const brackets = /^\s*[{[]/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /^abc[]/;
+```
+
+#### Do
+
+```tsx
+const re = /^abc[a-z]/;
+```
+
+```tsx
+const brackets = /^\s*[{[]/;
+```

package/rules/js/no-empty-pattern.md

@@ -0,0 +1,86 @@
+---
+id: js/no-empty-pattern
+title: "No empty destructuring patterns"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the pattern was meant to bind needs the author"
+stability: preview
+ported_from: [eslint/no-empty-pattern]
+since: 0.1.0
+---
+
+A destructuring pattern names at least one binding.
+
+**Why:** `const {} = obj` binds nothing; it's usually a mistyped default such as `{ a = {} }`.
+
+```codelaw
+match:
+  any:
+    - kind: object_pattern
+      regex: ^\{\s*\}$
+    - kind: array_pattern
+      regex: ^\[\s*\]$
+message: "This destructuring pattern binds nothing"
+```
+
+## How to fix
+
+1. Name the properties to bind inside the pattern, or remove it.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const { a: {} } = options;
+```
+
+#### Do
+
+```js
+const { a = {} } = options;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const { a: {} } = options;
+```
+
+#### Do
+
+```jsx
+const { a = {} } = options;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const { a: {} } = options;
+```
+
+#### Do
+
+```ts
+const { a = {} } = options;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const { a: {} } = options;
+```
+
+#### Do
+
+```tsx
+const { a = {} } = options;
+```

package/rules/js/no-empty-static-block.md

@@ -0,0 +1,99 @@
+---
+id: js/no-empty-static-block
+title: "No empty static blocks"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-empty-static-block]
+since: 0.1.0
+---
+
+A class has no empty `static { }` block.
+
+**Why:** An empty static block does nothing; it is leftover or unfinished code.
+
+```codelaw
+match:
+  kind: class_static_block
+  regex: ^static\s*\{\s*\}$
+message: "Empty static block"
+fix: [remove]
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```js
+class Config {
+  load() {}
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```jsx
+class Config {
+  load() {}
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```ts
+class Config {
+  load() {}
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```tsx
+class Config {
+  load() {}
+}
+```

package/rules/js/no-empty.md

@@ -0,0 +1,116 @@
+---
+id: js/no-empty
+title: "No empty blocks"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to fill the block, remove it or document it needs the author"
+stability: preview
+ported_from: [eslint/no-empty]
+since: 0.1.0
+---
+
+A block or `switch` has at least one statement, or a comment saying why it is empty. Function bodies
+may be empty.
+
+**Why:** An empty block is usually unfinished code, and an empty `catch` hides errors.
+
+```codelaw
+match:
+  any:
+    - kind: statement_block
+      regex: ^\{\s*\}$
+      not:
+        inside:
+          stopBy: neighbor
+          any: [{kind: function_declaration}, {kind: function_expression}, {kind: arrow_function}, {kind: method_definition}, {kind: generator_function_declaration}, {kind: generator_function}, { kind: class_static_block }]
+    - kind: switch_statement
+      has: { field: body, regex: '^\{\s*\}$' }
+message: "Empty block; remove it or say why it's empty"
+```
+
+## How to fix
+
+1. If the block is unfinished, write its code.
+2. If it's meant to be empty, put a comment in it saying why.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```js
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```jsx
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```ts
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```tsx
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```