From d58014d81b6e67ed411012c0e4f35477c07547da Mon Sep 17 00:00:00 2001
From: Sylvain Laperche <sylvain.laperche@gmail.com>
Date: Thu, 3 May 2018 19:12:10 +0200
Subject: [PATCH] Implement forward versions for open and close

This already exists for the toggle methods and it's quite convenient.
This commit reproduce this behavior for:
- `origami-open-node'
- `origami-open-node-recursively'
- `origami-close-node'
- `origami-close-node-recursively'
---
 origami.el | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/origami.el b/origami.el
index b9667fd..ac5cc5f 100644
--- a/origami.el
+++ b/origami.el
@@ -533,6 +533,19 @@ will be the deepest nested at POINT."
                                            (origami-fold-assoc path (lambda (node)
                                                                       (origami-fold-open-set node t))))))))
 
+(defun origami-forward-open-node (buffer point)
+  "Like `origami-open-node' but search forward in BUFFER for a
+fold node. If a closed fold node is found after POINT and before
+the next line break, it will be opened. Otherwise, behave exactly
+as `origami-open-node'."
+  (interactive (list (current-buffer) (point)))
+  (-when-let (tree (origami-get-fold-tree buffer))
+    (-when-let (path (origami-search-forward-for-path buffer point))
+      (origami-apply-new-tree buffer tree (origami-store-cached-tree
+                                           buffer
+                                           (origami-fold-assoc path (lambda (node)
+                                                                      (origami-fold-open-set node t))))))))
+
 (defun origami-open-node-recursively (buffer point)
   "Open the fold node and all of its children at POINT in BUFFER.
 The fold node opened will be the deepest nested at POINT."
@@ -548,6 +561,23 @@ The fold node opened will be the deepest nested at POINT."
                                                               (origami-fold-open-set node t))
                                                             node))))))))
 
+(defun origami-forward-open-node-recursively (buffer point)
+  "Like `origami-open-node-recursively' but search forward in BUFFER
+for a fold node. If a closed fold node is found after POINT and before
+the next line break, it will be opened and its children as well.
+Otherwise, behave exactly as `origami-open-node-recursively'."
+  (interactive (list (current-buffer) (point)))
+  (-when-let (tree (origami-get-fold-tree buffer))
+    (-when-let (path (origami-search-forward-for-path buffer point))
+      (origami-apply-new-tree
+       buffer tree (origami-store-cached-tree
+                    buffer
+                    (origami-fold-assoc path
+                                        (lambda (node)
+                                          (origami-fold-map (lambda (node)
+                                                              (origami-fold-open-set node t))
+                                                            node))))))))
+
 (defun origami-show-node (buffer point)
   "Like `origami-open-node' but also opens parent fold nodes
 recursively so as to ensure the position where POINT is is
@@ -574,6 +604,20 @@ will be the deepest nested at POINT."
                                             path (lambda (node)
                                                    (origami-fold-open-set node nil))))))))
 
+(defun origami-forward-close-node (buffer point)
+  "Like `origami-close-node' but search forward in BUFFER for a
+fold node. If an opened fold node is found after POINT and before
+the next line break, it will be closed. Otherwise, behave exactly
+as `origami-close-node'."
+  (interactive (list (current-buffer) (point)))
+  (-when-let (tree (origami-get-fold-tree buffer))
+    (-when-let (path (origami-search-forward-for-path buffer point))
+      (origami-apply-new-tree buffer tree (origami-store-cached-tree
+                                           buffer
+                                           (origami-fold-assoc
+                                            path (lambda (node)
+                                                   (origami-fold-open-set node nil))))))))
+
 (defun origami-close-node-recursively (buffer point)
   "Close the fold node and all of its children at POINT in BUFFER.
 The fold node closed will be the deepest nested at POINT."
@@ -589,6 +633,23 @@ The fold node closed will be the deepest nested at POINT."
                                                               (origami-fold-open-set node nil))
                                                             node))))))))
 
+(defun origami-forward-close-node-recursively (buffer point)
+  "Like `origami-close-node-recursively' but search forward in BUFFER
+for a fold node. If an opened fold node is found after POINT and before
+the next line break, it will be opened and its children as well.
+Otherwise, behave exactly as `origami-close-node-recursively'."
+  (interactive (list (current-buffer) (point)))
+  (-when-let (tree (origami-get-fold-tree buffer))
+    (-when-let (path (origami-search-forward-for-path buffer point))
+      (origami-apply-new-tree
+       buffer tree (origami-store-cached-tree
+                    buffer
+                    (origami-fold-assoc path
+                                        (lambda (node)
+                                          (origami-fold-map (lambda (node)
+                                                              (origami-fold-open-set node nil))
+                                                            node))))))))
+
 (defun origami-toggle-node (buffer point)
   "Toggle the fold node at POINT in BUFFER open or closed. The
 fold node opened or closed will be the deepest nested at POINT."