README.md

@@ -2,48 +2,58 @@
 <!---        THIS IS AN AUTO-GENERATED FILE        --->
 <!---  MANUAL CHANGES CAN AND WILL BE OVERWRITTEN  --->
 
-# pretty is an advanced pretty printer for Lua.
+# Pretty
+
+pretty is an advanced pretty printer for Lua.
 
 It's primarily a
-debugging tool, aiming for human readability, by detecting pattern in the input
+ debugging tool, aiming for human readability, by detecting pattern in the input
-data, and creating an output string utilizing and highlighting those patterns.
+ data, and creating an output string utilizing and highlighting those patterns.
 
 ## Code Example
 
 Setup is simple, use pretty = require 'pretty', and you're good to go.
 
-$ print(pretty( { 1, 2, 3 } ))
+```lua
-{ 1, 2, 3 }
+ > print(pretty( { 1, 2, 3 } ))
+ { 1, 2, 3 }
+
+> print(pretty( { hello = 'world', num = 42 } ))
+ {
+
+num   = 42
+hello = 'world'
 
-$ print(pretty( { hello = 'world', num = 42 } ))
-{
-    num   = 42
-    hello = 'world'
 }
 
-$ print(pretty( { abs = math.abs, max = math.max, some = function() end } ))
+> print(pretty( { abs = math.abs, max = math.max, some = function() end } ))
-{
+ {
-    abs  = builtin function (x)      ... end
+
-    max  = builtin function (x, ...) ... end
+abs  = builtin function (x)      ... end
-    some =         function ()       ... end
+max  = builtin function (x, ...) ... end
+some =         function ()       ... end
+
 }
 
-$ print(pretty( math.abs ))
+> print(pretty( math.abs ))
-builtin function (x)
+ builtin function (x)
-    -- math.abs
+
-    -- Returns the absolute value of x
+-- math.abs
+-- Returns the absolute value of x
+
+...
 
-    ...
 end
+ ```
 
 ## Motivation
 
 This project is the outcome of my frustration with existing pretty printers, and
-a desire to expand upon the pretty printer I developed for
+ a desire to expand upon the pretty printer I developed for
-Xenoterm. The original Xenoterm pretty
+ Xenoterm. The original Xenoterm pretty
-printer was much simpler than pretty - and the current is even simpler - but
+ printer was much simpler than pretty - and the current is even simpler - but
-the enhancements I make, when compared to other pretty printers, inspired me to
+ the enhancements I make, when compared to other pretty printers, inspired me to
-create pretty.
+ create pretty.
 
 pretty sorts it's priorities like so:
 
@@ -52,47 +62,209 @@ Lua-compatible output.
 Customization.
 
 I'd rather have good defaults than provide a ton of customization options. If an
-structure avoids easy representation in Lua, I'd rather extend the syntax, than
+ structure avoids easy representation in Lua, I'd rather extend the syntax, than
-lose the info.
+ lose the info.
 
 Another aspect where pretty shines is in exploratory programming, when
-attempting to avoid reliance on outside documentation. The amount of information
+ attempting to avoid reliance on outside documentation. The amount of information
-pretty exposes varies by the data you are inspecting. If you're inspecting
+ pretty exposes varies by the data you are inspecting. If you're inspecting
-a list of functions, their function signatures are visible, but if you're
+ a list of functions, their function signatures are visible, but if you're
-inspecting a single function, documentation and source location may appear if
+ inspecting a single function, documentation and source location may appear if
-available.
+ available.
 
 ## Features
 
-Written in good-old pure-blood Lua, with support for PUC Lua 5.0+ and LuaJIT 2.0+.
+Written in good-old pureblood Lua, with support for PUC Lua 5.0+ and
-Redefining what it means to be "human readable":
-Is multi-line centric, to aid readability.
-Indention and alignment of keys-value pairs.
-Keys-value pairs are
-    alpha-numerically sorted by key
-    type and thereafter alphabetically.
-The format and structure of output changes depending upon the input.  Maps
-    appear differently to deeply nested tables to long sequences with short
-    strings to short lists.
-Uses the standard debug library to gain information about functions and
-    other advanced structures.
 
