Merge pull request #191 from AtomLinter/arcanemagus/cleanup

Arcanemagus · web-flow · commit 95d152ece905 · 2017-03-30T16:26:33.000-07:00
Update to Linter v2
diff --git a/lib/main.js b/lib/main.js
@@ -1,127 +1,201 @@
 'use babel';
 
-export default {
-  config: {
-    // It should be noted that I, Kepler, hate these Config names. However these
-    //  are the names in use by many people. Changing them for the sake of clean
-    //  of clean code would cause a mess for our users. Because of this we
-    //  override the titles the editor gives them in the settings pane.
-    execPath: {
-      type: 'string',
-      default: 'clang',
-    },
-    clangIncludePaths: {
-      type: 'array',
-      default: ['.'],
-    },
-    clangSuppressWarnings: {
-      type: 'boolean',
-      default: false,
-    },
-    clangDefaultCFlags: {
-      type: 'string',
-      default: '-Wall',
-    },
-    clangDefaultCppFlags: {
-      type: 'string',
-      default: '-Wall -std=c++11',
-    },
-    clangDefaultObjCFlags: {
-      type: 'string',
-      default: '',
-    },
-    clangDefaultObjCppFlags: {
-      type: 'string',
-      default: '',
-    },
-    clangErrorLimit: {
-      type: 'integer',
-      default: 0,
-    },
-    verboseDebug: {
-      type: 'boolean',
-      default: false,
-    },
-  },
+// eslint-disable-next-line import/extensions, import/no-extraneous-dependencies
+import { CompositeDisposable } from 'atom';
+import { dirname, extname } from 'path';
 
+let helpers = null;
+let clangFlags = null;
+const regex = /(.+):(\d+):(\d+):(?:{(\d+):(\d+)-(\d+):(\d+)}.*:)? ([\w \\-]+): (.*)/g;
+
+export default {
   activate() {
     require('atom-package-deps').install('linter-clang');
+
+    // FIXME: Remove backwards compatibility in a future minor version
+    const oldPath = atom.config.get('linter-clang.execPath');
+    if (oldPath !== undefined) {
+      atom.config.unset('linter-clang.execPath');
+      if (oldPath !== 'clang') {
+        // If the old config wasn't set to the default migrate it over
+        atom.config.set('linter-pylint.executablePath', oldPath);
+      }
+    }
+
+    this.subscriptions = new CompositeDisposable();
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.executablePath', (value) => {
+        this.executablePath = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangIncludePaths', (value) => {
+        this.clangIncludePaths = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangSuppressWarnings', (value) => {
+        this.clangSuppressWarnings = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangDefaultCFlags', (value) => {
+        this.clangDefaultCFlags = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangDefaultCppFlags', (value) => {
+        this.clangDefaultCppFlags = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangDefaultObjCFlags', (value) => {
+        this.clangDefaultObjCFlags = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangDefaultObjCppFlags', (value) => {
+        this.clangDefaultObjCppFlags = value;
+      }),
+    );
+    this.subscriptions.add(
+      atom.config.observe('linter-clang.clangErrorLimit', (value) => {
+        this.clangErrorLimit = value;
+      }),
+    );
+  },
+
+  deactivate() {
+    this.subscriptions.dispose();
   },
 
   provideLinter() {
-    const helpers = require('atom-linter');
-    const clangFlags = require('clang-flags');
-    const regex = '(?<file>.+):(?<line>\\d+):(?<col>\\d+):({(?<lineStart>\\d+):(?<colStart>\\d+)-(?<lineEnd>\\d+):(?<colEnd>\\d+)}.*:)? (?<type>[\\w \\-]+): (?<message>.*)';
     return {
       name: 'clang',
-      grammarScopes: ['source.c', 'source.cpp', 'source.objc', 'source.objcpp'],
       scope: 'file',
-      lintOnFly: false,
-      lint: (activeEditor) => {
-        const command = atom.config.get('linter-clang.execPath');
-        const file = activeEditor.getPath();
-        const args = ['-fsyntax-only',
+      lintsOnChange: false,
+      grammarScopes: ['source.c', 'source.cpp', 'source.objc', 'source.objcpp'],
+      lint: async (editor) => {
+        if (helpers === null) {
+          helpers = require('atom-linter');
+        }
+        if (clangFlags === null) {
+          clangFlags = require('clang-flags');
+        }
+
+        const filePath = editor.getPath();
+        const fileExt = extname(filePath);
+        const fileText = editor.getText();
+
+        const args = [
+          '-fsyntax-only',
           '-fno-caret-diagnostics',
           '-fno-diagnostics-fixit-info',
           '-fdiagnostics-print-source-range-info',
-          '-fexceptions'];
+          '-fexceptions',
+          `-ferror-limit=${this.clangErrorLimit}`,
+        ];
 
-        const grammar = activeEditor.getGrammar().name;
+        const grammar = editor.getGrammar().name;
 
-        if (/^C\+\+/.test(grammar)) {
-          // const language = "c++";
-          args.push('-xc++');
-          args.push(...atom.config.get('linter-clang.clangDefaultCppFlags').split(/\s+/));
-        }
-        if (grammar === 'Objective-C++') {
-          // const language = "objective-c++";
-          args.push('-xobjective-c++');
-          args.push(...atom.config.get('linter-clang.clangDefaultObjCppFlags').split(/\s+/));
+        switch (grammar) {
+          case 'Objective-C':
+            args.push('-xobjective-c');
+            args.push(...this.clangDefaultObjCFlags.split(/\s+/));
+            break;
+          case 'Objective-C++':
+            args.push('-xobjective-c++');
+            args.push(...this.clangDefaultObjCppFlags.split(/\s+/));
+            break;
+          case 'C':
+            args.push('-xc');
+            args.push(...this.clangDefaultCFlags.split(/\s+/));
+            break;
+          default:
+          case 'C++':
+          case 'C++14':
+            args.push('-xc++');
+            args.push(...this.clangDefaultCppFlags.split(/\s+/));
+            break;
         }
-        if (grammar === 'C') {
-          // const language = "c";
-          args.push('-xc');
-          args.push(...atom.config.get('linter-clang.clangDefaultCFlags').split(/\s+/));
-        }
-        if (grammar === 'Objective-C') {
-          // const language = "objective-c";
-          args.push('-xobjective-c');
-          args.push(...atom.config.get('linter-clang.clangDefaultObjCFlags').split(/\s+/));
+
+        if (fileExt === '.hpp' || fileExt === '.hh' || fileExt === '.h') {
+          // Don't warn about #pragma once when linting header files
+          args.push('-Wno-pragma-once-outside-header');
         }
 
-        args.push(`-ferror-limit=${atom.config.get('linter-clang.clangErrorLimit')}`);
-        if (atom.config.get('linter-clang.clangSuppressWarnings')) {
+        if (this.clangSuppressWarnings) {
           args.push('-w');
         }
-        if (atom.config.get('linter-clang.verboseDebug')) {
+
+        if (atom.inDevMode()) {
           args.push('--verbose');
         }
 
-        atom.config.get('linter-clang.clangIncludePaths').forEach(path =>
+        this.clangIncludePaths.forEach(path =>
           args.push(`-I${path}`),
         );
 
         try {
-          const flags = clangFlags.getClangFlags(activeEditor.getPath());
+          const flags = clangFlags.getClangFlags(filePath);
           if (flags) {
             args.push(...flags);
           }
         } catch (error) {
-          if (atom.config.get('linter-clang.verboseDebug')) {
+          if (atom.inDevMode()) {
             // eslint-disable-next-line no-console
             console.log(error);
           }
         }
 
-        // The file is added to the arguments last.
-        args.push(file);
+        args.push(filePath);
+
+        let [projectPath] = atom.project.relativizePath(filePath);
+        if (projectPath === null) {
+          projectPath = dirname(filePath);
+        }
+
         const execOpts = {
           stream: 'stderr',
           allowEmptyStderr: true,
+          cwd: projectPath,
         };
-        return helpers.exec(command, args, execOpts).then(output =>
-          helpers.parse(output, regex),
-        );
+
+        const output = await helpers.exec(this.executablePath, args, execOpts);
+
+        if (editor.getText() !== fileText) {
+          // Editor contents have changed, tell Linter not to update results
+          // eslint-disable-next-line no-console
+          console.warn('linter-clang: Editor contents changed, not updating results');
+          return null;
+        }
+
+        const toReturn = [];
+        let match = regex.exec(output);
+
+        while (match !== null) {
+          let position;
+          if (match[4] !== undefined) {
+            const lineStart = Number.parseInt(match[4], 10) - 1;
+            const colStart = Number.parseInt(match[5], 10) - 1;
+            const lineEnd = Number.parseInt(match[6], 10) - 1;
+            const colEnd = Number.parseInt(match[7], 10) - 1;
+            position = [[lineStart, colStart], [lineEnd, colEnd]];
+          } else {
+            const line = Number.parseInt(match[2], 10) - 1;
+            const col = Number.parseInt(match[3], 10) - 1;
+            position = helpers.generateRange(editor, line, col);
+          }
+          const severity = /error/.test(match[8]) ? 'error' : 'warning';
+          toReturn.push({
+            severity,
+            location: { file: match[1], position },
+            excerpt: match[9],
+          });
+          match = regex.exec(output);
+        }
+
+        return toReturn;
       },
     };
   },
diff --git a/package.json b/package.json
@@ -9,7 +9,43 @@
   },
   "license": "MIT",
   "engines": {
-    "atom": ">0.50.0"
+    "atom": ">=1.4.0 <2.0.0"
+  },
+  "configSchema": {
+    "executablePath": {
+      "type": "string",
+      "default": "clang"
+    },
+    "clangIncludePaths": {
+      "type": "array",
+      "default": [
+        "."
+      ]
+    },
+    "clangSuppressWarnings": {
+      "type": "boolean",
+      "default": false
+    },
+    "clangDefaultCFlags": {
+      "type": "string",
+      "default": "-Wall"
+    },
+    "clangDefaultCppFlags": {
+      "type": "string",
+      "default": "-Wall -std=c++11"
+    },
+    "clangDefaultObjCFlags": {
+      "type": "string",
+      "default": ""
+    },
+    "clangDefaultObjCppFlags": {
+      "type": "string",
+      "default": ""
+    },
+    "clangErrorLimit": {
+      "type": "integer",
+      "default": 0
+    }
   },
   "scripts": {
     "test": "apm test",
@@ -18,13 +54,13 @@
   "providedServices": {
     "linter": {
       "versions": {
-        "1.0.0": "provideLinter"
+        "2.0.0": "provideLinter"
       }
     }
   },
   "dependencies": {
     "atom-linter": "^9.0.0",
-    "atom-package-deps": "^4.0.1",
+    "atom-package-deps": "^4.5.0",
     "clang-flags": "^0.2.2"
   },
   "devDependencies": {
@@ -34,7 +70,7 @@
     "jasmine-fix": "^1.0.1"
   },
   "package-deps": [
-    "linter"
+    "linter:2.0.0"
   ],
   "eslintConfig": {
     "extends": "airbnb-base",
diff --git a/spec/files/pragma/pragma_once.c b/spec/files/pragma/pragma_once.c
@@ -0,0 +1,3 @@
+#pragma once
+
+int main() {}
diff --git a/spec/files/pragma/pragma_once.cpp b/spec/files/pragma/pragma_once.cpp
@@ -0,0 +1,3 @@
+#pragma once
+
+int main() {}
diff --git a/spec/files/pragma/pragma_once.h b/spec/files/pragma/pragma_once.h
@@ -0,0 +1,3 @@
+#pragma once
+
+int main() {}
diff --git a/spec/files/pragma/pragma_once.hpp b/spec/files/pragma/pragma_once.hpp
@@ -0,0 +1,3 @@
+#pragma once
+
+int main() {}
diff --git a/spec/linter-clang-spec.js b/spec/linter-clang-spec.js

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+#pragma once`
	`2`	`+`
	`3`	`+int main() {}`