gleam2nix/gen-app: refactor, include information from gleam.toml file

src/app.rs

···
 //
 // SPDX-License-Identifier: 0BSD
 
+use std::{fs, path::Path};
+
 use miette::{Context, IntoDiagnostic, Result, miette};
 
-pub fn generate_app_file(
-    name: &str,
-    version: &str,
-    otp_dependencies: &Vec<String>,
-    out_path: &str,
-) -> Result<String> {
-    let otp_dependencies = otp_dependencies.join(",");
+use crate::{
+    Arguments,
+    gleam_toml::{self, GleamToml},
+};
+
+pub struct AppSpec {
+    pub name: String,
+    pub contents: String,
+}
+
+fn get_applications(otp_dependencies: Vec<String>, gleam_toml: &GleamToml) -> Vec<String> {
+    let extra_applications = gleam_toml
+        .erlang
+        .as_ref()
+        .and_then(|e| e.extra_applications.clone())
+        .unwrap_or_default();
+    let mut applications = [otp_dependencies, extra_applications].concat();
+    applications.sort();
+    applications.dedup();
+
+    applications
+}
 
-    let modules = std::fs::read_dir(&out_path)
+fn get_modules(out_dir: &str) -> Result<Vec<String>> {
+    std::fs::read_dir(out_dir)
         .into_diagnostic()?
         .collect::<Result<Vec<_>, _>>()
         .into_diagnostic()
-        .wrap_err(format!("While getting files in \"{out_path}\":"))?
+        .wrap_err(format!("While getting files in \"{out_dir}\":"))?
         .iter()
         .filter(|path| {
             path.path()
···
                 .map(|p| p.to_string())
                 .ok_or(miette!("Non UTF-8 filename in directory"))
         })
-        .collect::<Result<Vec<_>, _>>()?
-        .join(",");
+        .collect::<Result<Vec<_>, _>>()
+}
 
-    Ok(format!(
-        r#"{{application, {name}, [
-    {{vsn, "{version}"}},
-    {{applications, [{otp_dependencies}]}},
-    {{description, ""}},
+fn generate_app_spec(otp_dependencies: Vec<String>, out_dir: &str) -> Result<AppSpec> {
+    let gleam_toml = gleam_toml::parse("gleam.toml")?;
+
+    let applications = get_applications(otp_dependencies, &gleam_toml).join(",");
+    let modules = get_modules(out_dir)?.join(",");
+    let start_module = gleam_toml
+        .erlang
+        .and_then(|e| e.application_start_module)
+        .map(|module| format!("{{mod, {{'{module}', []}}}},\n"))
+        .unwrap_or_default();
+
+    Ok(AppSpec {
+        name: gleam_toml.name.clone(),
+        contents: format!(
+            r#"{{application, {0}, [
+    {{vsn, "{1}"}},
+    {start_module}{{applications, [{applications}]}},
+    {{description, "{2}"}},
     {{modules, [{modules}]}},
     {{registered, []}}
-]}}."#
-    ))
+]}}."#,
+            gleam_toml.name,
+            gleam_toml.version,
+            gleam_toml.description.unwrap_or_default()
+        ),
+    })
+}
+
+pub fn generate_app_file(args: Arguments) -> Result<()> {
+    let out_path = args
+        .rest
+        .first()
+        .ok_or(miette!("No output path specified"))?
+        .to_string();
+
+    let app_spec = generate_app_spec(args.otp_dependencies, &out_path)?;
+
+    fs::write(Path::new(&out_path).join(&app_spec.name), app_spec.contents).into_diagnostic()?;
+    println!("Successfully generated {}", app_spec.name);
+
+    Ok(())
 }

src/main.rs

···
 //
 // SPDX-License-Identifier: 0BSD
 
-use std::{fs, path::Path};
+use std::fs;
 
 use facet::Facet;
 use miette::{IntoDiagnostic, Result, miette};
···
 }
 
 #[derive(Debug, Facet)]
-struct Arguments {
+pub struct Arguments {
     #[facet(positional, default)]
-    command: String,
+    pub command: String,
 
     #[facet(positional, default)]
-    rest: Vec<String>,
-
-    #[facet(named, default, short = "n")]
-    name: Option<String>,
-
-    #[facet(named, default, short = "v")]
-    version: Option<String>,
+    pub rest: Vec<String>,
 
     #[facet(named, default, short = "d")]
-    otp_dependencies: Vec<String>,
+    pub otp_dependencies: Vec<String>,
 }
 
 fn gen_nix(args: Arguments) -> Result<()> {
···
     Ok(())
 }
 
-fn gen_app(args: Arguments) -> Result<()> {
-    let name = args.name.ok_or(miette!("No app name specified"))?;
-    let version = args.version.ok_or(miette!("No version specified"))?;
-    let out_path = args
-        .rest
-        .first()
-        .ok_or(miette!("No output path specified"))?
-        .to_string();
-
-    let app_contents = app::generate_app_file(&name, &version, &args.otp_dependencies, &out_path)?;
-    let app_file_name = format!("{}.app", name);
-
-    fs::write(Path::new(&out_path).join(&app_file_name), app_contents).into_diagnostic()?;
-    println!("Successfully generated {app_file_name}");
-
-    Ok(())
-}
-
 fn main() -> Result<()> {
     let args: Arguments = facet_args::from_std_args()?;
 
···
                 .ok_or(miette!("No module name specified"))?,
         ),
         Command::GenNix => gen_nix(args),
-        Command::GenApp => gen_app(args),
+        Command::GenApp => app::generate_app_file(args),
         Command::NotFound => Err(miette!("Command not found")),
     }
 }