Documented Layers, created example layer and template for it. (#8)

- Layers are now automatically discovered from directories in
  ./dev/layers.

- Added an example vix layer which imports features from vic/vix repo.

- Added an example vix template that includes said layer to test it all.

Author: vic

default.nix

@@ -15,7 +15,7 @@ let
 
   module = inputs.import-tree [
     ./dev/community
-    ((inputs.import-tree.addPath ./dev/layers).match ".+/dev/layers/[^/]+.nix")
+    ./dev/layers/options.nix
   ];
 
   ev = lib.modules.evalModules {

dev/book/src/Dendrix-Layers.md

@@ -22,24 +22,36 @@ If you were to use the example AI layer (from below), you'd do the following on
 
 ## Creating Layers
 
+A Dendrix Layer is defined at `./dev/layers/<name>/modules/**.nix`. If you create one, make sure you
+also provide a `./dev/layers/<name>/README.md` with details about usage or input requirements.
+
 For example, if the community comes up with an `ai` aspect shared across different repos, we
 could have a _blessed_ ai layer providing files from both repos and community-managed configurations.
 
 ```nix
 # This is an example of how an AI Layer might be defined in our Dendrix community repository.
 #
-# ./dev/layers/ai.nix
-{ inputs, config, ... }:
+# ./dev/layers/ai/modules/default.nix
+{ inputs, lib, ... }:
 let
-  ai-one = config.dendrix.community.repo-one.import-tree.ai; # import-tree for AI aspect from repo-one.
-  ai-two = config.dendrix.community.repo-two.import-tree.ai; # import-tree for AI aspect from repo-two.
-  ai-community = inputs.import-tree.addPath ./ai; # community-managed AI from ./dev/layers/ai/**.nix
+  ai-one = inputs.dendrix.repo-one.ai; # import-tree for AI aspect from repo-one.
+  ai-two = inputs.dendrix.repo-two.ai; # import-tree for AI aspect from repo-two.
 in
 {
-  dendrix.layers.ai = {lib, ...}: {
-    imports = [ ai-one ai-two ai-community ];
-    options.ai.something.enable = lib.mkEnableOption "Enable something for AI";
+  imports = [ ai-one ai-two ];
+
+  # flake-level community options.
+  options.ai.something.enable = lib.mkEnableOption "Enable something for AI";
+
+  # packages,checks,devshells,etc for AI
+  perSystem = {pkgs, ...}: {
+    packages.ai-cli = { };
   };
+
+  # extensions to the ai aspect.
+  flake.modules.nixos.ai = { };
+  flake.modules.darwin.ai = { };
+  flake.modules.homeManager.ai = { };
 }
 ```
 

dev/book/src/Getting-Started.md

@@ -2,6 +2,31 @@
 
 ## Usage (for existing flake-parts setups)
 
+Add the `dendrix` input to your flake:
+
+```nix
+# flake.nix -- add the dendrix input:
+{
+  inputs.dendrix.url = "github:vic/dendrix";
+
+  # Flatten dependencies.
+  #inputs.dendrix.inputs.import-tree.follows = "import-tree";
+  #inputs.dendrix.inputs.nixpkgs-lib.follows = "nixpkgs-lib";
+}
+```
+
+Then import Dendrix trees/layers on any flake-parts module of yours:
+
+```nix
+{ inputs, ... }:
+{
+  imports = [
+    # inputs.dendrix.vic-vix.macos-keys # example <macos-keys> aspect.
+    # inputs.dendrix.vix # example layer, see https://github.com/vic/dendrix/tree/main/dev/layers
+  ];
+}
+```
+
 See usage instructions for either [Dendrix Trees](Dendrix-Trees.html#using-community-import-trees) or [Dendrix Layers](Dendrix-Layers.html#using-existing-layers).
 
 ## Quick Start (for NixOS newcomers)

dev/book/theme/elm.js

@@ -3,6 +3,6 @@ inputs.flake-parts.lib.mkFlake { inherit inputs; } (
   inputs.import-tree [
     ./modules
     ./community
-    ((inputs.import-tree.addPath ./layers).match ".+/layers/[^/]+.nix")
+    ./layers/options.nix
   ]
 )

dev/default.nix

@@ -4,8 +4,8 @@ import Browser
 import Data
 import Deco
 import Dict exposing (Dict)
-import Html exposing (Html, button, code, div, p, pre, text)
-import Html.Attributes exposing (class, id)
+import Html exposing (Html, a, button, code, div, p, pre, text)
+import Html.Attributes exposing (class, href, id)
 import Html.Events exposing (onClick)
 import Json.Decode as D
 import Json.Encode as E
@@ -121,11 +121,12 @@ viewSelectedRepos model =
     , p []
         [ text "Add the following to your "
         , code [] [ text "flake.nix" ]
-        , text " to include these configuration modules."
+        , text " to include these configuration modules. See also: "
+        , a [ href "Getting-Started.html" ] [ text "Usage for Dendrix Trees/Layers" ]
         ]
     , viewUsageCode model.repos
     , p []
-        [ text "Then on any flake module of yours, extend any of these aspects with your custom configs, like:"
+        [ text "On a flake module of yours, extend any of these aspects with your custom configs, like:"
         , div []
             [ pre []
                 [ code [ class "language-nix" ]
@@ -168,20 +169,19 @@ viewUsageCode repos =
                 repoImports =
                     List.map
                         (\( repoName, treeName ) ->
-                            String.concat [ "      inputs.dendrix.", repoName, ".", treeName, "\n" ]
+                            String.concat [ "    inputs.dendrix.", repoName, ".", treeName, "\n" ]
                         )
                         trees
 
                 codes =
-                    [ """# flake.nix
+                    [ """# modules/dendrix-imports.nix -- on any module of yours.
+{ inputs, ... }:
 {
-  outputs = inputs: inputs.flake-parts.lib.mkFlake { inherit inputs; } 
-    (inputs.import-tree [
-      ./modules # your modules"""
+  imports = ["""
                     , "\n"
                     ]
                         ++ repoImports
-                        ++ [ "    ]);\n}", "\n" ]
+                        ++ [ "  ];\n}", "\n" ]
               in
               text (String.concat codes)
             ]

dev/elm/src/Results.elm

@@ -1,18 +1,28 @@
-{ lib, ... }:
+{ lib, inputs, ... }:
 let
 
-  moduleType = lib.types.oneOf [
-    lib.types.path
-    lib.types.attrs
-    (lib.types.functionTo lib.types.attrs)
-  ];
-
   layersOption = lib.mkOption {
-    description = "a flake-parts module";
-    default = { };
-    type = lib.types.attrsOf moduleType;
+    description = "layers flake-parts modules";
+    default = discoverLayers;
+    readOnly = true;
+    type = lib.types.attrsOf lib.types.attrs;
   };
 
+  discoverLayers = lib.pipe ./. [
+    builtins.readDir
+    (lib.mapAttrsToList (name: type: { inherit name type; }))
+    (lib.filter (x: x.type == "directory"))
+    (lib.map (x: x.name))
+    (lib.map (name: {
+      ${name} = {
+        imports = [
+          (inputs.import-tree ./${name}/modules)
+        ];
+      };
+    }))
+    lib.mergeAttrsList
+  ];
+
 in
 {
   options.dendrix.layers = layersOption;

dev/flake.lock

@@ -0,0 +1 @@
+# vix layer.