big changes, remove file from entry

engine.nix

@@ -1,59 +1,99 @@
-pkgs: {extraArgs, entries, templates}: let
+pkgs: src: {extraArgs, entries, templates}: let
   inherit (pkgs) lib;
 
-  inherit (builtins) abort dirOf;
+  inherit (builtins) abort dirOf toString;
+  inherit (lib.attrsets) hasAttr;
   inherit (lib.lists) forEach findFirst;
-  inherit (lib.strings) concatMapStrings concatStrings escapeShellArg isString;
+  inherit (lib.path) removePrefix;
+  inherit (lib.strings) concatMapStrings concatStrings escapeShellArg hasSuffix isString removeSuffix;
   inherit (lib.trivial) functionArgs;
 
   args = {inherit pkgs;}
     // (import ./stdlib.nix pkgs)
     // extraArgs;
 
+  isBaseTemplate = template:
+    isString template.output;
 
-  findTemplateFile = entry:
+  findTemplateFile = entry: let
-    findFirst (templateFile: let
+    _template = findFirst (templateFile: let
       templateFn = import templateFile;
       template = templateFn (functionArgs templateFn);
     in
       template.name == entry.template)
     null
     templates;
+  in
+    if _template == null then
+      abort "unknown template `${entry.template}`"
+    else
+      _template;
 
   applyTemplate = entry: templateFile: let
     templateFn = import templateFile;
     template = templateFn (args // entry);
   in
-    if (isString template.output)
+    if isBaseTemplate template then {
-    then {
       inherit (entry) file;
       inherit (template) output;
     }
     else let
-      newEntry = template.output;
+      newEntry = template.output // {inherit (entry) file;};
       foundTemplateFile = findTemplateFile newEntry;
     in
-    if foundTemplateFile == null then
-      abort "template `${newEntry.template}` not found"
-    else
       applyTemplate newEntry foundTemplateFile;
 
   processEntryFile = entryFile: let
-    entryFn = import entryFile;
+    entry = getEntry entryFile;
-    entry = entryFn args;
     foundTemplateFile = findTemplateFile entry;
   in
-    if foundTemplateFile == null then
+    applyTemplate entry foundTemplateFile;
-      abort "template `${entry.template}` not found"
-    else
-      applyTemplate entry foundTemplateFile;
 
-in /*sh*/''
+  replaceSuffix = from: to: string:
-  ${concatMapStrings
+    if !(hasSuffix from string) then
-    (result: /*sh*/''
+      abort "invalid suffix `${from}` for string `${string}`"
-      mkdir -p $out/${dirOf result.file}
+    else
-      echo ${escapeShellArg result.output} > $out/${result.file}
+      concatStrings [ (removeSuffix from string) to ];
-    '')
+
-    (forEach entries processEntryFile)
+  getTemplateFormat = entry: templateFile: let
-  }
+    templateFn = import templateFile;
-''
+    # getEntry needs to go down to the base template for the format
+    # but any template through the way can ask for a file
+    # so we just give it a placeholder - an empty string here
+    # since the output of this thing doesn't matter
+    template = templateFn (args // entry // { file = ""; });
+  in
+    if isBaseTemplate template then
+      template.format
+    else let
+      newEntry = template.output;
+      foundTemplateFile = findTemplateFile newEntry;
+    in
+      getTemplateFormat newEntry foundTemplateFile;
+
+  getEntry = entryFile: let
+    sourceFile = toString (removePrefix src entryFile);
+    entry = (import entryFile) args;
+    foundTemplateFile = findTemplateFile entry;
+    entryFormat = getTemplateFormat entry foundTemplateFile;
+  in
+    if !(hasAttr "file" entry) then
+      entry // {
+        file = replaceSuffix ".nix" ".${entryFormat}" sourceFile;
+      }
+    else
+      entry;
+
+in {
+  inherit getEntry;
+
+  buildScript = /*sh*/''
+    ${concatMapStrings
+      (result: /*sh*/''
+        mkdir -p $out/${dirOf result.file}
+        echo ${escapeShellArg result.output} > $out/${result.file}
+      '')
+      (forEach entries processEntryFile)
+    }
+  '';
+}