prettify-bru 0.1.9 → 0.1.10

package/README.md

@@ -1,11 +1,33 @@
-# Prettify Bru Files
+# Prettify Bruno Bru Files
+
+A simple CLI tool to prettify the contents of `.bru` files.
+
+## Installation
 
 To install in your project, run:
 
-`npm i prettify-bru`
+```
+npm i prettify-bru
+```
+
+Boom, now you can get a non-destructive report of all the incorrect formatting by running:
+
+```
+npx prettify-bru
+```
+
+The above command will walk subdirectories, finding all `.bru` files. 
+With each file it will assess the formatting of the JSON/JavsScript inside the following types of block:
+
+- `body:json` will be parsed with the JSON parser
+- `script:pre-request` blocks parsed with Babel
+- `script:post-request` blocks parsed with Babel
+- `tests` blocks parsed with Babel
 
-Boom, now you're ready you can run:
+To actually **modify** the files, I recommend committing your changes before doing this, run the command with the `--write` flag:
 
-`npx prettify-bru -d .`
+```
+npx prettify-bru --write
+```
 
-The above command will sweep through all directories looking to `.bru` files and it will find any `body:json` blocks and prettify the JSON inside.
+⚠️ This will modify the files in place, use with caution.

package/cli.js

@@ -1,36 +1,43 @@
 #!/usr/bin/env node
 
 import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { go } from './index.js';
+import {hideBin} from 'yargs/helpers';
+import {main} from './lib/main.js';
 
 const argv = yargs(hideBin(process.argv))
