Fixed code and tests

Author: Суворов Станислав

lib/cached_result.coffee

@@ -0,0 +1,19 @@
+class CachedResult
+  currentTTL: null
+  result: null
+
+  constructor: (result, TTL = 5) ->
+    @currentTTL = TTL
+    @result = result
+
+  getResult: =>
+    if do @valid
+      @currentTTL -= 1
+      @result
+    else
+      null
+
+  valid: =>
+    @currentTTL > 0
+
+module.exports = CachedResult

lib/linter-rust.coffee

@@ -2,9 +2,10 @@ fs = require 'fs'
 path = require 'path'
 XRegExp = require 'xregexp'
 semver = require 'semver'
-sb_exec = require 'sb-exec'
 {CompositeDisposable} = require 'atom'
+atom_linter = require 'atom-linter'
 errorModes = require './mode'
+CachedResult = require './cached_result'
 
 class LinterRust
   patternRustcVersion: XRegExp('rustc (?<version>1.\\d+.\\d+)(?:(?:-(?<nightly>nightly)|(?:[^\\s]+))? \
@@ -71,7 +72,7 @@ class LinterRust
           additional = if env.RUSTFLAGS? then ' ' + env.RUSTFLAGS else ''
           env.RUSTFLAGS = '--error-format=json' + additional
 
-      sb_exec.exec(command, args, {env: env, cwd: cwd, stream: 'both'})
+      atom_linter.exec(command, args, {env: env, cwd: cwd, stream: 'both'})
         .then (result) =>
           {stdout, stderr, exitCode} = result
           # first, check if an output says specified features are invalid
@@ -94,7 +95,7 @@ class LinterRust
 
             # call a needed parser
             output = errorMode.neededOutput(stdout, stderr)
-            messages = errorMode.parse output, @disabledWarnings
+            messages = errorMode.parse output, {@disabledWarnings, textEditor}
 
             # correct file paths
             messages.forEach (message) ->
@@ -120,7 +121,7 @@ class LinterRust
 
   initCmd: (editingFile) =>
     curDir = path.dirname editingFile
-    cargoManifestPath = @locateCargo path.dirname editingFile
+    cargoManifestPath = @locateCargo curDir
     if not @useCargo or not cargoManifestPath
       @decideErrorMode(curDir, 'rustc').then (mode) =>
         mode.buildArguments(this, [editingFile, cargoManifestPath]).then (cmd) =>
@@ -140,32 +141,43 @@ class LinterRust
           result.push ['--cfg', "feature=\"#{f}\""]
         result
 
+  cachedErrorMode: null
+
   decideErrorMode: (curDir, commandMode) =>
-    # current dir is set to handle overrides
-    sb_exec.exec(@rustcPath, ['--version'], {stream: 'stdout', cwd: curDir, stdio: 'pipe'}).then (stdout) =>
-      try
-        match = XRegExp.exec(stdout, @patternRustcVersion)
-        if match
-          nightlyWithJSON = match.nightly and match.date > '2016-08-08'
-          stableWithJSON = not match.nightly and semver.gte(match.version, '1.12.0')
-          canUseIntermediateJSON = nightlyWithJSON or stableWithJSON
-          switch commandMode
-            when 'cargo'
-              canUseProperCargoJSON = match.nightly and match.date > '2016-10-10'
-              if canUseProperCargoJSON
-                errorModes.JSON_CARGO
-              # this mode is used only through August till October, 2016
-              else if canUseIntermediateJSON
-                errorModes.FLAGS_JSON_CARGO
-              else
-                errorModes.OLD_CARGO
-            when 'rustc'
-              if canUseIntermediateJSON
-                errorModes.JSON_RUSTC
-              else
-                errorModes.OLD_RUSTC
-        else
-          throw 'rustc returned inapplicable result: ' + stdout
+    # error mode is cached to avoid delays
+    if @cachedErrorMode? and do @cachedErrorMode.valid
+      Promise.resolve().then () =>
+        do @cachedErrorMode.getResult
+    else
+      # current dir is set to handle overrides
+      atom_linter.exec(@rustcPath, ['--version'], {cwd: curDir}).then (stdout) =>
+        try
+          match = XRegExp.exec(stdout, @patternRustcVersion)
+          if match
+            nightlyWithJSON = match.nightly and match.date > '2016-08-08'
+            stableWithJSON = not match.nightly and semver.gte(match.version, '1.12.0')
+            canUseIntermediateJSON = nightlyWithJSON or stableWithJSON
+            switch commandMode
+              when 'cargo'
+                canUseProperCargoJSON = match.nightly and match.date > '2016-10-10'
+                if canUseProperCargoJSON
+                  errorModes.JSON_CARGO
+                # this mode is used only through August till October, 2016
+                else if canUseIntermediateJSON
+                  errorModes.FLAGS_JSON_CARGO
+                else
+                  errorModes.OLD_CARGO
+              when 'rustc'
+                if canUseIntermediateJSON
+                  errorModes.JSON_RUSTC
+                else
+                  errorModes.OLD_RUSTC
+          else
+            throw 'rustc returned unexpected result: ' + stdout
+      .then (result) =>
+        @cachedErrorMode = new CachedResult(result)
+        result
+
 
   locateCargo: (curDir) =>
     root_dir = if /^win/.test process.platform then /^.:\\$/ else /^\/$/

lib/mode.coffee

@@ -1,21 +1,23 @@
 XRegExp = require 'xregexp'
-sb_exec = require 'sb-exec'
 path = require 'path'
+atom_linter = require 'atom-linter'
+CachedResult = require './cached_result'
 
 pattern = XRegExp('(?<file>[^\n\r]+):(?<from_line>\\d+):(?<from_col>\\d+):\\s*\
   (?<to_line>\\d+):(?<to_col>\\d+)\\s+\
   ((?<error>error|fatal error)|(?<warning>warning)|(?<info>note|help)):\\s+\
   (?<message>.+?)[\n\r]+($|(?=[^\n\r]+:\\d+))', 's')
 
-parseOldMessages = (output, disabledWarnings) ->
+parseOldMessages = (output, {disabledWarnings, textEditor}) ->
   elements = []
   XRegExp.forEach output, pattern, (match) ->
-    if match.from_col == match.to_col
-      match.to_col = parseInt(match.to_col) + 1
-    range = [
-      [match.from_line - 1, match.from_col - 1],
-      [match.to_line - 1, match.to_col - 1]
-    ]
+    range = if match.from_col == match.to_col and match.from_line == match.to_line
+      atom_linter.rangeFromLineNumber(textEditor, Number.parseInt(match.from_line, 10) - 1, Number.parseInt(match.from_col, 10) - 1)
+    else
+      [
+        [match.from_line - 1, match.from_col - 1],
+        [match.to_line - 1, match.to_col - 1]
+      ]
     level = if match.error then 'error'
     else if match.warning then 'warning'
     else if match.info then 'info'
@@ -29,7 +31,7 @@ parseOldMessages = (output, disabledWarnings) ->
     elements.push element
   buildMessages elements, disabledWarnings
 
-parseJsonMessages = (messages, disabledWarnings) ->
+parseJsonMessages = (messages, {disabledWarnings}) ->
   elements = []
   for input in messages
     continue unless input and input.spans
@@ -39,7 +41,7 @@ parseJsonMessages = (messages, disabledWarnings) ->
       [primary_span.line_start - 1, primary_span.column_start - 1],
       [primary_span.line_end - 1, primary_span.column_end - 1]
     ]
