Merge pull request #143 from AtomLinter/arcanemagus/linter-v2

Update to Linter v2

Author: Arcanemagus

lib/init.coffee

@@ -75,7 +75,6 @@ module.exports =
   activate: ->
     require('atom-package-deps').install 'linter-rust'
 
-
   provideLinter: ->
     LinterRust = require('./linter-rust')
     @provider = new LinterRust()
@@ -84,5 +83,5 @@ module.exports =
       grammarScopes: ['source.rust']
       scope: 'project'
       lint: @provider.lint
-      lintOnFly: false
+      lintsOnChange: false
     }

lib/linter-rust.coffee

@@ -115,8 +115,8 @@ class LinterRust
 
             # correct file paths
             messages.forEach (message) ->
-              if !(path.isAbsolute message.filePath)
-                message.filePath = path.join curDir, message.filePath
+              if !(path.isAbsolute message.location.file)
+                message.file = path.join curDir, message.file
             messages
           else
             # whoops, we're in trouble -- let's output as much as we can
@@ -196,7 +196,6 @@ class LinterRust
         @cachedErrorMode = result
         result
 
-
   locateCargo: (curDir) =>
     root_dir = if /^win/.test process.platform then /^.:\\$/ else /^\/$/
     directory = path.resolve curDir

lib/mode.coffee

@@ -53,7 +53,6 @@ parseJsonMessages = (messages, {disabledWarnings}) ->
     for span in input.spans
       unless span.is_primary
         element.children.push
-          message: span.label
           range: [
             [span.line_start - 1, span.column_start - 1],
             [span.line_end - 1, span.column_end - 1]
@@ -81,12 +80,10 @@ buildMessages = (elements, disabledWarnings) ->
       when 'info', 'trace', 'note'
         # Add only if there is a last message
         if lastMessage
-          lastMessage.trace or= []
-          lastMessage.trace.push
-            type: "Trace"
-            text: element.message
-            filePath: element.file
-            range: element.range
+          lastMessage.reference = {
+            file: element.file
+            position: element.range
+          }
       when 'warning'
         # If the message is warning and user enabled disabling warnings
         # Check if this warning is disabled
@@ -111,19 +108,22 @@ buildMessages = (elements, disabledWarnings) ->
 
 constructMessage = (type, element) ->
   message =
-    type: type
-    text: element.message
-    filePath: element.file
-    range: element.range
+    severity: type.toLowerCase()
+    excerpt: element.message
+    location: {
+      file: element.file
+      position: element.range
+    }
   # children exists only in JSON messages
   if element.children
-    message.trace = []
     for children in element.children
-      message.trace.push
-        type: "Trace"
-        text: children.message
-        filePath: element.file
-        range: children.range or element.range
+      if children.range
+        # NOTE: Will only save the first valid reference
+        message.reference = {
+          file: element.file
+          position: children.range
+        }
+        break
   message
 
 buildRustcArguments = (linter, paths) ->

package.json

@@ -14,18 +14,18 @@
   "providedServices": {
     "linter": {
       "versions": {
-        "1.0.0": "provideLinter"
+        "2.0.0": "provideLinter"
       }
     }
   },
   "dependencies": {
     "atom-linter": "^10.0.0",
-    "atom-package-deps": "^4.3.1",
+    "atom-package-deps": "^5.0.0",
     "semver": "^5.3.0",
     "xregexp": "^4.1.1"
   },
   "package-deps": [
-    "linter",
+    "linter:2.0.0",
     "language-rust"
   ]
 }

spec/parse-spec.coffee

@@ -10,19 +10,21 @@ describe "errorModes::OLD_RUSTC::parse", ->
   it "should properly parse one line error message", ->
     expect(errorModes.OLD_RUSTC.parse('my/awesome file.rs:1:2: 3:4 error: my awesome text\n', {}))
       .toEqual([{
-        type: 'Error'
-        text: 'my awesome text'
-        filePath: 'my/awesome file.rs'
-        range: [[0, 1], [2, 3]]
+        severity: 'error'
+        excerpt: 'my awesome text'
+        location:
+          file: 'my/awesome file.rs'
+          position: [[0, 1], [2, 3]]
       }])
 
   it "should properly parse one line warning message", ->
     expect(errorModes.OLD_RUSTC.parse('foo:33:44: 22:33 warning: äüö<>\n', {}))
       .toEqual([{
-        type: 'Warning',
-        text: 'äüö<>'
-        filePath: 'foo'
-        range: [[32, 43], [21, 32]]
+        severity: 'warning',
+        excerpt: 'äüö<>'
+        location:
+          file: 'foo'
+          position: [[32, 43], [21, 32]]
       }])
 
   it "should return messages with a range of at least one character", ->
