Support short channel matching

Author: christiangnrd

.gitignore

@@ -356,4 +356,7 @@ MigrationBackup/
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
 
+# Apple junk
+*.DS_Store
+
 !/src/bin

README.md

@@ -150,7 +150,7 @@ To launch a specific Julia version, say in channel `release`, run `julia +releas
 
 The Julia launcher `julia` automatically determines which specific version of Julia to launch. There are several ways to control and override which Juliaup channel should be used:
 
-1. A command line Julia version specifier, such as `julia +release`.
+1. A command line Julia version specifier, such as `julia +release`. For non-version channels, any unambiguous installed channel prefix will launch that channel.
 2. The `JULIAUP_CHANNEL` environment variable.
 3. A directory override, set with the `juliaup override set` command.
 3. The default Juliaup channel.

src/bin/julialauncher.rs

@@ -167,39 +167,70 @@ enum JuliaupChannelSource {
     Default,
 }
 
+fn only<T, I>(mut iter: I) -> Option<T>
+where
+    I: Iterator<Item = T>,
+{
+    let first = iter.next();
+    if iter.next().is_some() {
+        // There are multiple elements
+        return None;
+    }
+    first
+}
+
 fn get_julia_path_from_channel(
     versions_db: &JuliaupVersionDB,
     config_data: &JuliaupConfig,
-    channel: &str,
+    requested_channel: &str,
     juliaupconfig_path: &Path,
     juliaup_channel_source: JuliaupChannelSource,
 ) -> Result<(PathBuf, Vec<String>)> {
+    let expanded_channel = if requested_channel
+        .chars()
+        .next()
+        .map(char::is_numeric)
+        .unwrap_or(false)
+    {
+        requested_channel
+    } else {
+        match only(
+            config_data
+                .installed_channels
+                .keys()
+                .filter(|&item| item.starts_with(requested_channel)),
+        ) {
+            Some(val) => val,
+            None => requested_channel,
+        }
+    };
+
     let channel_info = config_data
             .installed_channels
-            .get(channel)
+            .get(expanded_channel)
             .ok_or_else(|| match juliaup_channel_source {
                 JuliaupChannelSource::CmdLine => {
-                    if versions_db.available_channels.contains_key(channel) {
-                        UserError { msg: format!("`{}` is not installed. Please run `juliaup add {}` to install channel or version.", channel, channel) }
+                    if versions_db.available_channels.contains_key(expanded_channel) {
+                        UserError { msg: format!("`{}` is not installed. Please run `juliaup add {}` to install channel or version.", expanded_channel, expanded_channel) }
                     } else {
-                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}`. Please run `juliaup list` to get a list of valid channels and versions.",  channel) }
+                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}`. Please run `juliaup list` to get a list of valid channels and versions.",  expanded_channel) }
                     }
                 }.into(),
                 JuliaupChannelSource::EnvVar=> {
-                    if versions_db.available_channels.contains_key(channel) {
-                        UserError { msg: format!("`{}` for environment variable JULIAUP_CHANNEL is not installed. Please run `juliaup add {}` to install channel or version.", channel, channel) }
+                    if versions_db.available_channels.contains_key(expanded_channel) {
+                        UserError { msg: format!("`{}` for environment variable JULIAUP_CHANNEL is not installed. Please run `juliaup add {}` to install channel or version.", expanded_channel, expanded_channel) }
                     } else {
-                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}` in environment variable JULIAUP_CHANNEL. Please run `juliaup list` to get a list of valid channels and versions.",  channel) }
+                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}` in environment variable JULIAUP_CHANNEL. Please run `juliaup list` to get a list of valid channels and versions.",  expanded_channel) }
                     }
                 }.into(),
                 JuliaupChannelSource::Override=> {
-                    if versions_db.available_channels.contains_key(channel) {
-                        UserError { msg: format!("`{}` for directory override is not installed. Please run `juliaup add {}` to install channel or version.", channel, channel) }
+                    if versions_db.available_channels.contains_key(expanded_channel) {
+                        UserError { msg: format!("`{}` for directory override is not installed. Please run `juliaup add {}` to install channel or version.", expanded_channel, expanded_channel) }
                     } else {
-                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}` in directory override. Please run `juliaup list` to get a list of valid channels and versions.",  channel) }
+                        UserError { msg: format!("ERROR: Invalid Juliaup channel `{}` in directory override. Please run `juliaup list` to get a list of valid channels and versions.",  expanded_channel) }
                     }
                 }.into(),
