Better fix for checking when we should stop looking for JSON output.

The previous fix caused issues with Clippy.

Author: ehuss

cargo_build.py

@@ -185,18 +185,21 @@ def __init__(self, window, settings, command_info, initial_settings,
         self.working_dir = working_dir
 
     def run(self):
-        cmd_info = self.settings.get_command(self.command_info,
-                                             self.settings_path,
-                                             self.initial_settings)
-        if not cmd_info:
+        cmd = self.settings.get_command(self.command_info,
+                                        self.settings_path,
+                                        self.initial_settings)
+        if not cmd:
             return
         messages.clear_messages(self.window)
         p = rust_proc.RustProc()
         listener = opanel.OutputListener(self.window, self.working_dir)
+        print('command_info=%r' % self.command_info)
         try:
-            p.run(self.window, cmd_info['command'],
+            p.run(self.window, cmd['command'],
                   self.working_dir, listener,
-                  env=cmd_info['env'])
+                  env=cmd['env'],
+                  decode_json=self.command_info.get('allows_json', False),
+                  json_stop_pattern=self.command_info.get('json_stop_pattern'))
             p.wait()
         except rust_proc.ProcessTerminatedError:
             return

docs/build.md

@@ -169,6 +169,7 @@ Setting Name | Default | Description
 `allows_release` |  False | If True, allows `--release` flag.
 `allows_features` |  False | If True, allows feature flags.
 `allows_json` |  False | If True, allows `--message-format=json` flag.
+`json_stop_pattern` | None | A regular expression matched against Cargo's output to detect when it should stop looking for JSON messages (used by `cargo run` to stop looking for JSON messages once compilation is finished).
 `requires_manifest` | True | If True, the command must be run in a directory with a `Cargo.toml` manifest.
 `requires_view_path` |  False | If True, then the active view must be a Rust source file, and the path to that file will be passed into Cargo (used mainly by `cargo script`).
 `wants_run_args` |  False | If True, it will ask for extra args to pass to the executable (after the `--` flag separator).

rust/cargo_settings.py

@@ -48,6 +48,7 @@
         'allows_release': True,
         'allows_features': True,
         'allows_json': True,
+        'json_stop_pattern': '^\s*Running ',
     },
     'check': {
         'name': 'Check',

rust/rust_proc.py

@@ -140,14 +140,21 @@ class RustProc(object):
     # The thread used for reading output.
     _stdout_thread = None
 
-    def run(self, window, cmd, cwd, listener, env=None):
+    def run(self, window, cmd, cwd, listener, env=None,
+            decode_json=True, json_stop_pattern=None):
         """Run the process.
 
         :param window: Sublime window.
         :param cmd: The command to run (list of strings).
         :param cwd: The directory where to run the command.
         :param listener: `ProcListener` to receive the output.
         :param env: Dictionary of environment variables to add.
+        :param decode_json: If True, will check for lines starting with `{` to
+            decode as a JSON message.
+        :param json_stop_pattern: Regular expression used to detect when it
+            should stop looking for JSON messages.  This is used by `cargo
+            run` so that it does not capture output from the user's program
+            that might start with an open curly brace.
 
         :raises ProcessTermiantedError: Process was terminated by another
             thread.
@@ -157,6 +164,8 @@ def run(self, window, cmd, cwd, listener, env=None):
         self.listener = listener
         self.start_time = time.time()
         self.window = window
+        self.decode_json = decode_json
+        self.json_stop_pattern = json_stop_pattern
 
         from . import rust_thread
         try:
@@ -267,7 +276,6 @@ def wait(self):
         return rc
 
     def _read_stdout(self):
-        decode_json = True
         while True:
             line = self.proc.stdout.readline()
             if not line:
@@ -280,7 +288,7 @@ def _read_stdout(self):
                 self.listener.on_error(self,
                     '[Error decoding UTF-8: %r]' % line)
                 continue
-            if decode_json and line.startswith('{'):
+            if self.decode_json and line.startswith('{'):
                 try:
                     result = json.loads(line)
                 except:
@@ -293,10 +301,11 @@ def _read_stdout(self):
                         self._cleanup()
                         raise
             else:
-                if re.match('^\s*Finished', line):
-                    # If using "cargo run", we don't want to capture lines
-                    # starting with open bracket.
-                    decode_json = False
+                print('Checking pattern %r to line %r' % (self.json_stop_pattern, line))
+                if self.json_stop_pattern and \
+                        re.match(self.json_stop_pattern, line):
+                    # Stop looking for JSON open curly bracket.
+                    self.decode_json = False
                 # Sublime always uses \n internally.
                 line = line.replace('\r\n', '\n')
                 self.listener.on_data(self, line)

tests/test_cargo_build.py

@@ -194,11 +194,12 @@ def test_run_with_args(self):
 
     def _test_run_with_args(self, view):
         window = view.window()
+        # Curly braces to ensure it is not captured as JSON.
         self._run_build_wait('run',
-            settings={'extra_run_args': 'this is a test',
+            settings={'extra_run_args': '{this is a test}',
                       'target': '--bin bin2'})
         output = self._get_build_output(window)
-        self.assertRegex(output, '(?m)^this is a test$')
+        self.assertRegex(output, '(?m)^{this is a test}$')
 
     def test_test(self):
         """Test "Test" variant."""