simple internal templating system

guybedford · Dec 23, 2021 · d6320c9 · d6320c9
1 parent 5e69aa1
commit d6320c9
Show file tree

Hide file tree

Showing 5 changed files with 129 additions and 91 deletions.
diff --git a/chompfile.toml b/chompfile.toml
@@ -1,57 +1,27 @@
 version = 0.1
 
-[env]
-  BUILD_TYPE = "Debug"
-
-# [[task]]
-#   name = "build"
-#   target = "test/lib/#.js"
-#   deps = ["node_modules/.bin/swc", "test/src/#.ts"]
-#   run = "npx @chomp/svelte"
-
-# [[task]]
-#   name = "install"
-#   target = "node_modules/.bin/swc"
-#   run = "npm install @swc/core @swc/cli --save-dev"
-
-# [[task]]
-#   run = "@chomp/svelte"
-
 [[task]]
-  name = "tpl"
-  template = "chomp:svelte"
-  [task.args]
-    indir = "src"
-    outdir = "lib"
-
-[[template]]
-  name = "chomp:svelte"
-  definition = """({ outdir = 'lib', indir = 'src' }) => [{
-    target: `${outdir}/#.svelte.js`,
-    deps: [`${indir}/#.svelte`, 'node_modules/svelte', 'node_modules/mkdirp'],
-    engine: 'node',
-    run: `
-      import { readFileSync, writeFileSync } from 'fs';
-      import { compile } from 'svelte/compiler';
-      import mkdirp from 'mkdirp';
-      import { dirname } from 'path';
-
-      const source = readFileSync(process.env.dep, "utf-8");
-      const result = compile(source, {
-        filename: process.env.DEP,
-        css: false,
-      });
+  name = "install"
+  deps = ["build"]
+  run = """
+    cp target/Debug/chp.exe ~/bin/chp2.exe
+    cp target/Debug/chp.exe ~/bin/chp.exe
+  """
 
-      mkdirp.sync(dirname(process.env.TARGET));
-      writeFileSync(process.env.TARGET, result.js.code);
-      writeFileSync(process.env.TARGET + ".map", JSON.stringify(result.js.map));
+[[task]]
+  name = "build"
+  deps = ["build:templates"]
+  run = "cargo build"
 
-      const cssFile = process.env.TARGET.replace(/\\.js$/, ".css");
-      writeFileSync(cssFile, result.css.code);
-      writeFileSync(cssFile + ".map", JSON.stringify(result.css.map));
-    `
-  }, {
-    targets: ['node_modules/svelte', 'node_modules/mkdirp'],
-    run: 'npm install svelte mkdirp --save-dev'
-  }]
+[[task]]
+  name = "build:templates"
+  engine = "node"
+  run = """
+    import { readdirSync, readFileSync, writeFileSync } from 'fs';
+
+    let combinedTemplates = 'version = 0.1\\n';
+    for (const tpl of readdirSync('templates'))
+      combinedTemplates += readFileSync(`templates/${tpl}`).toString() + '\\n';
+    
+    writeFileSync('src/templates.toml', combinedTemplates);
   """
diff --git a/src/chompfile.rs b/src/chompfile.rs
@@ -5,8 +5,10 @@ use std::collections::BTreeMap;
 pub struct Chompfile {
     pub version: f32,
     pub env: Option<BTreeMap<String, String>>,
-    pub task: Option<Vec<ChompTaskMaybeTemplated>>,
-    pub template: Option<Vec<ChompTemplate>>,
+    #[serde(default)]
+    pub task: Vec<ChompTaskMaybeTemplated>,
+    #[serde(default)]
+    pub template: Vec<ChompTemplate>,
 }
 
 #[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]

diff --git a/src/task.rs b/src/task.rs
@@ -262,47 +262,43 @@ impl<'a> Runner<'a> {
         };
 
         let mut templates: BTreeMap<&String, &ChompTemplate> = BTreeMap::new();
-        if let Some(ref chompfile_templates) = chompfile.template {
-            for template in chompfile_templates {
-                templates.insert(&template.name, &template);
-            }
+        for template in &chompfile.template {
+            templates.insert(&template.name, &template);
         }
 
         // expand tasks into initial job list
-        if let Some(tasks) = &runner.chompfile.task {
-            for (i, task) in tasks.iter().enumerate() {
-                if task.template.is_none() {
-                    runner.add_task(task);
-                    continue;
-                }
-                let template = task.template.as_ref().unwrap();
-                // evaluate templates into tasks
-                if task.deps.is_some() || task.engine.is_some() || task.env.is_some() ||
-                    task.targets.is_some() || task.target.is_some() || task.run.is_some() {
-                    panic!("Template does not support normal task fields");
-                }
+        for (i, task) in runner.chompfile.task.iter().enumerate() {
+            if task.template.is_none() {
+                runner.add_task(task);
+                continue;
+            }
+            let template = task.template.as_ref().unwrap();
+            // evaluate templates into tasks
+            if task.deps.is_some() || task.engine.is_some() || task.env.is_some() ||
+                task.targets.is_some() || task.target.is_some() || task.run.is_some() {
+                panic!("Template does not support normal task fields");
+            }
 
-                let template = templates.get(template).expect("Unable to find template");
-                let mut template_tasks: Vec<ChompTaskMaybeTemplatedNoDefault> = run_js_fn(&template.definition, &task.args);
-                if template_tasks.len() == 0 {
-                    continue;
-                }
-                if let Some(name) = &task.name {
-                    template_tasks[0].name = Some(name.to_string());
-                }
-                for task in template_tasks.drain(..) {
-                    runner.add_task(&ChompTaskMaybeTemplated {
-                        name: task.name,
-                        target: task.target,
-                        targets: task.targets,
-                        deps: task.deps,
-                        env: task.env,
-                        run: task.run,
-                        engine: task.engine,
-                        template: task.template,
-                        args: task.args.unwrap_or_default(),
-                    });
-                }
+            let template = templates.get(template).expect("Unable to find template");
+            let mut template_tasks: Vec<ChompTaskMaybeTemplatedNoDefault> = run_js_fn(&template.definition, &task.args);
+            if template_tasks.len() == 0 {
+                continue;
+            }
+            if let Some(name) = &task.name {
+                template_tasks[0].name = Some(name.to_string());
+            }
+            for task in template_tasks.drain(..) {
+                runner.add_task(&ChompTaskMaybeTemplated {
+                    name: task.name,
+                    target: task.target,
+                    targets: task.targets,
+                    deps: task.deps,
+                    env: task.env,
+                    run: task.run,
+                    engine: task.engine,
+                    template: task.template,
+                    args: task.args.unwrap_or_default(),
+                });
             }
         }
         runner
@@ -1190,8 +1186,14 @@ async fn drive_watcher<'a>(
 }
 
 pub async fn run<'a>(opts: RunOptions<'a>) -> Result<(), TaskError> {
+    let mut default_chompfile: Chompfile = toml::from_str(include_str!("templates.toml")).unwrap();
+
     let chompfile_source = fs::read_to_string(opts.cfg_file).await?;
-    let chompfile: Chompfile = toml::from_str(&chompfile_source)?;
+    let mut chompfile: Chompfile = toml::from_str(&chompfile_source)?;
+
+    for template in default_chompfile.template.drain(..) {
+        chompfile.template.push(template);
+    }
 
     if chompfile.version != 0.1 {
         return Err(TaskError::InvalidVersionError(format!(

diff --git a/src/templates.toml b/src/templates.toml
@@ -0,0 +1,33 @@
+version = 0.1
+[[template]]
+  name = "chomp:svelte"
+  definition = """({ outdir = 'lib', indir = 'src' }) => [{
+    target: `${outdir}/#.svelte.js`,
+    deps: [`${indir}/#.svelte`, 'node_modules/svelte', 'node_modules/mkdirp'],
+    engine: 'node',
+    run: `
+      import { readFileSync, writeFileSync } from 'fs';
+      import { compile } from 'svelte/compiler';
+      import mkdirp from 'mkdirp';
+      import { dirname } from 'path';
+
+      const source = readFileSync(process.env.dep, "utf-8");
+      const result = compile(source, {
+        filename: process.env.DEP,
+        css: false,
+      });
+
+      mkdirp.sync(dirname(process.env.TARGET));
+      writeFileSync(process.env.TARGET, result.js.code);
+      writeFileSync(process.env.TARGET + ".map", JSON.stringify(result.js.map));
+
+      const cssFile = process.env.TARGET.replace(/\\.js$/, ".css");
+      writeFileSync(cssFile, result.css.code);
+      writeFileSync(cssFile + ".map", JSON.stringify(result.css.map));
+    `
+  }, {
+    targets: ['node_modules/svelte', 'node_modules/mkdirp'],
+    run: 'npm install svelte mkdirp --save-dev'
+  }]
+  """
+
diff --git a/templates/svelte.toml b/templates/svelte.toml
@@ -0,0 +1,31 @@
+[[template]]
+  name = "chomp:svelte"
+  definition = """({ outdir = 'lib', indir = 'src' }) => [{
+    target: `${outdir}/#.svelte.js`,
+    deps: [`${indir}/#.svelte`, 'node_modules/svelte', 'node_modules/mkdirp'],
+    engine: 'node',
+    run: `
+      import { readFileSync, writeFileSync } from 'fs';
+      import { compile } from 'svelte/compiler';
+      import mkdirp from 'mkdirp';
+      import { dirname } from 'path';
+
+      const source = readFileSync(process.env.dep, "utf-8");
+      const result = compile(source, {
+        filename: process.env.DEP,
+        css: false,
+      });
+
+      mkdirp.sync(dirname(process.env.TARGET));
+      writeFileSync(process.env.TARGET, result.js.code);
+      writeFileSync(process.env.TARGET + ".map", JSON.stringify(result.js.map));
+
+      const cssFile = process.env.TARGET.replace(/\\.js$/, ".css");
+      writeFileSync(cssFile, result.css.code);
+      writeFileSync(cssFile + ".map", JSON.stringify(result.css.map));
+    `
+  }, {
+    targets: ['node_modules/svelte', 'node_modules/mkdirp'],
+    run: 'npm install svelte mkdirp --save-dev'
+  }]
+  """