worm_hole 4.2.0

// Copyright (C) 2026 Rignchen
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use crate::{
	db::Database,
	error::{WHError, WHResult},
	path::FilePath,
};
use clap::Parser;
use std::{env::current_exe, fmt::Display, str::FromStr};

#[derive(Parser, Debug)]
pub struct Init {
	/// The shell to generate the init code for
	shell: Shell,

	// All these flags will be used to set the commands to write in the console to call worm_hole
	// Only the worm_hole and cd command has a default value
	/// The command used to call worm_hole
	#[clap(long, default_value = "wh")]
	worm_hole: String,
	/// The command used to change directory
	#[clap(long, default_value = "whcd")]
	cd: String,
	/// The command to add a new alias-path pairs
	#[clap(long)]
	add: Option<String>,
	/// The command to remove an alias-path pair
	#[clap(long)]
	remove: Option<String>,
	/// The command to list all alias-path pairs
	#[clap(long)]
	list: Option<String>,
	/// The command to search for an alias from its path
	#[clap(long)]
	search: Option<String>,
	/// The command to query a path from an alias
	#[clap(long)]
	query: Option<String>,
	/// The command to edit the path of an alias-path pair
	#[clap(long)]
	edit: Option<String>,
	/// The command to rename an alias without changing the path
	#[clap(long)]
	rename: Option<String>,
}

impl Init {
	pub fn run(&self, database: &Database, db_path: &str) -> WHResult<()> {
		database.init();
		print!("{}", self.shell.get_init_code(self, db_path)?);
		Ok(())
	}
}

#[derive(clap::ValueEnum, Debug, Clone)]
enum Shell {
	Bash,
	Fish,
	Zsh,
	Nu,
}
impl Shell {
	/// Add an alias to the string builder that will output the init code
	fn new_alias(&self, alias: &str, command: &str) -> WHResult<String> {
		Ok(match self {
			Shell::Bash | Shell::Zsh | Shell::Fish => {
				if alias.contains(' ') {
					return Err(WHError::Err(format!("Aliases cannot contain spaces in {self:?}"), 1));
				}
				format!("alias {}='{}'", alias, command)
			}
			Shell::Nu => format!("export alias '{}' = {}", alias, command),
		})
	}

	/// Turn some text into a comment for the current shell
	fn comment(&self, text: impl Display) -> String {
		format!("# {}", text)
	}

