prettify-bru 1.6.0 → 1.8.0

package/README.md

@@ -2,9 +2,12 @@
 
 A CLI tool to [prettify and format Bruno `.bru` files](https://www.npmjs.com/package/prettify-bru).
 
-Uses [Prettier](https://prettier.io/) to impose a standard format on all blocks of JSON and JavaScript code across multiple [Bruno](https://www.usebruno.com/) `.bru` files in your project.
+Removes junk and makes code shorter and more transferable between systems.
+Imposes a standard format on all blocks of JSON and JavaScript code across multiple [Bruno](https://www.usebruno.com/) `.bru` files in your project.
 
-Handles blocks: `body:json`, `script:pre-request`, `script:post-response` and `tests`. All blocks are parsed using [Babel](https://babeljs.io/docs/babel-parser).
+`body:json` blocks are formatted using [jsonc-parser](https://www.npmjs.com/package/jsonc-parser)
+
+`script:pre-request`, `script:post-response` and `tests` blocks are formatted using [Prettier](https://prettier.io/) with [Babel](https://babeljs.io/docs/babel-parser) parser.
 
 ## Table of contents
 
@@ -117,7 +120,47 @@ npm prettify-bru --write --only body:json speed-tests/get-all.bru
 
 ## Config file
 
-You can override any of the [Prettier options](https://prettier.io/docs/options) via the `prettier` property in your `.prettifybrurc` file.
+Create a `.prettifybrurc` file containing a JSON object with one or more of the following properties:
+
+### Agnostic File Paths
+
+Property: `agnosticFilePaths` {boolean} (Default: `true`)
+
+Replaces backslash folder separators in filenames with forward slashes so they work on Windows, Mac and Linux
+
+```
+file: @file(\Images\Memes\3-Spidermen.jpg) @contentType(image/jpeg)
+```
+
+will be changed to...
+
+```
+file: @file(/Images/Memes/3-Spidermen.jpg) @contentType(image/jpeg)
+```
+
+### Shorten Getters
+
+Property: `shortenGetters` {boolean} (Default: `true`)
+
+Shorten code by replacing uses of getters with property references
+
+```javascript
+expect(res.getStatus()).to.eql(200)
+expect(res.getBody().name).to.eql("Dave")
+```
+
+The above will become...
+
+```javascript
+expect(res.status).to.eql(200)
+expect(res.body.name).to.eql("Dave")
+```
+
+### Prettier
+
+Property: `prettier` {Object} (Default: `{}`)
+
+The `prettier` property object can contain overrides for any of the [Prettier options](https://prettier.io/docs/options).
 
 For example, to increase the line length limit from the default 80 up to 120 characters, your file would contain:
 
@@ -129,7 +172,7 @@ For example, to increase the line length limit from the default 80 up to 120 cha
 }
 ```
 
-*Note: Config file is supported from version 1.6.0 and above.*
+*Note: Config file is supported from version [1.6.0](CHANGELOG.md#160) and above.*
 
 ## Automatically checking PRs
 

package/lib/config.mjs

@@ -2,6 +2,20 @@ import {readIfExists} from './files.mjs'
 
 const configFilename = '.prettifybrurc'
 
+/**
+ * @typedef {Object} PrettifyBruConfig
+ * @property {boolean} agnosticFilePaths
+ * @property {boolean} shortenGetters
+ * @property {Object} prettier Prettier options
+ */
+
+/** @type {PrettifyBruConfig} */
+export const defaultConfig = {
+    agnosticFilePaths: true,
+    shortenGetters: true,
+    prettier: {},
+}
+
 /**
  *
  * @param {Object} console
@@ -44,21 +58,26 @@ export function parseFile(console, fileContents) {
 
     let config = {}
 
-    const supportedProperties = ['prettier']
+    const supportedProperties = {
+        agnosticFilePaths: 'a boolean',
+        shortenGetters: 'a boolean',
+        prettier: 'an object',
+    }
     Object.keys(fileConfig).forEach(key => {
-        if (supportedProperties.includes(key)) {
-            if (key === 'prettier') {
-                const value = fileConfig[key]
-                if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-                    console.warn(
-                        `⚠️  \x1b[33mprettier is not correct type, it should be an object\x1b[0m`
-                    )
-                    return
-                }
+        if (Object.hasOwn(supportedProperties, key)) {
+            const value = fileConfig[key]
+            const validType = supportedProperties[key]
+            const validates = validators[validType]
+
+            if (validates(value)) {
+                config[key] = fileConfig[key]
+            } else {
+                console.warn(
+                    `⚠️  \x1b[33m"${key}" is not correct type, it should be ${validType}\x1b[0m`
+                )
             }
-            config[key] = fileConfig[key]
         } else {
-            console.warn(`⚠️  \x1b[33m${key} is not a supported property\x1b[0m`)
+            console.warn(`⚠️  \x1b[33mIgnoring unsupported property "${key}"\x1b[0m`)
         }
     })
 
@@ -66,3 +85,12 @@ export function parseFile(console, fileContents) {
 
     return config
 }
+
+const validators = {
+    'an object': value => {
+        return value !== null && typeof value === 'object' && !Array.isArray(value)
+    },
+    'a boolean': value => {
+        return typeof value === 'boolean'
+    },
+}

package/lib/format.mjs

@@ -1,4 +1,6 @@
 import prettier from 'prettier'
+import {defaultConfig} from './config.mjs'
+import {format as jsoncFormat, applyEdits} from 'jsonc-parser'
 
 // This Prettier config should match what the Bruno GUI implements
 const defaultPrettierConfig = {
@@ -10,14 +12,10 @@ const defaultPrettierConfig = {
     printWidth: 80,
     trailingComma: 'none',
     endOfLine: 'lf',
+    parser: 'babel',
 }
 
-const formattableBlocks = [
-    ['body:json', 'json'],
-    ['script:pre-request', 'babel'],
-    ['script:post-response', 'babel'],
-    ['tests', 'babel'],
-]
+const formattableBlocks = ['body:json', 'script:pre-request', 'script:post-response', 'tests']
 
 /**
  * @typedef {Object} FileOutcome
@@ -28,14 +26,26 @@ const formattableBlocks = [
  */
 
 /**
- * Tidies overall structure of bru lang file and uses Prettier to format blocks of JSON/JavaScript
+ * Tidies structure of bru lang file, makes code shorter and operating system agnostic,
+ * applies standard formatting to both JSON and JavaScript blocks
  *
  * @param {string} originalContents The file contents as loaded from file system
  * @param {?string} only Limit to only the block type with a name containing value
- * @param {Object} config
+ * @param {Object} configOverrides Could be whole PrettifyBruConfig or partial
  * @returns {Promise<FileOutcome>}
  */
-export async function format(originalContents, only = null, config = {}) {
+export async function format(originalContents, only = null, configOverrides = {}) {
+    /** @type {import('./config.mjs').PrettifyBruConfig} */
+    const config = {
+        ...defaultConfig,
+        ...configOverrides,
+        prettier: Object.assign(
+            {},
+            defaultPrettierConfig,
+            Object.hasOwn(configOverrides, 'prettier') ? configOverrides.prettier : {}
+        ),
+    }
+
     let fileOutcome = {
         newContents: originalContents.replace(/\r\n/g, '\n'),
         blocksSearchedFor: 0,
@@ -43,23 +53,10 @@ export async function format(originalContents, only = null, config = {}) {
         errorMessages: [],
     }
 
-    const prettierConfig = Object.assign(
-        {},
-        defaultPrettierConfig,
-        Object.hasOwn(config, 'prettier') ? config.prettier : {}
-    )
-
-    let i
-    for (i in formattableBlocks) {
-        let [blockName, parser] = formattableBlocks[i]
+    for (const blockName of formattableBlocks) {
         if (only !== null && !blockName.includes(only)) continue
 
-        const blockOutcome = await formatBlock(
-            fileOutcome.newContents,
-            blockName,
-            parser,
-            prettierConfig
-        )
+        const blockOutcome = await formatBlock(fileOutcome.newContents, blockName, config)
         fileOutcome.blocksSearchedFor++
         if (blockOutcome.errorMessage !== null) {
             fileOutcome.errorMessages.push(blockOutcome.errorMessage)
@@ -69,7 +66,16 @@ export async function format(originalContents, only = null, config = {}) {
         }
     }
 
-    if (only === null) {
+    formattableBlocks.forEach(blockName => {
+        const emptyBlockOutcome = stripEmptyBlock(fileOutcome.newContents, blockName)
+
+        if (emptyBlockOutcome.changeable) {
+            fileOutcome.changeable = true
+            fileOutcome.newContents = emptyBlockOutcome.fileContents
+        }
+    })
+
+    if (only === null && config.agnosticFilePaths) {
         const fileBodyBlockOutcome = formatFilePaths(fileOutcome.newContents)
         if (fileBodyBlockOutcome.errorMessage !== null) {
             fileOutcome.errorMessages.push(fileBodyBlockOutcome.errorMessage)
@@ -91,11 +97,10 @@ export async function format(originalContents, only = null, config = {}) {
 /**
  * @param {string} fileContents
  * @param {string} blockName
- * @param {string} parser
- * @param {Object} prettierConfig
+ * @param {import('./config.mjs').PrettifyBruConfig} config
  * @returns {Promise<{fileContents: string, changeable: boolean, errorMessage: ?string}>}
  */
-async function formatBlock(fileContents, blockName, parser, prettierConfig) {
+async function formatBlock(fileContents, blockName, config) {
     let outcome = {fileContents, changeable: false, errorMessage: null}
 
     const blockBodyRegex = new RegExp('\n' + blockName + ' [{]\\n(.+?)\\n}\\n', 's')
@@ -108,27 +113,27 @@ async function formatBlock(fileContents, blockName, parser, prettierConfig) {
     // Remove 2-spaces of indentation, added due to being inside a Bru lang block
     let unindented = rawBody.replace(/^  /gm, '')
 
-    if (blockName === 'body:json') {
-        unindented = wrapNonStringPlaceholdersInDelimiters(unindented)
+    if (config.shortenGetters && ['script:post-response', 'tests'].includes(blockName)) {
+        unindented = shortenGetters(unindented)
     }
 
-    let prettierFormatted
-
-    try {
-        prettierFormatted = await prettier.format(
-            unindented,
-            Object.assign({}, prettierConfig, {parser})
-        )
-    } catch (e) {
-        outcome.errorMessage = `Prettier could not format ${blockName} because...\n${e.message}`
-        return outcome
-    }
+    let reformatted
 
     if (blockName === 'body:json') {
-        prettierFormatted = unwrapDelimitedPlaceholders(prettierFormatted)
+        unindented = wrapNonStringPlaceholdersInDelimiters(unindented)
+        const edits = jsoncFormat(unindented, undefined, {tabSize: 2, insertSpaces: true})
+        reformatted = applyEdits(unindented, edits)
+        reformatted = unwrapDelimitedPlaceholders(reformatted)
+    } else {
+        try {
+            reformatted = await prettier.format(unindented, config.prettier)
+        } catch (e) {
+            outcome.errorMessage = `Prettier could not format ${blockName} because...\n${e.message}`
+            return outcome
+        }
     }
 
-    const bodyLines = prettierFormatted.split('\n')
+    const bodyLines = reformatted.split('\n')
 
     // Remove leading/trailing empty lines
     while (bodyLines.length && bodyLines[0].trim() === '') bodyLines.shift()
@@ -149,6 +154,20 @@ async function formatBlock(fileContents, blockName, parser, prettierConfig) {
     return outcome
 }
 
+/**
+ * @param {string} blockContents
+ * @returns {string}
+ */
+function shortenGetters(blockContents) {
+    const props = ['body', 'headers', 'responseTime', 'status', 'statusText', 'url']
+    props.forEach(prop => {
+        const getter = 'get' + prop.substring(0, 1).toUpperCase() + prop.substring(1)
+        const getterRegex = new RegExp('(?<!\\w)res\.' + getter + '\\(\\)', 'g')
+        blockContents = blockContents.replaceAll(getterRegex, `res.${prop}`)
+    })
+    return blockContents
+}
+
 /**
  * Turns Bruno variable placeholders into strings with special delimiters, effectively making it valid JSON
  *
@@ -171,7 +190,25 @@ function unwrapDelimitedPlaceholders(jsonBlock) {
 
 /**
  * @param {string} fileContents
- * @returns {fileContents: string, changeable: boolean, errorMessage: ?string}
+ * @param {string} blockName
+ * @returns {{fileContents: string, changeable: boolean}}
+ */
+function stripEmptyBlock(fileContents, blockName) {
+    const emptyBlockRegex = new RegExp('\n' + blockName + ' [{]\\n}\\n', 's')
+
+    if (fileContents.match(emptyBlockRegex) !== null) {
+        return {
+            fileContents: fileContents.replace(emptyBlockRegex, ''),
+            changeable: true,
+        }
+    }
+
+    return {fileContents, changeable: false}
+}
+
+/**
+ * @param {string} fileContents
+ * @returns {{fileContents: string, changeable: boolean, errorMessage: ?string}}
  */
 function formatFilePaths(fileContents) {
     let changeable = false
@@ -192,7 +229,7 @@ function formatFilePaths(fileContents) {
 
 /**
  * @param {string} fileContents
- * @returns {fileContents: string, changeable: boolean}
+ * @returns {{fileContents: string, changeable: boolean}}
  */
 function formatOverallStructure(fileContents) {
     if (fileContents.match(/\n[}]\n[\s]+\n\w+/s) === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettify-bru",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Prettifies JSON and JavaScript blocks in Bruno .bru files",
   "keywords": [
     "bruno",
@@ -28,6 +28,7 @@
   ],
   "bin": "./cli.js",
   "dependencies": {
+    "jsonc-parser": "^3.3.1",
     "prettier": "^3.3.3",
     "yargs": "18.0.0"
   },