jalil/configuration.nix
1
1
Fork 0
Code Issues 1 Pull requests Projects Activity Actions

[fix] *.nix: reformat with alejandra

Browse source
This commit is contained in:
Jalil David Salamé Messina 2024-05-04 20:57:33 +02:00
parent 876dc45719
commit 39c2fb096c
Signed by: jalil
GPG key ID: F016B9E770737A0B
26 changed files with 565 additions and 562 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
docs/default.nix
View file

@ -1,38 +1,41 @@
{ pkgs, lib }: {
let pkgs,
lib,
}: let
# can be removed once https://github.com/rust-lang/mdBook/pull/2262 lands # can be removed once https://github.com/rust-lang/mdBook/pull/2262 lands
highlight = pkgs.fetchurl { highlight = pkgs.fetchurl {
url = "https://raw.githubusercontent.com/rust-lang/mdBook/7b9bd5049ce15ae5f301d5a40c50ce8359d9e9a8/src/theme/highlight.js"; url = "https://raw.githubusercontent.com/rust-lang/mdBook/7b9bd5049ce15ae5f301d5a40c50ce8359d9e9a8/src/theme/highlight.js";
hash = "sha256-pLP73zlmGkbC/zV6bwnB6ijRf9gVkj5/VYMGLhiQ1/Q="; hash = "sha256-pLP73zlmGkbC/zV6bwnB6ijRf9gVkj5/VYMGLhiQ1/Q=";
}; };
filterVisible = filterVisible = toplevelOption: option:
toplevelOption: option: option // {visible = option.visible && builtins.elemAt option.loc 0 == toplevelOption;};
option // { visible = option.visible && builtins.elemAt option.loc 0 == toplevelOption; };
home-eval = lib.evalModules { home-eval = lib.evalModules {
modules = [ ../home/options.nix ]; modules = [../home/options.nix];
specialArgs = { specialArgs = {
inherit pkgs; inherit pkgs;
}; };
}; };
nvim-eval = lib.evalModules { modules = [ ../nvim/options.nix ]; }; nvim-eval = lib.evalModules {modules = [../nvim/options.nix];};
nixos-eval = lib.evalModules { modules = [ ../system/options.nix ]; }; nixos-eval = lib.evalModules {modules = [../system/options.nix];};
home-markdown = home-markdown =
(pkgs.nixosOptionsDoc { (pkgs.nixosOptionsDoc {
inherit (home-eval) options; inherit (home-eval) options;
transformOptions = filterVisible "jhome"; transformOptions = filterVisible "jhome";
}).optionsCommonMark; })
.optionsCommonMark;
nvim-markdown = nvim-markdown =
(pkgs.nixosOptionsDoc { (pkgs.nixosOptionsDoc {
inherit (nvim-eval) options; inherit (nvim-eval) options;
transformOptions = filterVisible "jhome"; transformOptions = filterVisible "jhome";
}).optionsCommonMark; })
.optionsCommonMark;
nixos-markdown = nixos-markdown =
(pkgs.nixosOptionsDoc { (pkgs.nixosOptionsDoc {
inherit (nixos-eval) options; inherit (nixos-eval) options;
transformOptions = filterVisible "jconfig"; transformOptions = filterVisible "jconfig";
}).optionsCommonMark; })
in .optionsCommonMark;
{ in {
inherit nixos-markdown nvim-markdown home-markdown; inherit nixos-markdown nvim-markdown home-markdown;
docs = pkgs.stdenvNoCC.mkDerivation { docs = pkgs.stdenvNoCC.mkDerivation {
name = "nixos-configuration-book"; name = "nixos-configuration-book";
@ -54,7 +57,7 @@ in
sed -f sed-cmds <${nixos-markdown} >> ./src/nixos-options.md sed -f sed-cmds <${nixos-markdown} >> ./src/nixos-options.md
''; '';
nativeBuildInputs = [ pkgs.mdbook-toc ]; nativeBuildInputs = [pkgs.mdbook-toc];
buildPhase = "${pkgs.mdbook}/bin/mdbook build --dest-dir $out"; buildPhase = "${pkgs.mdbook}/bin/mdbook build --dest-dir $out";
}; };
} }

309
flake.nix
View file

@ -33,172 +33,173 @@
inputs.neovim-flake.inputs.nixpkgs.follows = "nixpkgs"; inputs.neovim-flake.inputs.nixpkgs.follows = "nixpkgs";
# Flake outputs that other flakes can use # Flake outputs that other flakes can use
outputs = outputs = {
{ self,
self, nixpkgs,
nixpkgs, stylix,
stylix, home-manager,
home-manager, nixos-hardware,
nixos-hardware, jpassmenu,
jpassmenu, audiomenu,
audiomenu, nixvim,
nixvim, neovim-flake,
neovim-flake, }: let
}: inherit (nixpkgs) lib;
let # Helpers for producing system-specific outputs
inherit (nixpkgs) lib; supportedSystems = [
# Helpers for producing system-specific outputs "x86_64-linux"
supportedSystems = [ "aarch64-linux"
"x86_64-linux" ];
"aarch64-linux" forEachSupportedSystem = f:
]; nixpkgs.lib.genAttrs supportedSystems (
forEachSupportedSystem = system:
f:
nixpkgs.lib.genAttrs supportedSystems (
system:
f { f {
inherit system; inherit system;
pkgs = import nixpkgs { inherit system; }; pkgs = import nixpkgs {inherit system;};
} }
); );
overlays = builtins.attrValues self.overlays; overlays = builtins.attrValues self.overlays;
in {
checks = forEachSupportedSystem (
{
pkgs,
system,
}: {
nvim = nixvim.lib.${system}.check.mkTestDerivationFromNixvimModule {
pkgs = import nixpkgs {inherit system overlays;};
module = ./nvim/nixvim.nix;
};
# alejandra = {};
# typos = {};
}
);
packages = forEachSupportedSystem (
{
pkgs,
system,
}: {
inherit
(import ./docs {inherit pkgs lib;})
docs
nixos-markdown
nvim-markdown
home-markdown
;
# Nvim standalone module
nvim = nixvim.legacyPackages.${system}.makeNixvimWithModule {
pkgs = import nixpkgs {inherit system overlays;};
module = ./nvim/nixvim.nix;
};
}
);
# Provide necessary overlays
overlays = {
nixvim = nixvim.overlays.default;
neovim-nightly = neovim-flake.overlay;
jpassmenu = jpassmenu.overlays.default;
audiomenu = audiomenu.overlays.default;
};
# Nix files formatter (run `nix fmt`)
formatter = forEachSupportedSystem ({pkgs, ...}: pkgs.alejandra);
# Example vm configuration
nixosConfigurations.vm = let
system = "x86_64-linux";
config.allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) ["steam-original"];
pkgs = import nixpkgs {inherit system overlays config;};
in in
{ lib.nixosSystem {
checks = forEachSupportedSystem ( inherit system pkgs;
{ pkgs, system }: modules = [
{ self.nixosModules.vm # import vm module
nvim = nixvim.lib.${system}.check.mkTestDerivationFromNixvimModule { {
pkgs = import nixpkgs { inherit system overlays; }; time.timeZone = "Europe/Berlin";
module = ./nvim/nixvim.nix; i18n.defaultLocale = "en_US.UTF-8";
};
# alejandra = {};
# typos = {};
}
);
packages = forEachSupportedSystem ( users.users.jdoe.password = "example";
{ pkgs, system }: users.users.jdoe.isNormalUser = true;
{ users.users.jdoe.extraGroups = [
inherit (import ./docs { inherit pkgs lib; }) "wheel"
docs "video"
nixos-markdown "networkmanager"
nvim-markdown ];
home-markdown
;
# Nvim standalone module
nvim = nixvim.legacyPackages.${system}.makeNixvimWithModule {
pkgs = import nixpkgs { inherit system overlays; };
module = ./nvim/nixvim.nix;
};
}
);
# Provide necessary overlays home-manager.users.jdoe = {
overlays = { home.username = "jdoe";
nixvim = nixvim.overlays.default; home.homeDirectory = "/home/jdoe";
neovim-nightly = neovim-flake.overlay;
jpassmenu = jpassmenu.overlays.default; jhome.enable = true;
audiomenu = audiomenu.overlays.default; jhome.gui.enable = true;
jhome.dev.rust.enable = true;
};
nix.registry.nixpkgs.flake = nixpkgs;
jconfig.enable = true;
jconfig.gui.enable = true;
}
];
}; };
# Nix files formatter (run `nix fmt`) nixosModules = let
formatter = forEachSupportedSystem ({ pkgs, ... }: pkgs.nixfmt-rfc-style); nvim-config.imports = [
nixvim.homeManagerModules.nixvim
./nvim
];
overlays = builtins.attrValues self.overlays;
homeManagerModuleSandalone = import ./home {inherit overlays nvim-config stylix;};
homeManagerModuleNixOS = import ./home {inherit overlays nvim-config;};
nixosModule = {
imports = [
(import ./system {inherit stylix;})
home-manager.nixosModules.home-manager
];
# Example vm configuration home-manager.useGlobalPkgs = true;
nixosConfigurations.vm = home-manager.useUserPackages = true;
let home-manager.sharedModules = [homeManagerModuleNixOS];
system = "x86_64-linux";
config.allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) [ "steam-original" ];
pkgs = import nixpkgs { inherit system overlays config; };
in
lib.nixosSystem {
inherit system pkgs;
modules = [
self.nixosModules.vm # import vm module
{
time.timeZone = "Europe/Berlin";
i18n.defaultLocale = "en_US.UTF-8";
users.users.jdoe.password = "example"; # Pin nixpkgs
users.users.jdoe.isNormalUser = true; nix.registry.nixpkgs.flake = nixpkgs;
users.users.jdoe.extraGroups = [ };
"wheel"
"video"
"networkmanager"
];
home-manager.users.jdoe = { machines = [
home.username = "jdoe"; "capricorn"
home.homeDirectory = "/home/jdoe"; "gemini"
"libra"
"vm"
];
mkMachine = hostname: {
imports = [
nixosModule
(import (./machines + "/${hostname}") {inherit nixos-hardware;})
];
home-manager.sharedModules = [{jhome.hostName = hostname;}];
};
machineModules = lib.genAttrs machines mkMachine;
in
{
default = nixosModule;
inherit nixosModule homeManagerModuleNixOS homeManagerModuleSandalone;
}
// machineModules;
jhome.enable = true; devShells = forEachSupportedSystem (
jhome.gui.enable = true; {
jhome.dev.rust.enable = true; pkgs,
}; system,
}: {
nix.registry.nixpkgs.flake = nixpkgs; default = pkgs.mkShell {
buildInputs = with pkgs; [
jconfig.enable = true; just
jconfig.gui.enable = true; self.packages.${system}.nvim
}
]; ];
QEMU_OPTS_WL = "-smp 4 -device virtio-gpu-rutabaga,gfxstream-vulkan=on,cross-domain=on,hostmem=2G,wsi=headless";
}; };
}
nixosModules = );
let };
nvim-config.imports = [
nixvim.homeManagerModules.nixvim
./nvim
];
overlays = builtins.attrValues self.overlays;
homeManagerModuleSandalone = import ./home { inherit overlays nvim-config stylix; };
homeManagerModuleNixOS = import ./home { inherit overlays nvim-config; };
nixosModule = {
imports = [
(import ./system { inherit stylix; })
home-manager.nixosModules.home-manager
];
home-manager.useGlobalPkgs = true;
home-manager.useUserPackages = true;
home-manager.sharedModules = [ homeManagerModuleNixOS ];
# Pin nixpkgs
nix.registry.nixpkgs.flake = nixpkgs;
};
machines = [
"capricorn"
"gemini"
"libra"
"vm"
];
mkMachine = hostname: {
imports = [
nixosModule
(import (./machines + "/${hostname}") { inherit nixos-hardware; })
];
home-manager.sharedModules = [ { jhome.hostName = hostname; } ];
};
machineModules = lib.genAttrs machines mkMachine;
in
{
default = nixosModule;
inherit nixosModule homeManagerModuleNixOS homeManagerModuleSandalone;
}
// machineModules;
devShells = forEachSupportedSystem (
{ pkgs, system }:
{
default = pkgs.mkShell {
buildInputs = with pkgs; [
just
self.packages.${system}.nvim
];
QEMU_OPTS_WL = "-smp 4 -device virtio-gpu-rutabaga,gfxstream-vulkan=on,cross-domain=on,hostmem=2G,wsi=headless";
};
}
);
};
} }

