Manageable printing Rules (#121)

* separate node types into files

* s/reduce/map

* map reduce no more

* s/const/function

* s/try...catch/if...else

* 🤦

* __dirname

* fix bad merge

* moar nodes

* update dir-to-object

* update nodes

* The logic of each rule has remained unchanged. It was only split in smaller and more manageable files.

* Following linting rules

* removing unused vars

* disabling operator-linebreak and implicit-arrow-linebreak that conflicted with prettier.js

* bump version

Author: Janther

__tests__/nodes/__snapshots__/index.test.js.snap

@@ -0,0 +1,65 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`nodes list to match snapshot 1`] = `
+Array [
+  "ArrayTypeName",
+  "AssemblyAssignment",
+  "AssemblyBlock",
+  "AssemblyCall",
+  "AssemblyCase",
+  "AssemblyFor",
+  "AssemblyIf",
+  "AssemblyLocalDefinition",
+  "AssemblySwitch",
+  "BinaryOperation",
+  "Block",
+  "BooleanLiteral",
+  "BreakStatement",
+  "Conditional",
+  "ContinueStatement",
+  "ContractDefinition",
+  "DecimalNumber",
+  "ElementaryTypeName",
+  "ElementaryTypeNameExpression",
+  "EmitStatement",
+  "EnumDefinition",
+  "EnumValue",
+  "EventDefinition",
+  "ExpressionStatement",
+  "ForStatement",
+  "FunctionCall",
+  "FunctionDefinition",
+  "FunctionTypeName",
+  "HexLiteral",
+  "HexNumber",
+  "Identifier",
+  "IfStatement",
+  "ImportDirective",
+  "IndexAccess",
+  "InheritanceSpecifier",
+  "InlineAssemblyStatement",
+  "LabelDefinition",
+  "Mapping",
+  "MemberAccess",
+  "ModifierDefinition",
+  "ModifierInvocation",
+  "NewExpression",
+  "NumberLiteral",
+  "Parameter",
+  "ParameterList",
+  "PragmaDirective",
+  "ReturnStatement",
+  "SourceUnit",
+  "StateVariableDeclaration",
+  "StringLiteral",
+  "StructDefinition",
+  "ThrowStatement",
+  "TupleExpression",
+  "UnaryOperation",
+  "UserDefinedTypeName",
+  "UsingForDeclaration",
+  "VariableDeclaration",
+  "VariableDeclarationStatement",
+  "WhileStatement",
+]
+`;

__tests__/nodes/index.test.js

@@ -0,0 +1,5 @@
+const nodes = require('../../src/nodes');
+
+test('nodes list to match snapshot', () => {
+  expect(Object.keys(nodes)).toMatchSnapshot();
+});

package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-solidity",
-  "version": "1.0.0-alpha.18",
+  "version": "1.0.0-alpha.19",
   "description": "prettier plugin for solidity",
   "main": "src",
   "scripts": {
@@ -59,6 +59,7 @@
     "jest-watch-typeahead": "^0.2.0"
   },
   "dependencies": {
+    "dir-to-object": "^2.0.0",
     "emoji-regex": "^7.0.3",
     "escape-string-regexp": "^1.0.5",
     "extract-comments": "^1.1.0",

src/clean.js

@@ -1,8 +1,8 @@
 // eslint-disable-next-line no-unused-vars
-const clean = (ast, newObj, parent) => {
+function clean(ast, newObj, parent) {
   ['code', 'codeStart', 'loc', 'range'].forEach(name => {
     delete newObj[name]; // eslint-disable-line no-param-reassign
   });
-};
+}
 
 module.exports = clean;

src/loc.js

@@ -1,14 +1,14 @@
 // see: https://github.com/prettier/prettier/blob/master/src/language-js/loc.js
 
-const getRange = (index, node) => {
+function getRange(index, node) {
   if (node.range) {
     return node.range[index];
   }
   if (node.expression.range) {
     return node.expression.range[index];
   }
   return null;
-};
+}
 
 module.exports = {
   locEnd: node => getRange(1, node),

src/nodes/ArrayTypeName.js

@@ -0,0 +1,27 @@
+/* eslint-disable operator-linebreak */
+const {
+  doc: {
+    builders: { concat }
+  }
+} = require('prettier');
+
+const ArrayTypeName = {
+  print: ({ node, path, print }) => {
+    let stateMutability = '';
+    if (
+      node.baseTypeName.name === 'address' &&
+      node.baseTypeName.stateMutability
+    ) {
+      stateMutability = concat([' ', node.baseTypeName.stateMutability]);
+    }
+    return concat([
+      path.call(print, 'baseTypeName'),
+      stateMutability,
+      '[',
+      node.length ? path.call(print, 'length') : '',
+      ']'
+    ]);
+  }
+};
+
+module.exports = ArrayTypeName;

src/nodes/AssemblyAssignment.js

@@ -0,0 +1,17 @@
+/* eslint-disable implicit-arrow-linebreak */
+const {
+  doc: {
+    builders: { join }
+  }
+} = require('prettier');
+
+const AssemblyAssignment = {
+  print: ({ path, print }) =>
+    join(' ', [
+      join(', ', path.map(print, 'names')),
+      ':=',
+      path.call(print, 'expression')
+    ])
+};
+
+module.exports = AssemblyAssignment;

src/nodes/AssemblyBlock.js

@@ -0,0 +1,21 @@
+/* eslint-disable implicit-arrow-linebreak */
+const {
+  doc: {
+    builders: { concat, hardline, indent }
+  }
+} = require('prettier');
+
+const printPreservingEmptyLines = require('./print-preserving-empty-lines');
+
+const AssemblyBlock = {
+  print: ({ options, path, print }) =>
+    concat([
+      '{',
+      indent(hardline),
+      indent(printPreservingEmptyLines(path, 'operations', options, print)),
+      hardline,
+      '}'
+    ])
+};
+
+module.exports = AssemblyBlock;

src/nodes/AssemblyCall.js

@@ -0,0 +1,31 @@
+const {
+  doc: {
+    builders: { concat, group, indent, join, line, softline }
+  }
+} = require('prettier');
+
+const AssemblyCall = {
+  print: ({ node, path, print }) => {
+    if (node.arguments.length === 0) {
+      return node.functionName;
+    }
+    return concat([
+      node.functionName,
+      '(',
+      group(
+        concat([
+          indent(
+            concat([
+              softline,
+              join(concat([',', line]), path.map(print, 'arguments'))
+            ])
+          ),
+          softline
+        ])
+      ),
+      ')'
+    ]);
+  }
+};
+
+module.exports = AssemblyCall;

src/nodes/AssemblyCase.js

@@ -0,0 +1,20 @@
+const {
+  doc: {
+    builders: { concat, join }
+  }
+} = require('prettier');
+
+const AssemblyCase = {
+  print: ({ node, path, print }) => {
+    let doc;
+
+    if (node.default) {
+      doc = concat(['default']);
+    } else {
+      doc = concat(['case ', path.call(print, 'value')]);
+    }
+    return join(' ', [doc, path.call(print, 'block')]);
+  }
+};
+
+module.exports = AssemblyCase;