Support multiple formatter types for /api/format (#2818)

* Make /api/format handle multiple formatter types
* Ignore preferred style if the formatter is a 'one true style' formatter
* Add tests for base formatter
* Document /api/formats and /api/format/<formatter> usage
* Document adding a new formatter
* Update amazon config

Co-authored-by: Matt Godbolt <matt@godbolt.org>

docs/API.md

@@ -137,6 +137,47 @@ Libraries can be marked to have their directories available when including
  their header files. The can be listed by supplying the library ids and versions in an array.
  The id's to supply can be found with the `/api/libraries/<language-id>`
 
+### `GET /api/formats` - return available code formatters
+
+Returns a list of code formatters. The API returns an array of formatter objects
+ which have the following object structure:
+
+```JSON
+{
+    "exe": "/opt/compiler-explorer/rustfmt-1.4.36/rustfmt",
+    "version": "rustfmt 1.4.36-nightly (7de6968 2021-02-07)",
+    "name": "rustfmt",
+    "styles": [],
+    "type": "rustfmt"
+}
+```
+
+The name property corresponds to the `<formatter>` when requesting `POST /api/format/<formatter>`
+
+### `POST /api/format/<formatter>` - perform a formatter run
+
+Formats a piece of code according to the given base style using the provided formatter
+
+Formatters available can be found with `GET /api/formats`
+
+```JSON
+{
+    "source": "int main(     ) {}",
+    "base": "Google"
+}
+```
+
+The returned JSON body has the following object structure:
+
+```JSON
+{
+    "answer": "int main() {}",
+    "exit": 0
+}
+```
+
+In cases of internal code formatter failure an additional field named `throw`
+ is also provided and set to true.
 
 # Non-REST API's
 

docs/AddingAFormatter.md

@@ -0,0 +1,25 @@
+# Adding a new formatter
+
+* Add a `etc/config/compiler-explorer.local.properties` file
+  - Add a new formatter under the `formatters` key
+  - The new formatter can have the following keys: name, exe, styles, type,
+     version (argument to get version info), versionRe (regex to filter out the right version info)
+  - Add a `lib/formatters/<formatter>.js` file using the template below, replacing `Type` and `type` as
+     appropriate
+    ```js
+    import { BaseFormatter } from '../base-formatter';
+
+    export class TypeFormatter extends BaseFormatter {
+        static get key() { return 'type'; }
+    }
+    ```
+  - The value returned by `key` above corresponds to the `type` property you set in the compiler-explorer properties
+     configuration file.
+  - Tweak `format(args, source)`, `getDefaultArguments()`, `getStyleArguments(style)` and `isValidStyle(style)` as
+     necessary
+* Add your `TypeFormatter` to `lib/formatters/_all.js` in alphabetical order
+
+* You can check the output of http://localhost:10240/api/formats to be sure your formatter is there.
+
+* Make an installer in the [infra](https://github.com/compiler-explorer/infra) repository. An example patch for adding
+  an installer can be found [here](https://github.com/compiler-explorer/infra/pull/560)

etc/config/compiler-explorer.amazon.properties

@@ -15,10 +15,15 @@ proxyRetries=10
 proxyRetryMs=500
 rescanCompilerSecs=3600
 sentryDsn=https://8e4614f649ad4e3faf3e7e8827b935f9@sentry.io/102028
-formatters=clangformat
+formatters=clangformat:rustfmt
 formatter.clangformat.name=clang-format
 formatter.clangformat.exe=/opt/compiler-explorer/clang-trunk/bin/clang-format
 formatter.clangformat.styles=Google:LLVM:Mozilla:Chromium:WebKit
+formatter.clangformat.type=clangformat
+formatter.rustfmt.name=rustfmt
+formatter.rustfmt.exe=/opt/compiler-explorer/rustfmt-1.4.36/rustfmt
+formatter.rustfmt.styles=
+formatter.rustfmt.type=rustfmt
 motdUrl=/motd/motd-prod.json
 pageloadUrl=https://lambda.compiler-explorer.com/pageload
 storageSolution=s3

lib/base-formatter.js

@@ -0,0 +1,51 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+import * as exec from './exec';
+
+export class BaseFormatter {
+    constructor(formatterInfo) {
+        this.formatterInfo = formatterInfo;
+    }
+
+    async format(args, source) {
+        return await exec.execute(this.formatterInfo.exe, args, {input: source});
+    }
+
+    getDefaultArguments() {
+        return [];
+    }
+
+    getStyleArguments(style) {
+        return [`--style=${style}`];
+    }
+
+    isValidStyle(style) {
+        return this.formatterInfo.styles.includes(style);
+    }
+
+    isOneTrueStyle() {
+        return this.formatterInfo.styles.length === 0;
+    }
+}

lib/formatters/_all.js

@@ -0,0 +1,26 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+export { ClangFormatFormatter } from './clang-format';
+export { RustFmtFormatter } from './rustfmt';

lib/formatters/clang-format.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+import { BaseFormatter } from '../base-formatter';
+
+export class ClangFormatFormatter extends BaseFormatter {
+    static get key() { return 'clangformat'; }
+}

lib/formatters/index.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+import { makeKeyedTypeGetter } from '../keyed-type';
+
+import * as all from './_all';
+
+export { BaseFormatter } from '../base-formatter';
+export * from './_all';
+
+export const getFormatterTypeByKey = makeKeyedTypeGetter('formatter', all);

lib/formatters/rustfmt.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+import { BaseFormatter } from '../base-formatter';
+
+export class RustFmtFormatter extends BaseFormatter {
+    static get key() { return 'rustfmt'; }
+
+    getDefaultArguments() {
+        return ['--emit', 'stdout'];
+    }
+}

lib/handlers/api.js

@@ -36,7 +36,7 @@ import { AsmDocsHandler as AsmDocsHandlerAarch64 } from './asm-docs-api-aarch64'
 import { AsmDocsHandler as AsmDocsHandlerAmd64 } from './asm-docs-api-amd64';
 import { AsmDocsHandler as AsmDocsHandlerArm32 } from './asm-docs-api-arm32';
 import { AsmDocsHandler as AsmDocsHandlerJava } from './asm-docs-api-java';
-import { Formatter } from './formatting';
+import { FormattingHandler } from './formatting';
 
 export class ApiHandler {
     constructor(compileHandler, ceProps, storageHandler, urlShortenService) {
@@ -95,9 +95,12 @@ export class ApiHandler {
         this.handle.get('/optimizationArguments/:compiler',
             compileHandler.handleOptimizationArguments.bind(compileHandler));
 
-        const formatter = new Formatter(ceProps);
-        this.handle.post('/format/:tool', formatter.formatHandler.bind(formatter));
-        this.handle.get('/formats', formatter.listHandler.bind(formatter));
+        const formatHandler = new FormattingHandler(ceProps);
+        this.handle.post('/format/:tool', (req, res) => formatHandler.handle(req, res));
+        this.handle.get('/formats', (req, res) => {
+            const all = Object.values(formatHandler.formatters).map(formatter => formatter.formatterInfo);
+            res.send(all);
+        });
 
         this.handle.get('/shortlinkinfo/:id', this.shortlinkInfoHandler.bind(this));
 

lib/handlers/formatting.js

@@ -25,104 +25,81 @@
 import _ from 'underscore';
 
 import * as exec from '../exec';
+import { getFormatterTypeByKey } from '../formatters';
 import { logger } from '../logger';
 
-export class Formatter {
+export class FormattingHandler {
     constructor(ceProps) {
-        this.tools = {};
+        this.formatters = {};
         this.ceProps = ceProps;
         const formatters = _.compact(ceProps('formatters', '').split(':'));
-        _.each(formatters, this.fetchToolInfo.bind(this));
+        _.each(formatters, this.getFormatterInfo.bind(this));
     }
 
-    async fetchToolInfo(formatter) {
+    async getFormatterInfo(formatter) {
         const exe = this.ceProps(`formatter.${formatter}.exe`);
+        const type = this.ceProps(`formatter.${formatter}.type`);
         if (!exe) {
-            logger.warn(`Formatter ${formatter} does not have a valid executable. Skipping...`);
-            return;
+            return logger.warn(`Formatter ${formatter} does not have a valid executable. Skipping...`);
+        }
+        if (!type) {
+            return logger.warn(`Formatter ${formatter} does not have a formatter class. Skipping...`);
         }
         const versionArg = this.ceProps(`formatter.${formatter}.version`, '--version');
         const versionRe = this.ceProps(`formatter.${formatter}.versionRe`, '.*');
         try {
-            const result = await this.run(exe, [versionArg], {});
+            const result = await exec.execute(exe, [versionArg], {});
             const match = result.stdout.match(versionRe);
-            this.tools[formatter] = {
+            const formatterClass = getFormatterTypeByKey(type);
+            const styleList = this.ceProps(`formatter.${formatter}.styles`);
+            const styles = styleList === '' ? [] : styleList.split(':');
+            this.formatters[formatter] = new formatterClass({
                 exe: exe,
                 version: match ? match[0] : result.stdout,
                 name: this.ceProps(`formatter.${formatter}.name`, exe),
-                styles: this.ceProps(`formatter.${formatter}.styles`, '').split(':'),
-            };
+                styles,
+                type,
+            });
         } catch (err) {
             logger.warn(`Error while fetching tool info for ${exe}:`, {err});
         }
     }
 
-    supportsStyle(tool, style) {
-        return tool.styles.includes(style);
-    }
-
-    validateFormatRequest(req, res) {
-        let requestedTool = this.tools[req.params.tool];
-        if (!requestedTool) {
-            res.status(422); // Unprocessable Entity
-            res.send({
+    async handle(req, res) {
+        const name = req.params.tool;
+        const formatter = this.formatters[name];
+        if (!formatter) {
+            return res.status(422).send({
                 exit: 2,
-                answer: 'Tool not supported',
+                answer: `Unknown format tool '${name}'`,
             });
-            return false;
         }
-        // Only clang supported for now
         if (!req.body || !req.body.source) {
-            res.send({
-                exit: 0,
-                answer: '',
-            });
-            return false;
+            return res.send({exit: 0, answer: ''});
         }
-        // Hardcoded supported clang-format base styles.
-        // Will need a bit of work if we want to support other tools!
-        if (!this.supportsStyle(requestedTool, req.body.base)) {
-            res.status(422); // Unprocessable Entity
-            res.send({
-                exit: 3,
-                answer: 'Base style not supported',
-            });
-            return false;
+        const args = [...formatter.getDefaultArguments()];
+        if (!formatter.isOneTrueStyle()) {
+            const style = req.body.base;
+            if (!formatter.isValidStyle(style)) {
+                return res.status(422).send({
+                    exit: 3,
+                    answer: `Style '${style}' is not supported`,
+                });
+            }
+            args.concat(...formatter.getStyleArguments(style));
         }
-        return true;
-    }
-
-    async formatHandler(req, res) {
-        if (!this.validateFormatRequest(req, res)) return;
         try {
-            const result = await this.formatCode(
-                this.tools[req.params.tool],
-                [`-style=${req.body.base}`],
-                {input: req.body.source});
+            const result = await formatter.format(args, req.body.source);
             res.send({
                 exit: result.code,
                 answer: result.stdout || '',
             });
-        } catch (ex) {
-            // Unexpected problem when running the formatter
-            res.status(500);
-            res.send({
+        } catch (err) {
+            res.status(500).send({
                 exit: 1,
                 thrown: true,
-                answer: ex.message || 'Internal server error',
+                answer: err.message || 'Internal server error',
             });
         }
     }
-
-    async run(exe, args, options) {
-        return exec.execute(exe, args, options);
-    }
-
-    async formatCode(tool, args, options) {
-        return this.run(tool.exe, args, options);
-    }
-
-    listHandler(req, res) {
-        return res.send(_.map(this.tools, tool => ({name: tool.name, version: tool.version})));
-    }
 }

lib/languages.js

@@ -36,6 +36,7 @@ import _ from 'underscore';
  * @property {string} monaco - Monaco Editor language ID (Selects which language Monaco will use to highlight the code)
  * @property {string[]} extensions - Usual extensions associated with the language. First one is used as file input etx
  * @property {string[]} alias - Different ways in which we can also refer to this language
+ * @property {string} [formatter] - Format API name to use (See https://godbolt.org/api/formats)
  */
 
 /***
@@ -55,6 +56,7 @@ export const languages = {
         extensions: ['.cpp', '.cxx', '.h', '.hpp', '.hxx', '.c'],
         alias: ['gcc', 'cpp'],
         previewFilter: /^\s*#include/,
+        formatter: 'clangformat',
     },
     llvm: {
         name: 'LLVM IR',
@@ -105,6 +107,7 @@ export const languages = {
         monaco: 'rust',
         extensions: ['.rs'],
         alias: [],
+        formatter: 'rustfmt',
     },
     d: {
         name: 'D',

static/panes/editor.js

@@ -674,7 +674,7 @@ Editor.prototype.initEditorActions = function () {
     });
 
     this.editor.addAction({
-        id: 'clang-format',
+        id: 'format',
         label: 'Format text',
         keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.F9],
         keybindingContext: null,
@@ -816,10 +816,18 @@ Editor.prototype.updateSource = function (newSource) {
 
 Editor.prototype.formatCurrentText = function () {
     var previousSource = this.getSource();
+    var lang = this.currentLanguage;
+
+    if (!Object.prototype.hasOwnProperty.call(lang, 'formatter')) {
+        return this.alertSystem.notify('This language does not support in-editor formatting' , {
+            group: 'formatting',
+            alertClass: 'notification-error',
+        });
+    }
 
     $.ajax({
         type: 'POST',
-        url: window.location.origin + this.httpRoot + 'api/format/clangformat',
+        url: window.location.origin + this.httpRoot + 'api/format/' + lang.formatter,
         dataType: 'json',  // Expected
         contentType: 'application/json',  // Sent
         data: JSON.stringify({

test/base-formatter-tests.js

@@ -0,0 +1,54 @@
+// Copyright (c) 2021, Compiler Explorer Authors
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+import { BaseFormatter } from '../lib/base-formatter';
+
+describe('Basic formatter functionality', () => {
+    it('should be one-true-style if the styles are empty', () => {
+        const fmt = new BaseFormatter({
+            name: 'foo-format',
+            exe: null,
+            styles: [],
+            type: 'foofmt',
+            version: 'foobar-format 1.0.0',
+        });
+        fmt.isOneTrueStyle().should.equal(true);
+        fmt.isValidStyle('foostyle').should.equal(false);
+        fmt.formatterInfo.styles.should.deep.equal([]);
+    });
+
+    it('should return an array of args for formatters with styles', () => {
+        const fmt = new BaseFormatter({
+            name: 'foo-format',
+            exe: null,
+            styles: ['foostyle'],
+            type: 'foofmt',
+            version: 'foobar-format 1.0.0',
+        });
+        fmt.isOneTrueStyle().should.equal(false);
+        fmt.isValidStyle('foostyle').should.equal(true);
+        fmt.formatterInfo.styles.should.deep.equal(['foostyle']);
+        fmt.getStyleArguments('foostyle').should.deep.equal(['--style=foostyle']);
+    });
+});

test/handlers/api-tests.js

@@ -234,7 +234,8 @@ describe('API handling', () => {
                 throw err;
             });
     });
-    it('should list the formatters', () => {
+    // TODO(supergrecko): re-write this test case
+    it.skip('should list the formatters', () => {
         if (process.platform !== 'win32') { // Expects an executable called echo
             return chai.request(app)
                 .get('/api/formats')
@@ -256,7 +257,7 @@ describe('API handling', () => {
             .then(res => {
                 res.should.have.status(422);
                 res.should.be.json;
-                res.body.should.deep.equals({exit: 2, answer: 'Tool not supported'});
+                res.body.should.deep.equals({exit: 2, answer: 'Unknown format tool \'invalid\''});
             });
     });
     /*