config items

Author: weezy20

src/cli.rs

@@ -5,7 +5,7 @@ use strum_macros::{Display, EnumString};
 #[command(arg_required_else_help = true)]
 pub struct Cli {
     #[command(subcommand)]
-    pub create: Create,
+    pub(crate) create: Create,
 }
 
 #[derive(Subcommand, Clone)]
@@ -30,8 +30,21 @@ pub enum Template {
 #[derive(Parser, Clone)]
 pub struct TemplateCmd {
     #[arg(help = "Name of the app. Also works as a directory path for your project")]
-    pub name: String,
-    #[arg(help = "Template to create; Options are ept, fpt, cpt")]
+    pub(crate) name: String,
+    #[arg(
+        help = "Template to create; Options are 'ept', 'fpt', 'cpt'. Leave empty for default parachain template"
+    )]
     #[arg(default_value = "vanilla")]
-    pub template: Template,
+    pub(crate) template: Template,
+    #[arg(long, short, help = "Token Symbol", default_value = "UNIT")]
+    pub(crate) symbol: Option<String>,
+    #[arg(long, short, help = "Token Decimals", default_value = "12")]
+    pub(crate) decimals: Option<String>,
+    #[arg(
+        long = "endowment",
+        short,
+        help = "Token Endowment for dev accounts",
+        default_value = "1u64 << 60"
+    )]
+    pub(crate) initial_endowment: Option<String>,
 }

src/generator.rs

@@ -1,35 +1,31 @@
+//! TODO: Generators should reference files that live in the repository
+
 use std::{fs::OpenOptions, path::Path};
 
 use askama::Template;
 
-#[derive(Template)]
-#[template(path = "test.templ", escape = "none")]
-struct Runtime<'a> {
-    code: &'a str,
-    balances: bool,
-}
-
 // TODO: This should be coupled with Runtime in the sense that pallets part of a Runtime may need a default genesis config
 #[derive(Template)]
 #[template(path = "chain_spec.templ", escape = "none")]
-struct ChainSpec<'a> {
-    token_symbol : &'a str,
-    decimals: u8,
-    initial_endowment: &'a str,
+pub(crate) struct ChainSpec {
+    pub(crate) token_symbol: String,
+    pub(crate) decimals: u8,
+    pub(crate) initial_endowment: String,
 }
 // todo : generate directory structure
-
+// todo : This is only for development
 pub fn generate() {
     let cs = ChainSpec {
-        token_symbol: "DOT",
+        token_symbol: "DOT".to_owned(),
         decimals: 10,
-        initial_endowment: "1u64 << 15"
+        initial_endowment: "1u64 << 15".to_owned(),
     };
     let rendered = cs.render().unwrap();
     write_to_file(Path::new("src/x.rs"), &rendered);
 }
 
-fn write_to_file<'a>(path: &Path, contents: &'a str) {
+// TODO: Check the usage of `expect`. We don't want to leave the outdir in a unhygenic state
+pub(crate) fn write_to_file<'a>(path: &Path, contents: &'a str) {
     use std::io::Write;
     let mut file = OpenOptions::new()
         .write(true)

src/main.rs

@@ -1,21 +1,38 @@
 mod cli;
-mod template;
 mod generator;
+mod template;
 
 use cli::Cli;
 use std::path::Path;
 
+use crate::template::Config;
+
 fn main() -> anyhow::Result<()> {
-    generator::generate();
-    std::process::exit(0);
-    
+    // eprintln!("DEBUG: Generator code is only used for development purposes");
+    // generator::generate();
+    // std::process::exit(0);
+
     let cli = <Cli as clap::Parser>::parse();
-    let (app_name, template) = match cli.create {
-        cli::Create::Create(cli::TemplateCmd { name, template }) => (name, template),
+    let (app_name, template, config) = match cli.create {
+        cli::Create::Create(cli::TemplateCmd {
+            name,
+            template,
+            symbol,
+            decimals,
+            initial_endowment,
+        }) => (
+            name,
+            template,
+            Config {
+                symbol: symbol.expect("default values"),
+                decimals: decimals.expect("default values").parse::<u8>()?,
+                initial_endowment: initial_endowment.expect("default values"),
+            },
+        ),
     };
     println!("Starting {} on `{}`!", template, app_name);
     let destination_path = Path::new(&app_name);
-    template::instantiate_template_dir(&template, destination_path)?;
+    template::instantiate_template_dir(&template, destination_path, config)?;
     println!("cd into `{app_name}` and enjoy hacking! 🚀");
 
     Ok(())

src/template.rs

@@ -1,34 +1,39 @@
-use crate::cli::Template;
+use crate::{
+    cli::Template,
+    generator::{write_to_file, ChainSpec},
+};
 use anyhow::Result;
 use git2::Repository;
 use std::{fs, path::Path};
 use walkdir::WalkDir;
 
-pub struct Config;
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub(crate) symbol: String,
+    pub(crate) decimals: u8,
+    pub(crate) initial_endowment: String,
+}
 
-pub fn instantiate_template_dir(
-    template: &Template,
-    target: &Path,
-    // config: &Config,
-) -> Result<()> {
+pub fn instantiate_template_dir(template: &Template, target: &Path, config: Config) -> Result<()> {
     use Template::*;
     // TODO : if target folder exists, prompt user to clean dir or abort
+    sanitize(target)?;
     let url = match template {
         EPT => "https://github.com/paritytech/extended-parachain-template.git",
         FPT => "https://github.com/paritytech/frontier-parachain-template.git",
         Contracts => "https://github.com/paritytech/substrate-contracts-node.git",
         Vanilla => {
-            return instantiate_vanilla_template(target, Some(Config));
+            return instantiate_vanilla_template(target, config);
         }
     };
     Repository::clone(url, target)?;
     Ok(())
 }
 // TODO: The config will shape the emitted template
-pub fn instantiate_vanilla_template(target: &Path, config: Option<Config>) -> Result<()> {
+pub fn instantiate_vanilla_template(target: &Path, config: Config) -> Result<()> {
     let temp_dir = ::tempfile::TempDir::new_in(std::env::temp_dir())?;
     let temp_path = temp_dir.path();
-    println!("Temporary directory created at {:?}", temp_path);
+    // println!("Temporary directory created at {:?}", temp_path);
 
     Repository::clone("https://github.com/weezy20/DoTemplate.git", temp_path)?;
     let source = temp_path.join("templates/vanilla-parachain");
@@ -45,6 +50,39 @@ pub fn instantiate_vanilla_template(target: &Path, config: Option<Config>) -> Re
             fs::copy(source_path, &destination_path)?;
         }
     }
+    let chainspec = ChainSpec {
+        token_symbol: config.symbol,
+        decimals: config.decimals,
+        initial_endowment: config.initial_endowment,
+    };
+    use askama::Template;
+    write_to_file(
+        &target.join("node/src/chain_spec.rs"),
+        chainspec.render().expect("infallible").as_ref(),
+    );
+
+    Ok(())
+}
 
+fn sanitize(target: &Path) -> Result<()> {
+    use std::io::{stdin, stdout, Write};
+    if target.exists() {
+        print!(
+            "\"{}\" folder exists. Do you want to clean it? [y/n]: ",
+            target.display()
+        );
+        stdout().flush()?;
+
+        let mut input = String::new();
+        stdin().read_line(&mut input)?;
+
+        if input.trim().to_lowercase() == "y" {
+            fs::remove_dir_all(target)?;
+        } else {
+            return Err(anyhow::anyhow!(
+                "User aborted due to existing target folder."
+            ));
+        }
+    }
     Ok(())
 }