-use crate::config::{Config, ConfigLoadError};

-use helix_core::config::{default_lang_config, user_lang_config};

-use std::{

- collections::HashSet,

- io::{IsTerminal, Write},

-};

-use termina::{

- style::{ColorSpec, StyleExt as _, Stylized},

- Terminal as _,

-};

- Tags,

- RainbowBracket,

- &[

- Self::Highlight,

- Self::TextObject,

- Self::AutoIndent,

- Self::Tags,

- Self::RainbowBracket,

- ]

- Self::AutoIndent => "indents.scm",

- Self::Tags => "tags.scm",

- Self::RainbowBracket => "rainbows.scm",

- Self::Tags => "Code Navigation Tags",

- Self::RainbowBracket => "Rainbow Brackets",

- Self::Tags => "Tags",

- Self::RainbowBracket => "Rainbow",

-pub fn general() -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

-

- let rt_dirs = helix_loader::runtime_dirs();

- writeln!(stdout, "Config file: {}", config_file.display())?;

- writeln!(stdout, "Config file: default")?;

- writeln!(stdout, "Language file: {}", lang_file.display())?;

- writeln!(stdout, "Language file: default")?;

- writeln!(stdout, "Log file: {}", log_file.display())?;

- writeln!(

- stdout,

- "Runtime directories: {}",

- rt_dirs

- .iter()

- .map(|d| d.to_string_lossy())

- .collect::<Vec<_>>()

- .join(";")

- )?;

- for rt_dir in rt_dirs.iter() {

- if let Ok(path) = std::fs::read_link(rt_dir) {

- let msg = format!(

- "Runtime directory {} is symlinked to: {}",

- rt_dir.display(),

- path.display()

- );

- writeln!(stdout, "{}", msg.yellow())?;

- }

- if !rt_dir.exists() {

- let msg = format!("Runtime directory does not exist: {}", rt_dir.display());

- writeln!(stdout, "{}", msg.yellow())?;

- } else if rt_dir.read_dir().ok().map(|it| it.count()) == Some(0) {

- let msg = format!("Runtime directory is empty: {}", rt_dir.display());

- writeln!(stdout, "{}", msg.yellow())?;

- }

- }

-

- Ok(())

-}

-

-pub fn clipboard() -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

- let config = match Config::load_default() {

- Ok(config) => config,

- Err(ConfigLoadError::Error(err)) if err.kind() == std::io::ErrorKind::NotFound => {

- Config::default()

- }

- Err(err) => {

- writeln!(stdout, "{}", "Configuration file malformed".red())?;

- writeln!(stdout, "{}", err)?;

- return Ok(());

- }

- };

-

- match config.editor.clipboard_provider.name().as_ref() {

- "none" => {

- writeln!(

- stdout,

- "{}",

- "System clipboard provider: Not installed".red()

- )?;

- writeln!(

- stdout,

- " {}",

- "For troubleshooting system clipboard issues, refer".red()

- )?;

- writeln!(stdout, " {}",

- "https://github.com/helix-editor/helix/wiki/Troubleshooting#copypaste-fromto-system-clipboard-not-working"

- .red().underlined())?;

- }

- name => writeln!(stdout, "System clipboard provider: {}", name)?,

-

- Ok(())

-}

-

-pub fn languages_all() -> std::io::Result<()> {

- languages(None)

-}

-

