What is Origami?

A text folding minor mode for Emacs.

With this minor mode enabled, you can collapse and expand regions of text.

The actual buffer contents are never changed in any way. This works by using overlays to affect how the buffer is presented. This also means that all of your usual editing commands should work with folded regions. For example killing and yanking folded text works as you would expect.

There are many commands provided to make expanding and collapsing text convenient.

What does it look like?

How do I install it?

The easiest way is to just use MELPA. For manual installation:

Firstly, origami requires the following dependencies:

• https://github.com/magnars/dash.el
• https://github.com/magnars/s.el

You should install these anyway, they make working with elisp much more comfortable.

Drop this package somewhere on your load-path or

(add-to-list 'load-path (expand-file-name "/path/to/origami.el/"))

Then

(require 'origami)

In a buffer run M-x origami-mode, and start experimenting with any of the supplied origami interactive functions. I recommend binding these to keys of your choice in the origami-mode-map.

This has been tested on Emacs 24.3 and 24.4.

What can it do?

Origami works by parsing the buffer to determine a fold structure. (Currently there is only support for determining the fold structure using a parser.)

The following commands are supplied to manipulate folds in the buffer:

origami-open-node	Open a fold node.
origami-open-node-recursively	Open a fold node and all of its children.
origami-show-node	Like origami-open-node but also opens parent fold nodes recursively so as to ensure the position where point is is visible.
origami-close-node	Close a fold node.
origami-close-node-recursively	Close a fold node and all of its children.
origami-toggle-node	Toggle open or closed a fold node.
origami-forward-toggle-node	Search forward on this line for a node and toggle it open or closed. This makes toggling nodes much more convenient.
origami-recursively-toggle-node	Acts like org-mode header collapsing. Cycle a fold between open, recursively open, closed.
origami-open-all-nodes	Open every fold in the buffer.
origami-close-all-nodes	Close every fold in the buffer.
origami-toggle-all-nodes	Toggle open/closed every fold node in the buffer.
origami-show-only-node	Close everything but the folds necessary to see the point. Very useful for concentrating on an area of code.
origami-previous-fold	Move to the previous fold.
origami-next-fold	Move to the next fold.
origami-undo	Undo the last folding operation.
origami-redo	Redo the last undone folding operation.
origami-reset	Remove all folds from the buffer and reset all origami state. Useful if origami messes up!

Does it support my favourite major-mode?

Probably not. Currently out of the box support is provided for:

• C
• C++
• Clojure
• Java
• Javascript
• Perl
• elisp
• Go
• PHP

It should be trivial to add support for any language that uses braces to delimit blocks. Just add to origami-parser-alist something like: (mode-name . origami-c-style-parser). Adding support for another lisp dialect should be almost as simple.

I'm happy to work on parsers for other languages if enough interest is expressed.

It should be fairly easy to write a parser. An origami parser is a function that takes a 'create function' and returns a function taking the string to be parsed. The returned function should return a list of fold nodes. Fold nodes are created using the passed-in create function. Best to use an example:

 (defun my-amazing-parser (create)
   (lambda (content)
     (list (funcall create beginning-of-the-fold-node-point-position ; inclusive
                           end-of-the-fold-node-point-position ; exclusive
                           offset  ; this allows you to show some of the start of the folded text
                           child-nodes))))

How is this different from yafolding?

I wasn't aware of yafolding before writing this. It looks like origami provides a richer set of functions for manipulating folds. It is also smarter about folding for the supported modes - yafolding uses indentation as a folding heuristic.

How is this different from hideshow?

Again, origami provides a much richer set of functions for manipulating folds. I looked at extending hideshow but gave up when I realised it kept all of its state in the buffer overlays. This makes it quite difficult to write some of the more complex fold manipulations.

Origami maintains a data structure representing the folds and provides a rich library of functions for manipulating it. This makes adding new folding operations easy.

How is this different from folding.el?

Folding.el uses markers in the buffer to annotate folds. It should be very easy to add support for this to origami if anyone is looking for this feature?

How is this different from folding implemented by a specific mode?

It's general purpose and concentrates only on providing a decent folding solution. You need only write a parser for origami to get all of its folding features for free.