@putout/printer 1.7.3 → 1.8.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.26, v1.8.0
+
+feature:
+- 14f4f82 @putout/printer: add support of SwitchStatement
+
+2023.03.26, v1.7.4
+
+feature:
+- 81adee2 @putout/printer: add newline before comment
+
 2023.03.24, v1.7.3
 
 feature:

package/lib/print-tokens/cook.js

@@ -26,4 +26,3 @@ module.exports.cook = (tokens) => {
     
     return cookedTokens;
 };
-

package/lib/tokenize/comments.js

@@ -1,16 +1,24 @@
 'use strict';
 
-module.exports.parseComments = (path, {print}) => {
+const {isFirst} = require('./is');
+const {markBefore} = require('./mark');
+
+module.exports.parseComments = (path, {print, indent, maybe}) => {
     const {leadingComments} = path.node;
     
     if (leadingComments)
-        parseLeadingComments(path, {print});
+        parseLeadingComments(path, {print, indent, maybe});
 };
 
-function parseLeadingComments(path, {print}) {
+function parseLeadingComments(path, {print, indent}) {
     const {leadingComments} = path.node;
     
+    if (shouldAddNewlineBefore(path))
+        print.linebreak();
+    
     for (const {type, value} of leadingComments) {
+        indent();
+        
         if (type === 'CommentLine') {
             print(`//${value}`);
             print.newline();
@@ -19,7 +27,18 @@ function parseLeadingComments(path, {print}) {
         
         if (type === 'CommentBlock') {
             print(`/*${value}*/`);
+            
+            if (path.isStatement()) {
+                print.newline();
+                markBefore(path);
+            }
+            
             continue;
         }
     }
 }
+
+function shouldAddNewlineBefore(path) {
+    return path.isStatement() && !isFirst(path);
+}
+

package/lib/tokenize/debug.js

@@ -2,7 +2,8 @@
 
 const {TYPES} = require('../types');
 const toSnakeCase = require('just-snake-case');
-const {DEBUG} = process.env;
+const {LOG, DEBUG} = process.env;
+const {codeFrameColumns} = require('@babel/code-frame');
 
 module.exports.createDebug = (tokens) => (a) => {
     if (!DEBUG)
@@ -13,3 +14,34 @@ module.exports.createDebug = (tokens) => (a) => {
         value: `/*__${toSnakeCase(a)}*/`,
     });
 };
+
+module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => (chunk) => {
+    if (!LOG)
+        return;
+    
+    if (chunk === newline) {
+        console.log(codeFrameColumns(store(), {}, {
+            highlightCode: true,
+        }));
+        return;
+    }
+    
+    store(chunk);
+};
+
+function createStore() {
+    let chunks = [];
+    
+    return (chunk) => {
+        if (chunk) {
+            chunks.push(chunk);
+            return;
+        }
+        
+        const result = chunks.join('');
+        chunks = [];
+        
+        return result;
+    };
+}
+

package/lib/tokenize/expressions/call-expression.js

@@ -20,8 +20,9 @@ module.exports.CallExpression = CallExpression;
 function CallExpression(path, {indent, print, maybe}) {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
-    if (isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath))
+    if (isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath)) {
         print.breakline();
+    }
     
     print('__callee');
     print('(');

package/lib/tokenize/statements/block-statement.js

@@ -26,9 +26,9 @@ module.exports.BlockStatement = (path, {indent, maybe, print}) => {
         print(',');
     }
     
-    const shouldAddNewLine = isAddNewLineAfter(path);
+    const shouldAddNewline = isAddNewLineAfter(path);
     
-    if (shouldAddNewLine) {
+    if (shouldAddNewline) {
         print.newline();
     }
 };

package/lib/tokenize/statements/expression-statement.js

@@ -8,21 +8,19 @@ const {
 
 const {isNext} = require('../is');
 
-module.exports.ExpressionStatement = (path, {write, indent, traverse, print}) => {
-    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path) && !hasPrevNewline(path)) {
+module.exports.ExpressionStatement = (path, {indent, print}) => {
+    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewline(path) && !hasPrevNewline(path)) {
         print.breakline();
         markBefore(path);
     }
     
-    const expressionPath = path.get('expression');
-    
     indent();
-    traverse(expressionPath);
-    write(';');
-    write.newline();
+    print('__expression');
+    print(';');
+    print.newline();
     
     if (isStrictMode(path) || isCoupleLinesExpression(path) && isNext(path)) {
-        write.newline();
+        print.newline();
         markAfter(path);
     }
 };
@@ -49,7 +47,7 @@ function isFirst(path) {
     return path.node === path.parentPath.node.body[0];
 }
 
-function shouldAddNewLine(path) {
+function shouldAddNewline(path) {
     const prev = path.getPrevSibling();
     
     if (prev.isVariableDeclaration())

package/lib/tokenize/statements/for-of-statement.js

@@ -1,6 +1,10 @@
 'use strict';
 
-const {hasPrevNewline, markAfter} = require('../mark');
+const {
+    hasPrevNewline,
+    markAfter,
+    markBefore,
+} = require('../mark');
 
 const {isFirst} = require('../is');
 
@@ -8,6 +12,7 @@ module.exports.ForOfStatement = (path, {indent, print}) => {
     if (!isFirst(path) && !hasPrevNewline(path)) {
         print.indent();
         print.newline();
+        markBefore(path);
     }
     
     indent();
@@ -22,7 +27,7 @@ module.exports.ForOfStatement = (path, {indent, print}) => {
     if (bodyPath.isExpressionStatement()) {
         indent.inc();
         print.newline();
-        print(bodyPath);
+        print('__body');
         indent.dec();
         print.newline();
         
@@ -31,7 +36,7 @@ module.exports.ForOfStatement = (path, {indent, print}) => {
     
     if (bodyPath.isBlockStatement()) {
         print(' ');
-        print(bodyPath);
+        print('__body');
     }
     
     if (path.getNextSibling().node) {

package/lib/tokenize/statements/index.js

@@ -12,6 +12,7 @@ const {ForStatement} = require('./for-statement');
 const importDeclarations = require('./import-declarations');
 const exportDeclarations = require('./export-declarations');
 const {WhileStatement} = require('./while-statement');
+const {SwitchStatement} = require('./switch-statement');
 
 module.exports = {
     ...importDeclarations,
@@ -27,6 +28,7 @@ module.exports = {
     Program(path, {traverse}) {
         path.get('body').forEach(traverse);
     },
+    SwitchStatement,
     ...TryStatements,
     BreakStatement(path, {print, indent}) {
         indent();

package/lib/tokenize/statements/switch-statement.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const {entries} = Object;
+
+module.exports.SwitchStatement = (path, {print, maybe}) => {
+    print('switch');
+    print.space();
+    print('(');
+    print('__discriminant');
+    print(') {');
+    
+    print.newline();
+    
+    const cases = path.get('cases');
+    const n = cases.length - 1;
+    
+    for (const [index, switchCase] of entries(cases)) {
+        print('case');
+        print.space();
+        print(switchCase.get('test'));
+        print(':');
+        
+        const isBlock = switchCase.get('consequent.0').isBlockStatement();
+        
+        maybe.indent.inc(!isBlock);
+        maybe.print.newline(!isBlock);
+        
+        for (const consequent of switchCase.get('consequent')) {
+            if (!consequent.isBlockStatement()) {
+                print(consequent);
+                continue;
+            }
+            
+            print.space();
+            print(consequent);
+        }
+        
+        if (index < n) {
+            print.indent();
+            maybe.indent.dec(!isBlock);
+            print.newline();
+        }
+    }
+    
+    print('}');
+};
+

package/lib/tokenize/statements/variable-declaration.js

@@ -9,19 +9,9 @@ const {
     markAfter,
 } = require('../mark');
 
-const isNextAssign = (path) => {
-    const nextPath = path.getNextSibling();
-    
-    if (!nextPath.isExpressionStatement())
-        return false;
-    
-    return nextPath.get('expression').isAssignmentExpression();
-};
-
 module.exports.VariableDeclaration = (path, {maybe, print}) => {
-    if (!isFirst(path) && isNewLineBefore(path) && !hasPrevNewline(path)) {
+    if (shouldAddNewlineBefore(path))
         print.breakline();
-    }
     
     const isParentBlock = /Program|BlockStatement/.test(path.parentPath.type);
     
@@ -36,7 +26,7 @@ module.exports.VariableDeclaration = (path, {maybe, print}) => {
     maybe.print(isParentBlock, ';');
     maybe.print.newline(isParentBlock);
     
-    const is = shouldAddNewLineAfter(path);
+    const is = shouldAddNewlineAfter(path);
     
     if (is) {
         print.linebreak();
@@ -44,7 +34,7 @@ module.exports.VariableDeclaration = (path, {maybe, print}) => {
     }
 };
 
-function shouldAddNewLineAfter(path) {
+function shouldAddNewlineAfter(path) {
     if (isLast(path))
         return true;
     
@@ -65,13 +55,19 @@ function shouldAddNewLineAfter(path) {
 
 const isLast = (path) => path.parentPath.isProgram() && !isNext(path);
 
-function isNewLineBefore(path) {
-    const prevPath = path.getPrevSibling();
+function shouldAddNewlineBefore(path) {
+    if (isFirst(path))
+        return false;
     
-    if (prevPath.isStatement() && !prevPath.isExpressionStatement() && !prevPath.isBlockStatement())
+    if (hasPrevNewline(path))
         return false;
     
-    if (prevPath.isExpressionStatement() && prevPath.get('expression').isStringLiteral())
+    if (hasPrevNewline(path.parentPath))
+        return false;
+    
+    const prevPath = path.getPrevSibling();
+    
+    if (prevPath.isStatement() && !prevPath.isExpressionStatement() && !prevPath.isBlockStatement())
         return false;
     
     if (isCoupleLines(path))
@@ -90,3 +86,12 @@ function isNewLineBefore(path) {
 function isFirst(path) {
     return path.node === path.parentPath.node.body[0];
 }
+const isNextAssign = (path) => {
+    const nextPath = path.getNextSibling();
+    
+    if (!nextPath.isExpressionStatement())
+        return false;
+    
+    return nextPath.get('expression').isAssignmentExpression();
+};
+

package/lib/tokenize/tokenize.js

@@ -6,7 +6,7 @@ const expressions = require('./expressions');
 const statements = require('./statements');
 const literals = require('./literals');
 const {TYPES} = require('../types');
-const {createDebug} = require('./debug');
+const {createDebug, createLog} = require('./debug');
 
 const {
     maybeMarkAfter,
@@ -33,13 +33,24 @@ function initFormat(format) {
     };
 }
 
+const createAddToken = (tokens) => {
+    const log = createLog();
+    return (token) => {
+        const {value} = token;
+        
+        log(value);
+        tokens.push(token);
+    };
+};
+
 module.exports.tokenize = (ast, overrides = {}) => {
     const format = initFormat(overrides.format);
     const tokens = [];
+    const addToken = createAddToken(tokens);
     const debug = createDebug(tokens);
     
     const write = (value) => {
-        tokens.push({
+        addToken({
             type: TYPES.TOKEN,
             value,
         });
@@ -55,7 +66,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
     const decIndent = () => --i;
     
     const indent = () => {
-        tokens.push({
+        addToken({
             type: TYPES.INDENT,
             value: printIndent(i, format.indent),
         });
@@ -67,21 +78,28 @@ module.exports.tokenize = (ast, overrides = {}) => {
     });
     
     const linebreak = () => {
-        tokens.push({
+        addToken({
             type: TYPES.NEWLINE,
             value: `${printIndent(i, format.indent)}\n`,
         });
     };
     
+    const space = () => {
+        addToken({
+            type: TYPES.SPACE,
+            value: ' ',
+        });
+    };
+    
     const breakline = () => {
-        tokens.push({
+        addToken({
             type: TYPES.NEWLINE,
             value: `\n${printIndent(i, format.indent)}`,
         });
     };
     
     const newline = () => {
-        tokens.push({
+        addToken({
             type: TYPES.NEWLINE,
             value: '\n',
         });
@@ -106,12 +124,9 @@ module.exports.tokenize = (ast, overrides = {}) => {
     });
     
     const printer = {
-        incIndent,
-        decIndent,
         indent,
         write,
         debug,
-        maybeIndent,
         traverse,
         maybe,
     };
@@ -140,7 +155,9 @@ module.exports.tokenize = (ast, overrides = {}) => {
             traverse,
         });
         
-        assign(print, write);
+        assign(print, write, {
+            space,
+        });
         
         assign(printer, {
             print,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",
@@ -26,6 +26,7 @@
     "report": "madrun report"
   },
   "dependencies": {
+    "@babel/code-frame": "^7.18.6",
     "@babel/parser": "^7.19.0",
     "@babel/traverse": "^7.21.2",
     "@babel/types": "^7.21.3",