-## Installation
+
+LuaJIT 2.0+.
+
+
+Redefining what it means to be "human readable":
+
+
+*    Is multi-line centric, to aid readablitiy.
+*    Indention and alignment of keys-value pairs.
+*    Keys-value pairs are [properly](http://www.davekoelle.com/alphanum.html)
+    sorted by key type and thereafter alphabetically.
+*    The format and structure of output changes depending upon the input.
+    Maps appear differently to deeply nested tables to long sequences
+    with short strings to short lists.
+*    Uses the standard debug library to gain information about functions
+    and other advanced structures.
+
+Installation
 
 pretty is loadable directly with require. Either clone or download this
-repository. Where you place it, depends upon what you want to do:
+ repository. Where you place it, depends upon what you want to do:
 
 **You want pretty in a specific project**: Place the pretty folder
-    somewhere in your project, and require it from one of your project files.
-**You want pretty on your system**: Place the pretty folder such that
-    it's visible from your Lua-path. On my system this might be
-    /usr/local/share/lua/5.1/. Now you can require it from anywhere.
 
-## API Documentation
+
+somewhere in your project, and require it from one of your project files.
+
+
+**You want pretty on your system**: Place the pretty folder such that
+
+
+it's visible from your Lua-path. On my system this might be
+/usr/local/share/lua/5.1/. Now you can require it from anywhere.
+
+API Documentation
 
 pretty exposes a single function, the pretty function itself. It's function
-signature is pretty(value, options). value can be any Lua value. options
+ signature is pretty(value, options). value can be any Lua value. options
-must be a table.
+ must be a table.
+
+### List of options
+
+pretty is sure to complain if you give it an unknown option, or if you give an
+ option a bad value.
+
+indent: string: The string to indent with. Four spaces by default.
+
+## TODO
+
+Tasks to be done before pretty can be called version 1.0.0, in order of
+ priority:
+
+Add a dedicated unicode submodule, to handle some minor alignment and
+
+
+character escaping issues. pretty should escape all malformed unicode
+sequences.
+
+
+Align numbers towards right for tabular views.
+Add support for setmetatable, and exploring values in metatables.
+Provide nice formatting for cdata datatype in LuaJIT.
+Find a better name than pretty.
+Enhance internal structure some amount. See TODO markers in files.
+
+It would be nice to have the following, but these are secondary:
+
+Add option for colored output. Primarily syntax highlighting, but also
+
+
+[BlueJ-style](www.bluej.org/about.html) scope highlighting, with some faint
+background colors.
+
+
+Expand on the comment output in output, for __tostring methods, and global
+
+
+namespaces like io or math.
+
+
+Fit output within a predefined width limit. Default to 80.
+Look into tool for understanding complex structures with recursive
+
+
+definitions. Whatever modes are thought up, they should be automatic modes,
+not an options. Should at least include modes for self-referential tables
+and Directed-Acyclic-Graphs.
+
+Alternative pretty printers
+
+pretty is large, slow, and requires the debug library to work. It's not
+ designed for serialization purposes, nor is it concerned with offering the same
+ level of customization as other libraries do.
+
+If you want a sleek, fast, customizable or embeddable library, there are
+ thankfully other options.
+
+inspect.lua: One of the classic debugging
+
+
+pretty printers.
+
+
+pprint.lua: Reimplementation of inspect.lua
+serpent: Advanced and fast pretty printer.
+pluto: Can serialize arbitrary parts of
+
+
+Lua, including functions, upvalues, and proper lexical scoping. Not written
+in native Lua.
+
+
+binser: Library for special purpose
+
+
+serialization.
+
+
+Even more are available at the lua-users wiki.
+
+## Thoughts on displaying tables in an intuitive way.
+
+Lua's table data-structure is likely to be the most concise data structure ever
+ invented. (If not, please send me a link!) Lists, maps, objects, classes,
+ proxies, etc. This obviously brings about it some difficulty when attempting to
+ represent these tables. What do we want to highlight, and what do we choose to
+ avoid?
+
+One notable issue is whether to show every key that a table answers (to lift
+ some Smalltalk terms) to, or to just display those it contains. That is, do we
+ think about __index in the table's metatable and what it returns, or do we
+ ignore __index? For cases where __index is a function, we cannot say
+ anything about the keys that the table answers to. If __index is a table, we
+ have a better idea, but it would be cluttered to display both types of keys side
+ by side.
+
+Native representation: Lua's native representation includes the type and
+
+
+address of the table. It allows for distinguishing between unique tables,
+but won't tell us anything about the contents.
+
+
+Omission: By representing tables as the pseudo-parsable {...}, it's
+
+
+clear we are talking about a table. We disregard the ability to
+distinguish between tables.
+
+
+2A. If the table is empty, we could represent it as {}. But what if the table
+
+
+has a metatable with __index defined? We could continue to represent it as
+{}, but {...} would be more "honest".
+
+
+Single-line: TODO
+Multi-line: TODO
+Columns: For some highly-regular structures, like lists of short strings,
+
+
+giving each string it's own line would be too long, but formatting them as a
+single-line list would be too cluttered. Thus we can take inspiration from
+the classic ls unix tool, and place the output into columns, to help guide
+the eyes.
+
+
+Tabular: Other structures are formatted like actual tables of data, e.g. a
+
+
+sequence of tuples, like one would see in an SQL database. For these
+structures it's an obvious choice to align them based on the keys.
+
+
+Pseudo-Tabular: Some structures are almost tabular, e.g. they are sequences
+
+
+of tuples, but some of the tuples differ in their structure. For these
+structures it's still useful to tabulate the keys that all tuples share. To
+do this we should sort the key order descending by the number of tuples with
+the key.
+But what do we do about the the outlier keys? We can either justify the
+entire table, and give specific spots for the outlier keys, thereby
+significantly increasing the size of the table, or we can leave the table
+unjustified, abandoning it's eye-guiding attributes.
+
+
+Special cases: (Array-tree, Table-Tree, Linked-List, Predictive Sequences) TODO
 
 
 

pretty.lua

@@ -1,206 +1,205 @@
---[[--
+--- Pretty
-
+--
-# Pretty
+-- `pretty` is an advanced pretty printer for [Lua](lua.org). It's primarily a
-
+-- debugging tool, aiming for human readability, by detecting pattern in the input
-`pretty` is an advanced pretty printer for [Lua](https://lua.org). It's primarily a
+-- data, and creating an output string utilizing and highlighting those patterns.
-debugging tool, aiming for human readability, by detecting pattern in the input
+--
-data, and creating an output string utilizing and highlighting those patterns.
+-- ## Code Example
-
+--
-## Code Example
+-- Setup is simple, use `pretty = require 'pretty'`, and you're good to go.
-
+--
-Setup is simple, use `pretty = require 'pretty'`, and you're good to go.
+-- ```lua
-
+-- > print(pretty( { 1, 2, 3 } ))
-```lua
+-- { 1, 2, 3 }
-$ print(pretty( { 1, 2, 3 } ))
+--
-{ 1, 2, 3 }
+-- > print(pretty( { hello = 'world', num = 42 } ))
-
+-- {
-$ print(pretty( { hello = 'world', num = 42 } ))
+-- 	num   = 42
-{
+-- 	hello = 'world'
-    num   = 42
+-- }
-    hello = 'world'
+--
-}
+-- > print(pretty( { abs = math.abs, max = math.max, some = function() end } ))
-
+-- {
-$ print(pretty( { abs = math.abs, max = math.max, some = function() end } ))
+-- 	abs  = builtin function (x)      ... end
-{
+-- 	max  = builtin function (x, ...) ... end
-    abs  = builtin function (x)      ... end
+-- 	some =         function ()       ... end
-    max  = builtin function (x, ...) ... end
+-- }
-    some =         function ()       ... end
+--
-}
+-- > print(pretty( math.abs ))
-
+-- builtin function (x)
-$ print(pretty( math.abs ))
+--     -- math.abs
-builtin function (x)
+-- 	-- Returns the absolute value of x
-    -- math.abs
+--
-    -- Returns the absolute value of x
+-- 	...
-
+-- end
-    ...
+-- ```
-end
+--
-```
+-- ## Motivation
-
+--
-## Motivation
+-- This project is the outcome of my frustration with existing pretty printers, and
-
+-- a desire to expand upon the pretty printer I developed for
-This project is the outcome of my frustration with existing pretty printers, and
+-- [Xenoterm](https://gitfub.space/takunomi/Xenoterm). The original Xenoterm pretty
-a desire to expand upon the pretty printer I developed for
+-- printer was much simpler than `pretty` - and the current is even simpler - but
-[Xenoterm](https://gitfub.space/takunomi/Xenoterm). The original Xenoterm pretty
+-- the enhancements I make, when compared to other pretty printers, inspired me to
-printer was much simpler than `pretty` - and the current is even simpler - but
+-- create `pretty`.
-the enhancements I make, when compared to other pretty printers, inspired me to
+--
-create `pretty`.
+-- `pretty` sorts it's priorities like so:
-
+--
-`pretty` sorts it's priorities like so:
+-- 1.	Human readability.
-
+-- 2.	Lua-compatible output.
-1.    Human readability.
+-- 3.	Customization.
-2.    Lua-compatible output.
+--
-3.    Customization.
+-- I'd rather have good defaults than provide a ton of customization options. If an
-
+-- structure avoids easy representation in Lua, I'd rather extend the syntax, than
-I'd rather have good defaults than provide a ton of customization options. If an
+-- lose the info.
-structure avoids easy representation in Lua, I'd rather extend the syntax, than
+--
-lose the info.
+-- Another aspect where `pretty` shines is in exploratory programming, when
-
+-- attempting to avoid reliance on outside documentation. The amount of information
-Another aspect where `pretty` shines is in exploratory programming, when
+-- `pretty` exposes varies by the data you are inspecting. If you're inspecting
-attempting to avoid reliance on outside documentation. The amount of information
+-- a list of functions, their function signatures are visible, but if you're
-`pretty` exposes varies by the data you are inspecting. If you're inspecting
+-- inspecting a single function, documentation and source location may appear if
-a list of functions, their function signatures are visible, but if you're
+-- available.
-inspecting a single function, documentation and source location may appear if
+--
-available.
+-- ## Features
-
+--
-## Features
+-- -	Written in good-old pureblood Lua, with support for PUC Lua 5.0+ and
-
+-- 	LuaJIT 2.0+.
-- Written in good-old pure-blood Lua, with support for PUC Lua 5.0+ and LuaJIT 2.0+.
+-- -	Redefining what it means to be "human readable":
-- Redefining what it means to be "human readable":
+-- 	*	Is multi-line centric, to aid readablitiy.
- * Is multi-line centric, to aid readability.
+-- 	*	Indention and alignment of keys-value pairs.
- * Indention and alignment of keys-value pairs.
+-- 	*	Keys-value pairs are [properly](http://www.davekoelle.com/alphanum.html)
- * Keys-value pairs are
+-- 		sorted by key type and thereafter alphabetically.
- [alpha-numerically](http://www.davekoelle.com/alphanum.html) sorted by key
+-- 	*	The format and structure of output changes depending upon the input.
- type and thereafter alphabetically.
+-- 		Maps appear differently to deeply nested tables to long sequences
- * The format and structure of output changes depending upon the input.  Maps
+-- 		with short strings to short lists.
- appear differently to deeply nested tables to long sequences with short
+-- 	*	Uses the standard `debug` library to gain information about functions
- strings to short lists.
+-- 		and other advanced structures.
- * Uses the standard `debug` library to gain information about functions and
+--
- other advanced structures.
+-- ## Installation
-
+--
-## Installation
+-- `pretty` is loadable directly with `require`. Either clone or download this
-
+-- repository. Where you place it, depends upon what you want to do:
-`pretty` is loadable directly with `require`. Either clone or download this
+--
-repository. Where you place it, depends upon what you want to do:
+-- 1.	**You want `pretty` in a specific project**: Place the `pretty` folder
-
+-- 	somewhere in your project, and `require` it from one of your project files.
-1.  **You want `pretty` in a specific project**: Place the `pretty` folder
+-- 2.	**You want `pretty` on your system**: Place the `pretty` folder such that
-somewhere in your project, and `require` it from one of your project files.
+-- 	it's visible from your Lua-path. On my system this might be
-2.  **You want `pretty` on your system**: Place the `pretty` folder such that
+-- 	`/usr/local/share/lua/5.1/`. Now you can `require` it from anywhere.
-it's visible from your Lua-path. On my system this might be
+--
-`/usr/local/share/lua/5.1/`. Now you can `require` it from anywhere.
+-- ## API Documentation
-
+--
-## API Documentation
+-- `pretty` exposes a single function, the `pretty` function itself. It's function
-
+-- signature is `pretty(value, options)`. `value` can be any Lua value. `options`
-`pretty` exposes a single function, the `pretty` function itself. It's function
+-- must be a table.
-signature is `pretty(value, options)`. `value` can be any Lua value. `options`
+--
-must be a table.
+-- ### List of options
-
+--
-### List of options
+-- `pretty` is sure to complain if you give it an unknown option, or if you give an
-
+-- option a bad value.
-`pretty` is sure to complain if you give it an unknown option, or if you give an
+--
-option a bad value.
+-- -	`indent: string`: The string to indent with. Four spaces by default.
-
+--
-- `indent: string`: The string to indent with. Four spaces by default.
+-- ## TODO
-
+--
-## TODO
+-- Tasks to be done before `pretty` can be called version 1.0.0, in order of
-
+-- priority:
-Tasks to be done before `pretty` can be called version 1.0.0, in order of
+--
-priority:
+-- -	Add a dedicated unicode submodule, to handle some minor alignment and
-
+-- 	character escaping issues. `pretty` should escape all malformed unicode
-- [ ] Add dedicated unicode submodule, to handle some minor alignment and
+-- 	sequences.
-character escaping issues. `pretty` should escape all malformed unicode
+-- -	Align numbers towards right for tabular views.
-sequences.
+-- -	Add support for `setmetatable`, and exploring values in metatables.
-- [ ] Align numbers towards right for tabular views.
+-- -	Provide nice formatting for `cdata` datatype in LuaJIT.
-- [ ] Add support for `setmetatable`, and exploring values in metatables.
+-- -	Find a better name than `pretty`.
-- [ ] Provide nice formatting for `cdata` datatype in LuaJIT.
+-- -	Enhance internal structure some amount. See `TODO` markers in files.
-- [ ] Find a better name than `pretty`.
+--
-- [ ] Enhance internal structure some amount. See `TODO` markers in files.
+-- It would be nice to have the following, but these are secondary:
-
+--
-It would be nice to have the following, but these are secondary:
+-- -	Add option for colored output. Primarily syntax highlighting, but also
-
+-- 	[BlueJ-style](www.bluej.org/about.html) scope highlighting, with some faint
-- [ ] Add option for colored output. Primarily syntax highlighting, but also
+-- 	background colors.
-[BlueJ-style](www.bluej.org/about.html) scope highlighting, with some faint
+-- -	Expand on the comment output in output, for `__tostring` methods, and global
-background colors.
+-- 	namespaces like `io` or `math`.
-- [ ] Expand on the comment output in output, for `__tostring` methods, and
+-- -	Fit output within a predefined width limit. Default to 80.
-global namespaces like `io` or `math`.
+-- -	Look into tool for understanding complex structures with recursive
-- [ ] Fit output within a predefined width limit. Default to 80.
+-- 	definitions. Whatever modes are thought up, they should be automatic modes,
-- [ ] Look into tool for understanding complex structures with recursive
+-- 	not an options. Should at least include modes for self-referential tables
-definitions. Whatever modes are thought up, they should be automatic modes, not
+-- 	and Directed-Acyclic-Graphs.
-an options. Should at least include modes for self-referential tables and
+--
-Directed-Acyclic-Graphs.
+-- ## Alternative pretty printers
-
+--
-## Alternative pretty printers
+-- `pretty` is large, slow, and requires the debug library to work. It's not
-
+-- designed for serialization purposes, nor is it concerned with offering the same
-`pretty` is large, slow, and requires the debug library to work. It's not
+-- level of customization as other libraries do.
-designed for serialization purposes, nor is it concerned with offering the same
+--
-level of customization as other libraries do.
+-- If you want a sleek, fast, customizable or embeddable library, there are
-
+-- thankfully other options.
-If you want a sleek, fast, customizable or embeddable library, there are
+--
-thankfully other options.
+-- -	[inspect.lua](github.com/kikito/inspect.lua): One of the classic debugging
-
+-- 	pretty printers.
-- [inspect.lua](github.com/kikito/inspect.lua): One of the classic debugging pretty printers.
+-- -	[pprint.lua](github.com/jagt/pprint.lua): Reimplementation of `inspect.lua`
-- [pprint.lua](github.com/jagt/pprint.lua): Reimplementation of `inspect.lua`
+-- -	[serpent](github.com/pkulchenko/serpent): Advanced and fast pretty printer.
-- [serpent](github.com/pkulchenko/serpent): Advanced and fast pretty printer.
+-- -	[pluto](lua-users.org/wiki/PlutoLibrary): Can serialize arbitrary parts of
-- [pluto](lua-users.org/wiki/PlutoLibrary): Can serialize arbitrary parts of
+-- 	Lua, including functions, upvalues, and proper lexical scoping. Not written
-Lua, including functions, upvalues, and proper lexical scoping. Not written in
+-- 	in native Lua.
-native Lua.
+-- -	[binser](github.com/bakpakin/binser): Library for special purpose
-- [binser](github.com/bakpakin/binser): Library for special purpose serialization.
+-- 	serialization.
-
+--
-Even more are available at [the lua-users wiki](lua-users.org/wiki/TableSerialization).
+-- Even more are available at [the lua-users wiki](lua-users.org/wiki/TableSerialization).
-
+--
-## Thoughts on displaying tables in an intuitive way.
+-- ## Thoughts on displaying tables in an intuitive way.
-
+--
-Lua's table data-structure is likely to be the most concise data structure ever
+-- Lua's table data-structure is likely to be the most concise data structure ever
-invented. (If not, please send me a link!) Lists, maps, objects, classes,
+-- invented. (If not, please send me a link!) Lists, maps, objects, classes,
-proxies, etc. This obviously brings about it some difficulty when attempting to
+-- proxies, etc. This obviously brings about it some difficulty when attempting to
-represent these tables. What do we want to highlight, and what do we choose to
+-- represent these tables. What do we want to highlight, and what do we choose to
-avoid?
+-- avoid?
-
+--
-One notable issue is whether to show every key that a table answers (to lift
+-- One notable issue is whether to show every key that a table answers (to lift
-some Smalltalk terms) to, or to just display those it contains. That is, do we
+-- some Smalltalk terms) to, or to just display those it contains. That is, do we
-think about `__index` in the table's metatable and what it returns, or do we
+-- think about `__index` in the table's metatable and what it returns, or do we
-ignore `__index`? For cases where `__index` is a function, we cannot say
+-- ignore `__index`? For cases where `__index` is a function, we cannot say
-anything about the keys that the table answers to. If `__index` is a table, we
+-- anything about the keys that the table answers to. If `__index` is a table, we
-have a better idea, but it would be cluttered to display both types of keys side
+-- have a better idea, but it would be cluttered to display both types of keys side
-by side.
+-- by side.
-
+--
-1.  Native representation: Lua's native representation includes the type and
+-- 1.  Native representation: Lua's native representation includes the type and
-address of the table. It allows for distinguishing between unique tables,
+--     address of the table. It allows for distinguishing between unique tables,
-but won't tell us anything about the contents.
+--     but won't tell us anything about the contents.
-2.  Omission: By representing tables as the pseudo-parsable `{...}`, it's
+-- 2.  Omission: By representing tables as the pseudo-parsable `{...}`, it's
-clear we are talking about a table. We disregard the ability to
+--     clear we are talking about a table. We disregard the ability to
-distinguish between tables.
+--     distinguish between tables.
-2.  If the table is empty, we could represent it as `{}`. But what if the table
+-- 2A. If the table is empty, we could represent it as `{}`. But what if the table
-has a metatable with `__index` defined? We could continue to represent it as
+--     has a metatable with `__index` defined? We could continue to represent it as
-`{}`, but `{...}` would be more "honest".
+--     `{}`, but `{...}` would be more "honest".
-3.  Single-line: TODO
+-- 3.  Single-line: TODO
-4.  Multi-line: TODO
+-- 4.  Multi-line: TODO
-5.  Columns: For some highly-regular structures, like lists of short strings,
+-- 5.  Columns: For some highly-regular structures, like lists of short strings,
-giving each string it's own line would be too long, but formatting them as a
+--     giving each string it's own line would be too long, but formatting them as a
-single-line list would be too cluttered. Thus we can take inspiration from
+--     single-line list would be too cluttered. Thus we can take inspiration from
-the classic `ls` unix tool, and place the output into columns, to help guide
+--     the classic `ls` unix tool, and place the output into columns, to help guide
-the eyes.
+--     the eyes.
-6.  Tabular: Other structures are formatted like actual tables of data, e.g. a
+-- 6.  Tabular: Other structures are formatted like actual tables of data, e.g. a
-sequence of tuples, like one would see in an SQL database. For these
+--     sequence of tuples, like one would see in an SQL database. For these
-structures it's an obvious choice to align them based on the keys.
+--     structures it's an obvious choice to align them based on the keys.
-7.  Pseudo-Tabular: Some structures are almost tabular, e.g. they are sequences
+-- 7.  Pseudo-Tabular: Some structures are almost tabular, e.g. they are sequences
-of tuples, but some of the tuples differ in their structure. For these
+--     of tuples, but some of the tuples differ in their structure. For these
-structures it's still useful to tabulate the keys that all tuples share. To
+--     structures it's still useful to tabulate the keys that all tuples share. To
-do this we should sort the key order descending by the number of tuples with
+--     do this we should sort the key order descending by the number of tuples with
-the key.
+--     the key.
-But what do we do about the the outlier keys? We can either justify the
+--     But what do we do about the the outlier keys? We can either justify the
-entire table, and give specific spots for the outlier keys, thereby
+--     entire table, and give specific spots for the outlier keys, thereby
-significantly increasing the size of the table, or we can leave the table
+--     significantly increasing the size of the table, or we can leave the table
-unjustified, abandoning it's eye-guiding attributes.
+--     unjustified, abandoning it's eye-guiding attributes.
-8.  Special cases: (Array-tree, Table-Tree, Linked-List, Predictive Sequences) TODO
+-- 8.  Special cases: (Array-tree, Table-Tree, Linked-List, Predictive Sequences) TODO
---]]
 
 --------------------------------------------------------------------------------
 -- Import files
 
 local import
 do
-    local this_path = ... and select('1', ...):match('.+%.') or ''
+    local thispath = ... and select('1', ...):match('.+%.') or ''
-    import = function (name, ignore_failure)  return require(this_path..name)  end
+    import = function (name, ignore_failure)  return require(thispath..name)  end
 end
 
 --------------------------------------------------------------------------------
@@ -422,10 +421,10 @@ local function attempt_to_align_into_columns (l, start_i, stop_i, nr_items_pr_ro
     assert(type(stop_i)  == 'number')
     assert(type(nr_items_pr_row) == 'number')
 
-    local column = {}
+	local column = {}
     ---
     local start_of_item_i, item_nr  =  nil, 0
-    for i = start_i, stop_i do
+	for i = start_i, stop_i do
         if type(l[i]) == 'table' and (l[i][1] == 'indent' or l[i][1] == 'seperator' or l[i][1] == 'unindent') then
             if start_of_item_i then
                 local width_of_item = width_of_strings_in_l(l, start_of_item_i, i-1)
@@ -434,12 +433,12 @@ local function attempt_to_align_into_columns (l, start_i, stop_i, nr_items_pr_ro
             end
             start_of_item_i, item_nr  =  i + 1, item_nr + 1
         end
-    end
+	end
     ---
     local width  =  nr_items_pr_row * 2 - 1  -- FIXME: Magic numbers: 2 = #', ', 1 = #' '
     for i = 1, #column do  width = width + column[i]  end
     --
-    return width, column
+	return width, column
 end
 
 local function align_into_columns (l, start_i, stop_i)
@@ -449,8 +448,8 @@ local function align_into_columns (l, start_i, stop_i)
 
     local start_i, stop_i = start_i or 1, stop_i or #l
 
-    assert(type(start_i)    == 'number')
+	assert(type(start_i)	== 'number')
-    assert(type(stop_i)    == 'number')
+	assert(type(stop_i)	== 'number')
 
     insert_alignment_estimations(l, start_i, stop_i)
 
@@ -481,7 +480,7 @@ local function align_into_columns (l, start_i, stop_i)
 
     -- Fit into columns.
     local start_of_item_i, item_nr  =  nil, 0
-    for i = start_i, stop_i do
+	for i = start_i, stop_i do
         if type(l[i]) ~= 'table' then
             -- Do nothing
         elseif (l[i][1] == 'indent' or l[i][1] == 'seperator' or l[i][1] == 'unindent') then
@@ -494,47 +493,47 @@ local function align_into_columns (l, start_i, stop_i)
             end
             start_of_item_i, item_nr  =  i + 1, item_nr + 1
         end
-    end
+	end
 end
 
 local function align_into_tabular_style (l, start_i, stop_i)
-    -- Adds alignment after separators, to create nicely aligned tabular-format.
+	-- Adds alignment after separators, to create nicely aligned tabular-format.
 
     -- Argument fixing and Error Checking
-    local start_i, stop_i = start_i or 1, stop_i or #l
+	local start_i, stop_i = start_i or 1, stop_i or #l
 
-    assert(type(l)             == 'table')
+	assert(type(l)         	== 'table')
-    assert(type(start_i)       == 'number')
+	assert(type(start_i)   	== 'number')
-    assert(type(stop_i)        == 'number')
+	assert(type(stop_i)    	== 'number')
-    assert(type(l[start_i])    == 'table' and l[start_i][1]    == 'indent')
+	assert(type(l[start_i])	== 'table' and l[start_i][1]	== 'indent')
-    assert(type(l[stop_i])     == 'table' and l[stop_i][1]     == 'unindent')
+	assert(type(l[stop_i]) 	== 'table' and l[stop_i][1] 	== 'unindent')
 
-    -- Calculate where to insert new alignment.
+	-- Calculate where to insert new alignment.
-    local indent, key_nr, index_of_last_meta, insert_later  =  0, 0, 1, {}
+	local indent, key_nr, index_of_last_meta, insert_later  =  0, 0, 1, {}
-    for i = start_i + 1, stop_i - 1 do
+	for i = start_i + 1, stop_i - 1 do
-        if type(l[i]) ~= 'table' then
+		if type(l[i]) ~= 'table' then
-            -- Do nothing
+			-- Do nothing
-        elseif l[i][1] == 'indent' then
+		elseif l[i][1] == 'indent' then
-            indent =  indent + 1
+			indent =  indent + 1
-            if indent == 1 then  key_nr = 1  end
+			if indent == 1 then  key_nr = 1  end
-            index_of_last_meta = i
+			index_of_last_meta = i
-        elseif l[i][1] == 'unindent' then
+		elseif l[i][1] == 'unindent' then
-            insert_later[#insert_later+1] = {'align', 'end_subtable_'..key_nr, width_of_strings_in_l(l, index_of_last_meta+1, i), i}
+			insert_later[#insert_later+1] = {'align', 'end_subtable_'..key_nr, width_of_strings_in_l(l, index_of_last_meta+1, i), i}
-            index_of_last_meta, key_nr  =  i, key_nr + 1
+			index_of_last_meta, key_nr  =  i, key_nr + 1
-            indent =  indent - 1
+			indent =  indent - 1
-        elseif l[i][1] == 'seperator' and indent ~= 0 then
+		elseif l[i][1] == 'seperator' and indent ~= 0 then
-            insert_later[#insert_later+1] = {'align', 'key_'..key_nr, width_of_strings_in_l(l, index_of_last_meta+1, i), i+1}
+			insert_later[#insert_later+1] = {'align', 'key_'..key_nr, width_of_strings_in_l(l, index_of_last_meta+1, i), i+1}
-            index_of_last_meta, key_nr  =  i, key_nr + 1
+			index_of_last_meta, key_nr  =  i, key_nr + 1
-        end
+		end
     end
-    -- Insert new alignment.
+	-- Insert new alignment.
-    for i = #insert_later, 1, -1 do
+	for i = #insert_later, 1, -1 do
-        local dat = insert_later[i]
+		local dat = insert_later[i]
-        table.insert(l, dat[#dat], dat)
+		table.insert(l, dat[#dat], dat)
-        dat[#dat] = nil
+		dat[#dat] = nil
-    end
+	end
-    -- Fix that alignemnt
+	-- Fix that alignemnt
-    return fix_alignment(l, start_i)
+	return fix_alignment(l, start_i)
 end
 
 local function fix_seperator_info (l, indent_char)
@@ -563,9 +562,9 @@ end
 
 --------------------------------------------------------------------------------
 
-local analyze_structure    =  import 'analyze_structure'
+local analyze_structure	=  import 'analyze_structure'
-local TABLE_TYPE           =  import 'common' . TABLE_TYPE
+local TABLE_TYPE       	=  import 'common' . TABLE_TYPE
-local DISPLAY              =  import 'common' . DISPLAY
+local DISPLAY          	=  import 'common' . DISPLAY
 
 --------------------------------------------------------------------------------
 -- Key-value pair formatting.
@@ -658,8 +657,8 @@ local function format_table (t, display, l, format_value)
         -- NOTE: Currently we only allow leaf-nodes to format into columns, due
         -- to issues with table alignment.
         align_into_columns(l, start_of_table_i)
-    elseif table_info.is_tabular then
+	elseif table_info.is_tabular then
-        align_into_tabular_style(l, start_of_table_i, #l)
+		align_into_tabular_style(l, start_of_table_i, #l)
     else
         -- Is long table: Fix whitespace alignment
         fix_alignment(l, start_of_table_i)