1 files changed, 156 insertions, 0 deletions
diff --git a/overlays/patches/emacs/overlay/parse.nix b/overlays/patches/emacs/overlay/parse.nix
new file mode 100644
index 000000000000..d17ee7bfb195
--- /dev/null
+++ b/overlays/patches/emacs/overlay/parse.nix
@@ -0,0 +1,156 @@
+{ pkgs, lib }:
+
+let
+  inherit (import ./repos/fromElisp { inherit pkgs; }) fromElisp fromOrgModeBabelElisp';
+
+  isStrEmpty = s: (builtins.replaceStrings [ " " ] [ "" ] s) == "";
+
+  splitString = _sep: _s: builtins.filter
+    (x: builtins.typeOf x == "string")
+    (builtins.split _sep _s);
+
+  # Parse (all) Package-Requires packageElisp headers found in the input string
+  # `packageElisp` into a list of package name strings.
+  #
+  # Example inputs:
+  #
+  #  ;; Package-Requires: ()
+  #  => [ ]
+  #  ;; Package-Requires: ((dash "2.12.1") (pkg-info "0.4") (let-alist "1.0.4") (seq "1.11") (emacs "24.3"))
+  #  => [ "dash" "pkg-info" "let-alist" "seq" "emacs" ]
+  #  ;; Package-Requires: (dash (pkg-info "0.4"))
+  #  => [ "dash" "pkg-info" ]
+  #  ;; Package-Requires: ((dash) (pkg-info "0.4"))
+  #  => [ "dash" "pkg-info" ]
+  parsePackagesFromPackageRequires = packageElisp:
+    let
+      lines = splitString "\r?\n" packageElisp;
+      requires =
+        lib.concatMapStrings
+          (line:
+            let match = builtins.match ";;;* *[pP]ackage-[rR]equires *: *\\((.*)\\) *" line;
+            in if match == null then "" else builtins.head match)
+          lines;
+      parseReqList = s:
+        let matchAndRest = builtins.match " *\\(? *([^ \"\\)]+)( +\"[^\"]+\" *\\)| *\\))?(.*)" s;
+        in
+        if isStrEmpty s then
+          [ ]
+        else
+          if matchAndRest == null then
+            throw "Failed to parse package requirements list: ${s}"
+          else
+            [ (builtins.head matchAndRest) ] ++ (parseReqList (builtins.elemAt matchAndRest 2));
+    in
+    parseReqList requires;
+
+  # Get a list of packages declared wanted with `use-package` in the
+  # input string `config`. The goal is to only list packages that
+  # would be installed by `use-package` on evaluation; thus we look at
+  # the `:ensure` and `:disabled` keyword values to attempt to figure
+  # out which and whether the package should be installed.
+  #
+  # Example input:
+  #
+  # ''
+  #   (use-package org
+  #     :commands org-mode
+  #     :bind (("C-c a" . org-agenda)
+  #            :map org-mode-map
+  #            ([C-right] . org-demote-subtree)
+  #            ([C-left] . org-promote-subtree)))
+  #
+  #   (use-package direnv
+  #     :ensure t
+  #     :config (direnv-mode))
+  #
+  #   (use-package paredit-mode
+  #     :ensure paredit
+  #     :hook (emacs-lisp-mode lisp-mode lisp-interaction-mode))
+  # ''
+  # => [ "direnv" "paredit" ]
+  parsePackagesFromUsePackage = {
+    configText
+    , alwaysEnsure ? false
+    , isOrgModeFile ? false
+    , alwaysTangle ? false
+  }:
+    let
+      readFunction =
+        if isOrgModeFile then
+          fromOrgModeBabelElisp' { ":tangle" = if alwaysTangle then "yes" else "no"; }
+        else
+          fromElisp;
+
+      find = item: list:
+        if list == [] then [] else
+          if builtins.head list == item then
+            list
+          else
+            find item (builtins.tail list);
+
+      getKeywordValue = keyword: list:
+        let
+          keywordList = find keyword list;
+        in
+          if keywordList != [] then
+            let
+              keywordValue = builtins.tail keywordList;
+            in
+              if keywordValue != [] then
+                builtins.head keywordValue
+              else
+                true
+          else
+            null;
+
+      isDisabled = item:
+        let
+          disabledValue = getKeywordValue ":disabled" item;
+        in
+          if disabledValue == [] then
+            false
+          else if builtins.isBool disabledValue then
+            disabledValue
+          else if builtins.isString disabledValue then
+            true
+          else
+            false;
+
+      getName = item:
+        let
+          ensureValue = getKeywordValue ":ensure" item;
+          usePackageName = builtins.head (builtins.tail item);
+        in
+          if builtins.isString ensureValue then
+            if lib.hasPrefix ":" ensureValue then
+              usePackageName
+            else
+              ensureValue
+          else if ensureValue == true || (ensureValue == null && alwaysEnsure) then
+            usePackageName
+          else
+            [];
+
+      recurse = item:
+        if builtins.isList item && item != [] then
+          let
+            packageManager = builtins.head item;
+          in
+            if builtins.elem packageManager [ "use-package" "leaf" ] then
+              if !(isDisabled item) then
+                [ packageManager (getName item) ] ++ map recurse item
+              else
+                []
+            else
+              map recurse item
+        else
+          [];
+    in
+      lib.flatten (map recurse (readFunction configText));
+
+in
+{
+  inherit parsePackagesFromPackageRequires;
+  inherit parsePackagesFromUsePackage;
+}