-    input.level = 'error' if input == 'fatal error'
+    input.level = 'error' if input.level == 'fatal error'
     element =
       type: input.level
       message: input.message
@@ -57,13 +59,17 @@ parseJsonMessages = (messages, disabledWarnings) ->
     elements.push element
   buildMessages elements, disabledWarnings
 
-parseJsonOutput = (output, disabledWarnings) ->
+parseJsonOutput = (output, {disabledWarnings, additionalFilter} ) ->
   results = output.split('\n').map (message) ->
     message = message.trim()
     if message.startsWith '{'
-      JSON.parse message
+      json = JSON.parse message
+      if additionalFilter?
+        additionalFilter(json)
+      else
+        json
   .filter (m) -> m?
-  parseJsonMessages results, disabledWarnings
+  parseJsonMessages results, {disabledWarnings}
 
 buildMessages = (elements, disabledWarnings) ->
   messages = []
@@ -134,7 +140,36 @@ buildRustcArguments = (linter, paths) ->
     cmd = cmd.concat [editingFile]
     [editingFile, cmd]
 
+cachedUsingMultitoolForClippy = null
+
 buildCargoArguments = (linter, cargoManifestPath) ->
+  buildCargoPath = (cargoPath, cargoCommand) ->
+    # the result is cached to avoid delays
+    if cachedUsingMultitoolForClippy? and do cachedUsingMultitoolForClippy.valid
+      Promise.resolve().then () =>
+        do cachedUsingMultitoolForClippy.getResult
+    else
+      # Decide if should use older multirust or newer rustup
+      usingMultitoolForClippy =
+        atom_linter.exec 'rustup', ['--version'], {ignoreExitCode: true}
+          .then ->
+            result: true, tool: 'rustup'
+          .catch ->
+            # Try to use older multirust at least
+            atom_linter.exec 'multirust', ['--version'], {ignoreExitCode: true}
+              .then ->
+                result: true, tool: 'multirust'
+              .catch ->
+                result: false
+      usingMultitoolForClippy.then (canUseMultirust) ->
+        if cargoCommand == 'clippy' and canUseMultirust.result
+          [canUseMultirust.tool, 'run', 'nightly', 'cargo']
+        else
+          [cargoPath]
+      .then (cached) =>
+        cachedUsingMultitoolForClippy = new CachedResult(cached, 20)
+        cached
+
   cargoArgs = switch linter.cargoCommand
     when 'check' then ['check']
     when 'test' then ['test', '--no-run']
@@ -143,42 +178,22 @@ buildCargoArguments = (linter, cargoManifestPath) ->
     else ['build']
 
   compilationFeatures = linter.compilationFeatures(true)
