feat: deprecate compose subcommand

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 <cmd>
-```
-
 ## 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 <args>           # manage.py in a fresh container
+ahab django run <cmd>                # in a fresh container, through the entrypoint
+ahab django bash                     # shell in a fresh container
+ahab django manage <args>            # manage.py
 ahab django makemigrations
 ahab django migrate <args>
 ahab django shell

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)]

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<String>,
     },
 
     /// Run Django's manage.py migrate.
     Migrate {
-        #[arg(value_enum)]
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        rest: Vec<String>,
+    },
+
+    /// Run a command in a fresh django container, through its entrypoint
+    Run {
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         rest: Vec<String>,
     },
 

src/cli/docker_compose.rs

@@ -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<String>,
-    },
-
-    /// Print services
-    Ps,
-
-    /// Stop, build and start containers.
-    Rebuild,
-
-    /// Stop and start containers.
-    Restart,
-
-    /// Start containers.
-    Start,
-
-    /// Stop containers.
-    Stop,
-
-    /// Up containers.
-    Up,
-}

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;

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 },
 }

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),

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}"

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(" ");

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()?;