robin/haze
1
0
Fork 0
mirror of https://codeberg.org/icewind/haze.git synced 2026-06-03 17:14:08 +02:00
Code Issues Projects Releases Wiki Activity

move checkout to new git subcommand

Browse source
This commit is contained in:
Robin Appelman 2025-11-20 20:48:10 +01:00
commit d86ee53f66
3 changed files with 320 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

207
src/args.rs
View file

@ -2,11 +2,28 @@ use crate::cloud::CloudOptions;
use crate::config::{HazeConfig, Preset};
use crate::service::{Service, ServiceTrait};
use miette::{IntoDiagnostic, Report, Result};
use std::fmt::Display;
use std::fmt::{Debug, Display};
use std::rc::Rc;
use std::str::FromStr;
use strum::{Display, EnumIter, EnumMessage, EnumProperty, EnumString, IntoStaticStr};
use strum::{
Display, EnumIter, EnumMessage, EnumProperty, EnumString, IntoEnumIterator, IntoStaticStr,
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub trait SubCommand: Display + EnumMessage + EnumProperty + Debug {
fn parent(&self) -> &'static str {
""
}
fn allows_filter(&self) -> bool {
false
}
fn sub_commands(&self) -> Option<Box<dyn Iterator<Item = Box<dyn SubCommand>>>> {
None
}
}
#[derive(Debug, Clone)]
pub enum HazeArgs {
List {
filter: Option<String>,
@ -65,8 +82,8 @@ pub enum HazeArgs {
filter: Option<String>,
},
Proxy,
Checkout {
branch: String,
Git {
operation: GitOperation,
},
Env {
filter: Option<String>,
@ -75,7 +92,7 @@ pub enum HazeArgs {
},
Update,
Help {
command: Option<HazeCommand>,
command: Option<Rc<dyn SubCommand>>,
},
Version,
Edit {
@ -84,6 +101,33 @@ pub enum HazeArgs {
},
}
#[derive(
Debug,
Clone,
Eq,
PartialEq,
Display,
EnumProperty,
EnumString,
IntoStaticStr,
EnumMessage,
EnumIter,
)]
#[strum(serialize_all = "lowercase")]
pub enum GitOperation {
/// Checkout a branch in all apps
///
/// "main" and "master" can be used interchangeably.
#[strum(props(Args = "[branch] branch to checkout"))]
Checkout { branch: String },
}
impl SubCommand for GitOperation {
fn parent(&self) -> &'static str {
" git"
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum LogService {
Service(Service),
@ -271,7 +315,26 @@ impl HazeArgs {
.next()
.map(S::into)
.ok_or_else(|| Report::msg("No branch provided"))?;
Ok(HazeArgs::Checkout { branch })
Ok(HazeArgs::Git {
operation: GitOperation::Checkout { branch },
})
}
HazeCommand::Git => {
let operation = args
.next()
.ok_or_else(|| Report::msg("No git operation provided"))?;
match operation.as_ref() {
"checkout" => {
let branch = args
.next()
.map(S::into)
.ok_or_else(|| Report::msg("No branch provided"))?;
Ok(HazeArgs::Git {
operation: GitOperation::Checkout { branch },
})
}
operation => Err(Report::msg(format!("Unknown git operation {operation}"))),
}
}
HazeCommand::Env => {
let mut args = args.map(S::into);
@ -286,13 +349,21 @@ impl HazeArgs {
}
HazeCommand::Update => Ok(HazeArgs::Update),
HazeCommand::Help => {
let command = args.next();
let command = command
.as_ref()
.map(|s| s.as_ref())
.map(HazeCommand::from_str)
.transpose()
.map_err(|_| Report::msg("Unknown command"))?;
let command = args
.next()
.map(|command| match command.as_ref() {
"git" => match args.next() {
Some(op) => GitOperation::from_str(op.as_ref())
.map(|op| Rc::new(op) as Rc<dyn SubCommand>)
.map_err(|_| Report::msg("Unknown command")),
None => Ok(Rc::new(HazeCommand::Git) as Rc<dyn SubCommand>),
},
command => HazeCommand::from_str(command)
.map(|command| Rc::new(command) as Rc<dyn SubCommand>)
.map_err(|_| Report::msg("Unknown command")),
})
.transpose()?;
Ok(HazeArgs::Help { command })
}
HazeCommand::Version => Ok(HazeArgs::Version),
@ -372,10 +443,9 @@ pub enum HazeCommand {
Unpin,
/// Start the proxy
Proxy,
/// Checkout a branch in all apps
///
/// Only switches branches if the target branch exists locally.
/// "main" and "master" can be used interchangeably.
/// Perform git operations on all apps
Git,
/// Deprecated, use `haze git checkout` instead
#[strum(props(Args = "[branch] branch to checkout"))]
Checkout,
/// Run command with notify_push environment variables
@ -394,8 +464,8 @@ pub enum HazeCommand {
Edit,
}
impl HazeCommand {
pub fn allows_filter(&self) -> bool {
impl SubCommand for HazeCommand {
fn allows_filter(&self) -> bool {
matches!(
self,
HazeCommand::List
@ -411,6 +481,13 @@ impl HazeCommand {
| HazeCommand::Edit
)
}
fn sub_commands(&self) -> Option<Box<dyn Iterator<Item = Box<dyn SubCommand>>>> {
match self {
HazeCommand::Git => Some(Box::new(GitOperation::iter().map(|op| Box::new(op) as _))),
_ => None,
}
}
}
#[test]
@ -425,45 +502,49 @@ fn test_arg_parse() {
preset: vec![],
};
assert_eq!(
fn assert_eq<A: Debug, B: Debug>(a: A, b: B) {
assert_eq!(format!("{a:?}"), format!("{b:?}"));
}
assert_eq(
HazeArgs::parse(&config, vec!["haze"].into_iter()).unwrap(),
HazeArgs::List { filter: None }
HazeArgs::List { filter: None },
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "test"].into_iter()).unwrap(),
HazeArgs::Test {
options: Default::default(),
args: vec![]
}
args: vec![],
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "asdasd"].into_iter()).unwrap(),
HazeArgs::List {
filter: Some("asdasd".to_string())
}
filter: Some("asdasd".to_string()),
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "asdasd", "db"].into_iter()).unwrap(),
HazeArgs::Db {
filter: Some("asdasd".to_string()),
root: false,
command: Vec::new(),
index: None,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "asdasd", "db", "root"].into_iter()).unwrap(),
HazeArgs::Db {
filter: Some("asdasd".to_string()),
root: true,
command: Vec::new(),
index: None,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "db", "select", "1"].into_iter()
vec!["haze", "asdasd", "db", "select", "1"].into_iter(),
)
.unwrap(),
HazeArgs::Db {
@ -471,12 +552,12 @@ fn test_arg_parse() {
root: false,
command: vec!["select".to_string(), "1".to_string()],
index: None,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "db", "root", "select 1"].into_iter()
vec!["haze", "asdasd", "db", "root", "select 1"].into_iter(),
)
.unwrap(),
HazeArgs::Db {
@ -484,12 +565,12 @@ fn test_arg_parse() {
root: true,
command: vec!["select 1".to_string()],
index: None,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "db", "root", "1", "select 1"].into_iter()
vec!["haze", "asdasd", "db", "root", "1", "select 1"].into_iter(),
)
.unwrap(),
HazeArgs::Db {
@ -497,12 +578,12 @@ fn test_arg_parse() {
root: true,
command: vec!["select 1".to_string()],
index: Some("1".into()),
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "db", "all", "select 1"].into_iter()
vec!["haze", "asdasd", "db", "all", "select 1"].into_iter(),
)
.unwrap(),
HazeArgs::Db {
@ -510,21 +591,21 @@ fn test_arg_parse() {
root: false,
command: vec!["select 1".to_string()],
index: Some("all".into()),
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "exec", "foo", "bar"].into_iter()).unwrap(),
HazeArgs::Exec {
filter: None,
service: None,
command: vec!["foo".to_string(), "bar".to_string()],
root: false,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "exec", "root", "foo", "bar"].into_iter()
vec!["haze", "exec", "root", "foo", "bar"].into_iter(),
)
.unwrap(),
HazeArgs::Exec {
@ -532,12 +613,12 @@ fn test_arg_parse() {
service: None,
command: vec!["foo".to_string(), "bar".to_string()],
root: true,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "exec", "foo", "bar"].into_iter()
vec!["haze", "asdasd", "exec", "foo", "bar"].into_iter(),
)
.unwrap(),
HazeArgs::Exec {
@ -545,12 +626,12 @@ fn test_arg_parse() {
service: None,
command: vec!["foo".to_string(), "bar".to_string()],
root: false,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "exec", "db", "foo", "bar"].into_iter()
vec!["haze", "asdasd", "exec", "db", "foo", "bar"].into_iter(),
)
.unwrap(),
HazeArgs::Exec {
@ -558,28 +639,28 @@ fn test_arg_parse() {
service: Some(ExecService::Db),
command: vec!["foo".to_string(), "bar".to_string()],
root: false,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "test", "foo", "bar"].into_iter()).unwrap(),
HazeArgs::Test {
options: Default::default(),
args: vec!["foo".into(), "bar".into()]
}
args: vec!["foo".into(), "bar".into()],
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(&config, vec!["haze", "logs", "-f", "smb"].into_iter()).unwrap(),
HazeArgs::Logs {
filter: None,
follow: true,
service: Some(LogService::from_type(&[], "smb").unwrap()),
count: None,
}
},
);
assert_eq!(
assert_eq(
HazeArgs::parse(
&config,
vec!["haze", "asdasd", "logs", "smb", "123"].into_iter()
vec!["haze", "asdasd", "logs", "smb", "123"].into_iter(),
)
.unwrap(),
HazeArgs::Logs {
@ -587,6 +668,6 @@ fn test_arg_parse() {
follow: false,
service: Some(LogService::from_type(&[], "smb").unwrap()),
count: Some(123),
}
},
);
}