	/// Get the init code for the shell
	/// The init code can be eval to create aliases and functions required to use worm_hole
	/// Works for bash, zsh and fish
	pub fn get_init_code(&self, aliases: &Init, db_path: &str) -> WHResult<String> {
		let mut builder = vec![self.comment(format!("This was generated using worm hole {}\n", env!("CARGO_PKG_VERSION")))];
		let wh = &aliases.worm_hole;
		builder.push(self.new_alias(
			&aliases.worm_hole,
			&format!(
				"{} --db-path {}",
				current_exe().unwrap().into_os_string().into_string().unwrap(),
				FilePath::from_str(db_path).unwrap().str()
			),
		)?);
		builder.push(self.get_cd_function(aliases));
		if let Some(add) = &aliases.add {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Add an alias-path pair to worm hole"));
						 builder.push(format!("export def '{add}' ["));
					builder.push(String::from("	alias: string"));
					builder.push(String::from("	path?: string # The real path to the location"));
					builder.push(String::from("]: nothing -> nothing {"));
						 builder.push(format!("	{wh} 'add' ...([$alias $path] | compact)"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(add, &format!("{wh} add"))?),
			};
		}
		if let Some(remove) = &aliases.remove {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Remove an alias-path pair from worm hole"));
						 builder.push(format!("export def '{remove}' ["));
					builder.push(String::from("	alias: string@__worm_hole_list"));
					builder.push(String::from("]: nothing -> nothing {"));
						 builder.push(format!("	{wh} 'rm' $alias"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(remove, &format!("{wh} rm"))?),
			};
		}
		if let Some(list) = &aliases.list {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#List all aliases and the corresponding path in worm hole"));
						 builder.push(format!("export def '{list}' []: nothing -> table<alias: string, path: string> {{"));
						 builder.push(format!("	{wh} 'ls'"));
					builder.push(String::from("	| parse --regex '(?P<alias>.+?)\\s+-> (?P<path>.+)'"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(list, &format!("{wh} ls"))?),
			};
		}
		if let Some(search) = &aliases.search {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Search for worm hole aliases with path matching a pattern"));
						 builder.push(format!("export def '{search}' ["));
					builder.push(String::from("	pattern?: string # The pattern to search for in the aliases's paths, search for aliases in the current directory if not provided"));
					builder.push(String::from("]: nothing -> table<alias: string, path: string> {"));
						 builder.push(format!("	{wh} 'search' ...([$pattern] | compact)"));
					builder.push(String::from("	| parse --regex '(?P<alias>.+?)\\s+-> (?P<path>.+)'"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(search, &format!("{wh} search"))?),
			};
		}
		if let Some(query) = &aliases.query {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Get the path for the given worm hole alias"));
						 builder.push(format!("export def '{query}' ["));
					builder.push(String::from("	alias: string@__worm_hole_list"));
					builder.push(String::from("]: nothing -> nothing {"));
						 builder.push(format!("	{wh} query $alias"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(query, &format!("{wh} query"))?),
			};
		}
		if let Some(edit) = &aliases.edit {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Edit the path of a worm hole alias"));
						 builder.push(format!("export def '{edit}' ["));
					builder.push(String::from("	alias: string@__worm_hole_list"));
					builder.push(String::from("	path?: string # The new path to the location"));
					builder.push(String::from("]: nothing -> nothing {"));
						 builder.push(format!("	{wh} edit ...([$alias $path] | compact)"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(edit, &format!("{wh} edit"))?),
			};
		}
		if let Some(rename) = &aliases.rename {
			match self {
				#[rustfmt::skip]
				Shell::Nu => {
					builder.push(String::from("#Change an alias in worm hole without changing the path"));
						 builder.push(format!("export def '{rename}' ["));
					builder.push(String::from("	old_alias: string@__worm_hole_list"));
					builder.push(String::from("	new_alias: string"));
					builder.push(String::from("]: nothing -> nothing {"));
						 builder.push(format!("	{wh} rename $old_alias $new_alias"));
					builder.push(String::from("}"));
				}
				_ => builder.push(self.new_alias(rename, &format!("{wh} rename"))?),
			};
		}
		builder.push(match self {
			Shell::Bash | Shell::Zsh => format!("export WH_ALIAS=\"{wh}\""),
			Shell::Fish => format!("set -gx WH_ALIAS \"{wh}\""),
			Shell::Nu => format!("export-env {{ $env.WH_ALIAS = '{wh}' }}"),
		});
		Ok(builder.join("\n"))
	}

	/// Get the function to change directory with worm_hole
	/// The function will call worm_hole query to get the path of the alias and cd to it
	/// The function is named whcd by default but can be changed with the --cd flag
	#[rustfmt::skip]
	fn get_cd_function(&self, aliases: &Init) -> String {
		let cd = &aliases.cd;
		let wh = &aliases.worm_hole;
		match self {
			Shell::Bash | Shell::Zsh => vec![
				     format!("{cd}() {{"),
				String::from("	if [ -z \"$1\" ]"),
				String::from("	then"),
				String::from("		cd $HOME"),
				String::from("	else"),
				     format!("		CD=$({wh} query \"$1\") && \\builtin cd \"$CD/$2\""),
				String::from("	fi"),
				String::from("}"),
			],
			Shell::Fish => vec![
				     format!("function {cd} -a alias -a subpath"),
				String::from("	if test -z $alias"),
				String::from("		cd $HOME"),
				String::from("	else"),
				     format!("		set -l CD ({wh} query \"$alias\")"),
				String::from("		if test -n $CD"),
				String::from("			builtin cd \"$CD/$subpath\""),
				String::from("		end"),
				String::from("	end"),
				String::from("end"),
			],
			Shell::Nu => vec![
				if let Some(list) = &aliases.list {
				     format!("def __worm_hole_list [] {{ ({list} | rename -c {{ alias: value path: description }}) }}")
				} else {
				     format!("def __worm_hole_list [] {{ ({wh} ls | parse --regex '(?P<value>.+?)\\s+-> (?P<description>.+)') }}")
				},
				String::from("#Change the current working directory using worm hole's aliases"),
				     format!("export def --env {cd} ["),
				String::from("	alias?: string@__worm_hole_list"),
				String::from("	subpath?: string"),
				String::from("] {"),
				String::from("	if $alias == null {"),
				String::from("		cd $env.HOME"),
				String::from("	} else {"),
				     format!("		mut CD = {wh} query $alias"),
				String::from("		if ($subpath != null) { $CD = $CD | path join $subpath }"),
				String::from("		cd $CD"),
				String::from("	}"),
				String::from("}"),
			],
		}.join("\n")
	}
}