Leo (text editor)
|Developer(s)||Edward K. Ream, et al.|
5.8 / September 30, 2018
|Type||Text editor, Outliner, IDE|
Leo (Leonine Editor with Outlines) is an open-source text editor/outliner that features clones (virtual copies of outline nodes) as its central tool of organization, navigation, customization and scripting.
Leo can manipulate text or code in any human or computer programming language (e.g., Python, C, C++, Java), as Leo is a language-independent or "adaptable LPE" (literate programming environment). Syntax highlighting is provided for many different programming languages. Leo is written in Python and can be extended with plugins written in Python. The GUI uses the Qt toolkit; the syntax-aware editor is based on Scintilla. Leo outlines are stored as XML files.
Trees, clones and views
Leo's foremost functionality, in addition to text editing, is that of an outliner, with a "vast range of convenience features for structuring and managing outlines" both by drag-and-drop via GUI and by keyboard commands. Leo's outline pane shows a tree of data nodes. Nodes contain headlines, body text, and other information. Headlines naturally serve as descriptions of the body text. For example, @file nodes are nodes whose headline starts with @file. Leo trees are in fact directed acyclic graphs; nodes may have more than one parent. Leo calls such nodes clones. Clones appear in several places in the outline pane. Views are simply nodes whose children contain clones. A single outline may contain arbitrarily many views of the nodes contained therein.
@file nodes represent external files, files on the computer's file system other than the outline file. When saving an outline Leo automatically writes all changed @file trees back to the external files. Comments, called sentinel lines, in external files represent the outline structure. When Leo reads an outline, these comments allow Leo to recreate @file trees using only the data in the external file. @auto nodes represent external files without using sentinel comments. When reading @auto nodes, Leo uses the program structure of the external file to create the @auto tree.
Leo's outline or hierarchical structure is distinct from the web of interleaved program and documentation "chunks" associated with classic literate programming tools. The body text of any Leo node may contain a Leo script, a Python script executed in the context of a Leo outline. A simple API gives Leo scripts full access to all data in loaded outlines, as well as full access to Leo's own source code. The API includes Python iterators that allow scripts to traverse outlines easily. Scripts may be composed of any tree of nodes. A markup language similar to noweb tells Leo how to create scripts from (parts of) an outline. Headlines control and guide scripts. Examples are:
- @test nodes create unit tests. Leo executes the body of an @test node as a unit test, without the body having to create an explicit subclass of Python's UnitTest.TestCase class.
- @button nodes create user-defined commands. Leo executes the script of an @button node in the context of any other outline node.
- Pieterse, Vreda; Kourie, Derrick G.; Boake, Andrew (2004). "A Case for Contemporary Literate Programming". SAICSIT ’04: Proceedings. Republic of South Africa: South African Institute for Computer Scientists and Information Technologists: 111–118. Archived from the original (PDF) on 2004. Table 2: "Some Adaptable LPEs", p. 113. Same authors' abridged version in book form: Eckstein, Jutta; Baumeister, Hubert (eds.). "Literate Programming to Enhance Agile Methods". Extreme Programming and Agile Processes in Software Engineering. Berlin; Heidelberg; New York: Springer-Verlag. pp. 250–253. ISBN 3-540-22137-9. Table 2: "Some Language Independent LPEs", p. 251
- Vestdam, Thomas; Nørmark, Kurt (September 2004). "Maintaining Program Understanding - Issues, Tools, and Future Directions". Nordic Journal of Computing. Finland. 11 (3): 303–320. ISSN 1236-6064. Archived from the original (PDF) on 2004. Retrieved 18 November 2014. Leo discussed on pp. 12-13 of author's copy of published article.
- Palmer, James Dean; Hillenbrand, Eddie (2009). "Reimagining Literate Programming". OOPSLA '09: Proceedings of the 24th ACM SIGPLAN Conference Companion on Object Oriented Programming Systems Languages and Applications. New York: ACM. pp. 1007–1014. doi:10.1145/1639950.1640072. Retrieved 19 November 2014.
A few literate programming systems have taken a much different tack based on novel user interfaces. Edward Ream’s literate editor, Leo, uses visual outlines that allow users to attach metadata and descriptions to program descriptions and data. Unfortunately, truly literate programs may break Leo’s hierarchical outline based paradigm.(p. 1009)
- Swaine, Michael (July 1998). "Programming Paradigms". Dr. Dobb's Journal. Archived from the original on 2016-04-15.Compares early version of LEO with Donald Knuth's WEB.