-                JuliaupChannelSource::Default => anyhow!("The Juliaup configuration is in an inconsistent state, the currently configured default channel `{}` is not installed.", channel)
+                JuliaupChannelSource::Default => anyhow!("The Juliaup configuration is in an inconsistent state, the currently configured default channel `{}` is not installed.", expanded_channel)
             })?;
 
     match channel_info {
@@ -212,12 +243,12 @@ fn get_julia_path_from_channel(
         JuliaupConfigChannel::SystemChannel { version } => {
             let path = &config_data
                 .installed_versions.get(version)
-                .ok_or_else(|| anyhow!("The juliaup configuration is in an inconsistent state, the channel {} is pointing to Julia version {}, which is not installed.", channel, version))?.path;
+                .ok_or_else(|| anyhow!("The juliaup configuration is in an inconsistent state, the channel {} is pointing to Julia version {}, which is not installed.", expanded_channel, version))?.path;
 
-            check_channel_uptodate(channel, version, versions_db).with_context(|| {
+            check_channel_uptodate(expanded_channel, version, versions_db).with_context(|| {
                 format!(
                     "The Julia launcher failed while checking whether the channel {} is up-to-date.",
-                    channel
+                    expanded_channel
                 )
             })?;
             let absolute_path = juliaupconfig_path
@@ -243,7 +274,7 @@ fn get_julia_path_from_channel(
             version: _,
         } => {
             if local_etag != server_etag {
-                if channel.starts_with("nightly") {
+                if expanded_channel.starts_with("nightly") {
                     // Nightly is updateable several times per day so this message will show
                     // more often than not unless folks update a couple of times a day.
                     // Also, folks using nightly are typically more experienced and need
@@ -254,12 +285,15 @@ fn get_julia_path_from_channel(
                 } else {
                     eprintln!(
                         "A new version of Julia for the `{}` channel is available. Run:",
-                        channel
+                        expanded_channel
                     );
                     eprintln!();
                     eprintln!("  juliaup update");
                     eprintln!();
-                    eprintln!("to install the latest Julia for the `{}` channel.", channel);
+                    eprintln!(
+                        "to install the latest Julia for the `{}` channel.",
+                        expanded_channel
+                    );
                 }
             }
 

tests/channel_selection.rs

@@ -125,4 +125,57 @@ fn channel_selection() {
         .assert()
         .failure()
         .stderr("ERROR: Invalid Juliaup channel `1.8.6`. Please run `juliaup list` to get a list of valid channels and versions.\n");
+
+    // Now testing short channel matching
+    // At this point, installed channels are: 1.6.7, 1.7.3, 1.8.5
+
+    // Test that incomplete number matching does not autocomplete:
+    // https://github.com/JuliaLang/juliaup/pull/838#issuecomment-2206640506
+    Command::cargo_bin("julia")
+        .unwrap()
+        .arg("+1.8")
+        .arg("-v")
+        .env("JULIA_DEPOT_PATH", depot_dir.path())
+        .env("JULIAUP_DEPOT_PATH", depot_dir.path())
+        .assert()
+        .failure();
+
+    // Test that completion works only when it should for words
+    Command::cargo_bin("juliaup")
+        .unwrap()
+        .arg("add")
+        .arg("release")
+        .env("JULIA_DEPOT_PATH", depot_dir.path())
+        .env("JULIAUP_DEPOT_PATH", depot_dir.path())
+        .assert()
+        .success()
+        .stdout("");
+
+    Command::cargo_bin("julia")
+        .unwrap()
+        .arg("+r")
+        .arg("-v")
+        .env("JULIA_DEPOT_PATH", depot_dir.path())
+        .env("JULIAUP_DEPOT_PATH", depot_dir.path())
+        .assert()
+        .success();
+
+    Command::cargo_bin("juliaup")
+        .unwrap()
+        .arg("add")
+        .arg("rc")
+        .env("JULIA_DEPOT_PATH", depot_dir.path())
+        .env("JULIAUP_DEPOT_PATH", depot_dir.path())
+        .assert()
+        .success()
+        .stdout("");
+
+    Command::cargo_bin("julia")
+        .unwrap()
+        .arg("+r")
+        .arg("-v")
+        .env("JULIA_DEPOT_PATH", depot_dir.path())
+        .env("JULIAUP_DEPOT_PATH", depot_dir.path())
+        .assert()
+        .failure();
 }