bad/devos
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity
devos/lib/flake.nix

94 lines
2.2 KiB
Nix
Raw Normal View History

ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
{
description = "DevOS environment configuriguration library.";
inputs =
{
deploy.url = "github:serokell/deploy-rs";
devshell.url = "github:numtide/devshell";
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
utils.url = "github:numtide/flake-utils";
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
};
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
outputs = inputs@{ self, nixpkgs, deploy, devshell, utils, ... }:
let
ref: make onion with flake-utils
2021-04-18 03:56:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
lib = nixpkgs.lib.makeExtensible (self:
let
attrs = import ./attrs.nix { lib = nixpkgs.lib // self; };
lists = import ./lists.nix { lib = nixpkgs.lib // self; };
strings = import ./strings.nix { lib = nixpkgs.lib // self; };
lib: init modules and move mkHosts modules there This helps to split up the code in mkHosts and creates a place where we can store modules relevent to devos. It will also be easier to remove unecessary parts of each module in the future when they are all compartmentalized.
2021-04-24 17:56:51 +02:00
modules = import ./modules.nix { lib = nixpkgs.lib // self; };
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
in
ref: make onion with flake-utils
2021-04-18 03:56:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
utils.lib
ref: make onion with flake-utils
2021-04-18 03:56:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
//
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
{
os = import ./devos {
fix: constructors of mkFlake function family
2021-04-19 05:29:28 +02:00
lib = nixpkgs.lib // self;
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
inherit utils;
fix: constructors of mkFlake function family
2021-04-19 05:29:28 +02:00
};
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
mkFlake = {
__functor = import ./mkFlake {
lib = nixpkgs.lib // self;
inherit deploy;
};
evalArgs = import ./mkFlake/evalArgs.nix { lib = nixpkgs.lib // self; };
evalOldArgs = import ./mkFlake/evalOldArgs.nix { lib = nixpkgs.lib // self; };
};
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
pkgs-lib = import ./pkgs-lib {
lib = nixpkgs.lib // self;
inherit nixpkgs deploy devshell;
};
inherit (attrs)
mapFilterAttrs
genAttrs'
safeReadDir
pathsToImportedAttrs
concatAttrs
filterPackages;
add and use lib.collectProfiles this function collects profiles recursively
2021-04-26 05:53:16 +02:00
inherit (lists) pathsIn collectProfiles;
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
inherit (strings) rgxToString;
lib: init modules and move mkHosts modules there This helps to split up the code in mkHosts and creates a place where we can store modules relevent to devos. It will also be easier to remove unecessary parts of each module in the future when they are all compartmentalized.
2021-04-24 17:56:51 +02:00
inherit modules;
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
}
);
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
in
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
{
lib = utils.lib // {
inherit (lib)
mkFlake;
};
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
}
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
//
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
utils.lib.eachDefaultSystem (system:
let
pkgs = import nixpkgs { inherit system; };
in
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
{
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
checks = {
tests = import ./tests {
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
inherit pkgs;
use: makeExtensible
2021-04-19 04:45:08 +02:00
lib = nixpkgs.lib // lib;
fixup: nix flake check I / X
2021-04-19 00:23:27 +02:00
};
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
};
mkFlakeDoc: move to packages output the packages output allows us to do `nix build .#nixosOptionsDoc`. theres also already an instantiated nixpkgs available there.
2021-04-24 17:14:58 +02:00
packages = {
mkFlakeDoc = pkgs.writeText "mkFlakeOptions.md"
(
pkgs.nixosOptionsDoc {
inherit (lib.mkFlake.evalArgs { nixos = "nixos"; args = { }; }) options;
}
).optionsMDDoc;
};
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
}
lib: one line for arguments, drop userFlake* Also format all files and add a flake.lock for lib for a folder thats meant to work on other flakes theres never a reason it should need to refer to itself, only other flakes. So "self" and "inputs" are better namings for these variables. The userFlake* is redundant and confusing, when trying to call the functions its hard to figure out how to use them when there are now two lines of arguments to figure out.
2021-04-24 03:13:03 +02:00
);
ref: extract lib into subflake
2021-04-02 04:10:24 +02:00
}
Reference in a new issue Copy permalink