The Great Grid Table Code Throwaway Day

1 files changed, 29 insertions, 213 deletions

diff --git a/rst_helpers.lua b/rst_helpers.lua
index bb48aed..0f6e10c 100644
--- a/rst_helpers.lua
+++ b/rst_helpers.lua
@@ -143,212 +143,47 @@ local function set_layout (line)
     return layout
 end
 
---function helpers.table.create(raw)
-    --local self = {}
-    --self.rows = {}
-
-    --local p = patterns
-
-    --self.resolve_parent = function(row, col)
-        --print(row, col)
-        --local cell = self.rows[row][col]
-        --local par_row, par_col
-        --if cell.parent then
-            --par_row, par_col = self.resolve_parent(cell.parent.y, cell.parent.x)
-        --else
-            --return par_row, par_col
-        --end
-    --end
-    
-    --self.__init = function()
-        --local hc = helpers.cell
-        --self.layout = set_layout(raw[1])
-        --local rowcount = 0
-
-        -- first get the correct horizontal spans
-        --local next_is_new_row = true
-        --for n, line in ipairs(raw) do
-            -- caching the test results
-            --local sepline = p.sep_line:match(line)
-            --local sephead = p.sep_head:match(line)
-            --local seppart = p.sep_part:match(line)
-            --local newrow  = sepline or sephead or seppart
-
-            --if newrow and n > 1 then
-                --if sephead then
-                    --self.has_head = true
-                --end
-                --rowcount = rowcount + 1
-            --end
-
-            --if not (sepline  or
-                    --sephead) then
-                --local row = {}
-                --row.newrow = (newrow or next_is_new_row) and true or false
-                --next_is_new_row = false
-                --local sl = self.layout
-                --local splitted = {p.cells:match(line, 1, sl)}
-                --local pos_layout, pos_line = 1, 1
-                --local last = nil
-                --local ignore = {}
-                --ignore.n, ignore.parent = 0, nil
-                --while pos_layout <= #sl.slices do
-                    --local splitpos = splitted[pos_line]
-                    --local splitpos = splitted[pos_layout]
-                    --local width_layout = sl.widths[pos_layout]
-                    --local span = 1
-                    --local this
-                    --if ignore.n > 0 then
-                        --ignore.n = ignore.n - 1
-                        --this = hc.create(false, n, pos_layout, true)
-                        --row[pos_layout] = this
-                        --this.parent = ignore.parent
-                    --else
-                        --local width_cell   = utf.len(splitpos)
-                        --if width_cell > width_layout then
-                            --print(splitpos, width_cell, sl.slices[pos_layout], width_layout)
-                            -- check the horizontal span
-                            --span = span + hc.get_x_span(splitpos, sl, pos_layout)
-                        --end
-                        --pos_line = pos_line + span
-                        --this = hc.create(splitpos, n, pos_layout, false)
-                        --if p.dashesonly:match(splitpos) then
-                            --this.variant = "separator"
-                        --end
-                        --this.span.x = span
-                        --last = this
-                        --row[pos_layout] = this
-                        --ignore.n = span - 1
-                        --ignore.parent = ignore.n > 0 and { y = rowcount, x = pos_layout } or nil
-                    --end
-                    --pos_layout = pos_layout + 1
-                    --print(">",this.pos.y,this.pos.x,this.span.y,this.span.x)
-                    --if this.span.y > 1 then
-                        --print(">"..this.content.."<")
-                    --end
-                --end
-                --self.rows[#self.rows+1] = row
-                --print(#self.rows.."<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
-                --for i,j in ipairs(row) do print(i,j.content) end
-                --print(row.newrow)
-            --else -- separator
-                --next_is_new_row = true
-
-            --end
-            --print(string.format("[t-%2s,%2s]> %s", n, m, cell))
-        --end
-        --print("rc = "..rowcount, "nr = "..#self.rows)
-        --self.rowcount = rowcount
-
-        --if self.rowcount < #self.rows then -- some cells span vertically
-            --local has_partsep = function(row)
-                --for n, cell in ipairs(row) do
-                    --if cell.variant == "separator" then
-                        --return true
-                    --end
-                --end
-                --return false
-            --end
-
-            --local dont_do_next = false
-            --for nr,row in ipairs(self.rows) do
-                --local ps = has_partsep(row)
-
-                --row.ignore = ps and true or false
-                --if ps then
-                    --self.rows[nr+1].newrow = true
-                --end
-                --if (not row.newrow or ps) and not dont_do_next then
-                    --print(">>>>>>>>>> NEXT <<<<<<<<<<<<")
-                    --print(row.newrow and has_partsep(row))
-                    -- continues last row either fully or partially
-                    --for nc, cell in ipairs(row) do
-                        --print(nr, nc, cell.content)
-                        --if cell.content == false then
-                            -- empty cell
-                        --elseif cell.variant ~= "separator" then
-                            --local par_row, par_col
-                            --if cell.parent then
-                                --par_row, par_col = self.resolve_parent(cell.parent.y, cell.parent.x)
-                                --print("old parent: ", par_row, par_col)
-                            --else -- no previous span, setting parent to preceding row
-                                --par_row, par_col = nr -1, nc
-                                --print("new parent: ", par_row, par_col)
-                            --end
-
-                            --print (nr, nc, cell.content, cell.parent, par_row, par_col)
-                            --local parent = self.rows[par_row][par_col]
-                            --parent.span.y   = parent.span.y + 1
-                            --parent.content  = parent.content .. cell.content
-                            --parent.stripped = parent.stripped .. " " .. cell.stripped
-
-                            --if ps then
-                                --local successor  = self.rows[nr+1][nc]
-                                --successor.parent = { x = par_col, y = par_row }
-                                --parent.span.y    = parent.span.y + 1
-                                --parent.content   = parent.content .. successor.content
-                                --parent.stripped  = parent.stripped .. " " .. successor.stripped
-                                --dont_do_next = true
-                            --else
-                                --dont_do_next = false
-                            --end
-                            --print(cell.content, parent.content)
-                            --add_y(cell)
-                        --end
-                    --end
-                --elseif dont_do_next then
-                    --row.ignore = true
-                    --dont_do_next = false
-                --end
-            --end
-        --end -- vertical span handler
-    --end -- end __init
-
-    --self.__init()
-    --return self
---end
-
 helpers_debug = true
 function helpers.table.create(raw)
-    local self = {}
-    self.rows = {}
-    self.layout = set_layout(raw[1])
+    local newtab = {}
+    newtab.rows = {}
+    newtab.layout = set_layout(raw[1])
 
     local p = helpers.patterns
 
-    self.resolve_parent = function(row, col, array)
-        local array = array or self.rows
+    newtab.resolve_parent = function(row, col, array)
+        local array = array or newtab.rows
         local cell = array[row][col]
         local par_row, par_col = row, col
         if cell.parent then
-            par_row, par_col = self.resolve_parent(cell.parent.y, cell.parent.x)
+            par_row, par_col = newtab.resolve_parent(cell.parent.y, cell.parent.x)
         end
         return par_row, par_col
     end
 
-    self.__init = function()
+    newtab.__init = function()
         local hc = helpers.cell
         local rowcount = 0
-        local selflayout = self.layout
+        local newtablayout = newtab.layout
         for nr, row in ipairs(raw) do
-            self.rows[nr] = {}
-            local this_row = self.rows[nr]
+            newtab.rows[nr] = {}
+            local this_row = newtab.rows[nr]
             this_row.sepline = p.sep_line:match(row)
             this_row.sephead = p.sep_head:match(row)
             this_row.seppart = p.sep_part:match(row)
             if this_row.sephead then
-                self.has_head = true
-                self.head_end = nr
+                newtab.has_head = true
+                newtab.head_end = nr
             end
 
-            local splitted = { p.cells:match(row, 1, selflayout) }
+            local splitted = { p.cells:match(row, 1, newtablayout) }
             local pos_layout, pos_row = 1, 1
             local make_empty = {}
             make_empty.n, make_empty.parent = 0, nil
 
-            while pos_layout <= #selflayout.widths do
+            while pos_layout <= #newtablayout.widths do
                 local splitpos = splitted[pos_layout]
-                local layoutwidth = selflayout.widths[pos_layout]
+                local layoutwidth = newtablayout.widths[pos_layout]
                 local span = 1
                 local this
 
@@ -356,10 +191,10 @@ function helpers.table.create(raw)
                     make_empty.n = make_empty.n - 1
                     this = hc.create("", nr, pos_layout, make_empty.parent)
                     this.parent  = make_empty.parent
-                    p_row, p_col = self.resolve_parent(this.parent.y, this.parent.x)
-                    local thisparent = self.rows[p_row][p_col]
+                    p_row, p_col = newtab.resolve_parent(this.parent.y, this.parent.x)
+                    local thisparent = newtab.rows[p_row][p_col]
                     if this_row.sepline or this_row.sephead or
-                        self.rows[p_row][p_col].variant == "separator" then
+                        newtab.rows[p_row][p_col].variant == "separator" then
                         this.variant = "separator"
                     else
                         this.variant = "empty1"
@@ -367,7 +202,7 @@ function helpers.table.create(raw)
                 else
                     local cellwidth = utf.len(splitpos)
                     if cellwidth > layoutwidth then
-                        span = span + hc.get_x_span(splitpos, selflayout, pos_layout)
+                        span = span + hc.get_x_span(splitpos, newtablayout, pos_layout)
                     end
                     pos_row = pos_row + span
                     this = hc.create(splitpos, nr, pos_layout, nil)
@@ -385,23 +220,18 @@ function helpers.table.create(raw)
             end -- while
         end -- for loop over rows
 
-        local oldrows = self.rows
-        --local newrows = {}
+        local oldrows = newtab.rows
         local newrows = oldrows
-        for nc, width in ipairs(selflayout.widths) do
+        for nc, width in ipairs(newtablayout.widths) do
             -- this is gonna be extremely slow but at least it's readable
             local newrow
-            --print("next columnt <-----------------------------")
             local currentrow = 1
             for nr, row in ipairs(newrows) do
-                --newrows[nr] = newrows[nr] or {}
                 local cell = row[nc]
                 dbg_write("nc: %s, nr:%2s | %9s | ", nc, nr,cell.variant)
                 if  row.sepline or row.sephead
                     or p.dashesonly:match(cell.content)
                     or cell.variant == "separator" then -- separator; skipping and beginning new row
-                    
-                    --newrows[currentrow] = cell
                     newrows[nr][nc] = cell
                     currentrow = currentrow + 1
                     newrow = true
@@ -411,7 +241,6 @@ function helpers.table.create(raw)
                     dbg_write("old >%24s< ", cell.stripped)
                     if cell.parent then dbg_write("parent |") else dbg_write("no par |") end
                     if newrow then
-                        --newrows[currentrow] = cell
                         newrows[nr][nc] = cell
                         currentrow = currentrow + 1
                     else -- continuing parent
@@ -419,11 +248,10 @@ function helpers.table.create(raw)
                         local par_row, par_col
                         local parent
                         if cell.parent then
-                            --dbg_write(" use %s,%2s | ", cell.parent.x, cell.parent.y)
-                            par_row, par_col = self.resolve_parent(cell.parent.y, cell.parent.x, newrows)
+                            par_row, par_col = newtab.resolve_parent(cell.parent.y, cell.parent.x, newrows)
                             dbg_write(" use %s,%2s | ", par_col, par_row)
                         else -- Using vertical predecessor.
-                            par_row, par_col = self.resolve_parent(nr-1,nc, newrows)
+                            par_row, par_col = newtab.resolve_parent(nr-1,nc, newrows)
                             dbg_write(" new %s,%2s | ", par_col, par_row)
                         end
                         parent = newrows[par_row][par_col]
@@ -433,19 +261,10 @@ function helpers.table.create(raw)
                             parent.span.y   = parent.span.y + 1
                         end
 
-                        --print(#newrows, par_row)
-                        --if cell.variant ~= "empty1" then
-                            -- Cells of type empty1 already have their content
-                            -- delegated onto their respective horizontal parent.
                             parent.content  = parent.content  .. cell.content
                             parent.stripped = parent.stripped .. " " .. cell.stripped
                             cell.variant = "empty2"
-                        --end
                         cell.parent  = { x = par_col, y = par_row }
-                        --this = hc.create("", nr, nc, { x = par_col, y = par_row }, "empty2")
-                        --this.variant = "empty2"
-                        --cell = hc.create("", nr, nc, { x = par_col, y = par_row }, "empty2")
-                        --newrows[nr][nc] = this
                     end
                     newrow = false
                 end
@@ -453,29 +272,26 @@ function helpers.table.create(raw)
                 newrows[nr][nc] = cell
             end -- for loop over rows
         end -- for loop over columns
-        --self.rows = oldrows
-        self.rows = newrows
+        --newtab.rows = oldrows
+        newtab.rows = newrows
     end
 
-    self.__init()
-
+    newtab.__init()
 
-    self.__draw_debug = function()
-        for nr, row in ipairs(self.rows) do
+    newtab.__draw_debug = function()
+        for nr, row in ipairs(newtab.rows) do
             for nc, cell in ipairs(row) do
                 local field = cell.variant:sub(1,7)
                 if cell.parent then
                     field = field .. string.format(" %s,%2s",cell.parent.x, cell.parent.y)
                 end
                 dbg_write("%12s | ", field)
-                --dbg_write("%10s | ",(cell.parent and "true" or "false"))
             end
             dbg_write("\n")
         end
     end
 
-    --self.__draw_debug()
-    return self
+    return newtab
 end