derped/nixos
1
0
Fork 0
Code Releases Activity

Remove emacs.

Browse source
This commit is contained in:
Kevin Baensch 2024-11-16 11:12:30 +01:00
parent 6b694fd58a
commit 51f1c74dc2
Signed by: derped
GPG key ID: C0F1D326C7626543
36 changed files with 1 additions and 2295 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
config/etc/i3/config.nix
View file

@ -18,7 +18,6 @@
exec ${pkgs.feh}/bin/feh --bg-scale $(xdg-user-dir PICTURES)/wallpaper.jpg
#exec pulseaudio -D
exec fcitx5
#exec env=LC_CTYPE=zh_CN.UTF-8 emacs --daemon
#exec conky -c $HOME/.my_little_conky/.conkyrc
#exec xsnow -nosanta -norudolf -notrees
#exec $LOCK
@ -139,8 +138,6 @@
floating_modifier $mod
# start a terminal
bindsym $mod+Shift+Return exec emacsclient -c
bindsym $mod+Mod1+Return exec emacsclient -c -e '(eshell t)'
bindsym $mod+Return exec alacritty
# kill focused window

19
machines/Lilim/options.nix
View file

@ -32,25 +32,6 @@ with lib; {
"dict"
"nodejs"
"latex"
"emacs"
"emacs::company"
"emacs::direnv"
"emacs::doom-modeline"
"emacs::doom-themes"
"emacs::elpy"
"emacs::flycheck"
"emacs::flyspell"
"emacs::latex"
"emacs::lsp"
"emacs::magit"
"emacs::mu4e"
"emacs::elfeed"
"emacs::nix-mode"
"emacs::org"
"emacs::transmission"
"emacs::web-mode"
"emacs::yaml-mode"
"emacs::yasnippet"
"extra"
"haskell"
"mail_utils"

18
machines/Marid/options.nix
View file

@ -26,24 +26,6 @@ with lib; {
"base"
"dict"
"nodejs"
"emacs"
"emacs::company"
"emacs::docker"
"emacs::doom-modeline"
"emacs::doom-themes"
"emacs::elpy"
"emacs::fcitx"
"emacs::flycheck"
"emacs::flyspell"
"emacs::undo-tree"
"emacs::lsp"
"emacs::magit"
"emacs::mu4e"
"emacs::nix-mode"
"emacs::org"
"emacs::php-mode"
"emacs::web-mode"
"emacs::yasnippet"
"extra"
"mail_utils"
"python3"

52
options/emacs-init-defaults.nix
View file

@ -1,52 +0,0 @@
# Original Source:
# https://gitlab.com/rycee/nur-expressions/raw/master/hm-modules/emacs-init-defaults.nix (49ff2d63e867c09e658c959c0d8a73d641061c30)
# MIT License
# Copyright (c) 2019 Robert Helgesson
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
{pkgs, ...}: {
programs.emacs.init.usePackage = {
deadgrep = {
config = ''
(setq deadgrep-executable "${pkgs.ripgrep}/bin/rg")
'';
};
ggtags = {
config = ''
(setq ggtags-executable-directory "${pkgs.global}/bin")
'';
};
idris-mode = {
config = ''
(setq idris-interpreter-path "${pkgs.idris}/bin/idris")
'';
};
pandoc-mode = {
config = ''
(setq pandoc-binary "${pkgs.pandoc}/bin/pandoc")
'';
};
ripgrep = {
config = ''
(setq ripgrep-executable "${pkgs.ripgrep}/bin/rg")
'';
};
};
}

469
options/emacs-init.nix
View file

@ -1,469 +0,0 @@
# Original Source:
# https://gitlab.com/rycee/nur-expressions/raw/master/hm-modules/emacs-init.nix (d27525db3358b9463fab1b4a7739cb77e27b768c)
# MIT License
# Copyright (c) 2019 Robert Helgesson
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
{
config,
lib,
pkgs,
...
}:
with lib; let
cfg = config.programs.emacs.init;
packageFunctionType = mkOptionType {
name = "packageFunction";
description = "function from epkgs to package";
check = isFunction;
merge = mergeOneOption;
};
usePackageType = types.submodule ({
name,
config,
...
}: {
options = {
enable = mkEnableOption "Emacs package ${name}";
package = mkOption {
type =
types.either
(types.str // {description = "name of package";})
packageFunctionType;
default = name;
description = ''
The package to use for this module. Either the package name
within the Emacs package set or a function taking the Emacs
package set and returning a package.
'';
};
defer = mkOption {
type = types.either types.bool types.ints.positive;
default = false;
description = ''
The <option>:defer</option> setting.
'';
};
demand = mkOption {
type = types.bool;
default = false;
description = ''
The <option>:demand</option> setting.
'';
};
diminish = mkOption {
type = types.listOf types.str;
default = [];
description = ''
The entries to use for <option>:diminish</option>.
'';
};
chords = mkOption {
type = types.attrsOf types.str;
default = {};
example = {
"jj" = "ace-jump-char-mode";
"jk" = "ace-jump-word-mode";
};
description = ''
The entries to use for <option>:chords</option>.
'';
};
mode = mkOption {
type = types.listOf types.str;
default = [];
description = ''
The entries to use for <option>:mode</option>.
'';
};
after = mkOption {
type = types.listOf types.str;
default = [];
description = ''
The entries to use for <option>:after</option>.
'';
};
bind = mkOption {
type = types.attrsOf types.str;
default = {};
example = {
"M-<up>" = "drag-stuff-up";
"M-<down>" = "drag-stuff-down";
};
description = ''
The entries to use for <option>:bind</option>.
'';
};
bindLocal = mkOption {
type = types.attrsOf (types.attrsOf types.str);
default = {};
example = {helm-command-map = {"C-c h" = "helm-execute-persistent-action";};};
description = ''
The entries to use for local keymaps in <option>:bind</option>.
'';
};
bindKeyMap = mkOption {
type = types.attrsOf types.str;
default = {};
example = {"C-c p" = "projectile-command-map";};
description = ''
The entries to use for <option>:bind-keymap</option>.
'';
};
command = mkOption {
type = types.listOf types.str;
default = [];
description = ''
The entries to use for <option>:commands</option>.
'';
};
config = mkOption {
type = types.lines;
default = "";
description = ''
Code to place in the <option>:config</option> section.
'';
};
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Additional lines to place in the use-package configuration.
'';
};
hook = mkOption {
type = types.listOf types.str;
default = [];
description = ''
The entries to use for <option>:hook</option>.
'';
};
init = mkOption {
type = types.lines;
default = "";
description = ''
The entries to use for <option>:init</option>.
'';
};
assembly = mkOption {
type = types.lines;
readOnly = true;
internal = true;
description = "The final use-package code.";
};
};
config = mkIf config.enable {
assembly = let
quoted = v: ''"${escape ["\""] v}"'';
mkBindHelper = cmd: prefix: bs:
optionals (bs != {}) (
[":${cmd} (${prefix}"]
++ mapAttrsToList (n: v: " (${quoted n} . ${v})") bs
++ [")"]
);
mkAfter = vs: optional (vs != []) ":after (${toString vs})";
mkCommand = vs: optional (vs != []) ":commands (${toString vs})";
mkDiminish = vs: optional (vs != []) ":diminish (${toString vs})";
mkMode = map (v: ":mode ${v}");
mkBind = mkBindHelper "bind" "";
mkBindLocal = bs: let
mkMap = n: mkBindHelper "bind" ":map ${n}";
in
flatten (mapAttrsToList mkMap bs);
mkBindKeyMap = mkBindHelper "bind-keymap" "";
mkChords = mkBindHelper "chords" "";
mkHook = map (v: ":hook ${v}");
mkDefer = v:
if isBool v
then optional v ":defer t"
else [":defer ${toString v}"];
mkDemand = v: optional v ":demand t";
in
concatStringsSep "\n " (
["(use-package ${name}"]
++ mkAfter config.after
++ mkBind config.bind
++ mkBindKeyMap config.bindKeyMap
++ mkBindLocal config.bindLocal
++ mkChords config.chords
++ mkCommand config.command
++ mkDefer config.defer
++ mkDemand config.demand
++ mkDiminish config.diminish
++ mkHook config.hook
++ mkMode config.mode
++ optionals (config.init != "") [":init" config.init]
++ optionals (config.config != "") [":config" config.config]
++ optional (config.extraConfig != "") config.extraConfig
)
+ ")";
};
});
usePackageStr = name: pkgConfStr: ''
(use-package ${name}
${pkgConfStr})
'';
mkRecommendedOption = type: extraDescription:
mkOption {
type = types.bool;
default = false;
example = true;
description =
''
Whether to enable recommended ${type} settings.
''
+ optionalString (extraDescription != "") ''
</para><para>
${extraDescription}
'';
};
# Recommended GC settings.
gcSettings = ''
(defun hm/reduce-gc ()
"Reduce the frequency of garbage collection."
(setq gc-cons-threshold 402653184
gc-cons-percentage 0.6))
(defun hm/restore-gc ()
"Restore the frequency of garbage collection."
(setq gc-cons-threshold 16777216
gc-cons-percentage 0.1))
;; Make GC more rare during init and while minibuffer is active.
(eval-and-compile #'hm/reduce-gc)
(add-hook 'minibuffer-setup-hook #'hm/reduce-gc)
;; But make it more regular after startup and after closing minibuffer.
(add-hook 'emacs-startup-hook #'hm/restore-gc)
(add-hook 'minibuffer-exit-hook #'hm/restore-gc)
;; Avoid unnecessary regexp matching while loading .el files.
(defvar hm/file-name-handler-alist file-name-handler-alist)
(setq file-name-handler-alist nil)
(defun hm/restore-file-name-handler-alist ()
"Restores the file-name-handler-alist variable."
(setq file-name-handler-alist hm/file-name-handler-alist)
(makunbound 'hm/file-name-handler-alist))
(add-hook 'emacs-startup-hook #'hm/restore-file-name-handler-alist)
'';
# Whether the configuration makes use of `:diminish`.
hasDiminish = any (p: p.diminish != []) (attrValues cfg.usePackage);
# Whether the configuration makes use of `:bind`.
hasBind = any (p: p.bind != {}) (attrValues cfg.usePackage);
# Whether the configuration makes use of `:chords`.
hasChords = any (p: p.chords != {}) (attrValues cfg.usePackage);
usePackageSetup =
''
(eval-when-compile
(require 'package)
(setq package-archives nil
package-enable-at-startup nil
package--init-file-ensured t)
(require 'use-package)
;; To help fixing issues during startup.
(setq use-package-verbose ${
if cfg.usePackageVerbose
then "t"
else "nil"
}))
''
+ optionalString hasDiminish ''
;; For :diminish in (use-package).
(require 'diminish)
''
+ optionalString hasBind ''
;; For :bind in (use-package).
(require 'bind-key)
''
+ optionalString hasChords ''
;; For :chords in (use-package).
(use-package use-package-chords
:config (key-chord-mode 1))
'';
initFile =
''
;;; hm-init.el --- Emacs configuration à la Home Manager.
;;
;; -*- lexical-binding: t; -*-
;;
;;; Commentary:
;;
;; A configuration generated from a Nix based configuration by
;; Home Manager.
;;
;;; Code:
${optionalString cfg.startupTimer ''
;; Remember when configuration started. See bottom for rest of this.
;; Idea taken from http://writequit.org/org/settings.html.
(defconst emacs-start-time (current-time))
''}
${optionalString cfg.recommendedGcSettings gcSettings}
${cfg.prelude}
${usePackageSetup}
''
+ concatStringsSep "\n\n"
(map (getAttr "assembly")
(filter (getAttr "enable")
(attrValues cfg.usePackage)))
+ ''
${cfg.postlude}
${optionalString cfg.startupTimer ''
;; Make a note of how long the configuration part of the start took.
(let ((elapsed (float-time (time-subtract (current-time)
emacs-start-time))))
(message "Loading settings...done (%.3fs)" elapsed))
''}
(provide 'hm-init)
;; hm-init.el ends here
'';
in {
imports = [./emacs-init-defaults.nix];
options.programs.emacs.init = {
enable = mkEnableOption "Emacs configuration";
recommendedGcSettings = mkRecommendedOption "garbage collection" ''
This will reduce garbage collection frequency during startup and
while the minibuffer is active.
'';
startupTimer = mkEnableOption "Emacs startup duration timer";
prelude = mkOption {
type = types.lines;
default = "";
description = ''
Configuration lines to add in the beginning of
<filename>init.el</filename>.
'';
};
postlude = mkOption {
type = types.lines;
default = "";
description = ''
Configuration lines to add in the end of
<filename>init.el</filename>.
'';
};
usePackageVerbose = mkEnableOption "verbose use-package mode";
usePackage = mkOption {
type = types.attrsOf usePackageType;
default = {};
example = literalExample ''
{
dhall-mode = {
mode = [ '''"\\.dhall\\'"''' ];
};
}
'';
description = ''
Attribute set of use-package configurations.
'';
};
};
config = mkIf cfg.enable {
machine.pkgsets.emacs.pkgs = epkgs: let
getPkg = v:
if isFunction v
then [(v epkgs)]
else optional (isString v && hasAttr v epkgs) epkgs.${v};
in
[epkgs.use-package]
++ optional hasBind epkgs.bind-key
++ optional hasDiminish epkgs.diminish
++ optional hasChords epkgs.use-package-chords
++ (
concatMap (v: getPkg v.package)
(builtins.attrValues cfg.usePackage)
);
# use lucid as toolkit; emacs will otherwise crash quite frequently when run in daemon mode
# https://gitlab.gnome.org/GNOME/gtk/issues/221
# Enabling again for now as gtk3 is needed for wayland support
machine.pkgsets.emacs.pkgwrap = let
inherit
((pkgs.emacsPackagesFor
(pkgs.emacs29.override {
withGTK2 = false;
withGTK3 = true;
withPgtk = true;
})))
emacsWithPackages
;
in
emacsWithPackages config.machine.pkgsets.emacs.pkgs;
environment.systemPackages = [
((pkgs.emacsPackagesFor config.machine.pkgsets.emacs.pkgwrap).trivialBuild {
pname = "hm-init";
version = "0";
src = pkgs.writeText "hm-init.el" initFile;
preferLocalBuild = true;
allowSubstitutes = false;
})
];
# This has no effect, will have to add a wrapper to emacs (or just copy this to ~/.emacs.d/init.el)
environment.etc."emacs.d/init.el".text = ''
(require 'hm-init)
(provide 'init)
'';
};
}

2
options/machine.nix
View file

@ -16,7 +16,7 @@ with lib; let
type = with types; oneOf [package (listOf package)];
default = fn.pkgFilter cfg.pkgsets."${pname}".pkgs;
description = ''
Package Wrapper for packages using a wrapper function (like python, emacs, haskell, ...)
Package Wrapper for packages using a wrapper function (like python, haskell, ...)
'';
};
pkgs = mkOption {

7
pkgs/systemPackages.nix
View file

@ -23,11 +23,4 @@ in {
cfg.pkgs)
cfg.pkgsets)
(v: v.pkgwrap));
services.emacs = mkIf (elem "emacs" cfg.pkgs) {
defaultEditor = true;
enable = true;
install = true;
package = cfg.pkgsets.emacs.pkgwrap;
};
}

169
pkgsets/emacs.nix
View file

@ -1,169 +0,0 @@
{
config,
lib,
fn,
pkgs,
...
}:
with lib; let
modefiles = fn.lst {
p = toString ./emacs;
b = true;
};
in rec {
imports =
[
../options/emacs-init.nix
]
++ modefiles;
programs.emacs.init = {
enable = elem "emacs" config.machine.pkgs;
recommendedGcSettings = true;
prelude = ''
;; Disable UI Clutter
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)
(tooltip-mode -1)
(blink-cursor-mode -1)
(setq ring-bell-function 'ignore)
(setq inhibit-startup-buffer-menu t)
(setq use-dialog-box nil)
(setq inhibit-startup-message t)
(setq inhibit-splash-screen t)
(setq initial-scratch-message nil)
(fset 'yes-or-no-p 'y-or-n-p)
(setq-default show-trailing-whitespace t)
;; Save and Backup behaviour
(add-hook 'before-save-hook 'delete-trailing-whitespace)
(setq create-lockfiles nil)
(setq backup-directory-alist `(("." . "~/.emacs_saves")))
(setq backup-by-copying t)
(setq delete-old-versions t
kept-new-versions 6
kept-old-versions 2
version-control t)
;; Tabs vs Spaces... I like Spaces
(setq-default indent-tabs-mode nil
tab-width 2
c-basic-offset 2
js-indent-level 2
sh-basic-offset 2
sh-indentation 2
smie-indent-basic 2)
;; General Functions I want
(put 'narrow-to-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
;; Global UI related Modes
(global-display-line-numbers-mode)
(setq display-line-numbers-width-start t)
(setq display-line-numbers-grow-only t)
(column-number-mode t)
(global-hl-line-mode t)
(size-indication-mode t)
(show-paren-mode t)
(setq split-height-threshold 200)
(setq split-width-threshold nil)
;; Text Scaling
(global-set-key (kbd "C-+") 'text-scale-increase)
(global-set-key (kbd "C--") 'text-scale-decrease)
;; Font Config
(defun set-fonts (frame)
(interactive)
"Adjust the font settings of FRAME so Emacs can display emoji and chinese properly."
(set-fontset-font t 'ascii (font-spec :family "DejaVu Sans Mono") frame 'preprend)
(set-fontset-font t 'big5 (font-spec :family "AR PL UMing TW") frame)
(set-fontset-font t 'chinese-gbk (font-spec :family "AR PL UMing CN") frame)
(set-fontset-font t 'symbol (font-spec :family "Symbola") frame 'prepend))
;; For when Emacs is started in GUI mode:
(set-fonts nil)
;; Hook for when a frame is created with emacsclient
;; see https://www.gnu.org/software/emacs/manual/html_node/elisp/Creating-Frames.html
(add-hook 'after-make-frame-functions 'set-fonts)
;; Fix keyboard input of 'dead-keys'
(require 'iso-transl)
;; Some small helper functions
;; These are based on the already existing 'kill' versions of the function
;; It's literally just a M-x r-str kill delete (and getting rid of tabs)
(defun delete-word (arg)
"Delete characters forward until encountering the end of a word.
With argument ARG, do this that many times."
(interactive "p")
(delete-region (point) (progn (forward-word arg) (point))))
(define-key global-map [remap kill-word] 'delete-word)
;; (define-key global-map (kbd <>) 'kill-word)
(defun backward-delete-word (arg)
"Delete characters backward until encountering the beginning of a word.
With argument ARG, do this that many times."
(interactive "p")
(delete-word (- arg)))
(define-key global-map [remap backward-kill-word] 'backward-delete-word)
(defun delete-whole-line (&optional arg)
"Delete current line.
With prefix ARG, delete that many lines starting from the current line.
If ARG is negative, delete backward. Also delete the preceding newline.
\(This is meant to make \\[repeat] work well with negative arguments.)
If ARG is zero, delete current line but exclude the trailing newline."
(interactive "p")
(or arg (setq arg 1))
(if (and (> arg 0) (eobp) (save-excursion (forward-visible-line 0) (eobp)))
(signal 'end-of-buffer nil))
(if (and (< arg 0) (bobp) (save-excursion (end-of-visible-line) (bobp)))
(signal 'beginning-of-buffer nil))
(unless (eq last-command 'delete-region)
(delete-new "")
(setq last-command 'delete-region))
(cond ((zerop arg)
;; We need to delete in two steps, because the previous command
;; could have been a delete command, in which case the text
;; before point needs to be prepended to the current delete
;; ring entry and the text after point appended. Also, we
;; need to use save-excursion to avoid copying the same text
;; twice to the delete ring in read-only buffers.
(save-excursion
(delete-region (point) (progn (forward-visible-line 0) (point))))
(delete-region (point) (progn (end-of-visible-line) (point))))
((< arg 0)
(save-excursion
(delete-region (point) (progn (end-of-visible-line) (point))))
(delete-region (point)
(progn (forward-visible-line (1+ arg))
(unless (bobp) (backward-char))
(point))))
(t
(save-excursion
(delete-region (point) (progn (forward-visible-line 0) (point))))
(delete-region (point)
(progn (forward-visible-line arg) (point))))))
(define-key global-map [remap kill-whole-line] 'delete-whole-line)
'';
};
}

176
pkgsets/emacs/company.nix
View file

@ -1,176 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib; let
# Source: https://github.com/Henry/dot-emacs/blob/master/my-lisp/company-pcomplete.el
company-pcomplete = pkgs.writeText "company-pcomplete.el" ''
;;; company-pcomplete.el --- company-mode pcomplete backend -*- lexical-binding: t -*-
;; Copyright (C) 2016 Free Software Foundation, Inc.
;; Author: Henry G. Weller
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;;
;; Based on `ac-pcomplete', see https://www.emacswiki.org/emacs/EshellCompletion
;; and `pcomplete`, see pcomplete.el.
;;; Code:
(require 'company)
(require 'cl-lib)
(require 'pcomplete)
(defgroup company-pcomplete nil
"Completion backend using pcomplete."
:group 'company)
(defvar company-pcomplete-available 'unknown)
(defun company-pcomplete--prefix ()
(let* ((pcomplete-stub)
pcomplete-seen
pcomplete-norm-func
pcomplete-args
pcomplete-last pcomplete-index
(pcomplete-autolist pcomplete-autolist)
(pcomplete-suffix-list pcomplete-suffix-list))
(pcomplete-completions)
(buffer-substring (pcomplete-begin) (point))))
(defun company-pcomplete--candidates ()
(let* ((pcomplete-stub)
(pcomplete-show-list t)
pcomplete-seen pcomplete-norm-func
pcomplete-args pcomplete-last pcomplete-index
(pcomplete-autolist pcomplete-autolist)
(pcomplete-suffix-list pcomplete-suffix-list)
(candidates (pcomplete-completions))
(prefix (buffer-substring (pcomplete-begin) (point)))
;; Collect all possible completions for the current stub
(cnds (all-completions pcomplete-stub candidates))
(bnds (completion-boundaries pcomplete-stub candidates nil ""))
(skip (- (length pcomplete-stub) (car bnds))))
;; Replace the stub at the beginning of each candidate by the prefix
(mapcar #'(lambda (cand) (concat prefix (substring cand skip))) cnds)))
(defun company-pcomplete-available ()
(when (eq company-pcomplete-available 'unknown)
(condition-case _err
(progn
(company-pcomplete--candidates)
(setq company-pcomplete-available t))
(error
(message "Company: pcomplete not found")
(setq company-pcomplete-available nil))))
company-pcomplete-available)
;;;###autoload
(defun company-pcomplete (command &optional _arg &rest ignored)
"`company-mode' completion backend using `pcomplete'."
(interactive (list 'interactive))
(cl-case command
(interactive (company-begin-backend 'company-pcomplete))
(prefix (when (company-pcomplete-available)
(company-pcomplete--prefix)))
(candidates (company-pcomplete--candidates))
(sorted t)))
(provide 'company-pcomplete)
'';
in
mkIf (elem "emacs::company" config.machine.pkgs) {
programs.emacs.init.usePackage = {
company = {
enable = true;
package = epkgs: [epkgs.company epkgs.company-web];
diminish = ["company-mode"];
hook =
["(after-init . global-company-mode)"]
++ optional (elem "emacs::rust" config.machine.pkgs)
''(rust-mode . (lambda () (setq company-backends '((company-capf :with company-yasnippet)))))''
++ optional (elem "emacs::web-mode" config.machine.pkgs)
'' (web-mode . (lambda () (set (make-local-variable 'company-backends) '(company-web-html company-css))
(company-mode t)))'';
bind = {"\t" = "'company-complete-common";};
init = ''(require 'ffap)'';
config = ''
;; (setq company-tooltip-align-annotations t)
(setq company-idle-delay 0.3
company-show-numbers t)
${
optionalString
(elem "emacs::org" config.machine.pkgs) ''
(load-file "${company-pcomplete}")''
}
'';
extraConfig = ''
:bind (:map company-mode-map
([remap completion-at-point] . company-complete-common)
([remap complete-symbol] . company-complete-common))
'';
};
company-box = {
enable = true;
hook = ["(company-mode . (lambda () (company-box-mode)))"];
config = ''
(setq company-box-icons-alist 'company-box-icons-all-the-icons)
(setq company-box-icons-lsp
`(( 1 . ,(all-the-icons-faicon "file-text-o" :v-adjust -0.0575)) ; Text
( 2 . ,(all-the-icons-faicon "cube" :v-adjust -0.0575)) ; Method
( 3 . ,(all-the-icons-faicon "cube" :v-adjust -0.0575)) ; Function
( 4 . ,(all-the-icons-faicon "cube" :v-adjust -0.0575)) ; Constructor
( 5 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Field
( 6 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Variable
( 7 . ,(all-the-icons-faicon "cog" :v-adjust -0.0575)) ; Class
( 8 . ,(all-the-icons-faicon "cogs" :v-adjust -0.0575)) ; Interface
( 9 . ,(all-the-icons-alltheicon "less")) ; Module
(10 . ,(all-the-icons-faicon "wrench" :v-adjust -0.0575)) ; Property
(11 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Unit
(12 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Value
(13 . ,(all-the-icons-material "content_copy" :v-adjust -0.2)) ; Enum
(14 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Keyword
(15 . ,(all-the-icons-material "content_paste" :v-adjust -0.2)) ; Snippet
(16 . ,(all-the-icons-material "palette" :v-adjust -0.2)) ; Color
(17 . ,(all-the-icons-faicon "file" :v-adjust -0.0575)) ; File
(18 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Reference
(19 . ,(all-the-icons-faicon "folder" :v-adjust -0.0575)) ; Folder
(20 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; EnumMember
(21 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Constant
(22 . ,(all-the-icons-faicon "cog" :v-adjust -0.0575)) ; Struct
(23 . ,(all-the-icons-faicon "bolt" :v-adjust -0.0575)) ; Event
(24 . ,(all-the-icons-faicon "tag" :v-adjust -0.0575)) ; Operator
(25 . ,(all-the-icons-faicon "cog" :v-adjust -0.0575)) ; TypeParameter
))
'';
};
all-the-icons = {enable = true;};
company-jedi = {
enable = elem "emacs::elpy" config.machine.pkgs;
};
};
fonts.packages = pkgs.emacs-all-the-icons-fonts.all;
}

15
pkgsets/emacs/direnv.nix
View file

@ -1,15 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::direnv" config.machine.pkgs) {
programs.emacs.init.usePackage.direnv = {
enable = true;
config = ''(direnv-mode)'';
};
services.lorri.enable = true;
environment.systemPackages = with pkgs; [lorri direnv];
}

22
pkgsets/emacs/docker.nix
View file

@ -1,22 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::docker" config.machine.pkgs) {
programs.emacs.init.usePackage = {
dockerfile-mode = {
enable = true;
};
docker = {
enable = true;
};
docker-compose-mode = {
enable = true;
};
docker-tramp = {
enable = true;
};
};
}

11
pkgsets/emacs/dockerfile.nix
View file

@ -1,11 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::dockerfile" config.machine.pkgs) {
programs.emacs.init.usePackage.dockerfile-mode = {
enable = true;
};
}

24
pkgsets/emacs/doom-modeline.nix
View file

@ -1,24 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::doom-modeline" config.machine.pkgs) {
programs.emacs.init.usePackage.doom-modeline = {
enable = true;
hook = ["(after-init . doom-modeline-mode)"];
config = ''
(setq doom-modeline-icon t)
(setq doom-modeline-height 25)
(setq doom-modeline-bar-width 3)
;; The default priority of detection is `ffip' > `projectile' > `project'.
(setq doom-modeline-project-detection 'project)
(setq doom-modeline-buffer-file-name-style 'truncate-upto-project)
(setq doom-modeline-unicode-fallback nil)
(setq doom-modeline--battery-status t)
'';
};
}

19
pkgsets/emacs/doom-themes.nix
View file

@ -1,19 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::doom-themes" config.machine.pkgs) {
programs.emacs.init.usePackage.doom-themes = {
enable = true;
config = ''
;; Load the theme (doom-one, doom-molokai, etc); keep in mind that each theme
;; may have their own settings.
(load-theme 'doom-solarized-dark t)
;; ${optionalString (elem "emacs::org" config.machine.pkgs) "(doom-themes-org-config)"}
'';
};
}

151
pkgsets/emacs/elfeed.nix
View file

@ -1,151 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::elfeed" config.machine.pkgs) {
programs.emacs.init.usePackage = {
elfeed = let
pyEnv = pkgs.python3.withPackages (ps: with ps; [beautifulsoup4 lxml requests]);
pyScript = pkgs.writeScript "elfeedFetcher.py" ''
#!${pyEnv}/bin/python3
import sys
from requests import get
from bs4 import BeautifulSoup
header_agent = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0'}
with get(sys.argv[1], headers=header_agent) as r:
soup = BeautifulSoup(r.text, 'lxml')
abstract = soup.find('dd', {"id": "abstract"}).text.replace('"', '\\"')
article = '\n\n'.join(
[soup.find('p', {"id": "first"}, class_="lead").text] +
[
p.text for p in
soup.find('div', {"id": "text"}).findAll('p')
]).replace('"', '\\"')
print(f"(setq abstract \"{abstract}\") (setq article \"{article}\")")
'';
in {
enable = true;
hook = [''(elfeed-new-entry . elfeed-content-fetcher)''];
config = ''
(load-file "~/.emacs.d/elfeed.el")
(defun elfeed-play-with-mpv (entry)
"Play entry link with mpv."
(interactive (elfeed-search-selected :single))
(start-process "elfeed-mpv" nil "mpv" "--ytdl-format=[height<=1080]" (elfeed-entry-link entry)))
(defun elfeed-search-show-entry-custom (entry)
"Custom actions for various sources."
(interactive (list (elfeed-search-selected :ignore-region)))
(if (equal (car (elfeed-entry-id entry)) "www.youtube.com") (elfeed-play-with-mpv entry)
(elfeed-show-entry entry)))
(define-key elfeed-search-mode-map [remap elfeed-search-show-entry] 'elfeed-search-show-entry-custom)
(defun elfeed-get-yt-description (url)
(shell-command-to-string (format "${pkgs.yt-dlp}/bin/yt-dlp --get-description \"%s\" 2> /dev/null" url)))
(defun elfeed-get-sd-article (url)
(eval-string (shell-command-to-string (format "${pyEnv}/bin/python3 ${pyScript} \"%s\" 2> /dev/null" url))))
(defun eval-string (string)
(eval (car (read-from-string (format "(progn %s)" string)))))
(defun elfeed-content-fetcher (entry)
"Fetches content for various entries (currently only sciencedaily)."
(interactive (list (elfeed-search-selected :ignore-region)))
(let ((url (elfeed-entry-link entry))
(feed-id (elfeed-deref (elfeed-entry-feed-id entry)))
)
(when (equal (car (elfeed-entry-id entry)) "www.sciencedaily.com")
(elfeed-get-sd-article (cdr (elfeed-entry-id entry)))
;; (setf (elfeed-entry-content entry) (elfeed-ref article))
(setf (elfeed-meta entry :content) (elfeed-ref article))
(setf (elfeed-meta entry :abstract) abstract)
(makunbound 'abstract)
(makunbound 'article))))
(defun elfeed-show-refresh--mail-style ()
"Update the buffer to match the selected entry, using a mail-style."
(interactive)
(let* ((inhibit-read-only t)
(title (elfeed-entry-title elfeed-show-entry))
(date (seconds-to-time (elfeed-entry-date elfeed-show-entry)))
(authors (elfeed-meta elfeed-show-entry :authors))
(link (elfeed-entry-link elfeed-show-entry))
(tags (elfeed-entry-tags elfeed-show-entry))
(tagsstr (mapconcat #'symbol-name tags ", "))
(nicedate (format-time-string "%a, %e %b %Y %T %Z" date))
(content (if (elfeed-meta elfeed-show-entry :content) (elfeed-deref (elfeed-meta elfeed-show-entry :content)) (elfeed-deref (elfeed-entry-content elfeed-show-entry))))
(type (elfeed-entry-content-type elfeed-show-entry))
(feed (elfeed-entry-feed elfeed-show-entry))
(feed-title (elfeed-feed-title feed))
(base (and feed (elfeed-compute-base (elfeed-feed-url feed)))))
(erase-buffer)
(insert (format (propertize "Title: %s\n" 'face 'message-header-name)
(propertize title 'face 'message-header-subject)))
(when elfeed-show-entry-author
(dolist (author authors)
(let ((formatted (elfeed--show-format-author author)))
(insert
(format (propertize "Author: %s\n" 'face 'message-header-name)
(propertize formatted 'face 'message-header-to))))))
(insert (format (propertize "Date: %s\n" 'face 'message-header-name)
(propertize nicedate 'face 'message-header-other)))
(insert (format (propertize "Feed: %s\n" 'face 'message-header-name)
(propertize feed-title 'face 'message-header-other)))
(when tags
(insert (format (propertize "Tags: %s\n" 'face 'message-header-name)
(propertize tagsstr 'face 'message-header-other))))
(insert (propertize "Link: " 'face 'message-header-name))
(elfeed-insert-link link link)
(insert "\n")
(cl-loop for enclosure in (elfeed-entry-enclosures elfeed-show-entry)
do (insert (propertize "Enclosure: " 'face 'message-header-name))
do (elfeed-insert-link (car enclosure))
do (insert "\n"))
(insert "\n")
(if content
(if (eq type 'html)
(elfeed-insert-html content base)
(insert content))
(insert (propertize "(empty)\n" 'face 'italic)))
(goto-char (point-min))))
(defun elfeed-db-gc (&optional stats-p)
"Clean up unused content from the content database.
If STATS is true, return the space cleared in bytes."
(elfeed-db-gc-empty-feeds)
(let* ((data (expand-file-name "data" elfeed-db-directory))
(dirs (directory-files data t "^[0-9a-z]\\{2\\}$"))
(ids (cl-mapcan (lambda (d) (directory-files d nil nil t)) dirs))
(table (make-hash-table :test 'equal)))
(dolist (id ids)
(setf (gethash id table) nil))
(with-elfeed-db-visit (entry _)
(let ((content (elfeed-entry-content entry))
(meta-content (elfeed-meta entry :content)))
(when (elfeed-ref-p content)
(setf (gethash (elfeed-ref-id content) table) t))
(when (elfeed-ref-p (meta-content))
(setf (gethash (elfeed-ref-id meta-content) table) t))))
(cl-loop for id hash-keys of table using (hash-value used)
for used-p = (or used (member id '("." "..")))
when (and (not used-p) stats-p)
sum (let* ((ref (elfeed-ref--create :id id))
(file (elfeed-ref--file ref)))
(* 1.0 (nth 7 (file-attributes file))))
unless used-p
do (elfeed-ref-delete (elfeed-ref--create :id id))
finally (cl-loop for dir in dirs
when (elfeed-directory-empty-p dir)
do (delete-directory dir)))))
'';
};
};
}

43
pkgsets/emacs/elpy.nix
View file

@ -1,43 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::elpy" config.machine.pkgs) {
programs.emacs.init.usePackage.elpy = {
enable = true;
after = ["python"];
command = ["elpy-enable"];
hook =
[
''
(elpy-mode
. (lambda ()
(set (make-local-variable 'company-backends)
'((company-dabbrev-code company-yasnippet elpy-company-backend)))))
''
]
++ (optional (elem "emacs::flyspell" config.machine.pkgs) "(elpy-mode . (lambda () (flyspell-prog-mode)))")
++ (optional (elem "emacs::flycheck" config.machine.pkgs) "(elpy-mode . (lambda () (flycheck-mode)))");
bindLocal = {
elpy-mode-map = {
"<tab>" = "company-indent-or-complete-common";
};
};
init = ''(with-eval-after-load 'python (elpy-enable))'';
config = ''
(setq elpy-project-root-finder-functions '(elpy-project-find-git-root elpy-project-find-python-root elpy-project-find-hg-root elpy-project-find-svn-root))
(setq elpy-rpc-backend "jedi")
(setq python-shell-interpreter "ipython"
python-shell-interpreter-args "-i --simple-prompt")
${optionalString (elem "emacs::flycheck" config.machine.pkgs) ''
;; manually set what python-mypy is and configure it to ignore 3rd party imports
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(setq-default flycheck-checker 'python-pylint)
(flycheck-add-next-checker 'python-pylint 'python-flake8 t)
;; (flycheck-add-next-checker 'python-mypy 'python-flake8 t)''}
'';
};
}

18
pkgsets/emacs/fcitx.nix
View file

@ -1,18 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::fcitx" config.machine.pkgs) {
programs.emacs.init.usePackage = {
fcitx = {
enable = true;
demand = true;
config = ''
;; (setq fcitx-use-dbus t)
(fcitx-default-setup)
'';
};
};
}

33
pkgsets/emacs/flycheck.nix
View file

@ -1,33 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::flycheck" config.machine.pkgs) {
programs.emacs.init.usePackage.flycheck = {
enable = true;
command = ["global-flycheck-mode"];
defer = 1;
bind = {};
config = ''
'';
};
programs.emacs.init.usePackage.flycheck-haskell = {
enable = elem "emacs::haskell" config.machine.pkgs;
};
programs.emacs.init.usePackage.flycheck-mypy = {
enable = elem "emacs::elpy" config.machine.pkgs;
};
programs.emacs.init.usePackage.pylint = {
enable = elem "emacs::elpy" config.machine.pkgs;
};
programs.emacs.init.usePackage.flycheck-rust = {
enable = elem "emacs::rust" config.machine.pkgs;
};
}

33
pkgsets/emacs/flyspell.nix
View file

@ -1,33 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::flyspell" config.machine.pkgs) {
programs.emacs.init.usePackage.flyspell = {
enable = true;
package = epkgs: null;
diminish = ["flyspell-mode"];
command = ["flyspell-mode" "flyspell-prog-mode"];
hook = [];
bind = {
"C-M-<tab>" = "flyspell-switch-dictionary";
"C-c f" = "ispell-word";
};
config = ''
;; Make flyspell less verbose and disable annoying keybind
(setq flyspell-issue-message-flag nil
flyspell-issue-welcome-flag nil
flyspell-use-meta-tab nil)
(defun flyspell-switch-dictionary ()
(interactive)
(let* ((dic ispell-current-dictionary)
(change (if (string= dic "deutsch8") "english" "deutsch8")))
(ispell-change-dictionary change)
(message "Dictionary switched to %s" change)
))
'';
};
}

30
pkgsets/emacs/latex.nix
View file

@ -1,30 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::latex" config.machine.pkgs) {
programs.emacs.init.usePackage = {
latex-mode = {
enable = true;
package = epkgs: null;
defer = true;
};
tex-site = {
enable = true;
defer = true;
package = epkgs: epkgs.auctex;
hook = [];
mode = [''("\\.tex\\'" . TeX-latex-mode)''];
};
preview = {
enable = true;
defer = true;
package = epkgs: epkgs.auctex;
};
};
}

60
pkgsets/emacs/lsp.nix
View file

@ -1,60 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::lsp" config.machine.pkgs) {
programs.emacs.init.usePackage = {
lsp-mode = {
enable = true;
command = ["lsp-mode"];
config = ''
(setq lsp-keymap-prefix "C-c")
(setq lsp-eldoc-render-all nil)
(defvar lsp-language-id-configuration '(
${optionalString (elem "emacs::rust" config.machine.pkgs)
''(rust-mode . "rust")''}
))
${optionalString (elem "emacs::rust" config.machine.pkgs) ''
(setq lsp-rust-clippy-preference "on")
''}
${optionalString (elem "emacs::web-mode" config.machine.pkgs) ''
(setq lsp-clients-deno-enable-unstable 't)
(setq lsp-clients-deno-import-map "./import_map.json")
(setq lsp-clients-deno-config "./deno.json")
''}
${optionalString (elem "emacs::php-mode" config.machine.pkgs) ''
(setq lsp-intelephense-php-version "8.2")
(setq lsp-intelephense-server-command `("${pkgs.nodePackages.intelephense}/bin/intelephense" "--stdio"))
''}
'';
};
lsp-ui = {
enable = true;
after = ["lsp-mode"];
config = ''
(setq lsp-ui-sideline-enable 't)
(setq lsp-ui-sideline-show-symbol nil)
(setq lsp-ui-sideline-show-hover nil)
(setq lsp-ui-doc-show-with-cursor 't)
(setq lsp-ui-doc-delay 1)
(setq lsp-ui-sideline-show-code-actions 't)
(setq lsp-ui-sideline-update-mode 'point)
(define-key lsp-ui-mode-map [remap xref-find-definitions] #'lsp-ui-peek-find-definitions)
(define-key lsp-ui-mode-map [remap xref-find-references] #'lsp-ui-peek-find-references)
'';
};
lsp-ui-flycheck = {
enable = true;
package = epkgs: [epkgs.lsp-ui];
after =
["lsp-ui"]
++ optional (elem "emacs::flycheck" config.machine.pkgs) "flycheck";
};
};
}

14
pkgsets/emacs/magit.nix
View file

@ -1,14 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::magit" config.machine.pkgs) {
programs.emacs.init.usePackage.magit = {
enable = true;
bind = {
"C-c m" = "magit-status";
};
};
}

122
pkgsets/emacs/mu4e.nix
View file

@ -1,122 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib; let
defaultEncrypt = pkgs.emacsPackages.trivialBuild rec {
pname = "defaultencrypt";
version = "ba07acc8e9fd692534c39c7cdad0a19dc0d897d9";
src = pkgs.fetchFromGitLab {
owner = "lechten";
repo = pname;
rev = version;
sha256 = "1ln7h1syx7yi7bqvirv90mk4rvwxg4zm1wvfcvhfh64s3hqrbfgl";
};
};
in
mkIf (elem "emacs::mu4e" config.machine.pkgs) {
programs.emacs.init.usePackage.pinentry = {
enable = true;
command = ["pinentry-start"];
hook = ["(after-init . pinentry-start)"];
};
programs.emacs.init.usePackage.mu4e = {
enable = true;
package = epkgs: null;
command = ["mu4e"];
diminish = ["mu4e-mode"];
hook = [
"(mu4e-view-mode . visual-line-mode)"
"(mu4e-compose-mode . flyspell-mode)"
'' (message-send . (lambda ()
(unless (yes-or-no-p "Send this message?")
(signal 'quit nil))))''
];
bind = {"\t" = "'company-complete-common";};
bindLocal = rec {
mu4e-headers-mode-map = {
"C-+" = "nil";
"C--" = "nil";
};
mu4e-view-mode-map = mu4e-headers-mode-map;
};
init = ''
;; (add-to-list 'load-path "${defaultEncrypt}/share/emacs/site-lisp")
;; (require 'jl-encrypt)
'';
config = ''
(setq mail-user-agent 'mu4e-user-agent)
(setq org-mu4e-link-query-in-headers-mode t)
(setq mu4e-maildir "~/.mail/Mail")
(setq mu4e-get-mail-command "${pkgs.isync.override { withCyrusSaslXoauth2 = true; }}/bin/mbsync -a")
(setq mu4e-context-policy 'pick-first)
(setq mu4e-change-filenames-when-moving t)
(setq starttls-use-gnutls t)
(setq message-send-mail-function 'smtpmail-send-it)
(setq mu4e-update-interval 300)
(setq mu4e-use-fancy-chars t)
(setq mu4e-view-show-addresses t)
(setq mu4e-headers-show-threads t)
(setq mu4e-headers-skip-duplicates t)
(setq mail-user-agent 'mu4e-user-agent)
(defvaralias 'mu4e-compose-signature 'message-signature)
(setq-default mu4e-save-multiple-attachments-without-asking t)
(setq-default mu4e-view-show-addresses t)
(setq-default mu4e-confirm-quit nil)
(setq-default mu4e-hide-index-messages t)
(setq-default mu4e-index-update-in-background t)
(setq mu4e-compose-in-new-frame nil)
;;rename files when moving
;;NEEDED FOR MBSYNC
(setq mu4e-change-filenames-when-moving t)
(setq mu4e-html2text-command "iconv -c -t utf-8 | ${pkgs.pandoc}/bin/pandoc -f html -t plain")
(setq mu4e-view-show-images t)
(when (fboundp 'imagemagick-register-types)
(imagemagick-register-types))
(setq message-kill-buffer-on-exit t)
;; Encryption Stuff
;; (setq mml-secure-openpgp-sign-with-sender t)
;; ;; (setq mm-sign-option ‘guided’)
;; (setq epa-pinentry-mode 'loopback)
;; mailAcc config goes here
(load-file "~/.emacs.d/mu4e.el")
(defun my-browse-url-firefox-privately (url &optional new-window)
"Make firefox open URL in private-browsing window."
(interactive (browse-url-interactive-arg "URL: "))
(let ((process-environment (browse-url-process-environment)))
(apply 'start-process
(concat "firefox " url)
nil
browse-url-firefox-program
(list "-private-window" url))))
(setq browse-url-browser-function 'my-browse-url-firefox-privately)
(add-to-list 'mu4e-view-actions
'("ViewInBrowser" . mu4e-action-view-in-browser) t)
'';
extraConfig = ''
:load-path "${pkgs.mu.mu4e}/share/emacs/site-lisp/mu4e"
'';
};
programs.emacs.init.usePackage.mu4e-alert = {
enable = true;
# hook = [ "after-init . mu4e-alert-enable-mode-line-display" ];
};
# programs.emacs.init.usePackage.org-mu4e = {
# enable = (elem "emacs::org" config.machine.pkgs);
# };
environment.systemPackages = with pkgs; [
mu
(isync.override { withCyrusSaslXoauth2 = true; })
];
}

13
pkgsets/emacs/nix-mode.nix
View file

@ -1,13 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::nix-mode" config.machine.pkgs) {
programs.emacs.init.usePackage.nix-mode = {
enable = true;
mode = [''"\\.nix\\'"''];
config = ''(setq nix-nixfmt-bin "nixfmt -w 150")'';
};
}

440
pkgsets/emacs/org.nix
View file

@ -1,440 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::org" config.machine.pkgs) {
programs.emacs.init.usePackage.org = {
enable = true;
package = epkgs: [epkgs.org];
mode = [''("\\.org\\'" . org-mode)''];
command = ["org-mode"];
hook =
[
"(org-mode . (lambda () (org-indent-mode)))"
''
(org-mode
. (lambda ()
;; Automatic line-wrapping in org-mode
;;(auto-fill-mode 1)
(setq completion-at-point-functions
'(org-completion-symbols
ora-cap-filesystem))))
''
''
(org-mode
. (lambda ()
"Beautify Org Checkbox Symbol"
(push '("[ ]" . "☐" ) prettify-symbols-alist)
(push '("[X]" . "☑" ) prettify-symbols-alist)
(push '("[-]" . "❍" ) prettify-symbols-alist)
(prettify-symbols-mode)))
''
]
++ optional (elem "emacs::flyspell" config.machine.pkgs) "(org-mode . (lambda () (flyspell-mode)))";
bind = {
"C-c a" = "org-agenda";
};
bindLocal = {
org-mode-map =
{
"M-<up>" = "org-metaup";
"M-<down>" = "org-metadown";
"M-." = "org-open-at-point";
"M-," = "org-mark-ring-goto";
"M-S-<return>" = "org-insert-todo-heading-respect-content";
"M-<return>" = "org-meta-return";
"M-p" = "org-previous-visible-heading";
"M-n" = "org-next-visible-heading";
}
// (optionalAttrs (elem "emacs::company" config.machine.pkgs) {
"<M-tab>" = "company-pcomplete";
});
};
config = ''
;; Insead of "..." show "…" when there's hidden folded content
;; org-prettify
(defface org-checkbox-done-text
'((t (:foreground "#71696A" :strike-through t)))
"Face for the text part of a checked org-mode checkbox.")
(font-lock-add-keywords
'org-mode
`(("^[ \t]*\\(?:[-+*]\\|[0-9]+[).]\\)[ \t]+\\(\\(?:\\[@\\(?:start:\\)?[0-9]+\\][ \t]*\\)?\\[\\(?:X\\|\\([0-9]+\\)/\\2\\)\\][^\n]*\n\\)"
1 'org-checkbox-done-text prepend))
'append)
;; Some characters to choose from: …, ⤵, ▼, ↴, ⬎, ⤷, and ⋱
(setq org-ellipsis " ▼")
;; get nice looking tables (only for non org-tables; rarely used)
(setq table-cell-horizontal-chars "\u2501")
(setq table-cell-vertical-char ?\u2503)
(setq table-cell-intersection-char ?\u254B)
(setq org-directory "~/Documents/org/")
;; Show headings up to level 2 by default when opening an org files
(setq org-startup-folded 'content)
;; Show inline images by default
(setq org-startup-with-inline-images t)
;; Add more levels to headlines that get displayed with imenu
(setq org-imenu-depth 5)
;; Enter key follows links (= C-c C-o)
(setq org-return-follows-link t)
;; Don't remove links after inserting
(setq org-keep-stored-link-after-insertion t)
(setq org-tag-alist (quote ((:startgroup)
("WAITING" . ?w)
("HOLD" . ?h)
("CANCELLED" . ?c)
("NOTE" . ?n)
(:endgroup)
("PERSONAL" . ?P)
("WORK" . ?W)
("ATOMX" . ?A)
("E5" . ?E)
("HOGASO" . ?H)
("ORG" . ?o)
("crypt" . ?C)
("FLAGGED" . ??))))
;; Allow setting single tags without the menu
(setq org-fast-tag-selection-single-key (quote expert))
(setq org-archive-mark-done nil)
(setq org-archive-location "%s_archive::* Archived Tasks")
;; C-RET, C-S-RET insert new heading after current task content
(setq org-insert-heading-respect-content nil)
;; Show a little bit more when using sparse-trees
(setq org-show-following-heading t)
(setq org-show-hierarchy-above t)
(setq org-show-siblings (quote ((default))))
;; don't show * / = etc
(setq org-hide-emphasis-markers t)
;; leave highlights in sparse tree after edit. C-c C-c removes highlights
(setq org-remove-highlights-with-change nil)
;; M-RET should not split the lines
(setq org-M-RET-may-split-line '((default . nil)))
(setq org-special-ctrl-a/e t)
(setq org-special-ctrl-k t)
(setq org-yank-adjusted-subtrees t)
;; Show org entities as UTF-8 characters (e.g. \sum as ∑)
(setq org-pretty-entities t)
;; But Don't print "bar" as subscript in "foo_bar"
(setq org-pretty-entities-include-sub-superscripts nil)
;; And also don't display ^ or _ as super/subscripts
(setq org-use-sub-superscripts nil)
;; undone TODO entries will block switching the parent to DONE
(setq org-enforce-todo-dependencies t)
(setq org-use-fast-todo-selection t)
(setq org-todo-keywords
(quote ((sequence "TODO(t)" "NEXT(n)" "|" "DONE(d)")
(sequence "WAITING(w@/!)" "HOLD(h@/!)" "|" "CANCELLED(c@/!)" "PHONE" "MEETING"))))
(setq org-todo-keyword-faces
(quote (("TODO" :foreground "red" :weight bold)
("NEXT" :foreground "blue" :weight bold)
("DONE" :foreground "forest green" :weight bold)
("WAITING" :foreground "orange" :weight bold)
("HOLD" :foreground "magenta" :weight bold)
("CANCELLED" :foreground "forest green" :weight bold)
("MEETING" :foreground "forest green" :weight bold)
("PHONE" :foreground "forest green" :weight bold))))
;; Auto completion for symbols in org-mode
;; https://oremacs.com/2017/10/04/completion-at-point/
(defun org-completion-symbols ()
(when (looking-back "[`~=][a-zA-Z]+" nil)
(let (cands)
(save-match-data
(save-excursion
(goto-char (point-min))
(while (re-search-forward "[`~=]\\([a-zA-Z.\\-_]+\\)[`~=]" nil t)
(cl-pushnew
(match-string-no-properties 0) cands :test 'equal))
cands))
(when cands
(list (match-beginning 0) (match-end 0) cands)))))
(defun ora-cap-filesystem ()
(let (path)
(when (setq path (ffap-string-at-point))
(when (string-match "\\`file:\\(.*\\)\\'" path)
(setq path (match-string 1 path)))
(let ((compl (all-completions path #'read-file-name-internal)))
(when compl
(let* ((str (car compl))
(offset
(let ((i 0)
(len (length str)))
(while (and (< i len)
(equal (get-text-property i 'face str)
'completions-common-part))
(cl-incf i))
i)))
(list (- (point) offset) (point) compl)))))))
'';
};
programs.emacs.init.usePackage.ob = {
enable = true;
package = epkgs: [epkgs.ob-ipython epkgs.ob-rust epkgs.ob-diagrams];
defer = true;
init = ''
(add-hook 'org-babel-after-execute-hook 'org-display-inline-images 'append)
'';
config = ''
(setq org-confirm-babel-evaluate nil) ; don't prompt me to confirm everytime I want to evaluate a block
(defun org-babel-restart-session-to-point (&optional arg)
"Restart session up to the src-block in the current point.
Goes to beginning of buffer and executes each code block with
`org-babel-execute-src-block' that has the same language and
session as the current block. ARG has same meaning as in
`org-babel-execute-src-block'."
(interactive "P")
(unless (org-in-src-block-p)
(error "You must be in a src-block to run this command"))
(let* ((current-point (point-marker))
(info (org-babel-get-src-block-info))
(lang (nth 0 info))
(params (nth 2 info))
(session (cdr (assoc :session params))))
(save-excursion
(goto-char (point-min))
(while (re-search-forward org-babel-src-block-regexp nil t)
;; goto start of block
(goto-char (match-beginning 0))
(let* ((this-info (org-babel-get-src-block-info))
(this-lang (nth 0 this-info))
(this-params (nth 2 this-info))
(this-session (cdr (assoc :session this-params))))
(when
(and
(< (point) (marker-position current-point))
(string= lang this-lang)
(src-block-in-session-p session))
(org-babel-execute-src-block arg)))
;; move forward so we can find the next block
(forward-line)))))
(defun org-babel-kill-session ()
"Kill session for current code block."
(interactive)
(unless (org-in-src-block-p)
(error "You must be in a src-block to run this command"))
(save-window-excursion
(org-babel-switch-to-session)
(kill-buffer)))
(defun org-babel-remove-result-buffer ()
"Remove results from every code block in buffer."
(interactive)
(save-excursion
(goto-char (point-min))
(while (re-search-forward org-babel-src-block-regexp nil t)
(org-babel-remove-result))))
;; this adds a "new language" in babel that gets exported as js in html
;; https://www.reddit.com/r/orgmode/comments/5bi6ku/tip_for_exporting_javascript_source_block_to/
(add-to-list 'org-src-lang-modes '("inline-js" . javascript))
(defvar org-babel-default-header-args:inline-js
'((:results . "html")
(:exports . "results")))
(defun org-babel-execute:inline-js (body _params)
(format "<script type=\"text/javascript\">\n%s\n</script>" body))
;; Path when plantuml is installed from AUR (package `plantuml')
(setq org-plantuml-jar-path "/opt/plantuml/plantuml.jar")
;; add all languages to org mode
(org-babel-do-load-languages
'org-babel-load-languages
'((C . t)
;;(R . t)
(asymptote)
(awk)
(calc . t)
(clojure . t)
(comint)
(css)
(ditaa . t)
(dot . t)
(emacs-lisp . t)
(fortran)
(gnuplot . t)
(haskell)
(io)
(java)
(js . t)
(latex)
(lilypond)
(lisp)
(lua . t)
(matlab)
(maxima)
(mscgen)
(ocaml)
(octave . t)
(org . t)
(perl)
(picolisp)
(plantuml . t)
(python . t)
;; (ipython . t)
;; (restclient . t)
(ref)
(ruby)
(sass)
(scala)
(scheme)
(screen)
(shell . t)
(shen)
(snippet)
(sql . t)
(sqlite . t)))
'';
};
programs.emacs.init.usePackage.org-src = {
enable = true;
package = epkgs: null;
defer = true;
init = ''(put 'org-src-preserve-indentation 'safe-local-variable 'booleanp)'';
config = ''
(setq org-src-window-setup 'current-window)
(setq org-src-fontify-natively t) ; syntax highlighting for source code blocks
;; Tab should do indent in code blocks
;; I think I hate this function (causes scroll on TAB
(setq org-src-tab-acts-natively t)
;; ?Fix weird scrolling
;; Don't remove (or add) any extra whitespace
(setq org-src-preserve-indentation nil)
(setq org-edit-src-content-indentation 0)
;;; Some helper function to manage org-babel sessions
(defun src-block-in-session-p (&optional name)
"Return if src-block is in a session of NAME.
NAME may be nil for unnamed sessions."
(let* ((info (org-babel-get-src-block-info))
;;(lang (nth 0 info))
;;(body (nth 1 info))
(params (nth 2 info))
(session (cdr (assoc :session params))))
(cond
;; unnamed session, both name and session are nil
((and (null session)
(null name))
t)
;; Matching name and session
((and
(stringp name)
(stringp session)
(string= name session))
t)
;; no match
(t nil))))
;; dot == graphviz-dot
(add-to-list 'org-src-lang-modes '("dot" . graphviz-dot))
;; Add 'conf-mode' to org-babel
(add-to-list 'org-src-lang-modes '("ini" . conf))
(add-to-list 'org-src-lang-modes '("conf" . conf))
'';
};
programs.emacs.init.usePackage.org-tempo = {
enable = true;
package = epkgs: null;
};
programs.emacs.init.usePackage.ox = {
enable = true;
package = epkgs: null;
defer = true;
command = [];
config = ''
;; Use html5 as org export and use new tags
(setq org-html-doctype "html5")
(setq org-html-html5-fancy t)
;; Don't add html footer to export
(setq org-html-postamble nil)
;; Don't export ^ or _ as super/subscripts
(setq org-export-with-sub-superscripts nil)
'';
};
programs.emacs.init.usePackage.ox-gfm = {
enable = true;
after = ["ox"];
};
programs.emacs.init.usePackage.ox-rst = {
enable = true;
after = ["ox"];
};
programs.emacs.init.usePackage.ox-md = {
enable = true;
package = epkgs: null;
after = ["ox"];
};
programs.emacs.init.usePackage.org-bullets = {
enable = true;
hook = ["(org-mode . org-bullets-mode)"];
};
programs.emacs.init.usePackage.org-crypt = {
enable = true;
package = epkgs: null;
after = ["org"];
hook = ["(org-mode . (lambda () (add-hook 'before-save-hook 'org-encrypt-entries nil t)))"];
command = ["org-decrypt-entry" "org-encrypt-entry"];
bindLocal = {
org-mode-map = {
"C-c d" = "org-decrypt-entry";
"C-c e" = "org-encrypt-entry";
};
};
config = ''
(setq org-tags-exclude-from-inheritance (quote ("crypt")))
;; GPG key to use for encryption
(load-file "~/.emacs.d/org-crypt-key.el")
;; don't ask to disable auto-save
(setq org-crypt-disable-auto-save "encrypt")
'';
};
programs.emacs.init.usePackage.org-drill = {
enable = true;
};
}

16
pkgsets/emacs/php-mode.nix
View file

@ -1,16 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::php-mode" config.machine.pkgs) {
programs.emacs.init.usePackage = {
php-mode = {
enable = true;
hook =
lib.optional (elem "emacs::lsp" config.machine.pkgs)
''(typescript-mode . (lambda () (lsp)))'';
};
};
}

18
pkgsets/emacs/powerline.nix
View file

@ -1,18 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::powerline" config.machine.pkgs) {
programs.emacs.init.usePackage.powerline = {
enable = true;
config = ''
;; color palette from https://github.com/kuanyui/moe-theme.el/blob/master/moe-theme.el#L283
(set-face-attribute 'mode-line nil :background "#afd7ff" :foreground "#005f87")
(set-face-attribute 'mode-line-buffer-id nil :background "#afd7ff" :foreground "#080808")
(set-face-attribute 'minibuffer-prompt nil :foreground "#5fafd7" :background "#3a3a3a")
(powerline-default-theme)
'';
};
}

55
pkgsets/emacs/rust.nix
View file

@ -1,55 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib; let
rustEnv = pkgs.symlinkJoin {
name = "rustEnv";
paths = config.machine.pkgsets.rustpkgs.pkgwrap;
};
in
mkIf (elem "emacs::rust" config.machine.pkgs) {
programs.emacs.init.usePackage.rust-mode = {
enable = true;
hook =
[''(rust-mode . (lambda () (cargo-minor-mode)))'']
++ (
if (elem "emacs::lsp" config.machine.pkgs)
then [''(rust-mode . (lambda () (lsp)))'']
else [''(rust-mode . (lambda () (racer-mode)))'']
);
mode = [''("\\.rs\\'" . rust-mode)''];
command = ["rust-mode"];
bindLocal = optionalAttrs (elem "emacs::company" config.machine.pkgs) {
rust-mode-map = {
"<tab>" = "company-indent-or-complete-common";
};
};
config = ''
(setq rust-rustfmt-bin "${rustEnv}/bin/rustfmt")
(setq rust-format-on-save t)
'';
};
programs.emacs.init.usePackage.cargo = {
enable = true;
defer = true;
};
programs.emacs.init.usePackage.racer = {
enable = true;
defer = true;
hook =
[
''(racer-mode . (lambda () (eldoc-mode)))''
]
++ optional (elem "emacs::company" config.machine.pkgs) ''(racer-mode . (lambda () (company-mode)))'';
config = ''
(setq racer-rust-src-path "${rustEnv}/lib/rustlib/src/rust/src")
(setq racer-cmd "${rustEnv}/bin/racer")
'';
};
}

12
pkgsets/emacs/solarized-theme.nix
View file

@ -1,12 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::solarized-theme" config.machine.pkgs) {
programs.emacs.init.usePackage.solarized-theme = {
enable = true;
config = "(load-theme 'solarized-dark t)";
};
}

17
pkgsets/emacs/telega.nix
View file

@ -1,17 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::telega" config.machine.pkgs) {
programs.emacs.init.usePackage.telegram = {
enable = true;
defer = true;
package = epkgs: [epkgs.telega epkgs.visual-fill-column];
command = ["telega"];
config = ''
(telega-alert-mode 1)
'';
};
}

50
pkgsets/emacs/transmission.nix
View file

@ -1,50 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::transmission" config.machine.pkgs) {
programs.emacs.init.usePackage = {
transmission = {
enable = true;
defer = true;
command = ["transmission"];
bindLocal = {
transmission-mode-map = {
"A" = '' (lambda ()
(interactive)
(transmission-add (read-string "Magnet URI: ")))'';
};
};
config = ''
;; Auto refresh for all transmission buffers
(setq transmission-refresh-modes '(transmission-mode
transmission-files-mode
transmission-info-mode
transmission-peers-mode))
(defun transmission ()
"Open a `transmission-mode' buffer."
(interactive)
(let* ((name "*transmission*")
(buffer (or (get-buffer name)
(generate-new-buffer name))))
(transmission-turtle-poll)
(unless (eq buffer (current-buffer))
(with-current-buffer buffer
(unless (eq major-mode 'transmission-mode)
(condition-case e
(progn
(transmission-mode)
(revert-buffer)
(goto-char (point-min)))
(error
(kill-buffer buffer)
(signal (car e) (cdr e))))))
(switch-to-buffer buffer))))
'';
};
};
}

18
pkgsets/emacs/undo-tree.nix
View file

@ -1,18 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::undo-tree" config.machine.pkgs) {
programs.emacs.init.usePackage.undo-tree = {
enable = true;
hook = ["(after-init . global-undo-tree-mode)"];
config = ''
(setq undo-tree-visualizer-diff 't)
(setq undo-tree-auto-save-history 't)
(setq undo-tree-enable-undo-in-region 't)
(setq undo-tree-history-directory-alist '(("." . "~/.emacs_undo")))
'';
};
}

100
pkgsets/emacs/web-mode.nix
View file

@ -1,100 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::web-mode" config.machine.pkgs) {
programs.emacs.init.usePackage = {
web-mode = {
enable = true;
init = "(require 'sgml-mode)";
hook = [
"(web-mode . (lambda () (sgml-electric-tag-pair-mode)))"
''
(web-mode . (lambda ()
(when (and (buffer-file-name)
(equal (file-name-extension (buffer-file-name)) "svelte"))
(lsp))))
''
];
# bind = {};
mode = [
''("\\.html\\'" . web-mode)''
''("\\.css\\'" . web-mode)''
''("\\.html?\\'" . web-mode)''
''("\\.svelte\\'" . web-mode)''
''("\\.phtml\\'" . web-mode)''
''("\\.tpl\\.php\\'" . web-mode)''
''("\\.[agj]sp\\'" . web-mode)''
''("\\.as[cp]x\\'" . web-mode)''
''("\\.erb\\'" . web-mode)''
''("\\.mustache\\'" . web-mode)''
''("\\.djhtml\\'" . web-mode)''
];
config = ''
(setq web-mode-markup-indent-offset 2)
(setq web-mode-css-indent-offset 2)
(setq web-mode-code-indent-offset 2)
(setq web-mode-sql-indent-offset 2)
(setq web-mode-script-padding 2)
(setq web-mode-style-padding 2)
(setq web-mode-part-padding 2)
(setq web-mode-block-padding 2)
(setq web-mode-enable-comment-annotation 't)
(setq web-mode-enable-current-element-highlight 't)
(setq web-mode-enable-sql-detection 't)
(setq web-mode-auto-close-style 2)
(setq web-mode-engines-alist
'(("php" . "\\.phtml\\'")
("blade" . "\\.blade\\."))
)
'';
};
js2-mode = {
enable = true;
mode = [
''("\\.js\\'" . js2-mode)''
];
};
typescript-mode = {
enable = true;
hook =
["(typescript-mode . (lambda () (subword-mode)))"]
++ lib.optional (elem "emacs::lsp" config.machine.pkgs)
''(typescript-mode . (lambda () (lsp)))'';
mode = [
''("\\.ts\\'" . typescript-mode)''
''("\\.tsx?\\'" . typescript-tsx-mode)''
];
init = ''
(define-derived-mode typescript-tsx-mode typescript-mode "tsx")
'';
config = ''
(setq typescript-indent-level 2)
'';
};
# https://github.com/NixOS/nixpkgs/pull/150239
tree-sitter = {
enable = true;
package = epkgs: [epkgs.tree-sitter (epkgs.tree-sitter-langs.withPlugins (p: epkgs.tree-sitter-langs.plugins ++ [p.tree-sitter-markdown p.tree-sitter-tsx]))];
hook = [
"(typescript-mode . tree-sitter-hl-mode)"
"(typescript-tsx-mode . tree-sitter-hl-mode)"
];
config = ''
(tree-sitter-require 'tsx)
(add-to-list 'tree-sitter-major-mode-language-alist '(typescript-tsx-mode . tsx))
'';
};
impatient-mode = {
enable = true;
};
simple-httpd = {
enable = true;
};
};
}

14
pkgsets/emacs/yaml-mode.nix
View file

@ -1,14 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::yaml-mode" config.machine.pkgs) {
programs.emacs.init.usePackage = {
yaml-mode = {
enable = true;
};
};
}

21
pkgsets/emacs/yasnippet.nix
View file

@ -1,21 +0,0 @@
{
config,
lib,
pkgs,
...
}:
with lib;
mkIf (elem "emacs::yasnippet" config.machine.pkgs) {
programs.emacs.init.usePackage = {
yasnippet = {
enable = true;
hook = ["(after-init . yas-global-mode)"];
# config = ''
# '';
};
yasnippet-snippets = {
enable = true;
};
};
}

12
pkgsets/emacs/yuck-mode.nix
View file

@ -1,12 +0,0 @@
{
config,
lib,
...
}:
with lib;
mkIf (elem "emacs::yuck-mode" config.machine.pkgs) {
programs.emacs.init.usePackage.yuck-mode = {
enable = true;
mode = [''"\\.yuck\\'"''];
};
}