@@ -31,47 +33,77 @@ describe "errorModes::OLD_RUSTC::parse", ->
         # expect(editor.getPath()).toContain 'c.coffee'
     expect(errorModes.OLD_RUSTC.parse('foo:1:1: 1:1 error: text\n', {textEditor: editor}))
       .toEqual([{
-        type: 'Error'
-        text: 'text'
-        filePath: 'foo'
-        range: [[0, 0], [0, 2]]
+        severity: 'error'
+        excerpt: 'text'
+        location:
+          file: 'foo'
+          position: [[0, 0], [0, 2]]
       }])
     expect(errorModes.OLD_RUSTC.parse('foo:2:1: 2:1 error: text\n', {textEditor: editor}))
       .toEqual([{
-        type: 'Error'
-        text: 'text'
-        filePath: 'foo'
-        range: [[1, 0], [1, 7]]
+        severity: 'error'
+        excerpt: 'text'
+        location:
+          file: 'foo'
+          position: [[1, 0], [1, 7]]
       }])
 
   it "should properly parse multiline messages", ->
     expect(errorModes.OLD_RUSTC.parse('bar:1:2: 3:4 error: line one\n\
                          two\n', {}))
       .toEqual([
-        { type: 'Error', text: 'line one\ntwo', filePath: 'bar', range: [[0, 1], [2, 3]] }
+        {
+          severity: 'error',
+          excerpt: 'line one\ntwo',
+          location: {
+            file: 'bar',
+            position: [[0, 1], [2, 3]]
+          }
+        }
       ])
     expect(errorModes.OLD_RUSTC.parse('bar:1:2: 3:4 error: line one\n\
                          two\n\
                          foo:1:1: 1:2 warning: simple line\n', {}))
       .toEqual([
-        { type: 'Error', text: 'line one\ntwo', filePath: 'bar', range: [[0, 1], [2, 3]] },
-        { type: 'Warning', text: 'simple line', filePath: 'foo', range: [[0, 0], [0, 1]] }
+        {
+          severity: 'error',
+          excerpt: 'line one\ntwo',
+          location: {
+            file: 'bar',
+            position: [[0, 1], [2, 3]]
+          }
+        },
+        {
+          severity: 'warning',
+          excerpt: 'simple line',
+          location: {
+            file: 'foo',
+            position: [[0, 0], [0, 1]]
+          }
+        }
       ])
     expect(errorModes.OLD_RUSTC.parse('bar:1:2: 3:4 error: line one\n\
                          two\n\
                          three\n\
                          foo:1   shouldnt match', {}))
       .toEqual([
-        { type: 'Error', text: 'line one\ntwo\nthree', filePath: 'bar', range: [[0, 1], [2, 3]] }
+        {
+          severity: 'error',
+          excerpt: 'line one\ntwo\nthree',
+          location: {
+            file: 'bar',
+            position: [[0, 1], [2, 3]]
+          }
+        }
       ])
 
   it "should also cope with windows line breaks", ->
-    expect(errorModes.OLD_RUSTC.parse('a:1:2: 3:4 error: a\r\nb\n', {})[0].text)
+    expect(errorModes.OLD_RUSTC.parse('a:1:2: 3:4 error: a\r\nb\n', {})[0].excerpt)
       .toEqual('a\r\nb')
 
     multi = errorModes.OLD_RUSTC.parse('a:1:2: 3:4 error: a\n\rb\n\rx:1:2: 3:4 error: asd\r\n', {})
-    expect(multi[0].text).toEqual('a\n\rb')
-    expect(multi[1].text).toEqual('asd')
+    expect(multi[0].excerpt).toEqual('a\n\rb')
+    expect(multi[1].excerpt).toEqual('asd')
 
   it "should not throw an error with extra whitespace in paths", ->
     buildLinterWithWhitespacePath = () ->