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

@@ -1843,9 +1843,62 @@ Elements have the form (NAME . FUNCTION).")
                     (with-no-warnings (hide-sublevels 1)))
      :toggle     outline-toggle-children
      :open       ,(lambda ()
-                    (with-no-warnings
-                      (show-entry)
-                      (show-children)))
+                    (save-excursion
+                      (let ((func-invisible-p
+                             (cond
+                              ((and (derived-mode-p 'org-mode)
+                                    (fboundp 'org-invisible-p))
+                               'org-invisible-p)
+
+                              ((and (or (derived-mode-p 'outline-mode)
+                                        (derived-mode-p 'outline-minor-mode))
+                                    (fboundp 'outline-invisible-p))
+                               'outline-invisible-p)
+
+                              (t
+                               'invisible-p)))
+                            (initial-point (point))
+                            (visual-point nil)
+                            (visual-init-point nil))
+                        ;; Unfolding loop
+                        (while (and
+                                ;; Folded?
+                                (save-excursion
+                                  (end-of-line)
+                                  (funcall func-invisible-p (point)))
+                                ;; When the real point differs from the visual
+                                ;; point, it indicates that the cursor is still
+                                ;; located within a hidden header. This prevents
+                                ;; infinite loops if the unfolding stops
+                                ;; changing the cursor position.
+                                (or
+                                 (not visual-init-point)
+                                 (not visual-point)
+                                 (/= visual-init-point visual-point)))
+
+                          (save-excursion
+                            (outline-back-to-heading)
+                            (beginning-of-line)
+                            (setq visual-point (point))
+                            (with-no-warnings
+                              (show-children))
+
+                            ;; Go back to point
+                            (goto-char initial-point)
+                            (outline-back-to-heading)
+                            (beginning-of-line)
+                            (setq visual-init-point (point))))
+
+                        ;; Previous version of `outline-show-entry'
+                        (save-excursion
+                          (outline-back-to-heading t)
+                          (outline-flag-region (1- (point))
+                                               (progn
+                                                 (outline-next-preface)
+                                                 (if (= 1 (- (point-max) (point)))
+                                                     (point-max)
+                                                   (point)))
+                                               nil)))))
      :open-rec   show-subtree
      :close      hide-subtree)
     ((origami-mode)