Add "Automatic" build variant.

Author: ehuss

RustEnhanced.sublime-build

@@ -4,6 +4,10 @@
     "command": "build",
 
     "variants": [
+        {
+            "name": "Automatic",
+            "command": "auto",
+        },
         {
             "name": "Run",
             "command": "run",

cargo_build.py

@@ -4,7 +4,7 @@
 import sublime
 import sublime_plugin
 from .rust import (rust_proc, rust_thread, opanel, util, messages,
-                   cargo_settings)
+                   cargo_settings, target_detect)
 from .rust.cargo_config import *
 
 # Maps command to an input string. Used to pre-populate the input panel with
@@ -43,15 +43,62 @@ class CargoExecCommand(sublime_plugin.WindowCommand):
     def run(self, command=None, command_info=None, settings=None):
         if command is None:
             return self.window.run_command('build', {'select': True})
-        self.command = command
-        self.command_info = cargo_settings.CARGO_COMMANDS\
-            .get(command, {}).copy()
-        if command_info:
-            self.command_info.update(command_info)
         self.initial_settings = settings if settings else {}
         self.settings = cargo_settings.CargoSettings(self.window)
         self.settings.load()
-        self._determine_working_path(self._run_check_for_args)
+        if command == 'auto':
+            self._detect_auto_build()
+        else:
+            self.command = command
+            self.command_info = cargo_settings.CARGO_COMMANDS\
+                .get(command, {}).copy()
+            if command_info:
+                self.command_info.update(command_info)
+            self._determine_working_path(self._run_check_for_args)
+
+    def _detect_auto_build(self):
+        """Handle the "auto" build variant, which automatically picks a build
+        command based on the current view."""
+        if not util.active_view_is_rust():
+            sublime.error_message(util.multiline_fix("""
+                Error: Could not determine what to build.
+
+                Open a Rust source file as the active Sublime view.
+            """))
+            return
+        td = target_detect.TargetDetector(self.window)
+        view = self.window.active_view()
+        targets = td.determine_targets(view.file_name())
+        if len(targets) == 0:
+            sublime.error_message(util.multiline_fix("""
+                Error: Could not determine what to build.
+
+                Try using one of the explicit build variants.
+            """))
+            return
+
+        elif len(targets) == 1:
+            self._auto_choice_made(targets, 0)
+
+        else:
+            # Can't determine a single target, let the user choose one.
+            display_items = [' '.join(x[1]) for x in targets]
+            on_done = functools.partial(self._auto_choice_made, targets)
+            self.window.show_quick_panel(display_items, on_done)
+
+    def _auto_choice_made(self, targets, index):
+        if index != -1:
+            src_path, cmd_line = targets[index]
+            actions = {
+                '--bin': 'run',
+                '--example': 'run',
+                '--lib': 'build',
+                '--bench': 'bench',
+                '--test': 'test',
+            }
+            cmd = actions[cmd_line[0]]
+            self.initial_settings['target'] = ' '.join(cmd_line)
+            self.run(command=cmd, settings=self.initial_settings)
 
     def _determine_working_path(self, on_done):
         """Determine where Cargo should be run.

docs/build.md

@@ -31,6 +31,7 @@ Ctrl-Shift-B / ⌘-Shift-B).  They are:
 Variant | Command | Description
 ------- | ------- | -----------
 (Default) | <code>cargo&nbsp;build</code> | Builds the project.
+Automatic | | Automatically detect the command to run based on the currently active view (tests do `test`, binaries and examples do `run`, libraries do `build`, benches do `bench`).
 Run | <code>cargo&nbsp;run</code> | Runs the binary.
 Run (with args)... | <code>cargo&nbsp;run&nbsp;-&#8288;-&#8288;&nbsp;*args*</code> | Runs the binary with optional arguments you specify.
 Test | <code>cargo&nbsp;test</code> | Runs unit and integration tests.

rust/cargo_settings.py

@@ -22,6 +22,15 @@
 from . import util, target_detect
 
 CARGO_COMMANDS = {
+    'auto': {
+        'name': 'Automatic',
+        'command': 'auto',
+        'allows_target': True,
+        'allows_target_triple': True,
+        'allows_release': True,
+        'allows_features': True,
+        'allows_json': True,
+    },
     'build': {
         'name': 'Build',
         'command': 'build',

rust/target_detect.py

@@ -153,7 +153,7 @@ def _targets_longest_matches(self, targets, file_name):
                 break
             path_match = p
         # If the match is both --bin and --lib in the same directory,
-        # just do --lib.
+        # just do --bin.
         if found_bin and found_lib:
             result = [x for x in result if x[1][0] != '--bin']
         return result

tests/test_cargo_build.py

@@ -386,3 +386,58 @@ def _test_build_env(self, view):
         self._run_build_wait('run')
         output = self._get_build_output(window)
         self.assertRegex(output, '(?m)^RUST_BUILD_ENV_TEST=abcdef$')
+
+    def test_auto_build(self):
+        """Test "auto" build."""
+        tests = [
+            # This should probably automatically use nightly?
+            ('benches/bench1.rs', r'may not be used on the stable release channel'),
+            ('examples/ex1.rs', r'(?m)^ex1$'),
+            ('src/bin/bin1.rs', r'(?m)^bin1$'),
+            ('src/altmain.rs', r'(?m)^altmain$'),
+            ('src/lib.rs', r'\[Running: cargo build --lib'),
+            ('src/lmod1.rs', r'\[Running: cargo build --lib'),
+            ('src/main.rs', r'(?m)^Hello$'),
+            ('tests/test1.rs', r'(?m)^test sample_test1 \.\.\. ok$'),
+        ]
+        for path, pattern in tests:
+            self._with_open_file('tests/multi-targets/' + path,
+                self._test_auto_build, pattern=pattern)
+
+    def _test_auto_build(self, view, pattern=None):
+        window = view.window()
+        self._run_build_wait('auto')
+        output = self._get_build_output(window)
+        self.assertRegex(output, pattern)
+
+    def test_ambiguous_auto_build(self):
+        """Test "auto" build with indeterminate target."""
+        self._with_open_file('tests/multi-targets/tests/common/helpers.rs',
+            self._test_ambiguous_auto_build)
+
+    def _test_ambiguous_auto_build(self, view):
+        window = view.window()
+        sqp = window.__class__.show_quick_panel
+        window.__class__.show_quick_panel = self._quick_panel
+        try:
+            self._test_ambiguous_auto_build2(view)
+        finally:
+            window.__class__.show_quick_panel = sqp
+
+    def _quick_panel(self, items, on_done, flags=0,
+                     selected_index=-1, on_highlighted=None):
+        self.assertEqual(items, self.quick_panel_items)
+        on_done(self.quick_panel_index)
+
+    def _test_ambiguous_auto_build2(self, view):
+        window = view.window()
+        self.quick_panel_items = ['--test test1', '--test test2']
+        self.quick_panel_index = 0
+        self._run_build_wait('auto')
+        output = self._get_build_output(window)
+        self.assertRegex(output, r'\[Running: cargo test --test test1 ')
+
+        self.quick_panel_index = 1
+        self._run_build_wait('auto')
+        output = self._get_build_output(window)
+        self.assertRegex(output, r'\[Running: cargo test --test test2 ')