Print list (#234)

* implementing printList pattern.

* Adding some edge cases

* small refactor of StructDefinition

* more cases for printList

* using options instead of multiple arguments

Author: Janther

src/nodes/AssemblyCall.js

@@ -1,31 +1,21 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line, softline }
+    builders: { concat }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 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
+  print: ({ node, path, print }) =>
+    node.arguments.length === 0
+      ? node.functionName
+      : concat([
+          node.functionName,
+          '(',
+          printList(path.map(print, 'arguments')),
+          ')'
         ])
-      ),
-      ')'
-    ]);
-  }
 };
 
 module.exports = AssemblyCall;

src/nodes/AssemblyFunctionDefinition.js

@@ -1,30 +1,34 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line, softline }
+    builders: { concat, group, indent, line }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const AssemblyFunctionDefinition = {
   print: ({ node, path, print }) =>
     concat([
       'function ',
       node.name,
       '(',
+      printList(path.map(print, 'arguments')),
+      ')',
       group(
         concat([
           indent(
             concat([
-              softline,
-              join(concat([',', line]), path.map(print, 'arguments'))
+              line,
+              '->',
+              printList(path.map(print, 'returnArguments'), {
+                firstSeparator: line,
+                lastSeparator: ''
+              })
             ])
           ),
-          softline
+          line
         ])
       ),
-      ')',
-      ' -> ',
-      join(', ', path.map(print, 'returnArguments')),
-      ' ',
       path.call(print, 'body')
     ])
 };

src/nodes/AssemblyLocalDefinition.js

