Move pkgsets folder into project root to conform with option naming.

Add simple package filter to auto remove broken packages.

pkgsets/emacs/company.nix

@@ -0,0 +1,167 @@
+{ 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;
+      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)))))'';
+      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.fonts = pkgs.emacs-all-the-icons-fonts.all;
+}

pkgsets/emacs/doom-modeline.nix

@@ -0,0 +1,21 @@
+{ 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)
+'';
+  };
+}

pkgsets/emacs/doom-themes.nix

@@ -0,0 +1,16 @@
+{ 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)"}
+    '';
+  };
+}

pkgsets/emacs/elpy.nix

@@ -0,0 +1,36 @@
+{ 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-mypy t)
+        (flycheck-add-next-checker 'python-mypy 'python-flake8 t)''}
+    '';
+  };
+}

pkgsets/emacs/fcitx.nix

@@ -0,0 +1,16 @@
+{ 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)
+      '';
+    };
+  };
+}

pkgsets/emacs/flycheck.nix

@@ -0,0 +1,35 @@
+{ 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-irony = {
+    enable = (elem "emacs::irony" 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);
+  };
+}

pkgsets/emacs/flyspell.nix

@@ -0,0 +1,31 @@
+{ 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)
+            ))
+    '';
+  };
+}

pkgsets/emacs/latex.nix

@@ -0,0 +1,27 @@
+{ 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;
+    };
+  };
+}

pkgsets/emacs/lsp.nix

@@ -0,0 +1,56 @@
+{ 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")
+        ''}
+      '';
+    };
+
+    lsp-ui = {
+      enable = true;
+      after = [ "lsp" ];
+      command = [ "lsp-ui-mode" "lsp-ui-sideline-mode" ];
+      config = ''
+        (setq lsp-ui-sideline-enable t
+              lsp-ui-sideline-show-symbol nil
+              lsp-ui-sideline-show-hover nil
+              lsp-ui-sideline-show-code-actions t
+              lsp-ui-sideline-update-mode 'point)
+      '';
+    };
+
+    lsp-ui-flycheck = {
+      enable = true;
+      package = epkgs: [ epkgs.lsp-ui ];
+      after = [ "lsp-ui" ]
+              ++ optional (elem "emacs::flycheck" config.machine.pkgs) "flycheck";
+    };
+
+    lsp-java = {
+      enable = (elem "emacs::java" config.machine.pkgs);
+      command = [ "lsp-java-enable" ];
+      hook = [ ''
+        (java-mode . (lambda ()
+          (lsp-java-enable)
+          (lsp-ui-sideline-mode)
+          (lsp-ui-flycheck-enable t)
+          (setq-local company-backends (list 'company-lsp))))
+        '' ];
+    };
+  };
+}

pkgsets/emacs/magit.nix

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

pkgsets/emacs/mu4e.nix

@@ -0,0 +1,119 @@
+{ 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}/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}/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
+  ];
+}

pkgsets/emacs/nix-mode.nix

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

pkgsets/emacs/org.nix

@@ -0,0 +1,427 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+mkIf (elem "emacs::org" config.machine.pkgs) {
+  programs.emacs.init.usePackage.org = {
+    enable = true;
+    package = epkgs: [ epkgs.org epkgs.org-plus-contrib ];
+    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)
+       (ledger . t)
+       (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 = null;
+  };
+
+  programs.emacs.init.usePackage.ox = {
+    enable = true;
+    package = 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 = 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;
+  };
+}

pkgsets/emacs/powerline.nix

@@ -0,0 +1,16 @@
+{ 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)
+    '';
+  };
+}

pkgsets/emacs/rust.nix

@@ -0,0 +1,41 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+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 "${pkgs.rustfmt}/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 (concat (getenv "HOME")
+        "/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/"))
+      (setq racer-cmd "${pkgs.rustracer}/bin/racer")
+    '';
+  };
+}

pkgsets/emacs/solarized-theme.nix

@@ -0,0 +1,10 @@
+{ 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)";
+  };
+}

pkgsets/emacs/transmission.nix

@@ -0,0 +1,47 @@
+{ 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)
+                        (transmission-draw)
+                        (goto-char (point-min)))
+                    (error
+                     (kill-buffer buffer)
+                     (signal (car e) (cdr e))))))
+              (switch-to-buffer buffer))))
+      '';
+    };
+  };
+}

pkgsets/emacs/web-mode.nix

@@ -0,0 +1,25 @@
+{ config, lib, ... }:
+
+with lib;
+
+mkIf (elem "emacs::web-mode" config.machine.pkgs) {
+  programs.emacs.init.usePackage.web-mode = {
+    enable = true;
+    mode = [
+      ''("\\.html?\\'" . 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-engines-alist
+            '(("php"    . "\\.phtml\\'")
+              ("blade"  . "\\.blade\\."))
+      )
+    '';
+  };
+}

pkgsets/emacs/yasnippet.nix

@@ -0,0 +1,18 @@
+{ 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;
+    };
+  };
+}