Fixes #1986: evil-open-fold fails to open folds in deeply nested outline/org headers

This commit fixes an issue in evil-mode where, in outline-mode or
org-mode, attempting to open a folded section (zo) fails when the cursor
is inside a deeply nested header. Previously, the fold would either not
expand or expand incorrectly, leaving the nested content hidden and
making navigation and editing of deeply nested structures difficult.

Author: jamescherti

evil-vars.el

@@ -1842,10 +1842,70 @@ Elements have the form (NAME . FUNCTION).")
      :close-all  ,(lambda ()
                     (with-no-warnings (hide-sublevels 1)))
      :toggle     outline-toggle-children
-     :open       ,(lambda ()
-                    (with-no-warnings
-                      (show-entry)
-                      (show-children)))
+     :open
+     ,(lambda ()
+        (save-excursion
+          (let (;; Invisible
+                (func-invisible-p
+                 (cond
+                  ;; `org-mode'
+                  ((and (derived-mode-p 'org-mode)
+                        (fboundp 'org-invisible-p))
+                   #'org-invisible-p)
+
+                  ;; `outline-mode' and `outline-minor-mode'
+                  ((and (or (derived-mode-p 'outline-mode)
+                            (bound-and-true-p outline-minor-mode))
+                        (fboundp 'outline-invisible-p))
+                   #'outline-invisible-p)))
+
+                ;; Back to heading
+                (func-back-to-heading
+                 (cond
+                  ;; `org-mode'
+                  ((and (derived-mode-p 'org-mode)
+                        (fboundp 'org-back-to-heading))
+                   #'org-back-to-heading)
+
+                  ;; `outline-mode' and `outline-minor-mode'
+                  ((and (or (derived-mode-p 'outline-mode)
+                            (bound-and-true-p outline-minor-mode))
+                        (fboundp 'outline-back-to-heading))
+                   #'outline-back-to-heading))))
+            (if (not (and func-back-to-heading
+                          func-invisible-p))
+                (with-no-warnings
+                  (show-entry)
+                  (show-children))
+              ;; Repeatedly reveal children and body until the entry is no
+              ;; longer folded
+              (condition-case nil
+                  (let ((header-visible (save-excursion
+                                          (funcall func-back-to-heading t)
+                                          (not (funcall func-invisible-p
+                                                        (point))))))
+                    ;; Repeatedly reveal children and body until the
+                    ;; entry is no longer folded
+                    (while (save-excursion
+                             ;; Folded?
+                             (funcall func-back-to-heading)
+                             (end-of-line)
+                             (funcall func-invisible-p (point)))
+                      (save-excursion
+                        (funcall func-back-to-heading)
+                        (with-no-warnings
+                          (show-children)
+                          (show-entry))))
+
+                    ;; If the header was previously hidden, hide the subtree to
+                    ;; collapse it. Otherwise, leave the fold open. This allows
+                    ;; the user to decide whether to expand the content under
+                    ;; the cursor.
+                    (unless header-visible
+                      (outline-hide-subtree)))
+                ;; Ignore the `outline-back-to-heading' error
+                (outline-before-first-heading
+                 nil))))))
      :open-rec   show-subtree
      :close      hide-subtree)
     ((origami-mode)