chore: refactor lua generation

lib/lua.nix

@@ -1,49 +1,51 @@
 {lib, ...}: let
   inherit (lib.strings) removeSuffix;
-  inherit (builtins) match;
+  inherit (builtins) match isNull typeOf concatStringsSep attrNames concatMap;
-  handleAst = data: let
-    ast = data.__ast;
-  in
-    if ast == "raw"
-    then data.data
-    else if ast == "return"
-    # TODO nix2lua can return null
-    then "return ${nix2lua data.data}"
-    else if ast == "fn"
-    then "function ${data.name}()\n${nix2lua data.data}\nend"
-    else abort ''Unknown ast type ${ast.__ast}'';
 
-  nix2lua = data: let
+  commaJoin = concatStringsSep ", ";
-    inherit (builtins) isInt isBool isNull isString isList isPath isAttrs isFunction typeOf concatStringsSep attrNames concatMap;
+  wrapNotNull' = val: value:
-    type = typeOf data;
-    condValue2list = val: value:
     if isNull val
     then []
     else [value];
-    value2list = val: condValue2list val val;
+  wrapNotNull = val: wrapNotNull' val val;
-  in
+
-    if data ? __ast
+  toLua = {
-    then handleAst data
+    ast = {
-    else if isInt data
+      raw = {data, ...}: data;
-    then toString data
+      return = {data, ...}: "return ${nix2lua data}";
-    else if isBool data
+      fn = {
-    then
+        data,
+        name,
+        args,
+        ...
+      }: "function ${name}(${commaJoin args})\n${nix2lua data}\nend";
+    };
+
+    type = rec {
+      null = _: "nil";
+      string = data: ''"${data}"'';
+      path = string;
+      lambda = data: builtins.trace "Skipping function" null;
+      int = data: toString data;
+
+      bool = data:
         if data
         then "true"
-      else "false"
+        else "false";
-    else if isString data || isPath data
+
-    then ''"${data}"''
+      ast = data: let
-    else if isNull data
+        astType = data.__ast;
-    then "nil"
+      in
-    else if isFunction data
+        if toLua.ast ? ${astType}
-    then (builtins.trace "Skipping function" null)
+        then toLua.ast.${astType} data
-    else if isList data
+        else abort ''Unknown ast type ${astType}'';
-    then let
+
-      nix2luaList = val: value2list (nix2lua val);
+      list = data: let
-      listContent = concatStringsSep ", " (concatMap nix2luaList data);
+        nix2luaList = val: wrapNotNull (nix2lua val);
-    in "{ ${listContent} }"
+        listContent = commaJoin (concatMap nix2luaList data);
-    else if isAttrs data
+      in "{ ${listContent} }";
-    then let
+
+      set = data: let
         mkKeyValue = key: let
           value = data.${key};
           luaKey =
@@ -52,15 +54,26 @@
             else key;
           luaValue = nix2lua value;
         in
-        # TODO Handle indentifier keys
+          wrapNotNull' luaValue ''
-        condValue2list luaValue ''
             ${luaKey} = ${luaValue},
           '';
         attrsContent = concatMap mkKeyValue (attrNames data);
       in ''
         {
           ${concatStringsSep "" attrsContent}}
-    ''
+      '';
+    };
+  };
+
+  newAst = type: set: set // {__ast = type;};
+
+  nix2lua = data: let
+    type = typeOf data;
+  in
+    if data ? __ast
+    then toLua.type.ast data
+    else if toLua.type ? ${type}
+    then toLua.type.${type} data
     else abort ''Type "${type}"'';
 in rec {
   inherit nix2lua;
@@ -75,21 +88,16 @@ in rec {
     (${wrapFunction (removeSuffix "\n" lua)})();
     -- end ${section}
   '';
+  raw = data: newAst "raw" {inherit data;};
 
-  raw = data: {
+  functionWithArgs = name: args: data:
-    inherit data;
+    newAst "fn" {
-    __ast = "raw";
+      inherit name data args;
     };
 
-  function = name: data: {
+  function = name: data: functionWithArgs name [] data;
-    inherit name data;
-    __ast = "fn";
-  };
 
   lambda = function "";
 
-  return = data: {
+  return = data: newAst "return" {inherit data;};
-    inherit data;
-    __ast = "return";
-  };
 }