From 6e44527a9ac2678bcd0b8bf9f55288cb286eb0a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matej=20Jane=C5=BEi=C4=8D?= Date: Fri, 4 Sep 2026 14:35:57 +0000 Subject: [PATCH] feat: deprecate compose subcommand --- README.md | 17 +++------------ src/cli/ahab.rs | 8 +------ src/cli/django.rs | 24 ++++++++++++--------- src/cli/docker_compose.rs | 40 ----------------------------------- src/cli/mod.rs | 2 -- src/cli/postgres.rs | 10 ++------- src/main.rs | 19 ++--------------- src/scripts/completions.rs | 2 +- src/scripts/django.rs | 10 +++++++++ src/scripts/docker_compose.rs | 20 +++++++++--------- 10 files changed, 43 insertions(+), 109 deletions(-) delete mode 100644 src/cli/docker_compose.rs diff --git a/README.md b/README.md index 78ca230..e86031f 100644 --- a/README.md +++ b/README.md @@ -49,19 +49,6 @@ since docker reads that too: COMPOSE_FILE=docker/docker-compose.yaml ``` -## compose - -Wrappers around the matching `docker compose` call, plus `exec` and `bash` -which default to the django service. - -```bash -ahab compose up # also build, down, ps, start, stop -ahab compose rebuild # stop, build, up -ahab compose restart # stop, up, so containers are recreated -ahab compose bash # shell in the django service -ahab compose exec -``` - ## service detection `ahab` finds the services it needs in `docker compose config`, so they can be @@ -83,7 +70,9 @@ project declares, falling back to `db` when it declares neither. ## django ```bash -ahab django manage # manage.py in a fresh container +ahab django run # in a fresh container, through the entrypoint +ahab django bash # shell in a fresh container +ahab django manage # manage.py ahab django makemigrations ahab django migrate ahab django shell diff --git a/src/cli/ahab.rs b/src/cli/ahab.rs index f0f0784..9596252 100644 --- a/src/cli/ahab.rs +++ b/src/cli/ahab.rs @@ -1,4 +1,4 @@ -use super::{Django, DockerCompose, Link, Postgres}; +use super::{Django, Link, Postgres}; use clap::{Parser, Subcommand}; use clap_complete::Shell; @@ -12,12 +12,6 @@ pub struct Ahab { #[derive(Debug, Subcommand)] pub enum Commands { - /// Docker compose related subcommands - Compose { - #[command(subcommand)] - command: DockerCompose, - }, - /// Django related subcommands Django { #[command(subcommand)] diff --git a/src/cli/django.rs b/src/cli/django.rs index c793a90..347eb45 100644 --- a/src/cli/django.rs +++ b/src/cli/django.rs @@ -1,31 +1,35 @@ use std::path::PathBuf; -use clap::Parser; +use clap::Subcommand; // TODO: (matej) dsu template command -#[derive(Parser, Debug)] +#[derive(Subcommand, Debug)] pub enum Django { + /// Start a bash session in a fresh django container + Bash, + /// Prepare empty management command 'command' in app 'app'. - MakeCommand { - #[arg(value_enum)] - app: PathBuf, - #[arg(value_enum)] - name: String, - }, + MakeCommand { app: PathBuf, name: String }, /// Run Django's manage.py makemigrations. Makemigrations, /// Pass arguments to Django's manage.py. Manage { - #[arg(value_enum)] + #[arg(trailing_var_arg = true, allow_hyphen_values = true)] rest: Vec, }, /// Run Django's manage.py migrate. Migrate { - #[arg(value_enum)] + #[arg(trailing_var_arg = true, allow_hyphen_values = true)] + rest: Vec, + }, + + /// Run a command in a fresh django container, through its entrypoint + Run { + #[arg(trailing_var_arg = true, allow_hyphen_values = true)] rest: Vec, }, diff --git a/src/cli/docker_compose.rs b/src/cli/docker_compose.rs deleted file mode 100644 index 3de53c3..0000000 --- a/src/cli/docker_compose.rs +++ /dev/null @@ -1,40 +0,0 @@ -use clap::Subcommand; - -// TODO: (matej) add Exec, Bash - -/// Wraper for docker compose; autodiscover compose file and source .env file. -#[derive(Subcommand, Debug)] -pub enum DockerCompose { - /// Start bash session inside container - Bash, - - /// Build containers. - Build, - - /// Down containers. - Down, - - /// Exec command inside container. - Exec { - #[arg(value_enum)] - rest: Vec, - }, - - /// Print services - Ps, - - /// Stop, build and start containers. - Rebuild, - - /// Stop and start containers. - Restart, - - /// Start containers. - Start, - - /// Stop containers. - Stop, - - /// Up containers. - Up, -} diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 016985a..a4fd174 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -1,11 +1,9 @@ mod ahab; mod django; -mod docker_compose; mod link; mod postgres; pub use ahab::{Ahab, Commands}; pub use django::Django; -pub use docker_compose::DockerCompose; pub use link::Link; pub use postgres::Postgres; diff --git a/src/cli/postgres.rs b/src/cli/postgres.rs index 3a0b71f..7924e80 100644 --- a/src/cli/postgres.rs +++ b/src/cli/postgres.rs @@ -5,14 +5,8 @@ use clap::Subcommand; #[derive(Subcommand, Debug)] pub enum Postgres { /// Import dump via pg_restore - Import { - #[arg(value_enum)] - path: PathBuf, - }, + Import { path: PathBuf }, /// Dump via pg_dump with format=c - Dump { - #[arg(value_enum)] - path: PathBuf, - }, + Dump { path: PathBuf }, } diff --git a/src/main.rs b/src/main.rs index c42019e..b6a10ed 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,24 +7,9 @@ fn main() -> Result<()> { let args = cli::Ahab::parse(); match args.command { - cli::Commands::Compose { command } => { - eprintln!( - "DEPRECATION NOTICE: this is deprecated in favor of docker compose COMPOSE_FILE env" - ); - match command { - cli::DockerCompose::Bash => scripts::docker_compose::bash(), - cli::DockerCompose::Build => scripts::docker_compose::build(), - cli::DockerCompose::Down => scripts::docker_compose::down(), - cli::DockerCompose::Exec { rest } => scripts::docker_compose::exec(&rest), - cli::DockerCompose::Ps => scripts::docker_compose::ps(), - cli::DockerCompose::Rebuild => scripts::docker_compose::rebuild(), - cli::DockerCompose::Restart => scripts::docker_compose::restart(), - cli::DockerCompose::Start => scripts::docker_compose::start(None), - cli::DockerCompose::Stop => scripts::docker_compose::stop(), - cli::DockerCompose::Up => scripts::docker_compose::up(), - } - } cli::Commands::Django { command } => match command { + cli::Django::Bash => scripts::django::bash(), + cli::Django::Run { rest } => scripts::django::run(&rest), cli::Django::MakeCommand { app, name } => scripts::django::make_command(&app, &name), cli::Django::Makemigrations => scripts::django::makemigrations(), cli::Django::Manage { rest } => scripts::django::manage(&rest), diff --git a/src/scripts/completions.rs b/src/scripts/completions.rs index 949e0ef..b7ffb0d 100644 --- a/src/scripts/completions.rs +++ b/src/scripts/completions.rs @@ -35,7 +35,7 @@ mod tests { for shell in Shell::value_variants() { let out = String::from_utf8(script(*shell)).expect("script is utf8"); - for subcommand in ["compose", "django", "postgres", "link", "completions"] { + for subcommand in ["django", "postgres", "link", "completions"] { assert!( out.contains(subcommand), "{shell:?} script never mentions {subcommand}" diff --git a/src/scripts/django.rs b/src/scripts/django.rs index fe4f50f..47f339f 100644 --- a/src/scripts/django.rs +++ b/src/scripts/django.rs @@ -6,6 +6,7 @@ use anyhow::{Result, anyhow}; use crate::command_builder::CommandBuilder; use crate::compose::Compose; +use crate::scripts::docker_compose; use crate::{create_file, safe_create_file}; const DEBUG_TEMPLATE: &str = r#"from django.core.management.base import BaseCommand @@ -54,6 +55,15 @@ pub fn make_command(app: &PathBuf, name: &str) -> Result<()> { Ok(()) } +pub fn bash() -> Result<()> { + run(&["bash".to_string()]) +} + +pub fn run(rest: &[String]) -> Result<()> { + let service = Compose::resolve()?.django()?; + docker_compose::run(&service, rest) +} + pub fn manage(rest: &[String]) -> Result<()> { let container = Compose::resolve()?.django()?; let joined = rest.join(" "); diff --git a/src/scripts/docker_compose.rs b/src/scripts/docker_compose.rs index 00e114d..d2212a6 100644 --- a/src/scripts/docker_compose.rs +++ b/src/scripts/docker_compose.rs @@ -1,9 +1,7 @@ use anyhow::Result; use crate::command_builder::CommandBuilder; -use crate::compose::Compose; -// simple commands pub fn build() -> Result<()> { CommandBuilder::docker_compose().args("build").exec() } @@ -12,11 +10,18 @@ pub fn down() -> Result<()> { CommandBuilder::docker_compose().args("down").exec() } -pub fn exec(rest: &[String]) -> Result<()> { - let service = Compose::resolve()?.django()?; +pub fn run(service: &str, rest: &[String]) -> Result<()> { + CommandBuilder::docker_compose() + .args("run --rm") + .args(service) + .args(rest) + .exec() +} + +pub fn exec(service: &str, rest: &[String]) -> Result<()> { CommandBuilder::docker_compose() .args("exec") - .args(&service) + .args(service) .args(rest) .exec() } @@ -38,11 +43,6 @@ pub fn up() -> Result<()> { CommandBuilder::docker_compose().args("up -d").exec() } -// shortcuts -pub fn bash() -> Result<()> { - exec(&["bash".to_string()]) -} - pub fn rebuild() -> Result<()> { stop()?; build()?;