277
src/help.rs
View file

@ -1,4 +1,4 @@
use crate::args::HazeCommand;
use crate::args::{HazeCommand, SubCommand};
use crate::database::DatabaseFamily;
use crate::php::PhpVersion;
use crate::service::ServiceType;
@ -6,114 +6,9 @@ use owo_colors::colors::xterm::Gray;
use owo_colors::OwoColorize;
use strum::{EnumMessage, EnumProperty, IntoEnumIterator};
pub fn help(command: Option<HazeCommand>) {
pub fn help(command: Option<&dyn SubCommand>) {
if let Some(command) = command {
println!("{}", command.get_documentation().unwrap_or_default());
println!();
print!(
"{} {}{} {}",
"Usage:".bright_yellow().bold(),
"haze".blue(),
if command.allows_filter() {
" [filter]".green()
} else {
"".green()
},
command.blue(),
);
let instance_args = command.get_bool("InstanceArgs").unwrap_or_default();
if instance_args {
print!(" {}", "[php version]".green());
print!(" {}", "[database type]".green());
print!(" {}", "[services]".green());
}
let args = if let Some(args) = command.get_str("Args") {
let args: &str = args;
print!(" {}", "[arguments]".green());
args.strip_prefix("[")
.unwrap_or(args)
.split(" [")
.filter_map(|arg| arg.split_once("] "))
.collect::<Vec<_>>()
} else {
vec![]
};
println!();
println!();
if instance_args {
println!("{}", "Php versions:".yellow().bold());
for php in PhpVersion::supported_versions() {
println!(" {}", php.blue());
}
println!();
println!("{}", "Database types:".yellow().bold());
let max_db_len = DatabaseFamily::iter()
.map(|service| <&'static str>::from(service).len())
.max()
.unwrap_or_default();
for db in DatabaseFamily::iter() {
let db: DatabaseFamily = db;
let db_str: &'static str = db.into();
let versions = match db.get_str("Versions") {
Some(versions) => {
let versions: Vec<_> = versions
.split(' ')
.map(|version| format!("{}{}{}", db.blue(), ":".blue(), version.blue()))
.collect();
Some(versions.join(", "))
}
None => None,
};
print!(" {}{} ", db.blue(), " ".repeat(max_db_len - db_str.len()));
if let Some(versions) = versions {
println!("supported versions: {versions}");
} else {
println!();
}
}
println!();
println!("{}", "Services:".yellow().bold());
let max_service_len = ServiceType::iter()
.map(|service| <&'static str>::from(service).len())
.max()
.unwrap_or_default();
for service in ServiceType::iter() {
let service: ServiceType = service;
let service_str: &'static str = service.into();
println!(
" {}{} {}",
service.blue(),
" ".repeat(max_service_len - service_str.len()),
service.get_documentation().unwrap_or_default(),
);
}
}
println!();
if !args.is_empty() {
let max_arg_len = args
.iter()
.map(|(arg, _)| arg.len())
.max()
.unwrap_or_default();
println!("{}", "Arguments:".yellow().bold());
for (arg, desc) in args {
println!(
" {}{}{}{} {}",
"[".green(),
arg.green(),
"]".green(),
" ".repeat(max_arg_len - arg.len()),
desc
);
}
}
subcommand_help(command);
} else {
println!(
"{} {} {}",
@ -171,3 +66,169 @@ pub fn help(command: Option<HazeCommand>) {
);
}
}
fn subcommand_help(command: &dyn SubCommand) {
println!("{}", command.get_documentation().unwrap_or_default());
println!();
print!(
"{} {}{}{} {}",
"Usage:".bright_yellow().bold(),
"haze".blue(),
if command.allows_filter() {
" [filter]".green()
} else {
"".green()
},
command.parent().blue(),
command.blue(),
);
let instance_args = command.get_bool("InstanceArgs").unwrap_or_default();
if instance_args {
print!(" {}", "[php version]".green());
print!(" {}", "[database type]".green());
print!(" {}", "[services]".green());
}
let args = if let Some(args) = command.get_str("Args") {
let args: &str = args;
print!(" {}", "[arguments]".green());
args.strip_prefix("[")
.unwrap_or(args)
.split(" [")
.filter_map(|arg| arg.split_once("] "))
.collect::<Vec<_>>()
} else {
vec![]
};
println!();
println!();
if instance_args {
println!("{}", "Php versions:".yellow().bold());
for php in PhpVersion::supported_versions() {
println!(" {}", php.blue());
}
println!();
println!("{}", "Database types:".yellow().bold());
let max_db_len = DatabaseFamily::iter()
.map(|service| service.to_string().len())
.max()
.unwrap_or_default();
for db in DatabaseFamily::iter() {
let db: DatabaseFamily = db;
let db_str: &'static str = db.into();
let versions = match db.get_str("Versions") {
Some(versions) => {
let versions: Vec<_> = versions
.split(' ')
.map(|version| format!("{}{}{}", db.blue(), ":".blue(), version.blue()))
.collect();
Some(versions.join(", "))
}
None => None,
};
print!(" {}{} ", db.blue(), " ".repeat(max_db_len - db_str.len()));
if let Some(versions) = versions {
println!("supported versions: {versions}");
} else {
println!();
}
}
println!();
println!("{}", "Services:".yellow().bold());
let max_service_len = ServiceType::iter()
.map(|service| service.to_string().len())
.max()
.unwrap_or_default();
for service in ServiceType::iter() {
let service: ServiceType = service;
let service_str: &'static str = service.into();
println!(
" {}{} {}",
service.blue(),
" ".repeat(max_service_len - service_str.len()),
service.get_documentation().unwrap_or_default(),
);
}
}
if let Some(sub_commands) = command.sub_commands() {
println!();
println!("{}", "Commands:".yellow().bold());
let max_command_len = command
.sub_commands()
.unwrap()
.map(|sub_command| sub_command.to_string().len())
.max()
.unwrap();
let max_doc_len = command
.sub_commands()
.unwrap()
.map(|sub_command| {
sub_command
.get_documentation()
.unwrap_or_default()
.split('\n')
.next()
.unwrap()
.len()
})
.max()
.unwrap();
for sub_command in sub_commands {
let command_str = sub_command.to_string();
let mut len = command_str.len();
if command_str.starts_with("--") {
len -= 2;
}
let doc: &str = sub_command.get_documentation().unwrap_or_default();
let doc = doc.split('\n').next().unwrap();
println!(
" {}{} {}{} {}",
sub_command.blue(),
" ".repeat(max_command_len - len),
doc,
" ".repeat(max_doc_len - doc.len()),
if sub_command.allows_filter() {
"- supports filter".fg::<Gray>()
} else {
"".fg::<Gray>()
},
);
}
println!();
println!(
"See {} {} {} for more information about a {}",
"haze help".blue(),
command.blue(),
"<COMMAND>".green(),
"<COMMAND>".green()
);
}
println!();
if !args.is_empty() {
let max_arg_len = args
.iter()
.map(|(arg, _)| arg.len())
.max()
.unwrap_or_default();
println!("{}", "Arguments:".yellow().bold());
for (arg, desc) in args {
println!(
" {}{}{}{} {}",
"[".green(),
arg.green(),
"]".green(),
" ".repeat(max_arg_len - arg.len()),
desc
);
}
}
}

8
src/main.rs
View file

@ -1,6 +1,6 @@
extern crate core;
use crate::args::{ExecService, HazeArgs};
use crate::args::{ExecService, GitOperation, HazeArgs};
use crate::cloud::{Cloud, CloudOptions};
use crate::config::HazeConfig;
use crate::database::DatabaseFamily;
@ -362,9 +362,11 @@ async fn main() -> Result<ExitCode> {
HazeArgs::Proxy => {
proxy(docker, config).await?;
}
HazeArgs::Checkout { branch } => {
HazeArgs::Git { operation } => match operation {
GitOperation::Checkout { branch } => {
checkout_all(&config.sources_root, &branch)?;
}
},
HazeArgs::Env {
filter,
command,
@ -452,7 +454,7 @@ async fn main() -> Result<ExitCode> {
println!("haze v{}", VERSION);
}
HazeArgs::Help { command } => {
help(command);
help(command.as_deref());
}
HazeArgs::Edit { filter, path } => {
let cloud = Cloud::get_by_filter(&docker, filter, &config).await?;