feat(options): granular style formatting (#85)

* implement granular style formatting

* attempt to fix CI

* document new styling options

---------

Co-authored-by: Victor Borja <[e-mail]>

dev/flake.nix

···
 # DO-NOT-EDIT. This file was auto-generated using github:vic/flake-file.
 # Use `nix run .#write-flake` to regenerate it.
 {
-
   outputs = inputs: inputs.flake-parts.lib.mkFlake { inherit inputs; } (inputs.import-tree ./modules);
 
   inputs = {
     devshell = {
-      inputs.nixpkgs.follows = "nixpkgs";
       url = "github:numtide/devshell";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
     flake-file.url = "path:..";
     flake-parts = {
-      inputs.nixpkgs-lib.follows = "nixpkgs-lib";
       url = "github:hercules-ci/flake-parts";
+      inputs.nixpkgs-lib.follows = "nixpkgs-lib";
     };
     import-tree.url = "github:vic/import-tree";
     nix-auto-follow = {
-      inputs.nixpkgs.follows = "nixpkgs";
       url = "github:fzakaria/nix-auto-follow";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
     nix-unit = {
+      url = "github:nix-community/nix-unit";
       inputs = {
         flake-parts.follows = "flake-parts";
         nixpkgs.follows = "nixpkgs";
         treefmt-nix.follows = "treefmt-nix";
       };
-      url = "github:nix-community/nix-unit";
     };
     nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";
     nixpkgs-lib.follows = "nixpkgs";
     treefmt-nix = {
-      inputs.nixpkgs.follows = "nixpkgs";
       url = "github:numtide/treefmt-nix";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
   };
-
 }

dev/modules/_lib/default.nix

···
         value = value;
       };
 
+  priorityComparator =
+    priority: a: b:
+    let
+      findPriority = name: lib.lists.findFirstIndex (p: p == name) (lib.length priority) priority;
+      priorityA = findPriority a;
+      priorityB = findPriority b;
+    in
+    if priorityA == priorityB then a < b else priorityA < priorityB;
+
+  priorityMapAttrsToList =
+    f: priority: attrs:
+    lib.pipe attrs [
+      lib.attrsToList
+      (lib.sort (a: b: priorityComparator priority a.name b.name))
+      (map ({ name, value }: f name value))
+    ];
+
+  styleHead =
+    styles:
+    if styles == [ ] then
+      {
+        attrSortPriority = [ ];
+        attrSep = " ";
+      }
+    else
+      lib.pipe styles [
+        lib.head
+        (
+          {
+            attrSortPriority ? [ ],
+            attrSep ? " ",
+          }:
+          {
+            inherit attrSortPriority attrSep;
+          }
+        )
+      ];
+
+  styleTail = styles: if styles == [ ] then [ ] else lib.tail styles;
+
   # expr to code
   nixCode =
-    x:
-    if lib.isStringLike x then
-      lib.strings.escapeNixString x
-    else if lib.isAttrs x then
-      lib.pipe x [
-        (lib.mapAttrsToList nixAttr)
-        (map ({ name, value }: "${name} = ${nixCode value}; "))
-        (values: "{ ${lib.concatStringsSep " " values} }")
+    {
+      expr,
+      styles ? [ ],
+    }:
+    let
+      style = styleHead styles;
+    in
+    if lib.isStringLike expr then
+      lib.strings.escapeNixString expr
+    else if lib.isAttrs expr then
+      lib.pipe expr [
+        (priorityMapAttrsToList nixAttr style.attrSortPriority)
+        (map (
+          { name, value }:
+          "${name} = ${
+            nixCode {
+              expr = value;
+              styles = styleTail styles;
+            }
+          };"
+        ))
+        (values: "{ ${lib.concatStringsSep style.attrSep values} }")
       ]
-    else if lib.isList x then
-      lib.pipe x [
-        (lib.map nixCode)
+    else if lib.isList expr then
+      lib.pipe expr [
+        (lib.map (
+          expr:
+          nixCode {
+            inherit expr;
+            styles = styleTail styles;
+          }
+        ))
         (values: "[ ${lib.concatStringsSep " " values} ]")
       ]
-    else if x == true then
+    else if expr == true then
       "true"
-    else if x == false then
+    else if expr == false then
       "false"
     else
-      toString x;
+      toString expr;
 
 in
 {
-  inherit inputsExpr isNonEmptyString nixCode;
+  inherit
+    inputsExpr
+    isNonEmptyString
+    priorityComparator
+    priorityMapAttrsToList
+    nixCode
+    ;
 }

docs/src/content/docs/reference/options.mdx

···
 };
 ```
 
+## Style options
+
+| Option | Type | Description |
+|---|---|---|
+| `flake-file.style.sep.flake` | `str` | The separator used between the top-level attributes of the flake |
+| `flake-file.style.sep.inputs` | `str` | The separator used between the top-level attributes of inputs |
+| `flake-file.style.sep.inputSchema` | `str` | The separator used between the top-level attributes of an input schema |
+| `flake-file.style.sep.nixConfig` | `str` | The separator used between the top-level attributes of nixConfig |
+| `flake-file.style.sortPriority.flake` | `listOf str` | When alphabetically sorting the top-level attributes of the flake, names within this list will receive a higher sort order according to its index |
+| `flake-file.style.sortPriority.inputs` | `listOf str` | When alphabetically sorting the top-level attributes of inputs, names within this list will receive a higher sort order according to its index |
+| `flake-file.style.sortPriority.inputSchema` | `listOf str` | When alphabetically sorting the top-level attributes of an input schema, names within this list will receive a higher sort order according to its index |
+| `flake-file.style.sortPriority.nixConfig` | `listOf str` | When alphabetically sorting the top-level attributes of nixConfig, names within this list will receive a higher sort order according to its index |
+
+
 ## Hook Options
 
 | Option | Type | Description |

modules/options/default.nix

···
     ./prune-lock.nix
     ./write-hooks.nix
     ./check-hooks.nix
+    ./style.nix
   ];
 }

modules/options/style.nix

···
+{ lib, ... }:
+let
+  mkSepOption =
+    name: default:
+    lib.mkOption {
+      description = ''
+        The separator used between the top-level attributes of ${name}.
+      '';
+      type = lib.types.str;
+      inherit default;
+    };
+
+  mkSortPriorityOption =
+    name: default:
+    lib.mkOption {
+      description = ''
+        When alphabetically sorting the top-level attributes of ${name}, names within
+        this list will receive a higher sort order according to its index.
+      '';
+      type = lib.types.listOf lib.types.str;
+      inherit default;
+    };
+in
+{
+  options.flake-file.style = {
+    sep = {
+      flake = mkSepOption "the flake" "\n\n";
+      inputs = mkSepOption "inputs" "\n";
+      inputSchema = mkSepOption "an input schema" "\n";
+      nixConfig = mkSepOption "nixConfig" "\n";
+    };
+
+    sortPriority = {
+      flake = mkSortPriorityOption "the flake" [
+        "description"
+        "outputs"
+        "nixConfig"
+        "inputs"
+      ];
+      inputs = mkSortPriorityOption "inputs" [ ];
+      inputSchema = mkSortPriorityOption "an input schema" [
+        "type"
+        "host"
+        "url"
+        "owner"
+        "repo"
+        "path"
+        "id"
+        "dir"
+        "narHash"
+        "rev"
+        "ref"
+        "submodules"
+        "flake"
+        "follows"
+        "inputs"
+      ];
+      nixConfig = mkSortPriorityOption "nixConfig" [ ];
+    };
+  };
+}

modules/write-flake.nix

···
   ...
 }@top:
 let
-  inherit (import ./../dev/modules/_lib lib) inputsExpr isNonEmptyString nixCode;
+  inherit (import ./../dev/modules/_lib lib)
+    inputsExpr
+    isNonEmptyString
+    priorityMapAttrsToList
+    nixCode
+    ;
+
+  inherit (config.flake-file.style) sep sortPriority;
 
   flake-file = config.flake-file;
 
-  template = ''
-    {
-      <description>
-      <outputs>
-      <nixConfig>
-      <inputs>
-    }
-  '';
-
-  unformatted = lib.pipe template [
-    (lib.replaceString "<description>" description)
-    (lib.replaceString "<outputs>" outputs)
-    (lib.replaceString "<nixConfig>" nixConfig)
-    (lib.replaceString "<inputs>" flakeInputs)
-    addHeader
-  ];
+  unformatted =
+    let
+      filteredAttrs = lib.filterAttrs (_: v: v != null) {
+        inherit description outputs nixConfig;
+        inputs = flakeInputs;
+      };
+      exprs = priorityMapAttrsToList (_: v: v) sortPriority.flake filteredAttrs;
+    in
+    addHeader ''
+      {
+        ${lib.concatStringsSep sep.flake exprs} 
+      }
+    '';
 
   description =
     if isNonEmptyString flake-file.description then
-      ''
-        description = ${nixCode flake-file.description};
-      ''
+      "description = ${nixCode { expr = flake-file.description; }};"
     else
-      "";
+      null;
 
-  outputs = ''
-    outputs = ${flake-file.outputs};
-  '';
+  outputs = "outputs = ${flake-file.outputs};";
 
   nixConfig =
     let
···
       ) flake-file.nixConfig;
     in
     if filteredConfig != { } then
-      ''
-        nixConfig = ${nixCode filteredConfig};
-      ''
+      "nixConfig = ${
+        nixCode {
+          expr = filteredConfig;
+          styles = [
+            {
+              attrSortPriority = sortPriority.nixConfig;
+              attrSep = sep.nixConfig;
+            }
+          ];
+        }
+      };"
     else
-      "";
+      null;
 
-  flakeInputs = ''
-    inputs = ${nixCode (inputsExpr flake-file.inputs)};
-  '';
+  flakeInputs = "inputs = ${
+    nixCode {
+      expr = inputsExpr flake-file.inputs;
+      styles = [
+        {
+          attrSortPriority = sortPriority.inputs;
+          attrSep = sep.inputs;
+        }
+        {
+          attrSortPriority = sortPriority.inputSchema;
+          attrSep = sep.inputSchema;
+        }
+        {
+          attrSortPriority = sortPriority.inputs;
+          attrSep = sep.inputs;
+        }
+      ];
+    }
+  };";
 
   addHeader =
     code: if isNonEmptyString flake-file.do-not-edit then flake-file.do-not-edit + code else code;

modules/write-inputs.nix

···
     # DO-NOT-EDIT: Generated by github:vic/flake-file.
     # To re-generate use: nix-shell . -A flake-file.sh --run write-inputs
   ''
-  + (nixCode (inputsExpr flake-file.inputs));
+  + (nixCode { expr = inputsExpr flake-file.inputs; });
 
   inputsFile =
     pkgs:

templates/default/flake.nix

···
 # DO-NOT-EDIT. This file was auto-generated using github:vic/flake-file.
 # Use `nix run .#write-flake` to regenerate it.
 {
-
   outputs = inputs: import ./outputs.nix inputs;
 
   inputs = {
···
     flake-parts.url = "github:hercules-ci/flake-parts";
     nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";
   };
-
 }

templates/dendritic/flake.nix

···
 # DO-NOT-EDIT. This file was auto-generated using github:vic/flake-file.
 # Use `nix run .#write-flake` to regenerate it.
 {
-
   outputs = inputs: inputs.flake-parts.lib.mkFlake { inherit inputs; } (inputs.import-tree ./modules);
 
   inputs = {
     flake-file.url = "github:vic/flake-file";
     flake-parts = {
-      inputs.nixpkgs-lib.follows = "nixpkgs-lib";
       url = "github:hercules-ci/flake-parts";
+      inputs.nixpkgs-lib.follows = "nixpkgs-lib";
     };
     import-tree.url = "github:vic/import-tree";
     nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";
     nixpkgs-lib.follows = "nixpkgs";
   };
-
 }

templates/parts/flake.nix

···
 # DO-NOT-EDIT. This file was auto-generated using github:vic/flake-file.
 # Use `nix run .#write-flake` to regenerate it.
 {
-
   outputs = inputs: import ./outputs.nix inputs;
 
   nixConfig = {
···
     nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";
     treefmt-nix.url = "github:numtide/treefmt-nix";
   };
-
 }