-.usage(`
+    .usage(`
 Usage: $0 [--write|-w] path
 
 Running the command with no arguments will modify all files
 
 `).options({
-    w: {
-      type: 'boolean',
-      default: false
-    },
-    path: {
-      default: '.',
-    },
-  })
-  .describe({
-    w: 'Write mode (Formats files in place, overwriting contents)',
-    h: 'Display the help message',
-  })
-  .boolean(['w', 'h'])
-  .help()
-  .alias('h', 'help')
-  .alias('w', 'write')
-  .parse();
+        w: {
+            type: 'boolean',
+            default: false
+        },
+        path: {
+            default: '.',
+        },
+    })
+    .describe({
+        w: 'Write mode (Formats files in place, overwriting contents)',
+        h: 'Display the help message',
+    })
+    .boolean(['w', 'h'])
+    .help()
+    .alias('h', 'help')
+    .alias('w', 'write')
+    .parse();
 
 if (argv.h) {
-  yargs.showHelp();
+    yargs.showHelp();
 } else {
-  go(argv.w, argv._[0]);
+    go(argv._[0], argv.w);
+}
+
+function go(path, write) {
+    main(process.cwd(), path, write).catch((err) => {
+        console.error(err);
+        process.exitCode = 1;
+    });
 }

package/lib/format.js

@@ -0,0 +1,91 @@
+/**
+ * Uses Prettier to format blocks of JSON/JavaScript
+ */
+
+import prettier from 'prettier'
+
+// This Prettier config should match what the Bruno GUI implements
+const prettierConfig = {
+    tabWidth: 4,
+    useTabs: false,
+    bracketSpacing: false,
+    trailingComma: "none",
+    endOfLine: "endOfLine",
+}
+
+const formattableBlocks = [
+    ['body:json', 'json'],
+    ['script:pre-request', 'babel'],
+    ['script:post-request', 'babel'],
+    ['tests', 'babel'],
+]
+
+
+export async function formatBlocks(originalContents) {
+
+    let fileOutcome = {
+        newContents: originalContents.replace(/\r\n/g, "\n"),
+        changed: false,
+        error_messages: []
+    }
+
+    let i
+    for (i in formattableBlocks) {
+        const blockOutcome = await formatBlock(fileOutcome.newContents, ...formattableBlocks[i])
+        if (blockOutcome.error_message !== null) {
+            fileOutcome.error_messages.push(blockOutcome.error_message)
+        } else if (blockOutcome.changed) {
+            fileOutcome.changed = true
+            fileOutcome.newContents = blockOutcome.fileContents;
+        }
+    }
+
+    return fileOutcome
+}
+
+async function formatBlock(fileContents, blockName, parser) {
+
+    let outcome = {fileContents, changed: false, error_message: null};
+
+    const blockBodyRegex = new RegExp('\n' + blockName + ' [{]\\n(.+?)\\n}\\n', 's')
+    const match = fileContents.match(blockBodyRegex)
+    if (match === null) {
+        return outcome
+    }
+    const rawBody = match[1]
+
+    // Remove 2-spaces of indentation, added due to being inside a Bru lang Multimap
+    const unindented = rawBody.replace(/^  /gm, "")
+
+    let prettierFormatted;
+
+    try {
+        prettierFormatted = await prettier.format(unindented, {
+            prettierConfig,
+            parser,
+        }).then((formatted) => formatted);
+    } catch (e) {
+        outcome.error_message = `Prettier could not format ${blockName} because...\n${e.message}`;
+        return outcome
+    }
+
+    const bodyLines = prettierFormatted.split("\n");
+
+    // Remove leading/trailing empty lines
+    while (bodyLines.length && bodyLines[0].trim() === "") bodyLines.shift();
+    while (bodyLines.length && bodyLines[bodyLines.length - 1].trim() === "") bodyLines.pop();
+
+    // Indent the whole body by 2 spaces so it sits inside the Bru lang Multimap
+    const indentedLines = bodyLines.map((l) => "  " + l)
+
+    const formattedBody = indentedLines.join("\n");
+
+    if (formattedBody === rawBody) {
+        // Nothing has changed after formatting
+        return outcome
+    }
+
+    outcome.fileContents = fileContents.replace(rawBody, formattedBody)
+    outcome.changed = true
+    return outcome;
+}

package/lib/main.js

@@ -0,0 +1,108 @@
+/**
+ * Finds all .bru files and formats contents
+ */
+
+import fs from 'fs'
+import path from 'path'
+import {formatBlocks} from './format.js'
+
+/**
+ *
+ * @param cwd {String} Current working directory
+ * @param path {String}
+ * @param write {Boolean}
+ * @returns {Promise<void>}
+ */
+export async function main(cwd, path, write) {
+
+    if (path === '.') {
+        path = cwd
+    } else if (!/^\//.test(path)) {
+        // Path is absolute, do not modify
+    } else {
+        // Append the relative path to the current working directory
+        path = cwd + '/' + path
+    }
+
+    const files = [];
+
+    walkDir(path, (p) => {
+        if (p.endsWith(".bru")) files.push(p);
+    });
+
+    if (files.length === 0) {
+        console.log("No .bru files found.");
+        return;
+    }
+
+    console.log(`Found ${files.length} .bru file(s)\n`);
+
+    let changedFiles = [];
+    let erroredFiles = [];
+
+    for (const filePath of files) {
+        const outcome = await processFile(filePath);
+
+        let displayFilePath = filePath.replace(new RegExp('^' + cwd), "");
+
+        if (outcome.changed) {
+            changedFiles.push({displayFilePath, outcome});
+        } else if (outcome.error_messages.length) {
+            erroredFiles.push({displayFilePath, outcome});
+        }
+    }
+
+    if (changedFiles.length) {
+        console.log(`\x1b[4m\x1b[32mReformatted blocks in ${changedFiles.length} file(s):\x1b[0m\n`);
+        changedFiles.forEach((r) => console.log(`✏️  \x1b[32m${r.displayFilePath}\x1b[0m`));
+        console.log(" ")
+    }
+
+    if (erroredFiles.length) {
+        console.warn(`\x1b[4m\x1b[33mEncountered errors in ${erroredFiles.length} file(s):\x1b[0m\n`);
+        erroredFiles.forEach((r, i) => {
+            console.warn(`${i + 1}) ${r.displayFilePath}\n`)
+            r.outcome.error_messages.forEach((err) => {
+                console.warn(`⚠️  \x1b[33m${err}\x1b[0m\n`)
+            })
+        })
+    }
+
+    console.log(
+        `\x1b[35mProcessed ${files.length} .bru file(s).\x1b[0m Reformatted blocks in ${changedFiles.length}. Encountered errors in ${erroredFiles.length}.`
+    );
+}
+
+function walkDir(dir, onFile) {
+    // Skip node_modules by default
+    const skip = new Set(["node_modules", ".git"]);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, {withFileTypes: true});
+    } catch (e) {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (skip.has(entry.name)) continue;
+            walkDir(full, onFile);
+        } else if (entry.isFile()) {
+            onFile(full);
+        }
+    }
+}
+
+async function processFile(filePath) {
+    const original = fs.readFileSync(filePath, "utf8");
+
+    const fileOutcome = await formatBlocks(original);
+
+    if (!fileOutcome.changed) {
+        return fileOutcome
+    }
+
+    fs.writeFileSync(filePath, fileOutcome.newContents, "utf8");
+
+    return fileOutcome;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettify-bru",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Prettifies JSON and JavaScript blocks in Bruno .bru files",
   "keywords": [
     "bruno",
@@ -20,15 +20,16 @@
     "url": "git+https://github.com/martinjoiner/prettify-bru.git"
   },
   "license": "GPL-3.0-or-later",
-  "author": "Martin Joiner (http://martinjoiner.co.uk)",
+  "author": "Martin Joiner (https://martinjoiner.co.uk)",
   "type": "module",
   "files": [
     "index.js",
     "cli.js",
-    "src/"
+    "lib/"
   ],
   "bin": "./cli.js",
   "dependencies": {
+    "prettier": "^3.3.3",
     "yargs": "18.0.0"
   },
   "scripts": {

package/index.js

@@ -1,13 +0,0 @@
-export function go(path, write) {
-  if (path === '.') {
-    path = process.cwd()
-  } else if (!/^\//.test(path)) {
-    // Path is absolute, do not modify
-  } else {
-    // Turn relative path into absolute
-    path = process.cwd() + '/' + path
-  }
-
-  console.log("go() method inside index.js");
-  console.log(path, write);
-};

package/src/index.js

@@ -1,3 +0,0 @@
-export function check() {
-  console.log("This is check");
-}