-  buildCargoPath(linter.cargoPath).then (cmd) ->
+  buildCargoPath(linter.cargoPath, linter.cargoCommand).then (cmd) ->
     cmd = cmd
       .concat cargoArgs
       .concat ['-j', linter.jobsNumber]
     cmd = cmd.concat compilationFeatures if compilationFeatures
     cmd = cmd.concat ['--manifest-path', cargoManifestPath]
     [cargoManifestPath, cmd]
 
-buildCargoPath = (cargoPath, cargoCommand) ->
-  usingMultitoolForClippy().then (canUseMultirust) ->
-    if cargoCommand == 'clippy' and canUseMultirust.result
-      [canUseMultirust.tool, 'run', 'nightly', 'cargo']
-    else
-      [cargoPath]
-
-usingMultitoolForClippy = () ->
-  # Try to use rustup
-  sb_exec.exec 'rustup', ['--version'], {ignoreExitCode: true}
-    .then ->
-      result: true, tool: 'rustup'
-    .catch ->
-      # Try to use odler multirust at least
-      sb_exec.exec 'multirust', ['--version'], {ignoreExitCode: true}
-        .then ->
-          result: true, tool: 'multirust'
-        .catch ->
-          result: false
-
 # These define the behabiour of each error mode linter-rust has
 errorModes =
   JSON_RUSTC:
     neededOutput: (stdout, stderr) ->
       stderr
 
-    parse: (output, disabledWarnings) =>
-      parseJsonOutput output, disabledWarnings
+    parse: (output, options) =>
+      parseJsonOutput output, options
 
     buildArguments: (linter, file) ->
       buildRustcArguments(linter, file).then (cmd_res) ->
@@ -190,16 +205,11 @@ errorModes =
     neededOutput: (stdout, stderr) ->
       stdout
 
-    parse: (output, disabledWarnings) ->
-      checkCompilerMessage = (message) ->
-        message = message.trim()
-        if message.startsWith '{'
-          input = JSON.parse message
-          input.message if input? and input.reason == "compiler-message"
-
-      results = output.split '\n'
-      results = results.map(checkCompilerMessage).filter((i) -> i?)
-      parseJsonMessages results, disabledWarnings
+    parse: (output, options) ->
+      options.additionalFilter = (json) ->
+        if input? and input.reason == "compiler-message"
+          input.message
+      parseJsonOutput output, options
 
     buildArguments: (linter, file) ->
       buildCargoArguments(linter, file).then (cmd_res) ->

package.json

@@ -16,9 +16,9 @@
     }
   },
   "dependencies": {
+    "atom-linter": "^8.0.0",
     "atom-package-deps": "^4.3.0",
     "semver": "^5.3.0",
-    "sb-exec": "^3.1.0",
     "xregexp": "~3.1.0"
   },
   "package-deps": [

spec/parse-spec.coffee

@@ -5,10 +5,10 @@ linter = new LinterRust()
 
 describe "errorModes::OLD_RUSTC::parse", ->
   it "should return 0 messages for an empty string", ->
-    expect(errorModes.OLD_RUSTC.parse('', [])).toEqual([])
+    expect(errorModes.OLD_RUSTC.parse('', {})).toEqual([])
 
   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', []))
+    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'
@@ -17,7 +17,7 @@ describe "errorModes::OLD_RUSTC::parse", ->
       }])
 
   it "should properly parse one line warning message", ->
-    expect(errorModes.OLD_RUSTC.parse('foo:33:44: 22:33 warning: äüö<>\n', []))
+    expect(errorModes.OLD_RUSTC.parse('foo:33:44: 22:33 warning: äüö<>\n', {}))
       .toEqual([{
         type: 'Warning',
         text: 'äüö<>'
@@ -26,47 +26,50 @@ describe "errorModes::OLD_RUSTC::parse", ->
       }])
 
   it "should return messages with a range of at least one character", ->
-    expect(errorModes.OLD_RUSTC.parse('foo:1:1: 1:1 error: text\n', []))
+    editor = atom.workspace.buildTextEditor()
+    editor.setText 'fn main() {\nprintln!("Hi test");}\n'
+        # 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, 1]]
+        range: [[0, 0], [0, 2]]
       }])
-    expect(errorModes.OLD_RUSTC.parse('foo:1:1: 2:1 error: text\n', []))
+    expect(errorModes.OLD_RUSTC.parse('foo:2:1: 2:1 error: text\n', {textEditor: editor}))
       .toEqual([{
         type: 'Error'
         text: 'text'
         filePath: 'foo'
-        range: [[0, 0], [1, 1]]
+        range: [[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', []))
+                         two\n', {}))
       .toEqual([
         { type: 'Error', text: 'line one\ntwo', filePath: 'bar', range: [[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', []))
+                         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]] }
       ])
     expect(errorModes.OLD_RUSTC.parse('bar:1:2: 3:4 error: line one\n\
                          two\n\
                          three\n\
-                         foo:1   shouldnt match', []))
+                         foo:1   shouldnt match', {}))
       .toEqual([
         { type: 'Error', text: 'line one\ntwo\nthree', filePath: 'bar', range: [[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].text)
       .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', [])
+    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')