cleanup and passing tests

Author: Janther

src/binary-operator-printers/addition.js

@@ -1,4 +1,4 @@
-import { defaultBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { defaultBinaryOperationPrinter } from './printers/default-binary-operation-printer.js';
 
 export const addition = {
   match: (op) => ['+', '-'].includes(op),

src/binary-operator-printers/bit.js

@@ -1,4 +1,4 @@
-import { defaultBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { defaultBinaryOperationPrinter } from './printers/default-binary-operation-printer.js';
 
 export const bit = {
   match: (op) => ['&', '|', '^'].includes(op),

src/binary-operator-printers/equality.js

@@ -1,11 +1,13 @@
-import {
-  createComparisonOperationPrinter,
-  createIndentIfNecessaryBuilder
-} from './printers/create-comparison-operation-printer.js';
+import { doc } from 'prettier';
+import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { createComparisonIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
 import { logical } from './logical.js';
 
-const equalityPrinter = createComparisonOperationPrinter(
-  createIndentIfNecessaryBuilder([logical])
+const { group } = doc.builders;
+
+const equalityPrinter = createBinaryOperationPrinter(
+  () => (document) => group(document), // always group
+  createComparisonIndentIfNecessaryBuilder([logical])
 );
 
 export const equality = {

src/binary-operator-printers/exponentiation.js

@@ -1,8 +1,6 @@
 import { doc } from 'prettier';
-import {
-  createBinaryOperationPrinter,
-  createIndentIfNecessaryBuilder
-} from './printers/create-binary-operation-printer.js';
+import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { createArithmeticIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
 import { addition } from './addition.js';
 import { equality } from './equality.js';
 import { inequality } from './inequality.js';
@@ -12,7 +10,7 @@ const { group } = doc.builders;
 
 const exponentiationPrinter = createBinaryOperationPrinter(
   () => (document) => group(document), // always group
-  createIndentIfNecessaryBuilder([
+  createArithmeticIndentIfNecessaryBuilder([
     addition,
     equality,
     inequality,

src/binary-operator-printers/inequality.js

@@ -1,12 +1,14 @@
-import {
-  createComparisonOperationPrinter,
-  createIndentIfNecessaryBuilder
-} from './printers/create-comparison-operation-printer.js';
+import { doc } from 'prettier';
+import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { createComparisonIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
 import { logical } from './logical.js';
 import { equality } from './equality.js';
 
-const inequalityPrinter = createComparisonOperationPrinter(
-  createIndentIfNecessaryBuilder([logical, equality])
+const { group } = doc.builders;
+
+const inequalityPrinter = createBinaryOperationPrinter(
+  () => (document) => group(document), // always group
+  createComparisonIndentIfNecessaryBuilder([logical, equality])
 );
 
 export const inequality = {

src/binary-operator-printers/multiplication.js

@@ -1,8 +1,6 @@
-import {
-  createBinaryOperationPrinter,
-  createGroupIfNecessaryBuilder,
-  createIndentIfNecessaryBuilder
-} from './printers/create-binary-operation-printer.js';
+import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { createArithmeticGroupIfNecessaryBuilder } from './printers/create-group-if-necessary-builder.js';
+import { createArithmeticIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
 import { addition } from './addition.js';
 import { bit } from './bit.js';
 import { equality } from './equality.js';
@@ -12,8 +10,8 @@ import { shift } from './shift.js';
 const matchers = [addition, bit, equality, inequality, shift];
 
 const multiplicationPrinter = createBinaryOperationPrinter(
-  createGroupIfNecessaryBuilder(matchers),
-  createIndentIfNecessaryBuilder(matchers)
+  createArithmeticGroupIfNecessaryBuilder(matchers),
+  createArithmeticIndentIfNecessaryBuilder(matchers)
 );
 
 export const multiplication = {

src/binary-operator-printers/printers/create-binary-operation-printer.js

@@ -1,32 +1,5 @@
-import { doc } from 'prettier';
-import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js';
-import { equality } from '../equality.js';
-import { inequality } from '../inequality.js';
 import { rightOperandPrinter } from './right-operand-printer.js';
 
-const { group, indent } = doc.builders;
-
-const comparisonMatchers = [equality, inequality];
-
-export const createGroupIfNecessaryBuilder =
-  (matchers) => (path) => (document) => {
-    const parentNode = path.getParentNode();
-    if (shouldGroupOrIndent(parentNode, matchers)) return group(document);
-    return document;
-  };
-
-export const createIndentIfNecessaryBuilder =
-  (matchers) => (path) => (document) => {
-    let node = path.getNode();
-    for (let i = 0; ; i += 1) {
-      const parentNode = path.getParentNode(i);
-      if (parentNode.type === 'ReturnStatement') return document;
-      if (shouldGroupOrIndent(parentNode, matchers)) return indent(document);
-      if (node === parentNode.right) return document;
-      node = parentNode;
-    }
-  };
-
 export const createBinaryOperationPrinter =
   (groupIfNecessaryBuilder, indentIfNecessaryBuilder) =>
   (node, path, print, options) => {
@@ -38,8 +11,3 @@ export const createBinaryOperationPrinter =
       indentIfNecessary(rightOperandPrinter(node, path, print, options))
     ]);
   };
-
-export const defaultBinaryOperationPrinter = createBinaryOperationPrinter(
-  createGroupIfNecessaryBuilder(comparisonMatchers),
-  createIndentIfNecessaryBuilder(comparisonMatchers)
-);

src/binary-operator-printers/printers/create-comparison-operation-printer.js

@@ -0,0 +1,11 @@
+import { doc } from 'prettier';
+import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js';
+
+const { group } = doc.builders;
+
+export const createArithmeticGroupIfNecessaryBuilder =
+  (matchers) => (path) => (document) => {
+    const parentNode = path.getParentNode();
+    if (shouldGroupOrIndent(parentNode, matchers)) return group(document);
+    return document;
+  };

src/binary-operator-printers/printers/create-group-if-necessary-builder.js

@@ -0,0 +1,28 @@
+import { doc } from 'prettier';
+import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js';
+
+const { indent } = doc.builders;
+
+const createIndentIfNecessaryBuilder =
+  (notIndentParentTypes) => (shouldIndentMatchers) => (path) => (document) => {
+    let node = path.getNode();
+    for (let i = 0; ; i += 1) {
+      const parentNode = path.getParentNode(i);
+      if (notIndentParentTypes.includes(parentNode.type)) return document;
+      if (shouldGroupOrIndent(parentNode, shouldIndentMatchers))
+        return indent(document);
+      if (node === parentNode.right) return document;
+      node = parentNode;
+    }
+  };
+
+export const createArithmeticIndentIfNecessaryBuilder =
+  createIndentIfNecessaryBuilder(['ReturnStatement']);
+
+export const createComparisonIndentIfNecessaryBuilder =
+  createIndentIfNecessaryBuilder([
+    'ReturnStatement',
+    'IfStatement',
+    'ForStatement',
+    'WhileStatement'
+  ]);