Remove bash script and push logic to Rust binary

Author: rafaelfranca

README.md

@@ -8,22 +8,19 @@ Rails versions for you, so you don't have to worry about it.
 You need to have Docker installed on your machine. You can find instructions on how to install Docker on your machine
 [here](https://docs.docker.com/engine/install/).
 
-## Usage
+## Installation
 
-First, clone the repository:
 
-```bash
-git clone https://github.com/rails/rails-new.git
-cd rails-new
-```
+
+## Usage
 
 To generate a new Rails application, you can run the following command:
 
 ```bash
-bin/rails-new myapp
+rails-new myapp
 ```
 
 Or with options:
 ```bash
-bin/rails-new myapp --main
+rails-new myapp --main
 ```

bin/rails-new

@@ -3,17 +3,56 @@
 // use std::process::Command;
 mod rails_new;
 use rails_new::Cli;
-use std::process::Command;
+use std::io::Write;
+use std::process::{Command, Stdio};
 
 use clap::Parser;
 
 fn main() {
     let cli = Cli::parse();
 
-    // Execute the bash file rails-new
-    let status = Command::new("bash")
-        .arg("bin/rails-new")
-        .arg(cli.name)
+    // read the content of the DOCKERFILE and store it in a variable
+    let dockerfile = include_str!("../Dockerfile");
+
+    let ruby_version = cli.ruby_version.unwrap();
+    let rails_version = cli.rails_version.unwrap();
+
+    // Run docker build --build-arg RUBY_VERSION=$RUBY_VERSION --build-arg RAILS_VERSION=$RAILS_VERSION -t rails-new-$RUBY_VERSION-$RAILS_VERSION
+    // passing the content of DOCKERFILE to the command stdin
+    let mut child = Command::new("docker")
+        .arg("build")
+        .arg("--build-arg")
+        .arg(format!("RUBY_VERSION={}", ruby_version))
+        .arg("--build-arg")
+        .arg(format!("RAILS_VERSION={}", rails_version))
+        .arg("-t")
+        .arg(format!("rails-new-{}-{}", ruby_version, rails_version))
+        .arg("-")
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("Failed to execute process");
+
+    let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+    stdin.write_all(dockerfile.as_bytes()).unwrap();
+
+    let status = child.wait().expect("failed to wait on child");
+
+    assert!(status.success());
+
+    // Run the image with docker run -v $(pwd):/$(pwd) -w $(pwd) rails-new-$RUBY_VERSION-$RAILS_VERSION rails new $@
+    let binding = std::env::current_dir().unwrap();
+    let current_dir = binding.to_str().unwrap();
+
+    let status = Command::new("docker")
+        .arg("run")
+        .arg("-v")
+        .arg(format!("{}:{}", current_dir, current_dir))
+        .arg("-w")
+        .arg(current_dir)
+        .arg(format!("rails-new-{}-{}", ruby_version, rails_version))
+        .arg("rails")
+        .arg("new")
+        .args(cli.args)
         .status()
         .expect("Failed to execute process");
 

src/main.rs

@@ -3,11 +3,29 @@ use clap::Parser;
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
 pub struct Cli {
-    pub name: String,
+    #[clap(trailing_var_arg = true, required = true)]
+    pub args: Vec<String>,
+    #[clap(long, short = 'u', default_value = "3.2.3")]
+    pub ruby_version: Option<String>,
+    #[clap(long, short = 'r', default_value = "7.1.3")]
+    pub rails_version: Option<String>,
 }
 
 #[test]
 fn verify_cli() {
     use clap::CommandFactory;
     Cli::command().debug_assert()
 }
+
+#[test]
+fn arguments_are_directed_to_rails_new() -> Result<(), Box<dyn std::error::Error>> {
+    use clap::CommandFactory;
+
+    let m = Cli::command().get_matches_from(vec!["rails-new", "my_app", "--main"]);
+
+    let trail: Vec<_> = m.get_many::<String>("args").unwrap().collect();
+
+    assert_eq!(trail, &["my_app", "--main"]);
+
+    Ok(())
+}

src/rails_new.rs

@@ -8,8 +8,10 @@ fn requires_a_name() -> Result<(), Box<dyn std::error::Error>> {
 
     cmd.assert()
         .failure()
-        .stderr(predicate::str::contains("the following required arguments were not provided:"))
-        .stderr(predicate::str::contains("<NAME>"));
+        .stderr(predicate::str::contains(
+            "the following required arguments were not provided:",
+        ))
+        .stderr(predicate::str::contains("<ARGS>..."));
 
     Ok(())
 }