Add specificKeywordCaseOverride and specificTypeCaseOverride

Author: ljunkie

README.md

@@ -68,7 +68,7 @@ bsfmt "source/**/*.brs" "!**/roku_modules/*.*"
 | noBsfmt |`boolean` | `false`   | Don't read a bsfmt.json file |
 | bsfmtPath |`string` | `undefined`   | Use a specified path to bsfmt.json instead of the default |
 ||||
-All boolean, string, and integer [`bsfmt.json`](#bsfmtjson-options) options are supported as well. Complex options such as `keywordCaseOverride` or `typeCaseOverride` are not currently supported via the CLI and should be provided in the `bsfmt.json` or through the node API. Feel free to [open an issue](https://github.com/rokucommunity/brighterscript-formatter/issues/new) if you would like to see support for these options via the CLI.
+All boolean, string, and integer [`bsfmt.json`](#bsfmtjson-options) options are supported as well. Complex options such as `keywordCaseOverride`, `typeCaseOverride`, `specificKeywordCaseOverride`, or `specificTypeCaseOverride` are not currently supported via the CLI and should be provided in the `bsfmt.json` or through the node API. Feel free to [open an issue](https://github.com/rokucommunity/brighterscript-formatter/issues/new) if you would like to see support for these options via the CLI.
 
 
 
@@ -83,7 +83,9 @@ All boolean, string, and integer [`bsfmt.json`](#bsfmtjson-options) options are
 |compositeKeywords| `"split", "combine", "original"`| `"split"` | Forces all composite keywords (i.e. `elseif`, `endwhile`, etc...) to be consistent. If `"split"`, they are split into their alternatives (`else if`, `end while`). If `"combine"`', they are combined (`elseif`, `endwhile`). If `"original"` or falsey, they are not modified. |
 |removeTrailingWhiteSpace|`boolean`|`true`| Remove (or don't remove) trailing whitespace at the end of each line |
 |[keywordCaseOverride](#keywordCaseOverride)| `object`| `undefined`| Provides a way to override keyword case at the individual TokenType level|
-|[typeCaseOverride](#typeCaseOverride)|`object`|`undefined`| Provides a way to override type keyword case at the individual TokenType level.Types are defined as keywords that are preceded by an `as` token.|
+|[typeCaseOverride](#typeCaseOverride)|`object`|`undefined`| Provides a way to override type keyword case at the individual TokenType level. Types are defined as keywords that are preceded by an `as` token.|
+|[specificKeywordCaseOverride](#specificKeywordCaseOverride)| `object`| `undefined`| Provides a way to override keyword case with a specific string at the individual keyword level|
+|[specificTypeCaseOverride](#specificTypeCaseOverride)|`object`|`undefined`| Provides a way to override type keyword case with a specific string at the individual keyword level. Types are defined as keywords that are preceded by an `as` token. This accepts specific casing strings rather than case options like "upper" or "lower".|
 |formatInteriorWhitespace|`boolean`|`true`| All whitespace between items is reduced to exactly 1 space character and certain keywords and operators are padded with whitespace.  This is a catchall property that will also disable the following rules: `insertSpaceBeforeFunctionParenthesis`, `insertSpaceBetweenEmptyCurlyBraces`, `insertSpaceAroundParameterAssignment`, `insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces`|
 |insertSpaceBeforeFunctionParenthesis|`boolean`|`false`| If true, a space is inserted to the left of an opening function declaration parenthesis. (i.e. `function main ()` or `function ()`). If false, all spacing is removed (i.e. `function main()` or `function()`).|
 |insertSpaceBetweenEmptyCurlyBraces|`boolean`|`false`| If true, empty curly braces will contain exactly 1 whitespace char (i.e. `{ }`). If false, there will be zero whitespace chars between empty curly braces (i.e. `{}`) |
@@ -128,6 +130,33 @@ For more flexibility in how to format the case of types, you can specify the cas
 
 A type is any token found directly after an `as` keyword.
 
+### specificKeywordCaseOverride
+For more flexibility in how to format the case of keywords, you can specify the case value preference for each individual keyword. Here's an example:
+
+```js
+{
+    "specificKeywordCaseOverride": {
+        "longinteger": "longInteger",
+        "endif": "EndIF"
+    }
+}
+```
+
+The full list of keywords detected by this option can be found [here](https://github.com/rokucommunity/brighterscript-formatter/blob/095f9dc5ec418d46d3ea6197712f5d11f71d922f/src/Formatter.ts#L1145).
+
+### specificTypeCaseOverride
+For more flexibility in how to format the case of types, you can specify the case value preference for each individual type. Here's an example:
+
+```js
+{
+    "specificTypeCaseOverride": {
+        "longinteger": "LongInteger"
+    }
+}
+```
+
+A type is any token found directly after an `as` keyword.
+
 ## Library
 
 ### General usage

bsfmt.schema.json

@@ -58,6 +58,14 @@
             "default": true,
             "description": "Removes all trailing whitespace at the end of each line."
         },
+        "specificKeywordCaseOverride": {
+            "type": "object",
+            "description": "Allows overriding specific keywords at the individual keyword level.\nExample {\"longinteger\": \"LongInteger\"} would make longinteger LongInteger"
+        },
+        "specificTypeCaseOverride": {
+            "type": "object",
+            "description": "Allows overriding specific types at the individual type level.\nExample {\"longinteger\": \"longInteger\"} would make longinteger longInteger"
+        },
         "keywordCaseOverride": {
             "type": "object",
             "description": "Allows overriding case at the individual keyword level.\nExample {\"string\": \"title\"} would make string always lower case regardless of keywordCase",

src/FormattingOptions.ts

@@ -51,6 +51,18 @@ export interface FormattingOptions {
      * Types are defined as keywords that are preceded by an `as` token.
      */
     typeCaseOverride?: Record<string, FormattingOptions['keywordCase']>;
+    /**
+     * Provides a way to override keyword case with a specific string.
+     * The key should be the lowercased keyword, and the value should be the desired casing.
+     * e.g. { "longinteger": "LongInteger" }
+     */
+    specificKeywordCaseOverride?: Record<string, string>;
+    /**
+     * Provides a way to override type keyword case with a specific string.
+     * The key should be the lowercased keyword, and the value should be the desired casing.
+     * e.g. { "longinteger": "LongInteger" }
+     */
+    specificTypeCaseOverride?: Record<string, string>;
     /**
      * If true (the default), all whitespace between items are reduced to exactly 1 space character,
      * and certain keywords and operators are padded with whitespace (i.e. `1+1` becomes `1 + 1`).

src/formatters/KeywordCaseFormatter.spec.ts

@@ -1,5 +1,7 @@
 import { expect } from 'chai';
 import { KeywordCaseFormatter } from './KeywordCaseFormatter';
+import { Formatter as MainFormatter } from '../Formatter';
+import { undent } from 'undent';
 
 describe('KeywordCaseFormatter', () => {
     let Formatter: KeywordCaseFormatter;
@@ -22,4 +24,61 @@ describe('KeywordCaseFormatter', () => {
             expect(Formatter['upperCaseLetter']('hello', 5)).to.equal('hello');
         });
     });
+
+    describe('specificCaseOverride', () => {
+        let formatter: MainFormatter;
+        beforeEach(() => {
+            formatter = new MainFormatter();
+        });
+
+        it('specificKeywordCaseOverride', () => {
+            const input = undent`sub Main() print "hello" end sub`;
+            const expected = undent`sub Main() PRINT "hello" endSub`;
+            expect(formatter.format(input, {
+                keywordCase: 'lower',
+                specificKeywordCaseOverride: {
+                    endsub: 'endSub',
+                    print: 'PRINT'
+                }
+            })).to.equal(expected);
+        });
+
+        it('specificTypeCaseOverride', () => {
+            const input = undent`sub Main(a as integer)`;
+            const expected = undent`sub Main(a as Integer)`;
+            expect(formatter.format(input, {
+                typeCase: 'lower',
+                specificTypeCaseOverride: {
+                    integer: 'Integer'
+                }
+            })).to.equal(expected);
+        });
+
+        it('specificKeywordCaseOverride and specificTypeCaseOverride using different cases', () => {
+            const input = undent`sub longinteger(a as longinteger)`;
+            const expected = undent`sub LongInteger(a as longInteger)`;
+            expect(formatter.format(input, {
+                typeCase: 'lower',
+                specificKeywordCaseOverride: {
+                    longinteger: 'LongInteger'
+                },
+                specificTypeCaseOverride: {
+                    longinteger: 'longInteger'
+                }
+            })).to.equal(expected);
+        });
+
+        it('specificKeywordCaseOverride and specificTypeCaseOverride using invalid values (must match the original keyword)', () => {
+            const input = undent`sub longinteger(a as longinteger)`;
+            expect(formatter.format(input, {
+                typeCase: 'lower',
+                specificKeywordCaseOverride: {
+                    longinteger: 'integer'
+                },
+                specificTypeCaseOverride: {
+                    longinteger: 'integer'
+                }
+            })).to.equal(input);
+        });
+    });
 });

src/formatters/KeywordCaseFormatter.ts

@@ -12,20 +12,37 @@ export class KeywordCaseFormatter {
 
             //if this token is a keyword
             if (Keywords.includes(token.kind)) {
-
                 let keywordCase: FormattingOptions['keywordCase'];
                 let lowerKind = token.kind.toLowerCase();
 
                 //a token is a type if it's preceded by an `as` token
                 if (this.isType(tokens, token)) {
+
+                    //if the token is a type, check for a specific override
+                    const specificTypeCaseOverride = options.specificTypeCaseOverride?.[lowerKind];
+                    if (specificTypeCaseOverride && specificTypeCaseOverride.toLowerCase() === lowerKind) {
+                        token.text = specificTypeCaseOverride;
+                        continue;
+                    }
+
                     //options.typeCase is always set to options.keywordCase when not provided
                     keywordCase = options.typeCase;
+
                     //if this is an overridden type keyword, use that override instead
                     if (options.typeCaseOverride && options.typeCaseOverride[lowerKind] !== undefined) {
                         keywordCase = options.typeCaseOverride[lowerKind];
                     }
                 } else {
+                    //if the token is a keyword, check for a specific override
+                    const specificKeywordCaseOverride = options.specificKeywordCaseOverride?.[lowerKind];
+                    if (specificKeywordCaseOverride && specificKeywordCaseOverride.toLowerCase() === lowerKind) {
+                        token.text = specificKeywordCaseOverride;
+                        continue;
+                    }
+
+                    //keywordCase is always set to options.keywordCase when not provided
                     keywordCase = options.keywordCase;
+
                     //if this is an overridable keyword, use that override instead
                     if (options.keywordCaseOverride && options.keywordCaseOverride[lowerKind] !== undefined) {
                         keywordCase = options.keywordCaseOverride[lowerKind];