Only disable links in VS code in the list

src/app_state.rs

@@ -1,5 +1,6 @@
 use anyhow::{bail, Context, Error, Result};
 use std::{
+    env,
     fs::{self, File},
     io::{Read, StdoutLock, Write},
     path::Path,
@@ -44,6 +45,8 @@ pub struct AppState {
     file_buf: Vec<u8>,
     official_exercises: bool,
     cmd_runner: CmdRunner,
+    // Running in VS Code.
+    vs_code: bool,
 }
 
 impl AppState {
@@ -131,6 +134,7 @@ impl AppState {
             file_buf: Vec::with_capacity(2048),
             official_exercises: !Path::new("info.toml").exists(),
             cmd_runner,
+            vs_code: env::var_os("TERM_PROGRAM").is_some_and(|v| v == "vscode"),
         };
 
         let state_file_status = slf.update_from_file();
@@ -163,6 +167,11 @@ impl AppState {
         &self.cmd_runner
     }
 
+    #[inline]
+    pub fn vs_code(&self) -> bool {
+        self.vs_code
+    }
+
     // Write the state file.
     // The file's format is very simple:
     // - The first line is a comment.
@@ -321,14 +330,10 @@ impl AppState {
                 .write_solution_to_disk(self.current_exercise_ind, current_exercise.name)
                 .map(Some)
         } else {
-            let solution_path = if let Some(dir) = current_exercise.dir {
-                format!("solutions/{dir}/{}.rs", current_exercise.name)
-            } else {
-                format!("solutions/{}.rs", current_exercise.name)
-            };
+            let sol_path = current_exercise.sol_path();
 
-            if Path::new(&solution_path).exists() {
-                return Ok(Some(solution_path));
+            if Path::new(&sol_path).exists() {
+                return Ok(Some(sol_path));
             }
 
             Ok(None)
@@ -461,6 +466,7 @@ mod tests {
             file_buf: Vec::new(),
             official_exercises: true,
             cmd_runner: CmdRunner::build().unwrap(),
+            vs_code: false,
         };
 
         let mut assert = |done: [bool; 3], expected: [Option<usize>; 3]| {

src/cargo_toml.rs

@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use std::path::Path;
 
-use crate::info_file::ExerciseInfo;
+use crate::{exercise::RunnableExercise, info_file::ExerciseInfo};
 
 /// Initial capacity of the bins buffer.
 pub const BINS_BUFFER_CAPACITY: usize = 1 << 14;

src/dev/check.rs

@@ -17,6 +17,8 @@ use crate::{
     CURRENT_FORMAT_VERSION,
 };
 
+const MAX_EXERCISE_NAME_LEN: usize = 32;
+
 // Find a char that isn't allowed in the exercise's `name` or `dir`.
 fn forbidden_char(input: &str) -> Option<char> {
     input.chars().find(|c| !c.is_alphanumeric() && *c != '_')
@@ -59,6 +61,9 @@ fn check_info_file_exercises(info_file: &InfoFile) -> Result<HashSet<PathBuf>> {
         if name.is_empty() {
             bail!("Found an empty exercise name in `info.toml`");
         }
+        if name.len() > MAX_EXERCISE_NAME_LEN {
+            bail!("The length of the exercise name `{name}` is bigger than the maximum {MAX_EXERCISE_NAME_LEN}");
+        }
         if let Some(c) = forbidden_char(name) {
             bail!("Char `{c}` in the exercise name `{name}` is not allowed");
         }

src/exercise.rs

@@ -68,6 +68,7 @@ pub struct Exercise {
 
 pub trait RunnableExercise {
     fn name(&self) -> &str;
+    fn dir(&self) -> Option<&str>;
     fn strict_clippy(&self) -> bool;
     fn test(&self) -> bool;
 
@@ -145,6 +146,31 @@ pub trait RunnableExercise {
 
         self.run::<true>(&bin_name, output, cmd_runner)
     }
+
+    fn sol_path(&self) -> String {
+        let name = self.name();
+
+        let mut path = if let Some(dir) = self.dir() {
+            // 14 = 10 + 1 + 3
+            // solutions/ + / + .rs
+            let mut path = String::with_capacity(14 + dir.len() + name.len());
+            path.push_str("solutions/");
+            path.push_str(dir);
+            path.push('/');
+            path
+        } else {
+            // 13 = 10 + 3
+            // solutions/ + .rs
+            let mut path = String::with_capacity(13 + name.len());
+            path.push_str("solutions/");
+            path
+        };
+
+        path.push_str(name);
+        path.push_str(".rs");
+
+        path
+    }
 }
 
 impl RunnableExercise for Exercise {
@@ -153,6 +179,11 @@ impl RunnableExercise for Exercise {
         self.name
     }
 
+    #[inline]
+    fn dir(&self) -> Option<&str> {
+        self.dir
+    }
+
     #[inline]
     fn strict_clippy(&self) -> bool {
         self.strict_clippy

src/info_file.rs

@@ -52,30 +52,6 @@ impl ExerciseInfo {
 
         path
     }
-
-    /// Path to the solution file starting with the `solutions/` directory.
-    pub fn sol_path(&self) -> String {
-        let mut path = if let Some(dir) = &self.dir {
-            // 14 = 10 + 1 + 3
-            // solutions/ + / + .rs
-            let mut path = String::with_capacity(14 + dir.len() + self.name.len());
-            path.push_str("solutions/");
-            path.push_str(dir);
-            path.push('/');
-            path
-        } else {
-            // 13 = 10 + 3
-            // solutions/ + .rs
-            let mut path = String::with_capacity(13 + self.name.len());
-            path.push_str("solutions/");
-            path
-        };
-
-        path.push_str(&self.name);
-        path.push_str(".rs");
-
-        path
-    }
 }
 
 impl RunnableExercise for ExerciseInfo {
@@ -84,6 +60,11 @@ impl RunnableExercise for ExerciseInfo {
         &self.name
     }
 
+    #[inline]
+    fn dir(&self) -> Option<&str> {
+        self.dir.as_deref()
+    }
+
     #[inline]
     fn strict_clippy(&self) -> bool {
         self.strict_clippy

src/init.rs

@@ -13,8 +13,8 @@ use std::{
 };
 
 use crate::{
-    cargo_toml::updated_cargo_toml, embedded::EMBEDDED_FILES, info_file::InfoFile,
-    term::press_enter_prompt,
+    cargo_toml::updated_cargo_toml, embedded::EMBEDDED_FILES, exercise::RunnableExercise,
+    info_file::InfoFile, term::press_enter_prompt,
 };
 
 #[derive(Deserialize)]

src/list/state.rs

@@ -14,13 +14,11 @@ use crate::{
     app_state::AppState,
     exercise::Exercise,
     term::{progress_bar, terminal_file_link, CountedWrite, MaxLenWriter},
-    MAX_EXERCISE_NAME_LEN,
 };
 
 use super::scroll_state::ScrollState;
 
-// +1 for column padding.
-const SPACE: &[u8] = &[b' '; MAX_EXERCISE_NAME_LEN + 1];
+const COL_SPACING: usize = 2;
 
 fn next_ln(stdout: &mut StdoutLock) -> io::Result<()> {
     stdout
@@ -41,7 +39,7 @@ pub struct ListState<'a> {
     pub message: String,
     app_state: &'a mut AppState,
     scroll_state: ScrollState,
-    name_col_width: usize,
+    name_col_padding: Vec<u8>,
     filter: Filter,
     term_width: u16,
     term_height: u16,
@@ -61,6 +59,7 @@ impl<'a> ListState<'a> {
             .map(|exercise| exercise.name.len())
             .max()
             .map_or(name_col_title_len, |max| max.max(name_col_title_len));
+        let name_col_padding = vec![b' '; name_col_width + COL_SPACING];
 
         let filter = Filter::None;
         let n_rows_with_filter = app_state.exercises().len();
@@ -73,7 +72,7 @@ impl<'a> ListState<'a> {
             message: String::with_capacity(128),
             app_state,
             scroll_state,
-            name_col_width,
+            name_col_padding,
             filter,
             // Set by `set_term_size`
             term_width: 0,
@@ -162,9 +161,15 @@ impl<'a> ListState<'a> {
             writer.stdout.queue(SetForegroundColor(Color::Reset))?;
 
             writer.write_str(exercise.name)?;
-            writer.write_ascii(&SPACE[..self.name_col_width + 2 - exercise.name.len()])?;
+            writer.write_ascii(&self.name_col_padding[exercise.name.len()..])?;
 
+            // The list links aren't shown correctly in VS Code on Windows.
+            // But VS Code shows its own links anyway.
+            if self.app_state.vs_code() {
+                writer.write_str(exercise.path)?;
+            } else {
                 terminal_file_link(&mut writer, exercise.path, Color::Blue)?;
+            }
 
             next_ln(stdout)?;
             stdout.queue(ResetColor)?;
@@ -184,7 +189,7 @@ impl<'a> ListState<'a> {
         // Header
         let mut writer = MaxLenWriter::new(stdout, self.term_width as usize);
         writer.write_ascii(b"  Current  State    Name")?;
-        writer.write_ascii(&SPACE[..self.name_col_width - 2])?;
+        writer.write_ascii(&self.name_col_padding[2..])?;
         writer.write_ascii(b"Path")?;
         next_ln(stdout)?;
 

src/main.rs

@@ -25,7 +25,6 @@ mod term;
 mod watch;
 
 const CURRENT_FORMAT_VERSION: u8 = 1;
-const MAX_EXERCISE_NAME_LEN: usize = 32;
 
 /// Rustlings is a collection of small exercises to get you used to writing and reading Rust code
 #[derive(Parser)]

src/term.rs

@@ -1,6 +1,5 @@
 use std::{
-    cell::Cell,
-    env, fmt, fs,
+    fmt, fs,
     io::{self, BufRead, StdoutLock, Write},
 };
 
@@ -11,10 +10,6 @@ use crossterm::{
     Command, QueueableCommand,
 };
 
-thread_local! {
-    static VS_CODE: Cell<bool> = Cell::new(env::var_os("TERM_PROGRAM").is_some_and(|v| v == "vscode"));
-}
-
 pub struct MaxLenWriter<'a, 'b> {
     pub stdout: &'a mut StdoutLock<'b>,
     len: usize,
@@ -161,11 +156,6 @@ pub fn terminal_file_link<'a>(
     path: &str,
     color: Color,
 ) -> io::Result<()> {
-    // VS Code shows its own links. This also avoids some issues, especially on Windows.
-    if VS_CODE.get() {
-        return writer.write_str(path);
-    }
-
     let canonical_path = fs::canonicalize(path).ok();
 
     let Some(canonical_path) = canonical_path.as_deref().and_then(|p| p.to_str()) else {