@@ -1,15 +1,17 @@
 const {
   doc: {
-    builders: { join }
+    builders: { concat, line }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const AssemblyLocalDefinition = {
   print: ({ path, print }) =>
-    join(' ', [
+    concat([
       'let',
-      join(', ', path.map(print, 'names')),
-      ':=',
+      printList(path.map(print, 'names'), { firstSeparator: line }),
+      ':= ',
       path.call(print, 'expression')
     ])
 };

src/nodes/AssemblySwitch.js

@@ -1,19 +1,22 @@
 const {
   doc: {
-    builders: { concat, hardline, indent, join }
+    builders: { concat, hardline }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const AssemblySwitch = {
-  print: ({ path, print }) => {
-    const doc = join(hardline, path.map(print, 'cases'));
-    return concat([
+  print: ({ path, print }) =>
+    concat([
       'switch ',
       path.call(print, 'expression'),
-      indent(hardline),
-      indent(doc)
-    ]);
-  }
+      printList(path.map(print, 'cases'), {
+        firstSeparator: hardline,
+        separator: hardline,
+        lastSeparator: ''
+      })
+    ])
 };
 
 module.exports = AssemblySwitch;

src/nodes/CatchClause.js

@@ -1,27 +1,19 @@
 const {
   doc: {
-    builders: { concat, group, join, indent, line, softline }
+    builders: { concat, group }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const CatchClause = {
   print: ({ node, path, print }) => {
     return group(
       concat([
         'catch ',
         node.isReasonStringType ? 'Error' : '',
         '(',
-        group(
-          concat([
-            indent(
-              concat([
-                softline,
-                join(concat([',', line]), path.map(print, 'parameters'))
-              ])
-            ),
-            softline
-          ])
-        ),
+        printList(path.map(print, 'parameters')),
         ') ',
         path.call(print, 'body')
       ])

src/nodes/ContractDefinition.js

@@ -1,35 +1,28 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line }
+    builders: { concat, group, indent, line }
   }
 } = require('prettier/standalone');
+
+const printList = require('./print-list');
 const printPreservingEmptyLines = require('./print-preserving-empty-lines');
 
-const inheritance = (node, path, print) => {
-  if (node.baseContracts.length > 0) {
-    return concat([
-      ' is',
-      indent(
-        concat([
-          line,
-          join(concat([',', line]), path.map(print, 'baseContracts'))
-        ])
-      )
-    ]);
-  }
-  return '';
-};
+const inheritance = (node, path, print) =>
+  node.baseContracts.length > 0
+    ? concat([
+        ' is',
+        printList(path.map(print, 'baseContracts'), { firstSeparator: line })
+      ])
+    : line;
 
-const body = (node, path, options, print) => {
-  if (node.subNodes.length > 0) {
-    return concat([
-      indent(line),
-      indent(printPreservingEmptyLines(path, 'subNodes', options, print)),
-      line
-    ]);
-  }
-  return '';
-};
+const body = (node, path, options, print) =>
+  node.subNodes.length > 0
+    ? concat([
+        indent(line),
+        indent(printPreservingEmptyLines(path, 'subNodes', options, print)),
+        line
+      ])
+    : '';
 
 const ContractDefinition = {
   print: ({ node, options, path, print }) =>
@@ -40,7 +33,6 @@ const ContractDefinition = {
           ' ',
           node.name,
           inheritance(node, path, print),
-          line,
           '{'
         ])
       ),

src/nodes/EnumDefinition.js

@@ -1,23 +1,21 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line, softline }
+    builders: { concat, group, line, softline }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const EnumDefinition = {
   print: ({ node, path, print, options }) =>
     group(
       concat([
         'enum ',
         node.name,
         ' {',
-        indent(
-          concat([
-            options.bracketSpacing ? line : softline,
-            join(concat([',', line]), path.map(print, 'members'))
-          ])
-        ),
-        options.bracketSpacing ? line : softline,
+        printList(path.map(print, 'members'), {
+          firstSeparator: options.bracketSpacing ? line : softline
+        }),
         '}'
       ])
     )

src/nodes/EventDefinition.js

@@ -1,25 +1,15 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line, softline }
+    builders: { concat }
   }
 } = require('prettier/standalone');
 
-const parameters = (node, path, print) => {
-  if (node.parameters && node.parameters.length > 0) {
-    return group(
-      concat([
-        indent(
-          concat([
-            softline,
-            join(concat([',', line]), path.map(print, 'parameters'))
-          ])
-        ),
-        softline
-      ])
-    );
-  }
-  return '';
-};
+const printList = require('./print-list');
+
+const parameters = (node, path, print) =>
+  node.parameters && node.parameters.length > 0
+    ? printList(path.map(print, 'parameters'))
+    : '';
 
 const EventDefinition = {
   print: ({ node, path, print }) =>

src/nodes/FunctionCall.js

@@ -1,48 +1,31 @@
 const {
   doc: {
-    builders: { concat, group, indent, join, line, softline }
+    builders: { concat, group, line, softline }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const printObject = (node, path, print, options) =>
   group(
     concat([
       '{',
-      indent(
-        concat([
-          options.bracketSpacing ? line : softline,
-          join(
-            concat([',', line]),
-            path
-              .map(print, 'arguments')
-              .map((arg, index) => concat([node.names[index], ': ', arg]))
-          )
-        ])
+      printList(
+        path
+          .map(print, 'arguments')
+          .map((arg, index) => concat([node.names[index], ': ', arg])),
+        { firstSeparator: options.bracketSpacing ? line : softline }
       ),
-      options.bracketSpacing ? line : softline,
       '}'
     ])
   );
 
-const printParameters = (node, path, print) =>
-  group(
-    concat([
-      indent(
-        concat([
-          softline,
-          join(concat([',', line]), path.map(print, 'arguments'))
-        ])
-      ),
-      softline
-    ])
-  );
-
 const printArguments = (node, path, print, options) => {
   if (node.names && node.names.length > 0) {
     return printObject(node, path, print, options);
   }
   if (node.arguments && node.arguments.length > 0) {
-    return printParameters(node, path, print);
+    return printList(path.map(print, 'arguments'));
   }
   return '';
 };

src/nodes/FunctionDefinition.js

@@ -1,31 +1,21 @@
 const {
   doc: {
-    builders: { concat, dedent, group, indent, join, line, softline }
+    builders: { concat, dedent, group, indent, join, line }
   }
 } = require('prettier/standalone');
 
+const printList = require('./print-list');
+
 const functionName = node => {
   if (node.isConstructor && !node.name) return 'constructor';
   if (node.name) return `function ${node.name}`;
   return 'function';
 };
 
-const parameters = (parametersType, node, path, print) => {
-  if (node[parametersType] && node[parametersType].length > 0) {
-    return group(
-      concat([
-        indent(
-          concat([
-            softline,
-            join(concat([',', line]), path.map(print, parametersType))
-          ])
-        ),
-        softline
-      ])
-    );
-  }
-  return '';
-};
+const parameters = (parametersType, node, path, print) =>
+  node[parametersType] && node[parametersType].length > 0
+    ? printList(path.map(print, parametersType))
+    : '';
 
 const visibility = node => {
   if (node.visibility && node.visibility !== 'default') {