-pub fn languages_selection() -> std::io::Result<()> {

- let selection = helix_loader::grammar::get_grammar_names().unwrap_or_default();

- languages(selection)

-fn languages(selection: Option<HashSet<String>>) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

- let mut syn_loader_conf = match user_lang_config() {

- Ok(conf) => conf,

- Err(err) => {

- let stderr = std::io::stderr();

- let mut stderr = stderr.lock();

-

- writeln!(

- stderr,

- "{}: {}",

- "Error parsing user language config".red(),

- err

- )?;

- writeln!(stderr, "{}", "Using default language config".yellow())?;

- default_lang_config()

- }

- };

-

- let mut headings = vec!["Language", "Language servers", "Debug adapter", "Formatter"];

- let terminal_cols = termina::PlatformTerminal::new()

- .and_then(|terminal| terminal.get_dimensions())

- .map(|size| size.cols)

- .unwrap_or(80);

- let is_terminal = std::io::stdout().is_terminal();

- let fit = |s: &str| -> Stylized<'static> {

- format!(

- s.get(..column_width - 2)

- .map(|s| format!("{}…", s))

- .unwrap_or_else(|| s.to_string())

- .stylized()

- let color = |s: Stylized<'static>, c: ColorSpec| if is_terminal { s.foreground(c) } else { s };

- let bold = |s: Stylized<'static>| if is_terminal { s.bold() } else { s };

- write!(stdout, "{}", bold(fit(heading)))?;

- writeln!(stdout)?;

- let check_binary_with_name = |cmd: Option<(&str, &str)>| match cmd {

- Some((name, cmd)) => match helix_stdx::env::which(cmd) {

- Ok(_) => color(fit(&format!("✓ {}", name)), ColorSpec::BRIGHT_GREEN),

- Err(_) => color(fit(&format!("✘ {}", name)), ColorSpec::BRIGHT_RED),

- None => color(fit("None"), ColorSpec::BRIGHT_YELLOW),

- let check_binary = |cmd: Option<&str>| check_binary_with_name(cmd.map(|cmd| (cmd, cmd)));

-

- if selection

- .as_ref()

- .is_some_and(|s| !s.contains(&lang.language_id))

- {

- continue;

- }

-

- write!(stdout, "{}", fit(&lang.language_id))?;

- let mut cmds = lang.language_servers.iter().filter_map(|ls| {

- syn_loader_conf

- .language_server

- .get(&ls.name)

- .map(|config| (ls.name.as_str(), config.command.as_str()))

- });

- write!(stdout, "{}", check_binary_with_name(cmds.next()))?;

-

- let dap = lang.debugger.as_ref().map(|dap| dap.command.as_str());

- write!(stdout, "{}", check_binary(dap))?;

-

- let formatter = lang

- .formatter

- .map(|formatter| formatter.command.as_str());

- write!(stdout, "{}", check_binary(formatter))?;

- true => write!(stdout, "{}", color(fit("✓"), ColorSpec::BRIGHT_GREEN))?,

- false => write!(stdout, "{}", color(fit("✘"), ColorSpec::BRIGHT_RED))?,

- writeln!(stdout)?;

-

- for cmd in cmds {

- write!(stdout, "{}", fit(""))?;

- writeln!(stdout, "{}", check_binary_with_name(Some(cmd)))?;

- }

-

- if selection.is_some() {

- writeln!(

- stdout,

- "\nThis list is filtered according to the 'use-grammars' option in languages.toml file.\n\

- To see the full list, use the '--health all' or '--health all-languages' option."

- )?;

- }

-

- Ok(())

-pub fn language(lang_str: String) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

-

- let syn_loader_conf = match user_lang_config() {

- Ok(conf) => conf,

- Err(err) => {

- let stderr = std::io::stderr();

- let mut stderr = stderr.lock();

-

- writeln!(

- stderr,

- "{}: {}",

- "Error parsing user language config".red(),

- err

- )?;

- writeln!(stderr, "{}", "Using default language config".yellow())?;

- default_lang_config()

- }

- };

- let msg = format!("Language '{}' not found", lang_str);

- writeln!(stdout, "{}", msg.red())?;

- writeln!(

- stdout,

- "Did you mean one of these: {} ?",

- suggestions.yellow()

- )?;

- return Ok(());

- probe_protocols(

- lang.language_servers.iter().filter_map(|ls| {

- syn_loader_conf

- .language_server

- .get(&ls.name)

- .map(|config| (ls.name.as_str(), config.command.as_str()))

- }),

- )?;

- )?;

-

- probe_protocol(

- "formatter",

- lang.formatter

- .as_ref()

- .map(|formatter| formatter.command.to_string()),

- )?;

-

- probe_parser(lang.grammar.as_ref().unwrap_or(&lang.language_id))?;

- probe_treesitter_feature(&lang_str, *ts_feat)?

- }

-

- Ok(())

-}

-

-fn probe_parser(grammar_name: &str) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

-

- write!(stdout, "Tree-sitter parser: ")?;

-

- match helix_loader::grammar::get_language(grammar_name) {

- Ok(Some(_)) => writeln!(stdout, "{}", "✓".green()),

- Ok(None) | Err(_) => writeln!(stdout, "{}", "None".yellow()),

- }

-}

-

-/// Display diagnostics about multiple LSPs and DAPs.

-fn probe_protocols<'a, I: Iterator<Item = (&'a str, &'a str)> + 'a>(

- protocol_name: &str,

- server_cmds: I,

-) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

- let mut server_cmds = server_cmds.peekable();

-

- write!(stdout, "Configured {}s:", protocol_name)?;

- if server_cmds.peek().is_none() {

- writeln!(stdout, "{}", " None".yellow())?;

- return Ok(());

- writeln!(stdout)?;

-

- for (name, cmd) in server_cmds {

- let (diag, icon) = match helix_stdx::env::which(cmd) {

- Ok(path) => (path.display().to_string().green(), "✓".green()),

- Err(_) => (format!("'{}' not found in $PATH", cmd).red(), "✘".red()),

- };

- writeln!(stdout, " {} {}: {}", icon, name, diag)?;

- }

-

- Ok(())

-fn probe_protocol(protocol_name: &str, server_cmd: Option<String>) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

-

- write!(stdout, "Configured {}:", protocol_name)?;

- let Some(cmd) = server_cmd else {

- writeln!(stdout, "{}", " None".yellow())?;

- return Ok(());

- };

- writeln!(stdout)?;

-

- let (diag, icon) = match helix_stdx::env::which(&cmd) {

- Ok(path) => (path.display().to_string().green(), "✓".green()),

- Err(_) => (format!("'{}' not found in $PATH", cmd).red(), "✘".red()),

- writeln!(stdout, " {} {}", icon, diag)?;

- Ok(())

-fn probe_treesitter_feature(lang: &str, feature: TsFeature) -> std::io::Result<()> {

- let stdout = std::io::stdout();

- let mut stdout = stdout.lock();

-

- true => "✓".green(),

- false => "✘".red(),

- writeln!(stdout, "{} queries: {}", feature.short_title(), found)?;

-

- Ok(())

-}

-

-pub fn print_health(health_arg: Option<String>) -> std::io::Result<()> {

- match health_arg.as_deref() {

- Some("languages") => languages_selection()?,

- Some("all-languages") => languages_all()?,

- Some("clipboard") => clipboard()?,

- None => {

- general()?;

- clipboard()?;

- writeln!(std::io::stdout().lock())?;

- languages_selection()?;

- }

- Some("all") => {

- general()?;

- clipboard()?;

- writeln!(std::io::stdout().lock())?;

- languages_all()?;

- }

- Some(lang) => language(lang.to_string())?,

- }

- Ok(())