15
home/default.nix
View file

@ -2,18 +2,15 @@
overlays, overlays,
nvim-config, nvim-config,
stylix ? null, stylix ? null,
}: }: {
{
config, config,
pkgs, pkgs,
lib, lib,
... ...
}: }: let
let
cfg = config.jhome; cfg = config.jhome;
devcfg = cfg.dev; devcfg = cfg.dev;
in in {
{
imports = imports =
[ [
# Apply overlays # Apply overlays
@ -82,7 +79,9 @@ in
services.gpg-agent.enable = true; services.gpg-agent.enable = true;
services.gpg-agent.maxCacheTtl = 86400; services.gpg-agent.maxCacheTtl = 86400;
services.gpg-agent.pinentryPackage = services.gpg-agent.pinentryPackage =
if config.jhome.gui.enable then pkgs.pinentry-qt else pkgs.pinentry-curses; if config.jhome.gui.enable
then pkgs.pinentry-qt
else pkgs.pinentry-curses;
services.gpg-agent.extraConfig = "allow-preset-passphrase"; services.gpg-agent.extraConfig = "allow-preset-passphrase";
# Spotifyd # Spotifyd
services.spotifyd.enable = true; services.spotifyd.enable = true;
@ -173,7 +172,7 @@ in
}; };
}) })
(lib.mkIf (cfg.enable && devcfg.enable && devcfg.rust.enable) { (lib.mkIf (cfg.enable && devcfg.enable && devcfg.rust.enable) {
home.packages = [ pkgs.rustup ] ++ devcfg.rust.extraPackages; home.packages = [pkgs.rustup] ++ devcfg.rust.extraPackages;
# Background code checker (for Rust) # Background code checker (for Rust)
programs.bacon = { programs.bacon = {
enable = true; enable = true;

25
home/gui/default.nix
View file

@ -4,22 +4,25 @@
pkgs, pkgs,
osConfig ? null, osConfig ? null,
... ...
}: }: let
let
inherit (config) jhome; inherit (config) jhome;
flatpakEnabled = if osConfig != null then osConfig.services.flatpak.enable else false; flatpakEnabled =
if osConfig != null
then osConfig.services.flatpak.enable
else false;
osSway = osConfig == null && !osConfig.programs.sway.enable; osSway = osConfig == null && !osConfig.programs.sway.enable;
swayPkg = if osSway then pkgs.sway else null; swayPkg =
if osSway
then pkgs.sway
else null;
cfg = jhome.gui; cfg = jhome.gui;
cursor.package = pkgs.nordzy-cursor-theme; cursor.package = pkgs.nordzy-cursor-theme;
cursor.name = "Nordzy-cursors"; cursor.name = "Nordzy-cursors";
iconTheme.name = "Papirus-Dark"; iconTheme.name = "Papirus-Dark";
iconTheme.package = pkgs.papirus-icon-theme; iconTheme.package = pkgs.papirus-icon-theme;
in in {
{
config = lib.mkIf (jhome.enable && cfg.enable) { config = lib.mkIf (jhome.enable && cfg.enable) {
home.packages = home.packages = with pkgs;
with pkgs;
[ [
webcord webcord
ferdium ferdium
@ -48,13 +51,13 @@ in
# Video player # Video player
programs.mpv = { programs.mpv = {
enable = true; enable = true;
scripts = builtins.attrValues { inherit (pkgs.mpvScripts) uosc thumbfast; }; scripts = builtins.attrValues {inherit (pkgs.mpvScripts) uosc thumbfast;};
}; };
# Status bar # Status bar
programs.waybar = { programs.waybar = {
enable = true; enable = true;
systemd.enable = true; systemd.enable = true;
settings = import ./waybar-settings.nix { inherit config lib; }; settings = import ./waybar-settings.nix {inherit config lib;};
}; };
# Terminal # Terminal
programs.wezterm = { programs.wezterm = {
@ -103,7 +106,7 @@ in
wayland.windowManager.sway = { wayland.windowManager.sway = {
enable = true; enable = true;
package = swayPkg; # no sway package if it comes from the OS package = swayPkg; # no sway package if it comes from the OS
config = import ./sway-config.nix { inherit config pkgs; }; config = import ./sway-config.nix {inherit config pkgs;};
}; };
# Set cursor style # Set cursor style

69
home/gui/keybindings.nix
View file

@ -1,5 +1,7 @@
{ pkgs, config }: {
let pkgs,
config,
}: let
cfg = config.jhome.gui.sway; cfg = config.jhome.gui.sway;
passmenu = "${pkgs.jpassmenu}/bin/jpassmenu"; passmenu = "${pkgs.jpassmenu}/bin/jpassmenu";
selectAudio = "${pkgs.audiomenu}/bin/audiomenu --menu 'fuzzel --dmenu'"; selectAudio = "${pkgs.audiomenu}/bin/audiomenu --menu 'fuzzel --dmenu'";
@ -18,21 +20,21 @@ let
]; ];
dirs = dirs =
map map
(dir: { (dir: {
key = swayconf.${dir}; key = swayconf.${dir};
arrow = dir; arrow = dir;
direction = dir; direction = dir;
}) })
[ [
"up" "up"
"down" "down"
"left" "left"
"right" "right"
]; ];
joinKeys = builtins.concatStringsSep "+"; joinKeys = builtins.concatStringsSep "+";
# Generate a keybind from a modifier prefix and a key # Generate a keybind from a modifier prefix and a key
keycombo = prefix: key: joinKeys (prefix ++ [ key ]); keycombo = prefix: key: joinKeys (prefix ++ [key]);
modKeybind = keycombo [ mod ]; modKeybind = keycombo [mod];
modCtrlKeybind = keycombo [ modCtrlKeybind = keycombo [
mod mod
"Ctrl" "Ctrl"
@ -51,13 +53,10 @@ let
dir2resize.right = "resize grow width"; dir2resize.right = "resize grow width";
dir2resize.left = "resize shrink width"; dir2resize.left = "resize shrink width";
# Bind a key combo to an action # Bind a key combo to an action
genKeybind = prefix: action: key: { "${prefix key}" = "${action key}"; }; genKeybind = prefix: action: key: {"${prefix key}" = "${action key}";};
genKey = genKey = prefix: action: genKeybind ({key, ...}: prefix key) ({direction, ...}: action direction);
prefix: action: genKeybind ({ key, ... }: prefix key) ({ direction, ... }: action direction); genArrow = prefix: action: genKeybind ({arrow, ...}: prefix arrow) ({direction, ...}: action direction);
genArrow = genArrowAndKey = prefix: action: key:
prefix: action: genKeybind ({ arrow, ... }: prefix arrow) ({ direction, ... }: action direction);
genArrowAndKey =
prefix: action: key:
(genKey prefix action key) // (genArrow prefix action key); (genKey prefix action key) // (genArrow prefix action key);
# Move window # Move window
moveWindowKeybinds = map (genArrowAndKey modShiftKeybind (dir: "move ${dir}")) dirs; moveWindowKeybinds = map (genArrowAndKey modShiftKeybind (dir: "move ${dir}")) dirs;
@ -66,19 +65,25 @@ let
# Resize window # Resize window
resizeWindowKeybinds = map (genArrowAndKey modCtrlKeybind (dir: dir2resize.${dir})) dirs; resizeWindowKeybinds = map (genArrowAndKey modCtrlKeybind (dir: dir2resize.${dir})) dirs;
# Move container to workspace # Move container to workspace
moveWorkspaceKeybindings = map (genKeybind modShiftKeybind ( moveWorkspaceKeybindings =
number: "move container to workspace number ${number}" map (genKeybind modShiftKeybind (
)) workspaces; number: "move container to workspace number ${number}"
))
workspaces;
# Focus workspace # Focus workspace
focusWorkspaceKeybindings = map (genKeybind modKeybind ( focusWorkspaceKeybindings =
number: "workspace number ${number}" map (genKeybind modKeybind (
)) workspaces; number: "workspace number ${number}"
))
workspaces;
# Move container to Workspace and focus on it # Move container to Workspace and focus on it
moveFocusWorkspaceKeybindings = map (genKeybind modCtrlShiftKeybind ( moveFocusWorkspaceKeybindings =
number: "move container to workspace number ${number}; workspace number ${number}" map (genKeybind modCtrlShiftKeybind (
)) workspaces; number: "move container to workspace number ${number}; workspace number ${number}"
))
workspaces;
in in
builtins.foldl' (l: r: l // r) builtins.foldl' (l: r: l // r)
{ {
"${mod}+Return" = "exec ${swayconf.terminal}"; "${mod}+Return" = "exec ${swayconf.terminal}";
"${mod}+D" = "exec ${swayconf.menu}"; "${mod}+D" = "exec ${swayconf.menu}";

44
home/gui/sway-config.nix
View file

@ -1,15 +1,16 @@
{ config, pkgs }: {
let config,
pkgs,
}: let
cfg = config.jhome.gui.sway; cfg = config.jhome.gui.sway;
modifier = "Mod4"; modifier = "Mod4";
terminal = config.jhome.gui.terminal; terminal = config.jhome.gui.terminal;
termCmd = termCmd =
if terminal == "wezterm" then if terminal == "wezterm"
"wezterm start" then "wezterm start"
else if terminal == "alacritty" then else if terminal == "alacritty"
"alacritty -e" then "alacritty -e"
else else builtins.abort "no command configured for ${terminal}";
builtins.abort "no command configured for ${terminal}";
menu = "${pkgs.fuzzel}/bin/fuzzel --terminal '${termCmd}'"; menu = "${pkgs.fuzzel}/bin/fuzzel --terminal '${termCmd}'";
# currently, there is some friction between sway and gtk: # currently, there is some friction between sway and gtk:
# https://github.com/swaywm/sway/wiki/GTK-3-settings-on-Wayland # https://github.com/swaywm/sway/wiki/GTK-3-settings-on-Wayland
@ -17,11 +18,10 @@ let
# for gsettings to work, we need to tell it where the schemas are # for gsettings to work, we need to tell it where the schemas are
# using the XDG_DATA_DIR environment variable # using the XDG_DATA_DIR environment variable
# run at the end of sway config # run at the end of sway config
configure-gtk = configure-gtk = let
let schema = pkgs.gsettings-desktop-schemas;
schema = pkgs.gsettings-desktop-schemas; datadir = "${schema}/share/gsettings-schemas/${schema.name}";
datadir = "${schema}/share/gsettings-schemas/${schema.name}"; in
in
pkgs.writers.writeDashBin "configure-gtk" '' pkgs.writers.writeDashBin "configure-gtk" ''
export XDG_DATA_DIRS=${datadir}:$XDG_DATA_DIRS export XDG_DATA_DIRS=${datadir}:$XDG_DATA_DIRS
gnome_schema=org.gnome.desktop.interface gnome_schema=org.gnome.desktop.interface
@ -38,17 +38,16 @@ let
${pkgs.glib}/bin/gsettings set "$gnome_schema" font-name "$font_name" ${pkgs.glib}/bin/gsettings set "$gnome_schema" font-name "$font_name"
${pkgs.glib}/bin/gsettings set "$gnome_schema" color-scheme prefer-dark ${pkgs.glib}/bin/gsettings set "$gnome_schema" color-scheme prefer-dark
''; '';
cmdOnce = command: { inherit command; }; cmdOnce = command: {inherit command;};
cmdAlways = command: { cmdAlways = command: {
inherit command; inherit command;
always = true; always = true;
}; };
in in {
{
inherit modifier terminal menu; inherit modifier terminal menu;
keybindings = import ./keybindings.nix { inherit config pkgs; }; keybindings = import ./keybindings.nix {inherit config pkgs;};
# Appearance # Appearance
bars = [ ]; # Waybar is started as a systemd service bars = []; # Waybar is started as a systemd service
gaps = { gaps = {
smartGaps = true; smartGaps = true;
smartBorders = "on"; smartBorders = "on";
@ -73,9 +72,12 @@ in
} }
]; ];
# Startup scripts # Startup scripts
startup = [ startup =
(cmdAlways "${configure-gtk}/bin/configure-gtk") [
] ++ (builtins.map cmdAlways cfg.exec.always) ++ (builtins.map cmdOnce cfg.exec.once); (cmdAlways "${configure-gtk}/bin/configure-gtk")
]
++ (builtins.map cmdAlways cfg.exec.always)
++ (builtins.map cmdOnce cfg.exec.once);
# Keyboard configuration # Keyboard configuration
input."type:keyboard" = { input."type:keyboard" = {
repeat_delay = "300"; repeat_delay = "300";

48
home/gui/waybar-settings.nix
View file

@ -1,31 +1,35 @@
{ config, lib }:
let
cfg = config.jhome.gui;
in
{ {
config,
lib,
}: let
cfg = config.jhome.gui;
in {
mainBar.layer = "top"; mainBar.layer = "top";
mainBar.position = "top"; mainBar.position = "top";
mainBar.margin = "2 2 2 2"; mainBar.margin = "2 2 2 2";
# Choose the order of the modules # Choose the order of the modules
mainBar.modules-left = [ "sway/workspaces" ]; mainBar.modules-left = ["sway/workspaces"];
mainBar.modules-center = [ "clock" ]; mainBar.modules-center = ["clock"];
mainBar.modules-right = [ mainBar.modules-right =
"pulseaudio" [
"backlight" "pulseaudio"
"battery" "backlight"
"sway/language" "battery"
"memory" "sway/language"
] ++ lib.optional (cfg.tempInfo != null) "temperature" ++ [ "tray" ]; "memory"
]
++ lib.optional (cfg.tempInfo != null) "temperature"
++ ["tray"];
mainBar."sway/workspaces".disable-scroll = true; mainBar."sway/workspaces".disable-scroll = true;
mainBar."sway/workspaces".persistent-workspaces."1" = [ ]; mainBar."sway/workspaces".persistent-workspaces."1" = [];
mainBar."sway/workspaces".persistent-workspaces."2" = [ ]; mainBar."sway/workspaces".persistent-workspaces."2" = [];
mainBar."sway/workspaces".persistent-workspaces."3" = [ ]; mainBar."sway/workspaces".persistent-workspaces."3" = [];
mainBar."sway/workspaces".persistent-workspaces."4" = [ ]; mainBar."sway/workspaces".persistent-workspaces."4" = [];
mainBar."sway/workspaces".persistent-workspaces."5" = [ ]; mainBar."sway/workspaces".persistent-workspaces."5" = [];
mainBar."sway/workspaces".persistent-workspaces."6" = [ ]; mainBar."sway/workspaces".persistent-workspaces."6" = [];
mainBar."sway/workspaces".persistent-workspaces."7" = [ ]; mainBar."sway/workspaces".persistent-workspaces."7" = [];
mainBar."sway/workspaces".persistent-workspaces."8" = [ ]; mainBar."sway/workspaces".persistent-workspaces."8" = [];
mainBar."sway/workspaces".persistent-workspaces."9" = [ ]; mainBar."sway/workspaces".persistent-workspaces."9" = [];
mainBar."sway/language".format = "{} "; mainBar."sway/language".format = "{} ";
mainBar."sway/language".min-length = 5; mainBar."sway/language".min-length = 5;
mainBar."sway/language".tooltip = false; mainBar."sway/language".tooltip = false;

78
home/options.nix
View file

@ -1,21 +1,24 @@
{ lib, pkgs, ... }: {
let lib,
pkgs,
...
}: let
inherit (lib) types; inherit (lib) types;
mkExtraPackagesOption = mkExtraPackagesOption = name: defaultPkgsPath: let
name: defaultPkgsPath: text =
let lib.strings.concatMapStringsSep " " (
text = lib.strings.concatMapStringsSep " " (
pkgPath: "pkgs." + (lib.strings.concatStringsSep "." pkgPath) pkgPath: "pkgs." + (lib.strings.concatStringsSep "." pkgPath)
) defaultPkgsPath; )
defaultText = lib.literalExpression "[ ${text} ]"; defaultPkgsPath;
default = builtins.map (pkgPath: lib.attrsets.getAttrFromPath pkgPath pkgs) defaultPkgsPath; defaultText = lib.literalExpression "[ ${text} ]";
in default = builtins.map (pkgPath: lib.attrsets.getAttrFromPath pkgPath pkgs) defaultPkgsPath;
in
lib.mkOption { lib.mkOption {
description = "Extra ${name} Packages."; description = "Extra ${name} Packages.";
type = types.listOf types.package; type = types.listOf types.package;
inherit default defaultText; inherit default defaultText;
example = [ ]; example = [];
}; };
identity.options = { identity.options = {
@ -47,12 +50,12 @@ let
enable = lib.mkEnableOption "Jalil's default user configuration"; enable = lib.mkEnableOption "Jalil's default user configuration";
gpg = lib.mkOption { gpg = lib.mkOption {
description = "GnuPG Configuration."; description = "GnuPG Configuration.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options.unlockKeys = lib.mkOption { options.unlockKeys = lib.mkOption {
description = "Keygrips of keys to unlock through `pam-gnupg` when logging in."; description = "Keygrips of keys to unlock through `pam-gnupg` when logging in.";
default = [ ]; default = [];
example = [ "6F4ABB77A88E922406BCE6627AFEEE2363914B76" ]; example = ["6F4ABB77A88E922406BCE6627AFEEE2363914B76"];
type = types.listOf types.str; type = types.listOf types.str;
}; };
}; };
@ -93,20 +96,20 @@ let
}; };
exec = lib.mkOption { exec = lib.mkOption {
description = "Run commands when starting sway."; description = "Run commands when starting sway.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options = { options = {
once = lib.mkOption { once = lib.mkOption {
description = "Programs to start only once (`exec`)."; description = "Programs to start only once (`exec`).";
type = types.listOf types.str; type = types.listOf types.str;
default = [ ]; default = [];
example = [ "signal-desktop --start-in-tray" ]; example = ["signal-desktop --start-in-tray"];
}; };
always = lib.mkOption { always = lib.mkOption {
description = "Programs to start whenever the config is sourced (`exec_always`)."; description = "Programs to start whenever the config is sourced (`exec_always`).";
type = types.listOf types.str; type = types.listOf types.str;
default = [ ]; default = [];
example = [ "signal-desktop --start-in-tray" ]; example = ["signal-desktop --start-in-tray"];
}; };
}; };
}; };
@ -114,7 +117,7 @@ let
}; };
gui.options = { gui.options = {
enable = lib.mkEnableOption ("GUI applications"); enable = lib.mkEnableOption "GUI applications";
tempInfo = lib.mkOption { tempInfo = lib.mkOption {
description = "Temperature info to display in the statusbar."; description = "Temperature info to display in the statusbar.";
default = null; default = null;
@ -122,7 +125,7 @@ let
}; };
sway = lib.mkOption { sway = lib.mkOption {
description = "Sway window manager configuration."; description = "Sway window manager configuration.";
default = { }; default = {};
type = types.submodule sway; type = types.submodule sway;
}; };
terminal = lib.mkOption { terminal = lib.mkOption {
@ -135,11 +138,10 @@ let
]; ];
}; };
}; };
in in {
{
options.jhome = lib.mkOption { options.jhome = lib.mkOption {
description = "Jalil's default home-manager configuration."; description = "Jalil's default home-manager configuration.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options = { options = {
enable = lib.mkEnableOption "jalil's home defaults"; enable = lib.mkEnableOption "jalil's home defaults";
@ -151,29 +153,29 @@ in
}; };
dev = lib.mkOption { dev = lib.mkOption {
description = "Setup development environment for programming languages."; description = "Setup development environment for programming languages.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options.enable = lib.mkEnableOption "development settings"; options.enable = lib.mkEnableOption "development settings";
options.neovimAsManPager = lib.mkEnableOption "neovim as the man pager"; options.neovimAsManPager = lib.mkEnableOption "neovim as the man pager";
options.extraPackages = mkExtraPackagesOption "dev" [ options.extraPackages = mkExtraPackagesOption "dev" [
[ "jq" ] # json parser ["jq"] # json parser
[ "just" ] # just a command runner ["just"] # just a command runner
[ "typos" ] # low false positive rate typo checker ["typos"] # low false positive rate typo checker
[ "git-absorb" ] # fixup! but automatic ["git-absorb"] # fixup! but automatic
[ "man-pages" ] # gimme the man pages ["man-pages"] # gimme the man pages
[ "man-pages-posix" ] # I said gimme the man pages!!! ["man-pages-posix"] # I said gimme the man pages!!!
]; ];
options.rust = lib.mkOption { options.rust = lib.mkOption {
description = "Jalil's default rust configuration."; description = "Jalil's default rust configuration.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options.enable = lib.mkEnableOption "rust development settings"; options.enable = lib.mkEnableOption "rust development settings";
options.extraPackages = mkExtraPackagesOption "Rust" [ options.extraPackages = mkExtraPackagesOption "Rust" [
[ "cargo-kcov" ] # code coverage ["cargo-kcov"] # code coverage
[ "cargo-msrv" ] # minimum supported version ["cargo-msrv"] # minimum supported version
[ "cargo-nextest" ] # better testing harness ["cargo-nextest"] # better testing harness
[ "cargo-sort" ] # sort deps and imports ["cargo-sort"] # sort deps and imports
[ "cargo-watch" ] # watch for file changes and run commands ["cargo-watch"] # watch for file changes and run commands
]; ];
}; };
}; };
@ -186,7 +188,7 @@ in
}; };
gui = lib.mkOption { gui = lib.mkOption {
description = "Jalil's default GUI configuration."; description = "Jalil's default GUI configuration.";
default = { }; default = {};
type = types.submodule gui; type = types.submodule gui;
}; };
}; };

14
home/users.nix
View file

@ -1,5 +1,8 @@
{ config, lib, ... }: {
let config,
lib,
...
}: let
inherit (config) jhome; inherit (config) jhome;
inherit (cfg.defaultIdentity) signingKey; inherit (cfg.defaultIdentity) signingKey;
@ -7,9 +10,8 @@ let
hasConfig = jhome.enable && cfg != null; hasConfig = jhome.enable && cfg != null;
hasKey = signingKey != null; hasKey = signingKey != null;
gpgHome = config.programs.gpg.homedir; gpgHome = config.programs.gpg.homedir;
unlockKey = hasConfig && cfg.gpg.unlockKeys != [ ]; unlockKey = hasConfig && cfg.gpg.unlockKeys != [];
in in {
{
config = lib.mkMerge [ config = lib.mkMerge [
(lib.mkIf hasConfig { (lib.mkIf hasConfig {
programs.git = { programs.git = {
@ -21,7 +23,7 @@ in
}; };
}; };
programs.jujutsu.settings = { programs.jujutsu.settings = {
user = lib.mkIf (cfg.defaultIdentity != null) { inherit (cfg.defaultIdentity) name email; }; user = lib.mkIf (cfg.defaultIdentity != null) {inherit (cfg.defaultIdentity) name email;};
signing = lib.mkIf hasKey { signing = lib.mkIf hasKey {
sign-all = true; sign-all = true;
backend = "gpg"; backend = "gpg";

7
machines/capricorn/default.nix
View file

@ -1,5 +1,4 @@
{ nixos-hardware }: {nixos-hardware}: {
{
imports = [ imports = [
# Include the results of the hardware scan. # Include the results of the hardware scan.
./hardware-configuration.nix ./hardware-configuration.nix
@ -10,8 +9,8 @@
]; ];
# Setup extra filesystem options # Setup extra filesystem options
fileSystems."/".options = [ "compress=zstd" ]; fileSystems."/".options = ["compress=zstd"];
fileSystems."/home".options = [ "compress=zstd" ]; fileSystems."/home".options = ["compress=zstd"];
fileSystems."/nix".options = [ fileSystems."/nix".options = [
"compress=zstd" "compress=zstd"
"noatime" "noatime"

17
machines/capricorn/hardware-configuration.nix
View file

@ -6,9 +6,8 @@
lib, lib,
modulesPath, modulesPath,
... ...
}: }: {
{ imports = [(modulesPath + "/installer/scan/not-detected.nix")];
imports = [ (modulesPath + "/installer/scan/not-detected.nix") ];
boot.initrd.availableKernelModules = [ boot.initrd.availableKernelModules = [
"xhci_pci" "xhci_pci"
@ -16,20 +15,20 @@
"usb_storage" "usb_storage"
"sd_mod" "sd_mod"
]; ];
boot.initrd.kernelModules = [ ]; boot.initrd.kernelModules = [];
boot.kernelModules = [ "kvm-intel" ]; boot.kernelModules = ["kvm-intel"];
boot.extraModulePackages = [ ]; boot.extraModulePackages = [];
fileSystems."/" = { fileSystems."/" = {
device = "/dev/disk/by-label/NIXROOT"; device = "/dev/disk/by-label/NIXROOT";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=root" ]; options = ["subvol=root"];
}; };
fileSystems."/nix" = { fileSystems."/nix" = {
device = "/dev/disk/by-label/NIXROOT"; device = "/dev/disk/by-label/NIXROOT";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=nix" ]; options = ["subvol=nix"];
}; };
fileSystems."/home" = { fileSystems."/home" = {
@ -42,7 +41,7 @@
fsType = "vfat"; fsType = "vfat";
}; };
swapDevices = [ { device = "/dev/disk/by-label/NIXSWAP"; } ]; swapDevices = [{device = "/dev/disk/by-label/NIXSWAP";}];
# Enables DHCP on each ethernet and wireless interface. In case of scripted networking # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
# (the default) this is the recommended approach. When using systemd-networkd it's # (the default) this is the recommended approach. When using systemd-networkd it's

12
machines/gemini/default.nix
View file

@ -1,9 +1,7 @@
# Edit this configuration file to define what should be installed on # Edit this configuration file to define what should be installed on
# your system. Help is available in the configuration.nix(5) man page # your system. Help is available in the configuration.nix(5) man page
# and in the NixOS manual (accessible by running ‘nixos-help’). # and in the NixOS manual (accessible by running ‘nixos-help’).
{ nixos-hardware }: {nixos-hardware}: {pkgs, ...}: {
{ pkgs, ... }:
{
imports = [ imports = [
# Include the results of the hardware scan. # Include the results of the hardware scan.
./hardware-configuration.nix ./hardware-configuration.nix
@ -14,9 +12,9 @@
nixos-hardware.nixosModules.common-gpu-amd nixos-hardware.nixosModules.common-gpu-amd
]; ];
fileSystems."/".options = [ "compress=zstd" ]; fileSystems."/".options = ["compress=zstd"];
fileSystems."/steam".options = [ "compress=zstd" ]; fileSystems."/steam".options = ["compress=zstd"];
fileSystems."/home".options = [ "compress=zstd" ]; fileSystems."/home".options = ["compress=zstd"];
fileSystems."/nix".options = [ fileSystems."/nix".options = [
"compress=zstd" "compress=zstd"
"noatime" "noatime"
@ -46,7 +44,7 @@
# }; # };
services.openssh.enable = true; services.openssh.enable = true;
services.openssh.startWhenNeeded = true; services.openssh.startWhenNeeded = true;
services.openssh.settings.AllowUsers = [ "jalil" ]; services.openssh.settings.AllowUsers = ["jalil"];
# Enable CUPS to print documents. # Enable CUPS to print documents.
services.printing.enable = true; services.printing.enable = true;

19
machines/gemini/hardware-configuration.nix
View file

@ -6,9 +6,8 @@
lib, lib,
modulesPath, modulesPath,
... ...
}: }: {
{ imports = [(modulesPath + "/installer/scan/not-detected.nix")];
imports = [ (modulesPath + "/installer/scan/not-detected.nix") ];
boot.initrd.availableKernelModules = [ boot.initrd.availableKernelModules = [
"nvme" "nvme"
@ -18,15 +17,15 @@
"usb_storage" "usb_storage"
"sd_mod" "sd_mod"
]; ];
boot.initrd.kernelModules = [ ]; boot.initrd.kernelModules = [];
boot.kernelModules = [ "kvm-amd" ]; boot.kernelModules = ["kvm-amd"];
boot.extraModulePackages = [ ]; boot.extraModulePackages = [];
fileSystems."/" = { fileSystems."/" = {
# device = "/dev/disk/by-label/NIXOSROOT"; # device = "/dev/disk/by-label/NIXOSROOT";
device = "/dev/disk/by-label/NIXOSHOME"; device = "/dev/disk/by-label/NIXOSHOME";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=root" ]; options = ["subvol=root"];
}; };
fileSystems."/steam" = { fileSystems."/steam" = {
@ -37,13 +36,13 @@
fileSystems."/home" = { fileSystems."/home" = {
device = "/dev/disk/by-label/NIXOSHOME"; device = "/dev/disk/by-label/NIXOSHOME";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=home" ]; options = ["subvol=home"];
}; };
fileSystems."/nix" = { fileSystems."/nix" = {
device = "/dev/disk/by-label/NIXOSROOT"; device = "/dev/disk/by-label/NIXOSROOT";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=nix" ]; options = ["subvol=nix"];
}; };
fileSystems."/boot" = { fileSystems."/boot" = {
@ -51,7 +50,7 @@
fsType = "vfat"; fsType = "vfat";
}; };
swapDevices = [ { device = "/dev/disk/by-label/SWAP"; } ]; swapDevices = [{device = "/dev/disk/by-label/SWAP";}];
# Enables DHCP on each ethernet and wireless interface. In case of scripted networking # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
# (the default) this is the recommended approach. When using systemd-networkd it's # (the default) this is the recommended approach. When using systemd-networkd it's

11
machines/libra/default.nix
View file

@ -1,10 +1,7 @@
# Edit this configuration file to define what should be installed on # Edit this configuration file to define what should be installed on
# your system. Help is available in the configuration.nix(5) man page, on # your system. Help is available in the configuration.nix(5) man page, on
# https://search.nixos.org/options and in the NixOS manual (`nixos-help`). # https://search.nixos.org/options and in the NixOS manual (`nixos-help`).
{nixos-hardware}: {pkgs, ...}: {
{ nixos-hardware }:
{ pkgs, ... }:
{
imports = [ imports = [
# Include the results of the hardware scan. # Include the results of the hardware scan.
./hardware-configuration.nix ./hardware-configuration.nix
@ -16,8 +13,8 @@
]; ];
fileSystems = { fileSystems = {
"/".options = [ "compress=zstd" ]; "/".options = ["compress=zstd"];
"/home".options = [ "compress=zstd" ]; "/home".options = ["compress=zstd"];
"/nix".options = [ "/nix".options = [
"compress=zstd" "compress=zstd"
"noatime" "noatime"
@ -25,7 +22,7 @@
}; };
boot.kernelPackages = pkgs.linuxPackages_latest; boot.kernelPackages = pkgs.linuxPackages_latest;
boot.kernelParams = [ "amdgpu.dcdebugmask=0x10" ]; # Fixes graphical issues boot.kernelParams = ["amdgpu.dcdebugmask=0x10"]; # Fixes graphical issues
hardware.opengl.enable = true; hardware.opengl.enable = true;
hardware.bluetooth.enable = true; hardware.bluetooth.enable = true;

20
machines/libra/hardware-configuration.nix
View file

@ -7,10 +7,8 @@
pkgs, pkgs,
modulesPath, modulesPath,
... ...
}: }: {
imports = [(modulesPath + "/installer/scan/not-detected.nix")];
{
imports = [ (modulesPath + "/installer/scan/not-detected.nix") ];
boot.initrd.availableKernelModules = [ boot.initrd.availableKernelModules = [
"nvme" "nvme"
@ -18,26 +16,26 @@
"usb_storage" "usb_storage"
"sd_mod" "sd_mod"
]; ];
boot.initrd.kernelModules = [ ]; boot.initrd.kernelModules = [];
boot.kernelModules = [ "kvm-amd" ]; boot.kernelModules = ["kvm-amd"];
boot.extraModulePackages = [ ]; boot.extraModulePackages = [];
fileSystems."/" = { fileSystems."/" = {
device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e"; device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=root" ]; options = ["subvol=root"];
}; };
fileSystems."/home" = { fileSystems."/home" = {
device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e"; device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=home" ]; options = ["subvol=home"];
}; };
fileSystems."/nix" = { fileSystems."/nix" = {
device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e"; device = "/dev/disk/by-uuid/efbda7f0-c286-4fb1-b780-d3128e4d1a3e";
fsType = "btrfs"; fsType = "btrfs";
options = [ "subvol=nix" ]; options = ["subvol=nix"];
}; };
fileSystems."/boot" = { fileSystems."/boot" = {
@ -45,7 +43,7 @@
fsType = "vfat"; fsType = "vfat";
}; };
swapDevices = [ ]; swapDevices = [];
# Enables DHCP on each ethernet and wireless interface. In case of scripted networking # Enables DHCP on each ethernet and wireless interface. In case of scripted networking
# (the default) this is the recommended approach. When using systemd-networkd it's # (the default) this is the recommended approach. When using systemd-networkd it's

3
machines/vm/default.nix
View file

@ -1,5 +1,4 @@
{ ... }: {...}: {
{
services.qemuGuest.enable = true; services.qemuGuest.enable = true;
boot.initrd.availableKernelModules = [ boot.initrd.availableKernelModules = [

96
nvim/augroups.nix
View file

@ -1,7 +1,7 @@
{ {
autoGroups."highlightOnYank" = { }; autoGroups."highlightOnYank" = {};
autoGroups."lspConfig" = { }; autoGroups."lspConfig" = {};
autoGroups."restoreCursorPosition" = { }; autoGroups."restoreCursorPosition" = {};
autoCmd = [ autoCmd = [
{ {
group = "highlightOnYank"; group = "highlightOnYank";
@ -38,53 +38,51 @@
group = "lspConfig"; group = "lspConfig";
event = "LspAttach"; event = "LspAttach";
pattern = "*"; pattern = "*";
callback = callback = let
let opts = "noremap = true, buffer = bufnr";
opts = "noremap = true, buffer = bufnr"; in {
in __raw = ''
{ function(opts)
__raw = '' local bufnr = opts.buf
function(opts) local client = vim.lsp.get_client_by_id(opts.data.client_id)
local bufnr = opts.buf local capabilities = client.server_capabilities
local client = vim.lsp.get_client_by_id(opts.data.client_id) -- Set Omnifunc if supported
local capabilities = client.server_capabilities if capabilities.completionProvider then
-- Set Omnifunc if supported vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
if capabilities.completionProvider then
vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
end
-- Enable inlay hints if supported
if capabilities.inlayHintProvider then
vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
end
-- Some Lsp servers do not advertise inlay hints properly so enable this keybinding regardless
vim.keymap.set('n', '<space>ht', function()
vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled(0), { bufnr = 0 })
end,
{ desc = '[H]ints [T]oggle', ${opts} }
)
-- Enable hover if supported
if capabilities.hoverProvider then
vim.keymap.set('n', 'K', vim.lsp.buf.hover, { desc = 'Hover Documentation', ${opts} })
end
-- Enable rename if supported
if capabilities.renameProvider then
vim.keymap.set('n', '<leader>r', vim.lsp.buf.rename, { desc = '[R]ename', ${opts} })
end
-- Enable code actions if supported
if capabilities.codeActionProvider then
vim.keymap.set({ 'n', 'v' }, '<leader>fa', vim.lsp.buf.code_action, { desc = '[F]ind Code [A]ctions', ${opts} })
end
-- Enable formatting if supported
if capabilities.documentFormattingProvider then
vim.keymap.set('n', '<leader>w', function() vim.lsp.buf.format { async = true } end, { desc = 'Format Buffer', ${opts} })
end
-- Other keybinds
vim.keymap.set('n', 'gd', vim.lsp.buf.definition, { desc = '[G]o to [D]efinition', ${opts} })
vim.keymap.set('n', 'gt', vim.lsp.buf.type_definition, { desc = '[G]o to [T]ype Definition', ${opts} })
vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, { desc = '[G]o to [I]mplementation', ${opts} })
end end
''; -- Enable inlay hints if supported
}; if capabilities.inlayHintProvider then
vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
end
-- Some Lsp servers do not advertise inlay hints properly so enable this keybinding regardless
vim.keymap.set('n', '<space>ht', function()
vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled(0), { bufnr = 0 })
end,
{ desc = '[H]ints [T]oggle', ${opts} }
)
-- Enable hover if supported
if capabilities.hoverProvider then
vim.keymap.set('n', 'K', vim.lsp.buf.hover, { desc = 'Hover Documentation', ${opts} })
end
-- Enable rename if supported
if capabilities.renameProvider then
vim.keymap.set('n', '<leader>r', vim.lsp.buf.rename, { desc = '[R]ename', ${opts} })
end
-- Enable code actions if supported
if capabilities.codeActionProvider then
vim.keymap.set({ 'n', 'v' }, '<leader>fa', vim.lsp.buf.code_action, { desc = '[F]ind Code [A]ctions', ${opts} })
end
-- Enable formatting if supported
if capabilities.documentFormattingProvider then
vim.keymap.set('n', '<leader>w', function() vim.lsp.buf.format { async = true } end, { desc = 'Format Buffer', ${opts} })
end
-- Other keybinds
vim.keymap.set('n', 'gd', vim.lsp.buf.definition, { desc = '[G]o to [D]efinition', ${opts} })
vim.keymap.set('n', 'gt', vim.lsp.buf.type_definition, { desc = '[G]o to [T]ype Definition', ${opts} })
vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, { desc = '[G]o to [I]mplementation', ${opts} })
end
'';
};
} }
]; ];
} }

5
nvim/default.nix
View file

@ -1,6 +1,5 @@
{ pkgs, ... }@opts: {pkgs, ...} @ opts: {
{ imports = [./options.nix];
imports = [ ./options.nix ];
config.programs.nixvim = (import ./nixvim.nix opts).config; config.programs.nixvim = (import ./nixvim.nix opts).config;
} }

24
nvim/nixvim.nix
View file

@ -3,21 +3,19 @@
lib, lib,
config, config,
... ...
}@args: } @ args: let
let
cfg = config.jhome.nvim; cfg = config.jhome.nvim;
hmAvailable = args ? hmConfig; hmAvailable = args ? hmConfig;
nixosAvailable = args ? nixosConfig; nixosAvailable = args ? nixosConfig;
darwinAvailable = args ? darwinConfig; darwinAvailable = args ? darwinConfig;
canSetAsDefault = hmAvailable || nixosAvailable; canSetAsDefault = hmAvailable || nixosAvailable;
notStandalone = hmAvailable || nixosAvailable || darwinAvailable; notStandalone = hmAvailable || nixosAvailable || darwinAvailable;
in in {
{ imports = [./options.nix];
imports = [ ./options.nix ];
config = lib.mkMerge [ config = lib.mkMerge [
(lib.optionalAttrs canSetAsDefault { defaultEditor = lib.mkDefault true; }) (lib.optionalAttrs canSetAsDefault {defaultEditor = lib.mkDefault true;})
(lib.optionalAttrs notStandalone { enable = lib.mkDefault true; }) (lib.optionalAttrs notStandalone {enable = lib.mkDefault true;})
(lib.mkIf cfg.enable { (lib.mkIf cfg.enable {
# package = pkgs.neovim-nightly; # package = pkgs.neovim-nightly;
globals.mapleader = " "; globals.mapleader = " ";
@ -49,15 +47,13 @@ in
# Enable local configuration :h 'exrc' # Enable local configuration :h 'exrc'
exrc = true; # safe since nvim 0.9 exrc = true; # safe since nvim 0.9
}; };
plugins = import ./plugins.nix { inherit lib pkgs; }; plugins = import ./plugins.nix {inherit lib pkgs;};
keymaps = import ./mappings.nix; keymaps = import ./mappings.nix;
inherit (import ./augroups.nix) autoGroups autoCmd; inherit (import ./augroups.nix) autoGroups autoCmd;
extraPlugins = extraPlugins = let
let jjdescription = pkgs.callPackage ./vim-jjdescription.nix {};
jjdescription = pkgs.callPackage ./vim-jjdescription.nix { }; in
in with pkgs.vimPlugins; [
with pkgs.vimPlugins;
[
nvim-web-devicons nvim-web-devicons
jjdescription jjdescription
]; ];

13
nvim/options.nix
View file

@ -1,7 +1,8 @@
{ lib, ... }: {lib, ...}: {
{ options.jhome.nvim.enable =
options.jhome.nvim.enable = lib.mkEnableOption "jalil's neovim configuration" // { lib.mkEnableOption "jalil's neovim configuration"
default = true; // {
example = false; default = true;
}; example = false;
};
} }

154
nvim/plugins.nix
View file

@ -1,5 +1,7 @@
{ lib, pkgs }:
{ {
lib,
pkgs,
}: {
bacon = { bacon = {
enable = true; enable = true;
settings.quickfix.enabled = true; settings.quickfix.enabled = true;
@ -10,15 +12,15 @@
"/" = { "/" = {
mapping.__raw = "cmp.mapping.preset.cmdline()"; mapping.__raw = "cmp.mapping.preset.cmdline()";
sources = [ sources = [
{ name = "rg"; } {name = "rg";}
{ name = "buffer"; } {name = "buffer";}
]; ];
}; };
":" = { ":" = {
mapping.__raw = "cmp.mapping.preset.cmdline()"; mapping.__raw = "cmp.mapping.preset.cmdline()";
sources = [ sources = [
{ name = "path"; } {name = "path";}
{ name = "cmdline"; } {name = "cmdline";}
]; ];
}; };
}; };
@ -118,16 +120,16 @@
conform-nvim = { conform-nvim = {
enable = true; enable = true;
formattersByFt = { formattersByFt = {
"_" = [ "trim_whitespace" ]; "_" = ["trim_whitespace"];
c = [ "clang_format" ]; c = ["clang_format"];
cpp = [ "clang_format" ]; cpp = ["clang_format"];
lua = [ "stylua" ]; lua = ["stylua"];
nix = [ "nixpkgs_fmt" ]; nix = ["nixpkgs_fmt"];
rust = [ "rustfmt" ]; rust = ["rustfmt"];
sh = [ "shfmt" ]; sh = ["shfmt"];
toml = [ "taplo" ]; toml = ["taplo"];
yaml = [ "yamlfmt" ]; yaml = ["yamlfmt"];
zig = [ "zigfmt" ]; zig = ["zigfmt"];
}; };
}; };
gitsigns.enable = true; gitsigns.enable = true;
@ -196,66 +198,64 @@
enable = true; enable = true;
indent = true; indent = true;
incrementalSelection.enable = true; incrementalSelection.enable = true;
grammarPackages = grammarPackages = let
let parsers = pkgs.vimPlugins.nvim-treesitter-parsers;
parsers = pkgs.vimPlugins.nvim-treesitter-parsers; in [
in parsers.asm
[ parsers.bash
parsers.asm # parsers.bibtex
parsers.bash parsers.c
# parsers.bibtex parsers.comment
parsers.c parsers.commonlisp
parsers.comment parsers.cpp
parsers.commonlisp parsers.css
parsers.cpp parsers.csv
parsers.css # parsers.d
parsers.csv parsers.diff
# parsers.d parsers.dockerfile
parsers.diff parsers.dot
parsers.dockerfile parsers.doxygen
parsers.dot parsers.git_config
parsers.doxygen parsers.git_rebase
parsers.git_config parsers.gitattributes
parsers.git_rebase parsers.gitcommit
parsers.gitattributes parsers.gitignore
parsers.gitcommit parsers.go
parsers.gitignore parsers.gomod
parsers.go parsers.gosum
parsers.gomod parsers.gowork
parsers.gosum parsers.html
parsers.gowork parsers.ini
parsers.html parsers.json
parsers.ini parsers.json5
parsers.json parsers.jsonc
parsers.json5 # parsers.latex
parsers.jsonc parsers.lua
# parsers.latex parsers.luadoc
parsers.lua parsers.luap
parsers.luadoc parsers.luau
parsers.luap parsers.make
parsers.luau parsers.markdown
parsers.make parsers.markdown_inline
parsers.markdown parsers.meson
parsers.markdown_inline parsers.nix
parsers.meson parsers.ocaml
parsers.nix parsers.ocaml_interface
parsers.ocaml parsers.pem
parsers.ocaml_interface parsers.python
parsers.pem parsers.rust
parsers.python parsers.scheme
parsers.rust parsers.sql
parsers.scheme parsers.ssh_config
parsers.sql parsers.toml
parsers.ssh_config parsers.tsv
parsers.toml parsers.vim
parsers.tsv parsers.vimdoc
parsers.vim parsers.wgsl
parsers.vimdoc parsers.wgsl_bevy
parsers.wgsl parsers.yaml
parsers.wgsl_bevy parsers.zig
parsers.yaml ];
parsers.zig
];
}; };
trouble = { trouble = {
enable = true; enable = true;
@ -264,12 +264,12 @@
lint = { lint = {
enable = true; enable = true;
lintersByFt = { lintersByFt = {
rust = [ "typos" ]; rust = ["typos"];
latex = [ latex = [
"chktex" "chktex"
"typos" "typos"
]; ];
markdown = [ "typos" ]; markdown = ["typos"];
}; };
}; };
} }

5
nvim/vim-jjdescription.nix
View file

@ -1,4 +1,7 @@
{ vimUtils, fetchFromGitHub }: {
vimUtils,
fetchFromGitHub,
}:
vimUtils.buildVimPlugin { vimUtils.buildVimPlugin {
name = "jjdescription"; name = "jjdescription";
src = fetchFromGitHub { src = fetchFromGitHub {

35
system/default.nix
View file

@ -1,30 +1,29 @@
{ stylix }: {stylix}: {
{
config, config,
pkgs, pkgs,
lib, lib,
... ...
}: }: let
let
cfg = config.jconfig; cfg = config.jconfig;
keysFromGithub = lib.attrsets.mapAttrs' (username: sha256: { keysFromGithub =
name = "pubkeys/${username}"; lib.attrsets.mapAttrs' (username: sha256: {
value = { name = "pubkeys/${username}";
mode = "0755"; value = {
source = builtins.fetchurl { mode = "0755";
inherit sha256; source = builtins.fetchurl {
url = "https://github.com/${username}.keys"; inherit sha256;
url = "https://github.com/${username}.keys";
};
}; };
}; })
}) cfg.importSSHKeysFromGithub; cfg.importSSHKeysFromGithub;
in in {
{
imports = [ imports = [
./options.nix ./options.nix
./gui ./gui
stylix.nixosModules.stylix stylix.nixosModules.stylix
# FIXME(https://github.com/danth/stylix/issues/216): Must configure stylix # FIXME(https://github.com/danth/stylix/issues/216): Must configure stylix
{ stylix = import ./stylix-config.nix { inherit config pkgs; }; } {stylix = import ./stylix-config.nix {inherit config pkgs;};}
]; ];
config = lib.mkIf cfg.enable { config = lib.mkIf cfg.enable {
@ -85,8 +84,8 @@ in
users.defaultUserShell = pkgs.zsh; users.defaultUserShell = pkgs.zsh;
# Open ports for spotifyd # Open ports for spotifyd
networking.firewall.allowedUDPPorts = [ 5353 ]; networking.firewall.allowedUDPPorts = [5353];
networking.firewall.allowedTCPPorts = [ 2020 ]; networking.firewall.allowedTCPPorts = [2020];
# Nix Settings # Nix Settings
nix.gc.automatic = true; nix.gc.automatic = true;

26
system/gui/default.nix
View file

@ -3,24 +3,24 @@
lib, lib,
pkgs, pkgs,
... ...
}: }: let
let
cfg = config.jconfig.gui; cfg = config.jconfig.gui;
enable = config.jconfig.enable && cfg.enable; enable = config.jconfig.enable && cfg.enable;
in in {
{
config = lib.mkMerge [ config = lib.mkMerge [
(lib.mkIf enable { (lib.mkIf enable {
environment.systemPackages = [ environment.systemPackages =
pkgs.gnome.adwaita-icon-theme [
pkgs.adwaita-qt pkgs.gnome.adwaita-icon-theme
pkgs.nordzy-cursor-theme pkgs.adwaita-qt
pkgs.pinentry-qt pkgs.nordzy-cursor-theme
] ++ lib.optional cfg.ydotool.enable pkgs.ydotool; pkgs.pinentry-qt
]
++ lib.optional cfg.ydotool.enable pkgs.ydotool;
systemd.user.services.ydotool = lib.mkIf cfg.ydotool.enable { systemd.user.services.ydotool = lib.mkIf cfg.ydotool.enable {
enable = cfg.ydotool.autoStart; enable = cfg.ydotool.autoStart;
wantedBy = [ "default.target" ]; wantedBy = ["default.target"];
description = "Generic command-line automation tool"; description = "Generic command-line automation tool";
documentation = [ documentation = [
"man:ydotool(1)" "man:ydotool(1)"
@ -45,7 +45,7 @@ in
programs.dconf.enable = true; programs.dconf.enable = true;
programs.sway.enable = cfg.sway; programs.sway.enable = cfg.sway;
programs.sway.extraPackages = [ ]; # No extra packages (by default it adds foot, dmenu, and other stuff) programs.sway.extraPackages = []; # No extra packages (by default it adds foot, dmenu, and other stuff)
programs.sway.wrapperFeatures.base = true; programs.sway.wrapperFeatures.base = true;
programs.sway.wrapperFeatures.gtk = true; programs.sway.wrapperFeatures.gtk = true;
@ -65,7 +65,7 @@ in
# XDG portals # XDG portals
xdg.portal.enable = true; xdg.portal.enable = true;
xdg.portal.wlr.enable = true; xdg.portal.wlr.enable = true;
xdg.portal.extraPortals = [ pkgs.xdg-desktop-portal-gtk ]; xdg.portal.extraPortals = [pkgs.xdg-desktop-portal-gtk];
# Default to the gtk portal # Default to the gtk portal
xdg.portal.config.preferred.default = "gtk"; xdg.portal.config.preferred.default = "gtk";
# Use wlr for screenshots and screen recording # Use wlr for screenshots and screen recording

36
system/options.nix
View file

@ -1,24 +1,21 @@
{ lib, ... }: {lib, ...}: let
let
inherit (lib) types; inherit (lib) types;
# Like mkEnableOption but defaults to true # Like mkEnableOption but defaults to true
mkDisableOption = mkDisableOption = option:
option:
(lib.mkEnableOption option) (lib.mkEnableOption option)
// { // {
default = true; default = true;
example = false; example = false;
}; };
mkImageOption = mkImageOption = {
{ description,
description, url,
url, sha256 ? "",
sha256 ? "", }:
}:
lib.mkOption { lib.mkOption {
inherit description; inherit description;
type = types.path; type = types.path;
default = builtins.fetchurl { inherit url sha256; }; default = builtins.fetchurl {inherit url sha256;};
defaultText = lib.literalMD "![${description}](${url})"; defaultText = lib.literalMD "![${description}](${url})";
}; };
@ -31,7 +28,7 @@ let
steamHardwareSupport = mkDisableOption "steam hardware support"; steamHardwareSupport = mkDisableOption "steam hardware support";
ydotool = lib.mkOption { ydotool = lib.mkOption {
description = "Jalil's default ydotool configuration."; description = "Jalil's default ydotool configuration.";
default = { }; default = {};
type = types.submodule { type = types.submodule {
options.enable = mkDisableOption "ydotool"; options.enable = mkDisableOption "ydotool";
options.autoStart = mkDisableOption "autostarting ydotool at login"; options.autoStart = mkDisableOption "autostarting ydotool at login";
@ -59,17 +56,17 @@ let
enable = lib.mkEnableOption "jalil's default configuration."; enable = lib.mkEnableOption "jalil's default configuration.";
dev = lib.mkOption { dev = lib.mkOption {
description = "Options for setting up a dev environment"; description = "Options for setting up a dev environment";
default = { }; default = {};
type = types.submodule { options.enable = lib.mkEnableOption "dev configuration"; }; type = types.submodule {options.enable = lib.mkEnableOption "dev configuration";};
}; };
gui = lib.mkOption { gui = lib.mkOption {
description = "Jalil's default configuration for a NixOS gui."; description = "Jalil's default configuration for a NixOS gui.";
default = { }; default = {};
type = types.submodule gui; type = types.submodule gui;
}; };
styling = lib.mkOption { styling = lib.mkOption {
description = "Jalil's styling options"; description = "Jalil's styling options";
default = { }; default = {};
type = types.submodule styling; type = types.submodule styling;
}; };
importSSHKeysFromGithub = lib.mkOption { importSSHKeysFromGithub = lib.mkOption {
@ -86,18 +83,17 @@ let
`users.users.<name>.openssh.authorizedKeys.keyFiles` on the users you `users.users.<name>.openssh.authorizedKeys.keyFiles` on the users you
want to allow ssh logins. want to allow ssh logins.
''; '';
default = { }; default = {};
example = { example = {
"jalil-salame" = "sha256:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; "jalil-salame" = "sha256:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
}; };
type = types.attrsOf types.str; type = types.attrsOf types.str;
}; };
}; };
in in {
{
options.jconfig = lib.mkOption { options.jconfig = lib.mkOption {
description = "Jalil's default NixOS configuration."; description = "Jalil's default NixOS configuration.";
default = { }; default = {};
type = types.submodule config; type = types.submodule config;
}; };
} }

11
system/stylix-config.nix
View file

@ -1,13 +1,14 @@
{ config, pkgs }: {
let config,
pkgs,
}: let
cfg = config.jconfig.styling; cfg = config.jconfig.styling;
nerdFontSymbols = pkgs.nerdfonts.override { fonts = [ "NerdFontsSymbolsOnly" ]; }; nerdFontSymbols = pkgs.nerdfonts.override {fonts = ["NerdFontsSymbolsOnly"];};
fallbackSymbols = { fallbackSymbols = {
name = "Symbols Nerd Font"; name = "Symbols Nerd Font";
package = nerdFontSymbols; package = nerdFontSymbols;
}; };
in in {
{
autoEnable = cfg.enable; autoEnable = cfg.enable;
image = cfg.wallpaper; image = cfg.wallpaper;
base16Scheme = "${pkgs.base16-schemes}/share/themes/gruvbox-dark-hard.yaml"; base16Scheme = "${pkgs.base16-schemes}/share/themes/gruvbox-dark-hard.yaml";