akkartik/view.love - Change A3XJXFLE7IX524G4HWJKMQYKJCMR3N2MVFFSW7ILAEDROTOUNF3QC

new fork: browse an immutable text file

Still has a cursor, which might be unnecessary.

Created by Kartik K. Agaram on August 20, 2022

A3XJXFLE7IX524G4HWJKMQYKJCMR3N2MVFFSW7ILAEDROTOUNF3QC

Dependencies

In channels

main

Change contents

File deletion: undo.lua

BF:BFD[12.2] → [13.2740:2772]

BF:BFD[13.2772] → [13.1:1]

B:BD[13.1] → [13.2:427]

∅:D[14.200] → [13.577:588]

∅:D[15.209] → [13.577:588]

B:BD[13.577] → [13.577:588]

∅:D[14.417] → [13.763:792]

∅:D[15.441] → [13.763:792]

B:BD[13.763] → [13.763:792]

∅:D[14.648] → [13.975:1004]

∅:D[15.694] → [13.975:1004]

B:BD[13.975] → [13.975:1004]

∅:D[16.36] → [13.1004:1116]

B:BD[13.1004] → [13.1004:1116]

∅:D[17.21] → [13.1147:1206]

∅:D[18.146] → [13.1147:1206]

∅:D[16.218] → [13.1147:1206]

∅:D[14.805] → [13.1147:1206]

∅:D[15.855] → [13.1147:1206]

B:BD[13.1147] → [13.1147:1206]

∅:D[14.984] → [13.1413:1427]

∅:D[15.1062] → [13.1413:1427]

B:BD[13.1413] → [13.1413:1427]

∅:D[16.253] → [13.1427:1559]

B:BD[13.1427] → [13.1427:1559]

∅:D[19.47] → [13.2296:2322]

∅:D[5.81] → [13.2296:2322]

B:BD[13.2296] → [13.2296:2322]

∅:D[20.313] → [13.2322:2739]

∅:D[16.852] → [13.2322:2739]

B:BD[13.2322] → [13.2322:2739]

B:BD[13.2739] → [16.853:918]

B:BD[13.2322] → [16.296:852]

B:BD[16.852] → [20.1:313]

B:BD[13.1559] → [16.254:269]

B:BD[16.269] → [5.1:81]

B:BD[13.1427] → [16.219:253]

B:BD[13.1206] → [14.806:928]

∅:D[14.679] → [16.60:122]

B:BD[16.60] → [16.60:122]

∅:D[21.32] → [16.202:218]

B:BD[16.202] → [16.202:218]

∅:D[14.707] → [18.22:48]

∅:D[15.729] → [18.22:48]

B:BD[18.22] → [18.22:48]

∅:D[14.756] → [18.84:110]

∅:D[15.792] → [18.84:110]

B:BD[18.84] → [18.84:110]

B:BD[18.110] → [14.757:805]

B:BD[18.48] → [14.708:756]

B:BD[16.218] → [14.680:707]

B:BD[16.122] → [21.1:32]

B:BD[13.1116] → [14.649:679]

B:BD[13.1004] → [16.1:36]

B:BD[13.792] → [14.418:648]

B:BD[13.588] → [14.201:417]

B:BD[13.427] → [14.1:200]

-- undo/redo by managing the sequence of events in the current session
-- based on https://github.com/akkartik/mu1/blob/master/edit/012-editor-undo.mu
-- Incredibly inefficient; we make a copy of lines on every single keystroke.
-- The hope here is that we're either editing small files or just reading large files.
-- TODO: highlight stuff inserted by any undo/redo operation
-- TODO: coalesce multiple similar operations
  end
end
    return result
  end
end
    return result
  end
end
-- Make copies of objects; the rest of the app may mutate them in place, but undo requires immutable histories.
  -- compare with App.initialize_globals
  local event = {
    lines={},
    -- no filename; undo history is cleared when filename changes
  }
  -- deep copy lines without cached stuff like text fragments
  end
  return event
end
-- https://stackoverflow.com/questions/640642/how-do-you-copy-a-lua-table-by-value/26367080#26367080
function deepcopy(obj, seen)
  if type(obj) ~= 'table' then return obj end
  if seen and seen[obj] then return seen[obj] end
  local s = seen or {}
  local result = setmetatable({}, getmetatable(obj))
  s[obj] = result
  for k,v in pairs(obj) do
    result[deepcopy(k, s)] = deepcopy(v, s)
  end
  return result
end
function minmax(a, b)
  return math.min(a,b), math.max(a,b)
end
function patch(lines, from, to)
--?   if #from.lines == 1 and #to.lines == 1 then
--?     assert(from.start_line == from.end_line)
--?     assert(to.start_line == to.end_line)
--?     assert(from.start_line == to.start_line)
--?     lines[from.start_line] = to.lines[1]
--?     return
--?   end
  assert(from.start_line == to.start_line)
  for i=from.end_line,from.start_line,-1 do
    table.remove(lines, i)
  end
  assert(#to.lines == to.end_line-to.start_line+1)
  for i=1,#to.lines do
    table.insert(lines, to.start_line+i-1, to.lines[i])
  end
end
function patch_placeholders(line_cache, from, to)
  assert(from.start_line == to.start_line)
  for i=from.end_line,from.start_line,-1 do
    table.remove(line_cache, i)
  end
  assert(#to.lines == to.end_line-to.start_line+1)
  for i=1,#to.lines do
    table.insert(line_cache, to.start_line+i-1, {})
  end
end
  for i=s,e do
    local line = State.lines[i]
    table.insert(event.lines, {data=line.data})
    start_line=s,
    end_line=e,
    screen_top=deepcopy(State.screen_top1),
    selection=deepcopy(State.selection1),
    cursor=deepcopy(State.cursor1),
  -- Snapshot everything by default, but subset if requested.
    e = s
  end
  if s < 1 then s = 1 end
  if e < 1 then e = 1 end
  if e > #State.lines then e = #State.lines end
  if s > #State.lines then s = #State.lines end
  assert(#State.lines > 0)
  assert(s)
  if e == nil then
function snapshot(State, s,e)
-- Copy all relevant global state.
function redo_event(State)
  if State.next_history <= #State.history then
--?     print('restoring history', State.next_history+1)
    local result = State.history[State.next_history]
    State.next_history = State.next_history+1
function undo_event(State)
  if State.next_history > 1 then
--?     print('moving to history', State.next_history-1)
    State.next_history = State.next_history-1
    local result = State.history[State.next_history]
function record_undo_event(State, data)
  State.history[State.next_history] = data
  State.next_history = State.next_history+1
  for i=State.next_history,#State.history do
    State.history[i] = nil

Deletion in text_tests.lua at line 15 [22.2]

B:BD[15.2318] → [3.2:791]

end
function test_backspace_from_start_of_final_line()
  io.write('\ntest_backspace_from_start_of_final_line')
  -- display final line of text with cursor at start of it
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def'}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.cursor1 = {line=2, pos=1}
  Text.redraw_all(Editor_state)
  -- backspace scrolls up
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(#Editor_state.lines, 1, 'F - test_backspace_from_start_of_final_line/#lines')
  check_eq(Editor_state.cursor1.line, 1, 'F - test_backspace_from_start_of_final_line/cursor')
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_backspace_from_start_of_final_line/screen_top')

Deletion in text_tests.lua at line 17 [22.2]

∅:D[23.1487] → [24.3:126]

B:BD[24.3] → [24.3:126]

B:BD[24.126] → [25.143:189]

∅:D[25.189] → [15.2319:2355]

∅:D[26.490] → [15.2319:2355]

B:BD[24.126] → [15.2319:2355]

B:BD[15.2355] → [20.414:446]

∅:D[20.446] → [27.56:82]

B:BD[15.2355] → [27.56:82]

B:BD[27.82] → [28.132:178]

B:BD[28.178] → [26.491:520]

∅:D[26.520] → [24.216:287]

∅:D[15.2478] → [24.216:287]

B:BD[24.216] → [24.216:287]

B:BD[24.287] → [29.2:149]

B:BD[29.149] → [25.190:236]

∅:D[25.236] → [15.2479:2517]

∅:D[26.625] → [15.2479:2517]

B:BD[29.149] → [15.2479:2517]

B:BD[15.2517] → [20.447:479]

∅:D[20.479] → [15.2603:2724]

B:BD[15.2603] → [15.2603:2724]

B:BD[15.2724] → [28.179:226]

∅:D[28.226] → [30.2:7]

B:BD[29.320] → [30.2:7]

function test_insert_first_character()
  io.write('\ntest_insert_first_character')
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{}
  Text.redraw_all(Editor_state)
  edit.draw(Editor_state)
  edit.run_after_textinput(Editor_state, 'a')
  local y = Editor_state.top
  App.screen.check(y, 'a', 'F - test_insert_first_character/screen:1')
end
function test_press_ctrl()
  io.write('\ntest_press_ctrl')
  -- press ctrl while the cursor is on text
  App.screen.init{width=50, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{''}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.run_after_keychord(Editor_state, 'C-m')
end

Deletion in text_tests.lua at line 566 [22.2]

B:BD[31.1127] → [32.2:137]

B:BD[32.137] → [33.422:461]

B:BD[33.461] → [25.1600:1646]

∅:D[25.1646] → [15.13841:13882]

∅:D[26.4249] → [15.13841:13882]

B:BD[33.461] → [15.13841:13882]

B:BD[15.13882] → [20.1755:1787]

∅:D[20.1787] → [15.13968:14133]

B:BD[15.13968] → [15.13968:14133]

B:BD[15.14133] → [27.907:933]

∅:D[34.496] → [32.348:365]

∅:D[27.933] → [32.348:365]

B:BD[32.348] → [32.348:365]

B:BD[32.365] → [28.1650:1696]

∅:D[28.1696] → [32.396:452]

B:BD[32.396] → [32.396:452]

B:BD[32.452] → [5.194:275]

∅:D[19.231] → [35.2:172]

∅:D[5.275] → [35.2:172]

∅:D[15.14215] → [35.2:172]

B:BD[32.520] → [35.2:172]

B:BD[35.172] → [33.462:501]

B:BD[33.501] → [25.1647:1693]

∅:D[25.1693] → [15.14216:14257]

∅:D[26.4354] → [15.14216:14257]

B:BD[33.501] → [15.14216:14257]

B:BD[15.14257] → [20.1788:1820]

∅:D[20.1820] → [15.14343:14508]

B:BD[15.14343] → [15.14343:14508]

B:BD[15.14508] → [27.934:960]

∅:D[34.511] → [35.383:465]

∅:D[27.960] → [35.383:465]

B:BD[35.383] → [35.383:465]

B:BD[35.465] → [36.47:95]

B:BD[36.95] → [2.2:38]

∅:D[2.38] → [36.96:135]

B:BD[35.508] → [36.96:135]

∅:D[36.135] → [35.531:620]

B:BD[35.531] → [35.531:620]

B:BD[35.620] → [15.14509:14601]

B:BD[15.14601] → [5.276:377]

∅:D[19.328] → [37.2:7]

∅:D[5.377] → [37.2:7]

∅:D[35.787] → [37.2:7]

∅:D[15.14702] → [37.2:7]

B:BD[32.520] → [37.2:7]

function test_edit_deletes_selection()
  io.write('\ntest_edit_deletes_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- press a key
  edit.run_after_textinput(Editor_state, 'x')
  -- selected text is deleted and replaced with the key
  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_edit_deletes_selection')
end
function test_edit_with_shift_key_deletes_selection()
  io.write('\ntest_edit_with_shift_key_deletes_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- mimic precise keypresses for a capital letter
  App.fake_key_press('lshift')
  edit.keychord_pressed(Editor_state, 'd', 'd')
  edit.textinput(Editor_state, 'D')
  edit.key_released(Editor_state, 'd')
  App.fake_key_release('lshift')
  -- selected text is deleted and replaced with the key
  check_nil(Editor_state.selection1.line, 'F - test_edit_with_shift_key_deletes_selection')
  check_eq(Editor_state.lines[1].data, 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')
end

Deletion in text_tests.lua at line 583 [22.2]

∅:D[15.15076] → [38.2:104]

B:BD[37.617] → [38.2:104]

B:BD[38.104] → [33.542:581]

B:BD[33.581] → [25.1741:1787]

∅:D[25.1787] → [15.15077:15118]

∅:D[26.4564] → [15.15077:15118]

B:BD[33.581] → [15.15077:15118]

B:BD[15.15118] → [20.1854:1886]

∅:D[20.1886] → [15.15204:15369]

B:BD[15.15204] → [15.15204:15369]

B:BD[15.15369] → [27.988:1014]

∅:D[34.541] → [38.315:332]

∅:D[27.1014] → [38.315:332]

B:BD[38.315] → [38.315:332]

B:BD[38.332] → [28.1745:1792]

∅:D[28.1792] → [38.364:451]

B:BD[38.364] → [38.364:451]

B:BD[38.451] → [5.378:444]

∅:D[19.390] → [38.504:641]

∅:D[5.444] → [38.504:641]

∅:D[15.15436] → [38.504:641]

B:BD[38.504] → [38.504:641]

B:BD[38.641] → [33.582:621]

B:BD[33.621] → [25.1788:1834]

∅:D[25.1834] → [15.15437:15485]

∅:D[26.4669] → [15.15437:15485]

B:BD[33.621] → [15.15437:15485]

B:BD[15.15485] → [20.1887:1919]

∅:D[20.1919] → [15.15571:15736]

B:BD[15.15571] → [15.15571:15736]

B:BD[15.15736] → [27.1015:1041]

∅:D[34.556] → [38.859:923]

∅:D[27.1041] → [38.859:923]

B:BD[38.859] → [38.859:923]

B:BD[38.923] → [28.1793:1840]

∅:D[28.1840] → [38.955:1068]

B:BD[38.955] → [38.955:1068]

B:BD[38.1068] → [5.445:531]

∅:D[19.472] → [32.520:525]

∅:D[5.531] → [32.520:525]

∅:D[37.617] → [32.520:525]

∅:D[38.1141] → [32.520:525]

∅:D[15.15823] → [32.520:525]

B:BD[32.520] → [32.520:525]

B:BD[32.525] → [39.2:164]

B:BD[39.164] → [25.1835:1881]

∅:D[25.1881] → [15.15824:15886]

∅:D[26.4774] → [15.15824:15886]

B:BD[39.164] → [15.15824:15886]

B:BD[15.15886] → [20.1920:1952]

∅:D[20.1952] → [15.15972:16093]

B:BD[15.15972] → [15.15972:16093]

B:BD[15.16093] → [27.1042:1068]

B:BD[27.1068] → [26.4775:4804]

∅:D[26.4804] → [39.363:452]

∅:D[15.16130] → [39.363:452]

B:BD[39.363] → [39.363:452]

B:BD[39.452] → [15.16131:16166]

∅:D[15.16166] → [39.474:563]

B:BD[39.474] → [39.474:563]

B:BD[39.563] → [15.16167:16202]

∅:D[15.16202] → [39.585:742]

B:BD[39.585] → [39.585:742]

B:BD[39.742] → [15.16203:16247]

∅:D[15.16247] → [39.773:795]

B:BD[39.773] → [39.773:795]

B:BD[39.795] → [28.1841:1894]

∅:D[28.1894] → [39.833:854]

B:BD[39.833] → [39.833:854]

B:BD[39.854] → [15.16248:16335]

B:BD[15.16335] → [5.532:625]

∅:D[19.561] → [39.1008:1013]

∅:D[5.625] → [39.1008:1013]

∅:D[15.16428] → [39.1008:1013]

B:BD[39.1008] → [39.1008:1013]

∅:D[32.525] → [22.2457:2571]

∅:D[39.1013] → [22.2457:2571]

∅:D[31.1127] → [22.2457:2571]

B:BD[22.2457] → [22.2457:2571]

B:BD[22.2571] → [25.1882:1928]

∅:D[25.1928] → [15.16429:16484]

∅:D[26.4909] → [15.16429:16484]

B:BD[22.2571] → [15.16429:16484]

B:BD[15.16484] → [20.1953:1985]

∅:D[20.1985] → [15.16570:16691]

B:BD[15.16570] → [15.16570:16691]

B:BD[15.16691] → [27.1069:1095]

B:BD[27.1095] → [28.1895:1941]

B:BD[28.2079] → [26.4910:4939]

∅:D[26.4939] → [22.2936:3005]

∅:D[15.16728] → [22.2936:3005]

B:BD[22.2936] → [22.2936:3005]

B:BD[22.3005] → [15.16729:16764]

B:BD[15.16764] → [40.1849:1917]

∅:D[40.1917] → [15.16765:16800]

B:BD[22.3096] → [15.16765:16800]

B:BD[15.16800] → [40.1918:1986]

∅:D[40.1986] → [22.3188:3260]

B:BD[22.3188] → [22.3188:3260]

B:BD[22.3260] → [41.2:27]

B:BD[41.27] → [26.4940:4997]

B:BD[26.4997] → [25.1929:1975]

∅:D[25.1975] → [15.16865:16927]

∅:D[26.5101] → [15.16865:16927]

B:BD[15.16865] → [15.16865:16927]

B:BD[15.16927] → [20.1986:2018]

∅:D[20.2018] → [15.17013:17134]

B:BD[15.17013] → [15.17013:17134]

B:BD[15.17134] → [27.1096:1122]

B:BD[27.1122] → [26.5102:5131]

∅:D[26.5131] → [22.3553:3627]

∅:D[15.17171] → [22.3553:3627]

B:BD[22.3553] → [22.3553:3627]

B:BD[22.3627] → [15.17172:17207]

∅:D[15.17207] → [22.3649:3723]

B:BD[22.3649] → [22.3649:3723]

B:BD[22.3723] → [15.17208:17243]

∅:D[15.17243] → [22.3745:3819]

B:BD[22.3745] → [22.3745:3819]

B:BD[22.3819] → [41.28:71]

B:BD[41.71] → [28.2080:2130]

∅:D[28.2130] → [15.17244:17485]

B:BD[22.3911] → [15.17244:17485]

B:BD[15.17485] → [26.5132:5155]

∅:D[26.5155] → [22.4130:4193]

∅:D[15.17515] → [22.4130:4193]

B:BD[22.4130] → [22.4130:4193]

B:BD[22.4193] → [15.17516:17551]

∅:D[15.17551] → [22.4215:4279]

B:BD[22.4215] → [22.4215:4279]

B:BD[22.4279] → [15.17552:17587]

∅:D[15.17587] → [22.4301:4366]

B:BD[22.4301] → [22.4301:4366]

end
function test_cut()
  io.write('\ntest_cut')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- press a key
  edit.run_after_keychord(Editor_state, 'C-x')
  check_eq(App.clipboard, 'a', 'F - test_cut/clipboard')
  -- selected text is deleted
  check_eq(Editor_state.lines[1].data, 'bc', 'F - test_cut/data')
end
function test_paste_replaces_selection()
  io.write('\ntest_paste_replaces_selection')
  -- display a line of text with a selection
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.selection1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- set clipboard
  App.clipboard = 'xyz'
  -- paste selection
  edit.run_after_keychord(Editor_state, 'C-v')
  -- selection is reset since shift key is not pressed
  -- selection includes the newline, so it's also deleted
  check_eq(Editor_state.lines[1].data, 'xyzdef', 'F - test_paste_replaces_selection')
end
function test_deleting_selection_may_scroll()
  io.write('\ntest_deleting_selection_may_scroll')
  -- display lines 2/3/4
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=2}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'def', 'F - test_deleting_selection_may_scroll/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_deleting_selection_may_scroll/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl', 'F - test_deleting_selection_may_scroll/baseline/screen:3')
  -- set up a selection starting above the currently displayed page
  Editor_state.selection1 = {line=1, pos=2}
  -- delete selection
  edit.run_after_keychord(Editor_state, 'backspace')
  -- page scrolls up
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_deleting_selection_may_scroll')
  check_eq(Editor_state.lines[1].data, 'ahi', 'F - test_deleting_selection_may_scroll/data')
end
function test_edit_wrapping_text()
  io.write('\ntest_edit_wrapping_text')
  App.screen.init{width=50, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=4}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  edit.run_after_textinput(Editor_state, 'g')
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_edit_wrapping_text/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'de', 'F - test_edit_wrapping_text/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'fg', 'F - test_edit_wrapping_text/screen:3')
end
function test_insert_newline()
  io.write('\ntest_insert_newline')
  -- display a few lines
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_insert_newline/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_insert_newline/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_insert_newline/baseline/screen:3')
  -- hitting the enter key splits the line
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_insert_newline/screen_top')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_insert_newline/cursor:line')
  check_eq(Editor_state.cursor1.pos, 1, 'F - test_insert_newline/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'a', 'F - test_insert_newline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'bc', 'F - test_insert_newline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_insert_newline/screen:3')

Deletion in text_tests.lua at line 585 [22.2]

B:BD[23.1493] → [23.1493:1614]

B:BD[23.1614] → [26.5156:5213]

B:BD[26.5213] → [25.1976:2022]

∅:D[25.2022] → [15.17652:17693]

∅:D[26.5317] → [15.17652:17693]

B:BD[15.17652] → [15.17652:17693]

B:BD[15.17693] → [20.2019:2051]

∅:D[20.2051] → [15.17779:17900]

B:BD[15.17779] → [15.17779:17900]

∅:D[15.17900] → [23.1798:1841]

B:BD[23.1798] → [23.1798:1841]

B:BD[23.1841] → [28.2131:2181]

∅:D[28.2181] → [15.17901:18093]

B:BD[23.1876] → [15.17901:18093]

B:BD[15.18093] → [5.626:817]

∅:D[19.743] → [22.4366:4452]

∅:D[5.817] → [22.4366:4452]

∅:D[23.2207] → [22.4366:4452]

∅:D[15.18284] → [22.4366:4452]

B:BD[22.4366] → [22.4366:4452]

B:BD[22.4452] → [42.2:27]

B:BD[42.27] → [26.5318:5375]

B:BD[26.5375] → [25.2023:2069]

∅:D[25.2069] → [15.18349:18411]

∅:D[26.5479] → [15.18349:18411]

B:BD[15.18349] → [15.18349:18411]

B:BD[15.18411] → [20.2052:2084]

∅:D[20.2084] → [15.18497:18618]

B:BD[15.18497] → [15.18497:18618]

B:BD[15.18618] → [27.1123:1149]

B:BD[27.1149] → [26.5480:5509]

∅:D[26.5509] → [22.4745:4826]

∅:D[15.18655] → [22.4745:4826]

B:BD[22.4745] → [22.4745:4826]

B:BD[22.4826] → [15.18656:18691]

∅:D[15.18691] → [22.4848:4929]

B:BD[22.4848] → [22.4848:4929]

B:BD[22.4929] → [15.18692:18727]

∅:D[15.18727] → [22.4951:5032]

B:BD[22.4951] → [22.4951:5032]

B:BD[22.5032] → [42.28:101]

∅:D[42.101] → [22.5089:5115]

B:BD[22.5089] → [22.5089:5115]

B:BD[22.5115] → [28.2182:2229]

∅:D[28.2229] → [15.18728:18990]

B:BD[22.5147] → [15.18728:18990]

B:BD[15.18990] → [26.5510:5533]

∅:D[26.5533] → [22.5387:5459]

∅:D[15.19020] → [22.5387:5459]

B:BD[22.5387] → [22.5387:5459]

B:BD[22.5459] → [15.19021:19056]

∅:D[15.19056] → [22.5481:5553]

B:BD[22.5481] → [22.5481:5553]

B:BD[22.5553] → [15.19057:19092]

∅:D[15.19092] → [22.5575:5652]

B:BD[22.5575] → [22.5575:5652]

function test_insert_newline_at_start_of_line()
  io.write('\ntest_insert_newline_at_start_of_line')
  -- display a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- hitting the enter key splits the line
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_insert_newline_at_start_of_line/cursor:line')
  check_eq(Editor_state.cursor1.pos, 1, 'F - test_insert_newline_at_start_of_line/cursor:pos')
  check_eq(Editor_state.lines[1].data, '', 'F - test_insert_newline_at_start_of_line/data:1')
  check_eq(Editor_state.lines[2].data, 'abc', 'F - test_insert_newline_at_start_of_line/data:2')
end
function test_insert_from_clipboard()
  io.write('\ntest_insert_from_clipboard')
  -- display a few lines
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_insert_from_clipboard/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_insert_from_clipboard/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_insert_from_clipboard/baseline/screen:3')
  -- paste some text including a newline, check that new line is created
  App.clipboard = 'xy\nz'
  edit.run_after_keychord(Editor_state, 'C-v')
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_insert_from_clipboard/screen_top')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_insert_from_clipboard/cursor:line')
  check_eq(Editor_state.cursor1.pos, 2, 'F - test_insert_from_clipboard/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'axy', 'F - test_insert_from_clipboard/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'zbc', 'F - test_insert_from_clipboard/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_insert_from_clipboard/screen:3')
end

Deletion in text_tests.lua at line 680 [22.2]

B:BD[22.6255] → [43.2:108]

B:BD[43.108] → [26.7200:7257]

B:BD[26.7257] → [25.2258:2304]

∅:D[25.2304] → [15.23423:23485]

∅:D[26.7361] → [15.23423:23485]

B:BD[15.23423] → [15.23423:23485]

B:BD[15.23485] → [20.2249:2281]

∅:D[20.2281] → [15.23571:23723]

B:BD[15.23571] → [15.23571:23723]

B:BD[15.23723] → [27.1482:1508]

∅:D[34.863] → [43.344:383]

∅:D[27.1508] → [43.344:383]

B:BD[43.344] → [43.344:383]

B:BD[43.383] → [28.3658:3705]

∅:D[28.3705] → [43.415:429]

B:BD[43.415] → [43.415:429]

B:BD[43.429] → [15.23724:23800]

∅:D[15.23800] → [43.492:497]

B:BD[43.492] → [43.492:497]

function test_cut_without_selection()
  io.write('\ntest_cut_without_selection')
  -- display a few lines
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  Editor_state.selection1 = {}
  edit.draw(Editor_state)
  -- try to cut without selecting text
  edit.run_after_keychord(Editor_state, 'C-x')
  -- no crash
  check_nil(Editor_state.selection1.line, 'F - test_cut_without_selection')
end

Deletion in text_tests.lua at line 1164 [22.2]

B:BD[22.28742] → [22.28742:28904]

B:BD[22.28904] → [26.10606:10663]

B:BD[26.10663] → [25.3104:3150]

∅:D[25.3150] → [15.37713:37775]

∅:D[26.10767] → [15.37713:37775]

B:BD[15.37713] → [15.37713:37775]

B:BD[15.37775] → [20.3047:3079]

∅:D[20.3079] → [15.37861:37982]

B:BD[15.37861] → [15.37861:37982]

B:BD[15.37982] → [27.1968:1994]

B:BD[27.1994] → [26.10768:10797]

∅:D[26.10797] → [22.29145:29238]

∅:D[15.38019] → [22.29145:29238]

B:BD[22.29145] → [22.29145:29238]

B:BD[22.29238] → [15.38020:38055]

∅:D[15.38055] → [22.29260:29353]

B:BD[22.29260] → [22.29260:29353]

B:BD[22.29353] → [15.38056:38091]

∅:D[15.38091] → [22.29375:29525]

B:BD[22.29375] → [22.29375:29525]

B:BD[22.29525] → [28.4604:4654]

∅:D[28.4654] → [15.38092:38390]

B:BD[22.29560] → [15.38092:38390]

B:BD[15.38390] → [26.10798:10821]

∅:D[26.10821] → [22.29836:29920]

∅:D[15.38420] → [22.29836:29920]

B:BD[22.29836] → [22.29836:29920]

B:BD[22.29920] → [15.38421:38456]

∅:D[15.38456] → [22.29942:30024]

B:BD[22.29942] → [22.29942:30024]

B:BD[22.30024] → [15.38457:38492]

∅:D[15.38492] → [22.30046:30337]

B:BD[22.30046] → [22.30046:30337]

B:BD[22.30337] → [26.10822:10879]

B:BD[26.10879] → [25.3151:3197]

∅:D[25.3197] → [15.38557:38619]

∅:D[26.10983] → [15.38557:38619]

B:BD[15.38557] → [15.38557:38619]

B:BD[15.38619] → [20.3080:3112]

∅:D[20.3112] → [15.38705:38826]

B:BD[15.38705] → [15.38705:38826]

B:BD[15.38826] → [27.1995:2021]

B:BD[27.2021] → [26.10984:11013]

∅:D[26.11013] → [22.30578:30763]

∅:D[15.38863] → [22.30578:30763]

B:BD[22.30578] → [22.30578:30763]

B:BD[22.30763] → [28.4655:4705]

∅:D[28.4705] → [15.38864:39243]

B:BD[22.30798] → [15.38864:39243]

B:BD[15.39243] → [26.11014:11037]

∅:D[26.11037] → [22.31155:31264]

∅:D[15.39273] → [22.31155:31264]

B:BD[22.31155] → [22.31155:31264]

B:BD[22.31264] → [15.39274:39309]

∅:D[15.39309] → [22.31286:31396]

B:BD[22.31286] → [22.31286:31396]

end
function test_enter_on_bottom_line_scrolls_down()
  io.write('\ntest_enter_on_bottom_line_scrolls_down')
  -- display a few lines with cursor on bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_enter_on_bottom_line_scrolls_down/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_enter_on_bottom_line_scrolls_down/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_enter_on_bottom_line_scrolls_down/baseline/screen:3')
  -- after hitting the enter key the screen scrolls down
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(Editor_state.screen_top1.line, 2, 'F - test_enter_on_bottom_line_scrolls_down/screen_top')
  check_eq(Editor_state.cursor1.line, 4, 'F - test_enter_on_bottom_line_scrolls_down/cursor:line')
  check_eq(Editor_state.cursor1.pos, 1, 'F - test_enter_on_bottom_line_scrolls_down/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'def', 'F - test_enter_on_bottom_line_scrolls_down/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'g', 'F - test_enter_on_bottom_line_scrolls_down/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'hi', 'F - test_enter_on_bottom_line_scrolls_down/screen:3')
end
function test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom()
  io.write('\ntest_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom')
  -- display just the bottom line on screen
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=4, pos=2}
  Editor_state.screen_top1 = {line=4, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'jkl', 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/baseline/screen:1')
  -- after hitting the enter key the screen does not scroll down
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(Editor_state.screen_top1.line, 4, 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/screen_top')
  check_eq(Editor_state.cursor1.line, 5, 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/cursor:line')
  check_eq(Editor_state.cursor1.pos, 1, 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'j', 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'kl', 'F - test_enter_on_final_line_avoids_scrolling_down_when_not_at_bottom/screen:2')

Deletion in text_tests.lua at line 1166 [22.2]

B:BD[22.31401] → [42.102:328]

B:BD[42.328] → [26.11038:11095]

B:BD[26.11095] → [25.3198:3244]

∅:D[25.3244] → [15.39374:39419]

∅:D[26.11199] → [15.39374:39419]

B:BD[15.39374] → [15.39374:39419]

B:BD[15.39419] → [20.3113:3145]

∅:D[20.3145] → [15.39505:39626]

B:BD[15.39505] → [15.39505:39626]

B:BD[15.39626] → [27.2022:2048]

∅:D[34.1163] → [42.529:603]

∅:D[27.2048] → [42.529:603]

B:BD[42.529] → [42.529:603]

B:BD[42.603] → [28.4706:4752]

∅:D[28.4752] → [15.39627:40033]

B:BD[42.634] → [15.39627:40033]

B:BD[15.40033] → [26.11200:11229]

∅:D[26.11229] → [42.1024:1147]

∅:D[15.40069] → [42.1024:1147]

B:BD[42.1024] → [42.1024:1147]

∅:D[42.1147] → [44.16:175]

B:BD[22.31401] → [44.16:175]

B:BD[44.175] → [26.11230:11287]

B:BD[26.11287] → [25.3245:3291]

∅:D[25.3291] → [15.40134:40196]

∅:D[26.11391] → [15.40134:40196]

B:BD[15.40134] → [15.40134:40196]

B:BD[15.40196] → [20.3146:3178]

∅:D[20.3178] → [15.40282:40403]

B:BD[15.40282] → [15.40282:40403]

B:BD[15.40403] → [27.2049:2075]

B:BD[27.2075] → [26.11392:11421]

∅:D[26.11421] → [44.416:510]

∅:D[15.40440] → [44.416:510]

B:BD[44.416] → [44.416:510]

B:BD[44.510] → [15.40441:40476]

∅:D[15.40476] → [44.532:626]

B:BD[44.532] → [44.532:626]

B:BD[44.626] → [15.40477:40512]

∅:D[15.40512] → [44.648:813]

B:BD[44.648] → [44.648:813]

B:BD[44.813] → [28.4753:4891]

∅:D[28.4891] → [15.40513:40814]

B:BD[44.906] → [15.40513:40814]

B:BD[15.40814] → [26.11422:11445]

∅:D[26.11445] → [44.1185:1270]

∅:D[15.40844] → [44.1185:1270]

B:BD[44.1185] → [44.1185:1270]

B:BD[44.1270] → [15.40845:40880]

B:BD[15.40880] → [40.2961:3047]

∅:D[40.3047] → [15.40881:40916]

B:BD[44.1379] → [15.40881:40916]

B:BD[15.40916] → [40.3048:3132]

∅:D[40.3132] → [45.2:7]

B:BD[44.1484] → [45.2:7]

function test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom()
  io.write('\ntest_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom')
  -- display just an empty bottom line on screen
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', ''}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- after hitting the inserting_text key the screen does not scroll down
  edit.run_after_textinput(Editor_state, 'a')
  check_eq(Editor_state.screen_top1.line, 2, 'F - test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom/screen_top')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom/cursor:line')
  check_eq(Editor_state.cursor1.pos, 2, 'F - test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom/cursor:pos')
  local y = Editor_state.top
  App.screen.check(y, 'a', 'F - test_inserting_text_on_final_line_avoids_scrolling_down_when_not_at_bottom/screen:1')
end
function test_typing_on_bottom_line_scrolls_down()
  io.write('\ntest_typing_on_bottom_line_scrolls_down')
  -- display a few lines with cursor on bottom line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=4}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_typing_on_bottom_line_scrolls_down/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_typing_on_bottom_line_scrolls_down/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_typing_on_bottom_line_scrolls_down/baseline/screen:3')
  -- after typing something the line wraps and the screen scrolls down
  edit.run_after_textinput(Editor_state, 'j')
  edit.run_after_textinput(Editor_state, 'k')
  edit.run_after_textinput(Editor_state, 'l')
  check_eq(Editor_state.screen_top1.line, 2, 'F - test_typing_on_bottom_line_scrolls_down/screen_top')
  check_eq(Editor_state.cursor1.line, 3, 'F - test_typing_on_bottom_line_scrolls_down/cursor:line')
  check_eq(Editor_state.cursor1.pos, 7, 'F - test_typing_on_bottom_line_scrolls_down/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'def', 'F - test_typing_on_bottom_line_scrolls_down/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghij', 'F - test_typing_on_bottom_line_scrolls_down/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'kl', 'F - test_typing_on_bottom_line_scrolls_down/screen:3')
end

Deletion in text_tests.lua at line 1288 [22.2]

∅:D[44.1489] → [22.31401:31582]

∅:D[45.5989] → [22.31401:31582]

B:BD[22.31401] → [22.31401:31582]

B:BD[22.31582] → [33.622:663]

B:BD[33.663] → [25.3480:3526]

∅:D[25.3526] → [15.44471:44540]

∅:D[26.12414] → [15.44471:44540]

B:BD[33.663] → [15.44471:44540]

B:BD[15.44540] → [20.3311:3343]

∅:D[20.3343] → [15.44626:44748]

B:BD[15.44626] → [15.44626:44748]

B:BD[15.44748] → [27.2184:2210]

B:BD[27.2210] → [26.12415:12444]

∅:D[26.12444] → [22.31897:32015]

∅:D[15.44785] → [22.31897:32015]

B:BD[22.31897] → [22.31897:32015]

B:BD[22.32015] → [15.44786:44821]

∅:D[15.44821] → [22.32037:32155]

B:BD[22.32037] → [22.32037:32155]

B:BD[22.32155] → [15.44822:44857]

∅:D[15.44857] → [22.32177:32347]

B:BD[22.32177] → [22.32177:32347]

B:BD[22.32347] → [28.5088:5226]

B:BD[28.5226] → [46.950:1063]

∅:D[46.1063] → [26.12445:12468]

B:BD[15.44946] → [26.12445:12468]

∅:D[26.12468] → [22.32532:32650]

∅:D[15.44976] → [22.32532:32650]

B:BD[22.32532] → [22.32532:32650]

B:BD[22.32650] → [15.44977:45012]

∅:D[15.45012] → [22.32672:32790]

B:BD[22.32672] → [22.32672:32790]

B:BD[22.32790] → [15.45013:45048]

∅:D[15.45048] → [22.32812:33004]

B:BD[22.32812] → [22.32812:33004]

B:BD[22.33004] → [26.12469:12584]

∅:D[47.1141] → [22.33130:33154]

∅:D[48.1205] → [22.33130:33154]

∅:D[49.1812] → [22.33130:33154]

∅:D[28.5356] → [22.33130:33154]

∅:D[26.12584] → [22.33130:33154]

∅:D[15.45163] → [22.33130:33154]

B:BD[22.33130] → [22.33130:33154]

B:BD[22.33154] → [46.1064:1178]

B:BD[46.1178] → [50.950:1063]

∅:D[50.1063] → [22.33305:33490]

∅:D[46.1291] → [22.33305:33490]

∅:D[15.45341] → [22.33305:33490]

B:BD[22.33305] → [22.33305:33490]

B:BD[22.33490] → [25.3527:3573]

∅:D[25.3573] → [15.45342:45404]

∅:D[26.12689] → [15.45342:45404]

B:BD[22.33490] → [15.45342:45404]

B:BD[15.45404] → [20.3344:3376]

∅:D[20.3376] → [15.45490:45611]

B:BD[15.45490] → [15.45490:45611]

B:BD[15.45611] → [27.2211:2237]

B:BD[27.2237] → [26.12690:12719]

∅:D[26.12719] → [22.33676:33759]

∅:D[15.45648] → [22.33676:33759]

B:BD[22.33676] → [22.33676:33759]

B:BD[22.33759] → [15.45649:45684]

∅:D[15.45684] → [22.33781:33864]

B:BD[22.33781] → [22.33781:33864]

B:BD[22.33864] → [15.45685:45720]

∅:D[15.45720] → [22.33886:34032]

B:BD[22.33886] → [22.33886:34032]

B:BD[22.34032] → [28.5357:5410]

∅:D[28.5410] → [15.45721:45897]

B:BD[22.34070] → [15.45721:45897]

B:BD[15.45897] → [26.12720:12743]

∅:D[26.12743] → [22.34237:34314]

∅:D[15.45927] → [22.34237:34314]

B:BD[22.34237] → [22.34237:34314]

B:BD[22.34314] → [15.45928:45963]

∅:D[15.45963] → [22.34336:34410]

B:BD[22.34336] → [22.34336:34410]

B:BD[22.34410] → [15.45964:45999]

∅:D[15.45999] → [22.34432:34682]

B:BD[22.34432] → [22.34432:34682]

B:BD[22.34682] → [26.12744:12801]

B:BD[25.3620] → [25.3620:3666]

∅:D[25.3666] → [15.46064:46130]

∅:D[26.13009] → [15.46064:46130]

B:BD[15.46064] → [15.46064:46130]

B:BD[15.46130] → [20.3377:3409]

∅:D[20.3409] → [15.46216:46337]

B:BD[15.46216] → [15.46216:46337]

B:BD[15.46337] → [27.2238:2264]

B:BD[27.2264] → [26.13010:13039]

∅:D[26.13039] → [22.34927:35022]

∅:D[15.46374] → [22.34927:35022]

B:BD[22.34927] → [22.34927:35022]

B:BD[22.35022] → [15.46375:46410]

∅:D[15.46410] → [22.35044:35209]

B:BD[22.35044] → [22.35044:35209]

B:BD[22.35209] → [28.5411:5464]

B:BD[28.5464] → [26.13040:13063]

B:BD[26.13063] → [40.3133:3220]

∅:D[40.3220] → [15.46442:46477]

B:BD[22.35352] → [15.46442:46477]

B:BD[15.46477] → [40.3221:3306]

∅:D[40.3306] → [15.46478:46513]

B:BD[22.35458] → [15.46478:46513]

∅:D[15.46513] → [22.35480:35566]

B:BD[22.35480] → [22.35480:35566]

B:BD[22.35566] → [15.46514:46921]

∅:D[15.46921] → [23.2208:2360]

B:BD[22.35921] → [23.2208:2360]

B:BD[23.2360] → [26.13064:13121]

B:BD[25.3713] → [25.3713:3759]

∅:D[25.3759] → [15.46986:47034]

∅:D[26.13329] → [15.46986:47034]

B:BD[15.46986] → [15.46986:47034]

B:BD[15.47034] → [20.3410:3442]

∅:D[20.3442] → [15.47120:47161]

B:BD[15.47120] → [15.47120:47161]

∅:D[15.47161] → [23.2497:2537]

B:BD[23.2497] → [23.2497:2537]

B:BD[23.2537] → [28.5465:5518]

B:BD[28.5518] → [5.818:908]

∅:D[19.829] → [22.35921:36235]

∅:D[5.908] → [22.35921:36235]

∅:D[23.2652] → [22.35921:36235]

∅:D[15.47252] → [22.35921:36235]

B:BD[22.35921] → [22.35921:36235]

B:BD[22.36235] → [26.13330:13387]

B:BD[25.3806] → [25.3806:3852]

∅:D[25.3852] → [15.47317:47386]

∅:D[26.13595] → [15.47317:47386]

B:BD[15.47317] → [15.47317:47386]

B:BD[15.47386] → [20.3443:3475]

∅:D[20.3475] → [15.47472:47557]

B:BD[15.47472] → [15.47472:47557]

∅:D[15.47557] → [22.36424:36505]

B:BD[22.36424] → [22.36424:36505]

B:BD[22.36505] → [28.5519:5572]

B:BD[28.5572] → [5.909:996]

∅:D[19.912] → [22.36617:36661]

∅:D[5.996] → [22.36617:36661]

∅:D[15.47645] → [22.36617:36661]

B:BD[22.36617] → [22.36617:36661]

B:BD[22.36661] → [15.47646:47824]

∅:D[15.47824] → [22.36813:36839]

B:BD[22.36813] → [22.36813:36839]

B:BD[22.36839] → [15.47825:47914]

∅:D[15.47914] → [22.36915:37096]

B:BD[22.36915] → [22.36915:37096]

B:BD[22.37096] → [26.13596:13653]

B:BD[26.13653] → [25.3853:3899]

∅:D[25.3945] → [15.47979:48048]

∅:D[26.13861] → [15.47979:48048]

B:BD[15.47979] → [15.47979:48048]

B:BD[15.48048] → [20.3476:3508]

∅:D[20.3508] → [15.48134:48219]

B:BD[15.48134] → [15.48134:48219]

∅:D[15.48219] → [22.37285:37331]

B:BD[22.37285] → [22.37285:37331]

B:BD[22.37331] → [28.5573:5626]

B:BD[28.5626] → [5.997:1092]

∅:D[19.1003] → [22.37451:37491]

∅:D[5.1092] → [22.37451:37491]

∅:D[15.48315] → [22.37451:37491]

B:BD[22.37451] → [22.37451:37491]

B:BD[22.37491] → [15.48316:48510]

∅:D[15.48510] → [22.37659:37685]

B:BD[22.37659] → [22.37659:37685]

B:BD[22.37685] → [15.48511:48608]

∅:D[15.48608] → [22.37769:37944]

B:BD[22.37769] → [22.37769:37944]

B:BD[22.37944] → [26.13862:13919]

B:BD[26.13919] → [25.3946:3992]

∅:D[25.4038] → [15.48673:48742]

∅:D[26.14127] → [15.48673:48742]

B:BD[15.48673] → [15.48673:48742]

B:BD[15.48742] → [20.3509:3541]

∅:D[20.3541] → [15.48828:48913]

B:BD[15.48828] → [15.48828:48913]

∅:D[15.48913] → [22.38133:38224]

B:BD[22.38133] → [22.38133:38224]

B:BD[22.38224] → [28.5627:5680]

B:BD[28.5680] → [5.1093:1283]

∅:D[19.1184] → [22.38426:38468]

∅:D[5.1283] → [22.38426:38468]

∅:D[15.49104] → [22.38426:38468]

B:BD[22.38426] → [22.38426:38468]

B:BD[22.38468] → [15.49105:49293]

∅:D[15.49293] → [22.38630:38656]

B:BD[22.38630] → [22.38630:38656]

B:BD[22.38656] → [15.49294:49388]

∅:D[15.49388] → [22.38737:38875]

B:BD[22.38737] → [22.38737:38875]

B:BD[22.38875] → [26.14128:14185]

B:BD[26.14185] → [25.4039:4085]

∅:D[25.4131] → [15.49453:49522]

∅:D[26.14393] → [15.49453:49522]

B:BD[15.49453] → [15.49453:49522]

B:BD[15.49522] → [20.3542:3574]

∅:D[20.3574] → [15.49608:49693]

B:BD[15.49608] → [15.49608:49693]

∅:D[15.49693] → [22.39064:39134]

B:BD[22.39064] → [22.39064:39134]

B:BD[22.39134] → [28.5681:5734]

B:BD[28.5734] → [5.1284:1466]

∅:D[19.1357] → [22.39328:39370]

∅:D[5.1466] → [22.39328:39370]

∅:D[15.49876] → [22.39328:39370]

B:BD[22.39328] → [22.39328:39370]

B:BD[22.39370] → [15.49877:50059]

∅:D[15.50059] → [22.39526:39552]

B:BD[22.39526] → [22.39526:39552]

B:BD[22.39552] → [15.50060:50151]

∅:D[15.50151] → [22.39630:39774]

B:BD[22.39630] → [22.39630:39774]

B:BD[22.39774] → [26.14394:14451]

B:BD[26.14451] → [25.4132:4178]

∅:D[25.4224] → [15.50216:50285]

∅:D[26.14659] → [15.50216:50285]

B:BD[15.50216] → [15.50216:50285]

B:BD[15.50285] → [20.3575:3607]

∅:D[20.3607] → [15.50371:50456]

B:BD[15.50371] → [15.50371:50456]

∅:D[15.50456] → [22.39963:40038]

B:BD[22.39963] → [22.39963:40038]

B:BD[22.40038] → [28.5735:5788]

B:BD[28.5788] → [5.1467:1649]

∅:D[19.1530] → [22.40232:40274]

∅:D[5.1649] → [22.40232:40274]

∅:D[15.50639] → [22.40232:40274]

B:BD[22.40232] → [22.40232:40274]

B:BD[22.40274] → [15.50640:50822]

∅:D[15.50822] → [22.40430:40456]

B:BD[22.40430] → [22.40430:40456]

B:BD[22.40456] → [15.50823:50914]

∅:D[15.50914] → [22.40534:40650]

B:BD[22.40534] → [22.40534:40650]

B:BD[22.40650] → [25.4225:4271]

∅:D[25.4271] → [15.50915:50970]

∅:D[26.14764] → [15.50915:50970]

B:BD[22.40650] → [15.50915:50970]

B:BD[15.50970] → [20.3608:3640]

∅:D[20.3640] → [15.51056:51177]

B:BD[15.51056] → [15.51056:51177]

∅:D[15.51177] → [22.40806:40830]

B:BD[22.40806] → [22.40806:40830]

B:BD[22.40830] → [27.2265:2291]

B:BD[27.2291] → [28.5789:5835]

∅:D[28.5835] → [15.51178:51546]

B:BD[22.40861] → [15.51178:51546]

B:BD[15.51546] → [26.14765:14794]

∅:D[26.14794] → [22.41200:41276]

∅:D[15.51582] → [22.41200:41276]

B:BD[22.41200] → [22.41200:41276]

B:BD[22.41276] → [15.51583:51618]

∅:D[15.51618] → [22.41298:41375]

B:BD[22.41298] → [22.41298:41375]

B:BD[22.41375] → [15.51619:51654]

∅:D[15.51654] → [22.41397:41483]

B:BD[22.41397] → [22.41397:41483]

B:BD[22.41483] → [28.5836:5883]

∅:D[28.5883] → [15.51655:51987]

B:BD[22.41515] → [15.51655:51987]

B:BD[15.51987] → [26.14795:14818]

∅:D[26.14818] → [22.41812:41879]

∅:D[15.52017] → [22.41812:41879]

B:BD[22.41812] → [22.41812:41879]

B:BD[22.41879] → [15.52018:52053]

∅:D[15.52053] → [22.41901:41968]

B:BD[22.41901] → [22.41901:41968]

B:BD[22.41968] → [15.52054:52089]

∅:D[15.52089] → [22.41990:42173]

B:BD[22.41990] → [22.41990:42173]

B:BD[22.42173] → [25.4272:4318]

∅:D[25.4318] → [15.52090:52146]

∅:D[26.14923] → [15.52090:52146]

B:BD[22.42173] → [15.52090:52146]

B:BD[15.52146] → [20.3641:3673]

∅:D[20.3673] → [15.52232:52353]

B:BD[15.52232] → [15.52232:52353]

∅:D[15.52353] → [22.42330:42354]

B:BD[22.42330] → [22.42330:42354]

B:BD[22.42354] → [28.5884:5937]

∅:D[28.5937] → [15.52354:52722]

B:BD[22.42392] → [15.52354:52722]

B:BD[15.52722] → [26.14924:14953]

∅:D[26.14953] → [22.42731:42807]

∅:D[15.52758] → [22.42731:42807]

B:BD[22.42731] → [22.42731:42807]

B:BD[22.42807] → [15.52759:52794]

∅:D[15.52794] → [22.42829:42905]

B:BD[22.42829] → [22.42829:42905]

B:BD[22.42905] → [15.52795:52830]

∅:D[15.52830] → [22.42927:43065]

B:BD[22.42927] → [22.42927:43065]

B:BD[22.43065] → [28.5938:5985]

∅:D[28.5985] → [15.52831:53345]

B:BD[22.43097] → [15.52831:53345]

B:BD[15.53345] → [26.14954:14977]

∅:D[26.14977] → [22.43550:43617]

∅:D[15.53375] → [22.43550:43617]

B:BD[22.43550] → [22.43550:43617]

B:BD[22.43617] → [15.53376:53411]

∅:D[15.53411] → [22.43639:43707]

B:BD[22.43639] → [22.43639:43707]

B:BD[22.43707] → [15.53412:53447]

∅:D[15.53447] → [22.43729:43796]

B:BD[22.43729] → [22.43729:43796]

B:BD[22.43796] → [51.2:144]

B:BD[51.144] → [33.664:703]

B:BD[33.703] → [25.4319:4365]

∅:D[25.4365] → [15.53448:53489]

∅:D[26.15082] → [15.53448:53489]

B:BD[33.703] → [15.53448:53489]

B:BD[15.53489] → [20.3674:3706]

∅:D[20.3706] → [15.53575:53740]

B:BD[15.53575] → [15.53575:53740]

B:BD[15.53740] → [27.2292:2318]

∅:D[34.1313] → [51.355:381]

∅:D[27.2318] → [51.355:381]

B:BD[51.355] → [51.355:381]

B:BD[51.381] → [28.5986:6032]

B:BD[28.6032] → [5.1650:1741]

∅:D[19.1617] → [15.53832:53929]

∅:D[5.1741] → [15.53832:53929]

B:BD[15.53832] → [15.53832:53929]

∅:D[15.53929] → [51.574:584]

B:BD[51.574] → [51.574:584]

B:BD[51.584] → [28.6033:6127]

∅:D[52.34] → [51.616:643]

∅:D[28.6127] → [51.616:643]

B:BD[51.616] → [51.616:643]

B:BD[51.643] → [15.53930:54098]

∅:D[51.785] → [22.43796:43800]

∅:D[15.54098] → [22.43796:43800]

B:BD[22.43796] → [22.43796:43800]

B:BD[22.43800] → [53.2:3]

function test_position_cursor_on_recently_edited_wrapping_line()
  -- draw a line wrapping over 2 screen lines
  io.write('\ntest_position_cursor_on_recently_edited_wrapping_line')
  App.screen.init{width=100, height=200}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def ghi jkl mno pqr ', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=25}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc def ghi ', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline1/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl mno pqr ', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline1/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'xyz', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline1/screen:3')
  -- add to the line until it's wrapping over 3 screen lines
  edit.run_after_textinput(Editor_state, 's')
  edit.run_after_textinput(Editor_state, 't')
  edit.run_after_textinput(Editor_state, 'u')
  check_eq(Editor_state.cursor1.pos, 28, 'F - test_position_cursor_on_recently_edited_wrapping_line/cursor:pos')
  y = Editor_state.top
  App.screen.check(y, 'abc def ghi ', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline2/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl mno pqr ', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline2/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'stu', 'F - test_position_cursor_on_recently_edited_wrapping_line/baseline2/screen:3')
  -- try to move the cursor earlier in the third screen line by clicking the mouse
  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+Editor_state.line_height*2+5, 1)
  -- cursor should move
  check_eq(Editor_state.cursor1.line, 1, 'F - test_position_cursor_on_recently_edited_wrapping_line/cursor:line')
  check_eq(Editor_state.cursor1.pos, 26, 'F - test_position_cursor_on_recently_edited_wrapping_line/cursor:pos')
end
function test_backspace_can_scroll_up()
  io.write('\ntest_backspace_can_scroll_up')
  -- display the lines 2/3/4 with the cursor on line 2
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'def', 'F - test_backspace_can_scroll_up/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_backspace_can_scroll_up/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl', 'F - test_backspace_can_scroll_up/baseline/screen:3')
  -- after hitting backspace the screen scrolls up by one line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_backspace_can_scroll_up/screen_top')
  check_eq(Editor_state.cursor1.line, 1, 'F - test_backspace_can_scroll_up/cursor')
  y = Editor_state.top
  App.screen.check(y, 'abcdef', 'F - test_backspace_can_scroll_up/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_backspace_can_scroll_up/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl', 'F - test_backspace_can_scroll_up/screen:3')
end
function test_backspace_can_scroll_up_screen_line()
  io.write('\ntest_backspace_can_scroll_up_screen_line')
  -- display lines starting from second screen line of a line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=5}
  Editor_state.screen_top1 = {line=3, pos=5}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'jkl', 'F - test_backspace_can_scroll_up_screen_line/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'mno', 'F - test_backspace_can_scroll_up_screen_line/baseline/screen:2')
  -- after hitting backspace the screen scrolls up by one screen line
  edit.run_after_keychord(Editor_state, 'backspace')
  y = Editor_state.top
  App.screen.check(y, 'ghij', 'F - test_backspace_can_scroll_up_screen_line/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'kl', 'F - test_backspace_can_scroll_up_screen_line/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'mno', 'F - test_backspace_can_scroll_up_screen_line/screen:3')
  check_eq(Editor_state.screen_top1.line, 3, 'F - test_backspace_can_scroll_up_screen_line/screen_top')
  check_eq(Editor_state.screen_top1.pos, 1, 'F - test_backspace_can_scroll_up_screen_line/screen_top')
  check_eq(Editor_state.cursor1.line, 3, 'F - test_backspace_can_scroll_up_screen_line/cursor:line')
  check_eq(Editor_state.cursor1.pos, 4, 'F - test_backspace_can_scroll_up_screen_line/cursor:pos')
end
function test_backspace_past_line_boundary()
  io.write('\ntest_backspace_past_line_boundary')
  -- position cursor at start of a (non-first) line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  -- backspace joins with previous line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'abcdef', "F - test_backspace_past_line_boundary")
end
-- some tests for operating over selections created using Shift- chords
-- we're just testing delete_selection, and it works the same for all keys
function test_backspace_over_selection()
  io.write('\ntest_backspace_over_selection')
  -- select just one character within a line with cursor before selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  -- backspace deletes the selected character, even though it's after the cursor
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection/data")
  -- cursor (remains) at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_selection/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_over_selection/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_selection/selection")
end
function test_backspace_over_selection_reverse()
  io.write('\ntest_backspace_over_selection_reverse')
  -- select just one character within a line with cursor after selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=1, pos=1}
  -- backspace deletes the selected character
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection_reverse/data")
  -- cursor moves to start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_selection_reverse/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_over_selection_reverse/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_selection_reverse/selection")
end
function test_backspace_over_multiple_lines()
  io.write('\ntest_backspace_over_multiple_lines')
  -- select just one character within a line with cursor after selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=4, pos=2}
  -- backspace deletes the region and joins the remaining portions of lines on either side
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'akl', "F - test_backspace_over_multiple_lines/data:1")
  check_eq(Editor_state.lines[2].data, 'mno', "F - test_backspace_over_multiple_lines/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_multiple_lines/cursor:line")
  check_eq(Editor_state.cursor1.pos, 2, "F - test_backspace_over_multiple_lines/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_multiple_lines/selection")
end
function test_backspace_to_end_of_line()
  io.write('\ntest_backspace_to_end_of_line')
  -- select region from cursor to end of line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=1, pos=4}
  -- backspace deletes rest of line without joining to any other line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'a', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2].data, 'def', "F - test_backspace_to_start_of_line/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_to_start_of_line/cursor:line")
  check_eq(Editor_state.cursor1.pos, 2, "F - test_backspace_to_start_of_line/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_to_start_of_line/selection")
end
function test_backspace_to_start_of_line()
  io.write('\ntest_backspace_to_start_of_line')
  -- select region from cursor to start of line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.selection1 = {line=2, pos=3}
  -- backspace deletes beginning of line without joining to any other line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'abc', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2].data, 'f', "F - test_backspace_to_start_of_line/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 2, "F - test_backspace_to_start_of_line/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_to_start_of_line/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_to_start_of_line/selection")
end
function test_undo_insert_text()
  io.write('\ntest_undo_insert_text')
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=4}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- insert a character
  edit.draw(Editor_state)
  edit.run_after_textinput(Editor_state, 'g')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_undo_insert_text/baseline/cursor:line')
  check_eq(Editor_state.cursor1.pos, 5, 'F - test_undo_insert_text/baseline/cursor:pos')
  check_nil(Editor_state.selection1.line, 'F - test_undo_insert_text/baseline/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_insert_text/baseline/selection:pos')
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_undo_insert_text/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'defg', 'F - test_undo_insert_text/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'xyz', 'F - test_undo_insert_text/baseline/screen:3')
  -- undo
  edit.run_after_keychord(Editor_state, 'C-z')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_undo_insert_text/cursor:line')
  check_eq(Editor_state.cursor1.pos, 4, 'F - test_undo_insert_text/cursor:pos')
  check_nil(Editor_state.selection1.line, 'F - test_undo_insert_text/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_insert_text/selection:pos')
  y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_undo_insert_text/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_undo_insert_text/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'xyz', 'F - test_undo_insert_text/screen:3')
end
function test_undo_delete_text()
  io.write('\ntest_undo_delete_text')
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'defg', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=5}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  -- delete a character
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_undo_delete_text/baseline/cursor:line')
  check_eq(Editor_state.cursor1.pos, 4, 'F - test_undo_delete_text/baseline/cursor:pos')
  check_nil(Editor_state.selection1.line, 'F - test_undo_delete_text/baseline/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_delete_text/baseline/selection:pos')
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_undo_delete_text/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'def', 'F - test_undo_delete_text/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'xyz', 'F - test_undo_delete_text/baseline/screen:3')
  -- undo
--?   -- after undo, the backspaced key is selected
  edit.run_after_keychord(Editor_state, 'C-z')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_undo_delete_text/cursor:line')
  check_eq(Editor_state.cursor1.pos, 5, 'F - test_undo_delete_text/cursor:pos')
  check_nil(Editor_state.selection1.line, 'F - test_undo_delete_text/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_delete_text/selection:pos')
--?   check_eq(Editor_state.selection1.line, 2, 'F - test_undo_delete_text/selection:line')
--?   check_eq(Editor_state.selection1.pos, 4, 'F - test_undo_delete_text/selection:pos')
  y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_undo_delete_text/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'defg', 'F - test_undo_delete_text/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'xyz', 'F - test_undo_delete_text/screen:3')
end
function test_undo_restores_selection()
  io.write('\ntest_undo_restores_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- delete selected text
  edit.run_after_textinput(Editor_state, 'x')
  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_undo_restores_selection/baseline')
  check_nil(Editor_state.selection1.line, 'F - test_undo_restores_selection/baseline:selection')
  -- undo
  edit.run_after_keychord(Editor_state, 'C-z')
  edit.run_after_keychord(Editor_state, 'C-z')
  -- selection is restored
  check_eq(Editor_state.selection1.line, 1, 'F - test_undo_restores_selection/line')
  check_eq(Editor_state.selection1.pos, 2, 'F - test_undo_restores_selection/pos')
end

Deletion in text.lua at line 6 [54.1]
∅:D[22.43955] → [13.2775:2790]
B:BD[13.2775] → [13.2775:2790]
```
require 'undo'
```

Deletion in text.lua at line 152 [54.1]

B:BD[55.1568] → [56.3:37]

∅:D[56.37] → [47.1143:1182]

B:BD[57.28] → [47.1143:1182]

B:BD[47.1182] → [58.3:76]

B:BD[58.76] → [14.1020:1073]

∅:D[14.1073] → [56.84:235]

B:BD[56.84] → [56.84:235]

B:BD[56.235] → [59.3:37]

B:BD[59.37] → [7.3:68]

∅:D[7.68] → [60.64:134]

B:BD[56.302] → [60.64:134]

∅:D[60.134] → [26.15185:15258]

B:BD[26.15185] → [26.15185:15258]

∅:D[61.107] → [56.531:690]

∅:D[26.15258] → [56.531:690]

B:BD[56.531] → [56.531:690]

∅:D[56.690] → [62.396:402]

∅:D[15.56526] → [62.396:402]

B:BD[62.396] → [62.396:402]

B:BD[62.402] → [14.1074:1161]

∅:D[56.764] → [63.60:65]

∅:D[14.1161] → [63.60:65]

∅:D[16.1342] → [63.60:65]

∅:D[15.56607] → [63.60:65]

B:BD[63.60] → [63.60:65]

B:BD[63.65] → [59.38:79]

B:BD[59.79] → [5.1939:2204]

∅:D[19.2113] → [64.3:61]

∅:D[5.2204] → [64.3:61]

B:BD[59.344] → [64.3:61]

∅:D[64.61] → [59.396:438]

B:BD[59.396] → [59.396:438]

∅:D[17.107] → [65.513:518]

∅:D[59.438] → [65.513:518]

∅:D[66.763] → [65.513:518]

∅:D[44.1690] → [65.513:518]

∅:D[13.6449] → [65.513:518]

∅:D[15.57058] → [65.513:518]

B:BD[65.513] → [65.513:518]

function Text.textinput(State, t)
  if App.mouse_down(1) then return end
  if App.ctrl_down() or App.alt_down() or App.cmd_down() then return end
  local before = snapshot(State, State.cursor1.line)
--?   print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)
  Text.insert_at_cursor(State, t)
  if State.cursor_y > App.screen.height - State.line_height then
    Text.populate_screen_line_starting_pos(State, State.cursor1.line)
    Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
--?     print('=>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)
  end
  record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
end
function Text.insert_at_cursor(State, t)
  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line].data, byte_offset)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1.pos = State.cursor1.pos+1
end

Deletion in text.lua at line 155 [54.1]
∅:D[67.121] → [68.1:35]
∅:D[69.173] → [68.1:35]
∅:D[70.732] → [68.1:35]
∅:D[71.8394] → [68.1:35]
∅:D[15.57146] → [68.1:35]
B:BD[65.627] → [68.1:35]
∅:D[68.35] → [65.627:655]
∅:D[72.63] → [65.627:655]
∅:D[73.296] → [65.627:655]
∅:D[74.337] → [65.627:655]
B:BD[65.627] → [65.627:655]
B:BD[65.655] → [67.122:165]
B:BD[67.165] → [14.1162:1210]
∅:D[14.1210] → [59.439:469]
B:BD[16.1421] → [59.439:469]
∅:D[59.469] → [67.166:192]
B:BD[75.27] → [67.166:192]
B:BD[67.192] → [7.69:136]
∅:D[7.136] → [26.15259:15334]
B:BD[67.261] → [26.15259:15334]
∅:D[76.176] → [77.105:113]
∅:D[61.214] → [77.105:113]
∅:D[67.360] → [77.105:113]
∅:D[26.15334] → [77.105:113]
∅:D[15.57427] → [77.105:113]
B:BD[77.105] → [77.105:113]
B:BD[77.113] → [78.3:28]
B:BD[78.28] → [14.1211:1313]
∅:D[17.196] → [63.134:163]
∅:D[67.449] → [63.134:163]
∅:D[79.768] → [63.134:163]
∅:D[14.1313] → [63.134:163]
∅:D[16.1504] → [63.134:163]
∅:D[80.1648] → [63.134:163]
∅:D[13.6560] → [63.134:163]
∅:D[15.57523] → [63.134:163]
B:BD[63.134] → [63.134:163]
B:BD[63.163] → [14.1314:1369]
∅:D[14.1369] → [67.498:651]
B:BD[67.498] → [67.498:651]
B:BD[67.651] → [59.470:509]
B:BD[59.509] → [7.137:204]
∅:D[7.204] → [60.135:207]
B:BD[67.720] → [60.135:207]
∅:D[60.207] → [26.15438:15513]
B:BD[26.15438] → [26.15438:15513]
∅:D[61.321] → [67.953:1114]
∅:D[26.15513] → [67.953:1114]
B:BD[67.953] → [67.953:1114]
∅:D[67.1114] → [62.806:814]
∅:D[15.58335] → [62.806:814]
B:BD[62.806] → [62.806:814]
B:BD[62.814] → [78.29:54]
B:BD[78.54] → [14.1370:1459]
∅:D[17.285] → [65.2046:2081]
∅:D[81.292] → [65.2046:2081]
∅:D[79.789] → [65.2046:2081]
∅:D[67.1190] → [65.2046:2081]
∅:D[14.1459] → [65.2046:2081]
∅:D[16.1617] → [65.2046:2081]
∅:D[66.1901] → [65.2046:2081]
∅:D[13.6671] → [65.2046:2081]
∅:D[15.58418] → [65.2046:2081]
B:BD[65.2046] → [65.2046:2081]
B:BD[65.2081] → [67.1191:1225]
B:BD[67.1225] → [26.15514:15574]
∅:D[82.247] → [78.55:82]
∅:D[26.15574] → [78.55:82]
B:BD[67.1309] → [78.55:82]
∅:D[83.67] → [71.8453:8474]
∅:D[78.82] → [71.8453:8474]
∅:D[17.376] → [71.8453:8474]
∅:D[79.812] → [71.8453:8474]
∅:D[13.6820] → [71.8453:8474]
B:BD[71.8453] → [71.8453:8474]
B:BD[71.8474] → [16.1618:1635]
B:BD[16.1635] → [67.1310:1344]
B:BD[67.1344] → [14.1460:1511]
B:BD[14.1511] → [5.2205:2393]
∅:D[67.1576] → [65.2256:2306]
∅:D[66.2082] → [65.2256:2306]
∅:D[19.2292] → [65.2256:2306]
∅:D[5.2393] → [65.2256:2306]
∅:D[15.58881] → [65.2256:2306]
B:BD[65.2256] → [65.2256:2306]
B:BD[65.2306] → [5.2394:2569]
∅:D[67.1752] → [65.2442:2455]
∅:D[66.2222] → [65.2442:2455]
∅:D[19.2453] → [65.2442:2455]
∅:D[5.2569] → [65.2442:2455]
∅:D[15.59099] → [65.2442:2455]
B:BD[65.2442] → [65.2442:2455]
B:BD[65.2455] → [5.2570:2685]
∅:D[67.1868] → [65.2544:2556]
∅:D[66.2314] → [65.2544:2556]
∅:D[19.2559] → [65.2544:2556]
∅:D[5.2685] → [65.2544:2556]
∅:D[15.59243] → [65.2544:2556]
B:BD[65.2544] → [65.2544:2556]
B:BD[65.2556] → [67.1869:1917]
∅:D[67.1917] → [65.2590:2600]
∅:D[66.2395] → [65.2590:2600]
∅:D[15.59306] → [65.2590:2600]
B:BD[65.2590] → [65.2590:2600]
B:BD[65.2600] → [67.1918:1957]
B:BD[67.1957] → [14.1512:1585]
B:BD[14.1585] → [19.2560:2580]
B:BD[19.2580] → [5.2686:2887]
∅:D[5.2887] → [19.2761:2870]
B:BD[19.2761] → [19.2761:2870]
∅:D[19.2870] → [67.2406:2454]
B:BD[65.2958] → [67.2406:2454]
∅:D[67.2454] → [84.2858:2866]
∅:D[15.59983] → [84.2858:2866]
B:BD[66.2804] → [84.2858:2866]
B:BD[84.2866] → [3.793:1154]
∅:D[3.1154] → [85.3:57]
B:BD[67.2510] → [85.3:57]
∅:D[85.57] → [26.15654:15731]
B:BD[26.15654] → [26.15654:15731]
∅:D[26.15731] → [61.540:685]
B:BD[61.540] → [61.540:685]
∅:D[86.95] → [65.2992:3000]
∅:D[61.685] → [65.2992:3000]
∅:D[66.2804] → [65.2992:3000]
∅:D[84.3103] → [65.2992:3000]
B:BD[65.2992] → [65.2992:3000]
B:BD[65.3000] → [64.62:122]
∅:D[64.122] → [67.2810:2865]
B:BD[67.2810] → [67.2810:2865]
B:BD[67.2865] → [78.83:108]
B:BD[78.108] → [14.1586:1675]
∅:D[17.434] → [65.3034:3066]
∅:D[79.833] → [65.3034:3066]
∅:D[14.1675] → [65.3034:3066]
∅:D[16.1843] → [65.3034:3066]
∅:D[67.2941] → [65.3034:3066]
∅:D[13.6889] → [65.3034:3066]
∅:D[15.60561] → [65.3034:3066]
B:BD[65.3034] → [65.3034:3066]
B:BD[65.3066] → [67.2942:2976]
B:BD[67.2976] → [26.15732:15792]
∅:D[82.339] → [78.109:136]
∅:D[26.15792] → [78.109:136]
B:BD[67.3060] → [78.109:136]
∅:D[83.111] → [71.8533:8546]
∅:D[78.136] → [71.8533:8546]
∅:D[17.525] → [71.8533:8546]
∅:D[79.856] → [71.8533:8546]
∅:D[13.7038] → [71.8533:8546]
B:BD[71.8533] → [71.8533:8546]
B:BD[71.8546] → [16.1844:1869]
B:BD[16.1869] → [5.2888:2968]
∅:D[19.2946] → [14.1676:1727]
∅:D[5.2968] → [14.1676:1727]
B:BD[67.3141] → [14.1676:1727]
∅:D[14.1727] → [16.1969:1978]
∅:D[67.3185] → [16.1969:1978]
∅:D[15.60854] → [16.1969:1978]
B:BD[16.1969] → [16.1969:1978]
B:BD[16.1978] → [14.1728:1801]
∅:D[14.1801] → [71.8546:8554]
∅:D[16.2032] → [71.8546:8554]
∅:D[67.3252] → [71.8546:8554]
∅:D[15.60935] → [71.8546:8554]
B:BD[71.8546] → [71.8546:8554]
B:BD[71.8554] → [5.2969:3237]
∅:D[66.3019] → [65.3265:3315]
∅:D[19.3200] → [65.3265:3315]
∅:D[5.3237] → [65.3265:3315]
∅:D[67.3521] → [65.3265:3315]
∅:D[15.61267] → [65.3265:3315]
B:BD[65.3265] → [65.3265:3315]
B:BD[65.3315] → [5.3238:3413]
∅:D[66.3159] → [65.3451:3464]
∅:D[19.3361] → [65.3451:3464]
∅:D[5.3413] → [65.3451:3464]
∅:D[67.3697] → [65.3451:3464]
∅:D[15.61485] → [65.3451:3464]
B:BD[65.3451] → [65.3451:3464]
B:BD[65.3464] → [5.3414:3529]
∅:D[66.3251] → [65.3553:3565]
∅:D[19.3467] → [65.3553:3565]
∅:D[5.3529] → [65.3553:3565]
∅:D[67.3813] → [65.3553:3565]
∅:D[15.61629] → [65.3553:3565]
B:BD[65.3553] → [65.3553:3565]
B:BD[65.3565] → [67.3814:3856]
∅:D[66.3332] → [65.3600:3610]
∅:D[67.3856] → [65.3600:3610]
∅:D[15.61679] → [65.3600:3610]
B:BD[65.3600] → [65.3600:3610]
B:BD[65.3610] → [67.3857:3907]
B:BD[67.3907] → [19.3468:3488]
B:BD[19.3488] → [5.3530:3652]
∅:D[19.3595] → [20.4335:4389]
∅:D[5.3652] → [20.4335:4389]
B:BD[65.3914] → [20.4335:4389]
B:BD[20.4389] → [87.227:286]
∅:D[87.286] → [65.3914:3922]
∅:D[20.4453] → [65.3914:3922]
B:BD[65.3914] → [65.3914:3922]
B:BD[65.3922] → [64.123:183]
∅:D[64.183] → [78.137:162]
B:BD[67.4265] → [78.137:162]
B:BD[78.162] → [14.1802:1891]
```
  --== shortcuts that mutate text
  if chord == 'return' then
    local before_line = State.cursor1.line
    local before = snapshot(State, before_line)
    Text.insert_return(State)
    State.selection1 = {}
    if State.cursor_y > App.screen.height - State.line_height then
      Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
    end
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, before_line, State.cursor1.line)})
  elseif chord == 'tab' then
    local before = snapshot(State, State.cursor1.line)
--?     print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)
    Text.insert_at_cursor(State, '\t')
    if State.cursor_y > App.screen.height - State.line_height then
      Text.populate_screen_line_starting_pos(State, State.cursor1.line)
      Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
--?       print('=>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)
    end
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  elseif chord == 'backspace' then
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
    local before
    if State.cursor1.pos > 1 then
      before = snapshot(State, State.cursor1.line)
      local byte_start = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos-1)
      local byte_end = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
      if byte_start then
        if byte_end then
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].data, byte_end)
        else
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
        end
        State.cursor1.pos = State.cursor1.pos-1
      end
    elseif State.cursor1.line > 1 then
      before = snapshot(State, State.cursor1.line-1, State.cursor1.line)
      -- join lines
      State.cursor1.pos = utf8.len(State.lines[State.cursor1.line-1].data)+1
      State.lines[State.cursor1.line-1].data = State.lines[State.cursor1.line-1].data..State.lines[State.cursor1.line].data
      table.remove(State.lines, State.cursor1.line)
      table.remove(State.line_cache, State.cursor1.line)
      State.cursor1.line = State.cursor1.line-1
    end
    if State.screen_top1.line > #State.lines then
      Text.populate_screen_line_starting_pos(State, #State.lines)
      local line_cache = State.line_cache[#State.line_cache]
      State.screen_top1 = {line=#State.lines, pos=line_cache.screen_line_starting_pos[#line_cache.screen_line_starting_pos]}
    elseif Text.lt1(State.cursor1, State.screen_top1) then
      local top2 = Text.to2(State, State.screen_top1)
      top2 = Text.previous_screen_line(State, top2, State.left, State.right)
      State.screen_top1 = Text.to1(State, top2)
      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    assert(Text.le1(State.screen_top1, State.cursor1))
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  elseif chord == 'delete' then
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
    local before
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      before = snapshot(State, State.cursor1.line)
    else
      before = snapshot(State, State.cursor1.line, State.cursor1.line+1)
    end
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      local byte_start = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
      local byte_end = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos+1)
      if byte_start then
        if byte_end then
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].data, byte_end)
        else
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
        end
        -- no change to State.cursor1.pos
      end
    elseif State.cursor1.line < #State.lines then
      -- join lines
      State.lines[State.cursor1.line].data = State.lines[State.cursor1.line].data..State.lines[State.cursor1.line+1].data
      table.remove(State.lines, State.cursor1.line+1)
      table.remove(State.line_cache, State.cursor1.line+1)
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
```
Replacement in text.lua at line 156 [54.1]
B:BD[68.247] → [68.247:277]
```
  elseif chord == 'left' then
```
[68.247]
[10.3]
```
  if chord == 'left' then
```

Deletion in text.lua at line 238 [54.1]

∅:D[88.159] → [75.188:193]

B:BD[75.188] → [75.188:193]

B:BD[75.193] → [59.2022:2057]

B:BD[59.2057] → [5.3653:3864]

∅:D[19.3790] → [87.287:346]

∅:D[5.3864] → [87.287:346]

B:BD[59.2281] → [87.287:346]

B:BD[87.346] → [5.3865:3973]

∅:D[19.3889] → [64.184:242]

∅:D[5.3973] → [64.184:242]

B:BD[59.2389] → [64.184:242]

∅:D[64.302] → [59.2495:2563]

B:BD[59.2495] → [59.2495:2563]

end
function Text.insert_return(State)
  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  table.insert(State.lines, State.cursor1.line+1, {data=string.sub(State.lines[State.cursor1.line].data, byte_offset)})
  table.insert(State.line_cache, State.cursor1.line+1, {})
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1.line = State.cursor1.line+1
  State.cursor1.pos = 1

Deletion in select.lua at line 94 [22.43980]
∅:D[19.7858] → [22.46481:46495]
B:BD[22.46481] → [22.46481:46495]
B:BD[22.46495] → [89.5:10]
B:BD[89.10] → [90.4293:4328]
∅:D[90.4328] → [82.1580:1669]
B:BD[82.1580] → [82.1580:1669]
B:BD[82.1669] → [90.4329:4360]
∅:D[91.583] → [89.100:116]
∅:D[82.1713] → [89.100:116]
∅:D[90.4360] → [89.100:116]
B:BD[89.100] → [89.100:116]
∅:D[89.116] → [22.46495:46500]
B:BD[22.46495] → [22.46495:46500]
B:BD[22.46500] → [90.4361:4399]
∅:D[90.4399] → [82.1765:1885]
B:BD[82.1765] → [82.1765:1885]
B:BD[82.1885] → [14.1894:1939]
B:BD[14.1939] → [90.4400:4444]
∅:D[90.4444] → [14.1940:2027]
B:BD[82.1943] → [14.1940:2027]
∅:D[82.2016] → [22.46735:46740]
∅:D[14.2027] → [22.46735:46740]
∅:D[15.79891] → [22.46735:46740]
B:BD[22.46735] → [22.46735:46740]
B:BD[22.46740] → [90.4445:4496]
∅:D[90.4496] → [82.2081:2305]
B:BD[82.2081] → [82.2081:2305]
∅:D[82.2305] → [22.46968:47121]
∅:D[15.80165] → [22.46968:47121]
B:BD[22.46968] → [22.46968:47121]
```
    end
  end
end
function Text.cut_selection(State)
  if State.selection1.line == nil then return end
  local result = Text.selection(State)
  Text.delete_selection(State)
  return result
end
function Text.delete_selection(State)
  if State.selection1.line == nil then return end
  local minl,maxl = minmax(State.selection1.line, State.cursor1.line)
  local before = snapshot(State, minl, maxl)
  Text.delete_selection_without_undo(State)
  record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
end
function Text.delete_selection_without_undo(State)
  if State.selection1.line == nil then return end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp = State.selection1.line,State.selection1.pos
  local maxl,maxp = State.cursor1.line,State.cursor1.pos
  if minl > maxl then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
  elseif minl == maxl then
    if minp > maxp then
      minp,maxp = maxp,minp
```

Deletion in select.lua at line 95 [22.43980]

B:BD[22.47129] → [22.47129:47135]

B:BD[22.47135] → [82.2306:2509]

B:BD[82.2509] → [9.679:762]

  end
  -- update State.cursor1 and State.selection1
  State.cursor1.line = minl
  State.cursor1.pos = minp
  if Text.lt1(State.cursor1, State.screen_top1) then
    State.screen_top1.line = State.cursor1.line
    State.screen_top1.pos = Text.pos_at_start_of_screen_line(State, State.cursor1)

Deletion in select.lua at line 96 [22.43980]
B:BD[39.1166] → [82.2593:2617]
∅:D[82.2617] → [22.47231:47298]
∅:D[15.80547] → [22.47231:47298]
B:BD[22.47231] → [22.47231:47298]
B:BD[22.47298] → [64.564:608]
B:BD[64.608] → [5.6327:6453]
∅:D[69.1424] → [22.47487:47540]
∅:D[82.2782] → [22.47487:47540]
∅:D[5.6453] → [22.47487:47540]
∅:D[19.7975] → [22.47487:47540]
∅:D[15.80733] → [22.47487:47540]
B:BD[22.47487] → [22.47487:47540]
B:BD[22.47540] → [5.6454:6567]
∅:D[82.2896] → [22.47635:47674]
∅:D[5.6567] → [22.47635:47674]
∅:D[19.8074] → [22.47635:47674]
∅:D[15.80868] → [22.47635:47674]
B:BD[22.47635] → [22.47635:47674]
B:BD[22.47674] → [5.6568:6621]
∅:D[82.2950] → [22.47721:47747]
∅:D[5.6621] → [22.47721:47747]
∅:D[19.8123] → [22.47721:47747]
∅:D[15.80929] → [22.47721:47747]
B:BD[22.47721] → [22.47721:47747]
B:BD[22.47747] → [82.2951:2984]
B:BD[82.2984] → [87.1780:1818]
∅:D[87.1818] → [22.47774:47780]
∅:D[82.2984] → [22.47774:47780]
∅:D[20.7625] → [22.47774:47780]
∅:D[15.80970] → [22.47774:47780]
B:BD[22.47774] → [22.47774:47780]
B:BD[22.47780] → [5.6622:6698]
```
  State.selection1 = {}
  -- delete everything between min (inclusive) and max (exclusive)
  Text.clear_screen_line_cache(State, minl)
  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)
  if minl == maxl then
--?     print('minl == maxl')
    State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..State.lines[minl].data:sub(max_offset)
    return
  end
  assert(minl < maxl)
  local rhs = State.lines[maxl].data:sub(max_offset)
  for i=maxl,minl+1,-1 do
    table.remove(State.lines, i)
    table.remove(State.line_cache, i)
  end
  State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..rhs
```

Deletion in main_tests.lua at line 46 [93.7]

∅:D[11.80] → [92.7:99]

∅:D[5.7872] → [92.7:99]

∅:D[19.9279] → [92.7:99]

∅:D[15.85118] → [92.7:99]

B:BD[94.871] → [92.7:99]

B:BD[92.99] → [26.17202:17261]

∅:D[26.17261] → [92.152:234]

∅:D[15.85185] → [92.152:234]

B:BD[92.152] → [92.152:234]

B:BD[92.234] → [15.85186:85266]

B:BD[15.85266] → [78.167:197]

∅:D[78.197] → [92.306:1001]

B:BD[92.306] → [92.306:1001]

end
function test_drop_file_saves_previous()
  io.write('\ntest_drop_file_saves_previous')
  App.screen.init{width=Editor_state.left+300, height=300}
  -- initially editing a file called foo that hasn't been saved to filesystem yet
  Editor_state.lines = load_array{'abc', 'def'}
  Editor_state.filename = 'foo'
  schedule_save(Editor_state)
  -- now drag a new file bar from the filesystem
  App.filesystem['bar'] = 'abc\ndef\nghi\n'
  local fake_dropped_file = {
    opened = false,
    getFilename = function(self)
                    return 'bar'
                  end,
    open = function(self)
             self.opened = true
           end,
    lines = function(self)
              assert(self.opened)
              return App.filesystem['bar']:gmatch('[^\n]+')
            end,
    close = function(self)
              self.opened = false
            end,
  }
  App.filedropped(fake_dropped_file)
  -- filesystem now contains a file called foo
  check_eq(App.filesystem['foo'], 'abc\ndef\n', 'F - test_drop_file_saves_previous')

Deletion in edit.lua at line 68 [95.413]
B:BD[15.97660] → [15.97660:97681]
∅:D[15.97681] → [95.3654:3655]
B:BD[95.3654] → [95.3654:3655]
B:BD[95.3655] → [15.97682:97734]
```
    next_save = nil,
    -- undo
    history = {},
    next_history = 1,
```
Deletion in edit.lua at line 109 [95.413]
∅:D[96.43] → [27.4253:4315]
B:BD[95.6353] → [27.4253:4315]
B:BD[27.4315] → [97.421:445]
∅:D[97.445] → [27.4361:4387]
B:BD[27.4361] → [27.4361:4387]
∅:D[27.4387] → [95.6457:6468]
∅:D[15.99992] → [95.6457:6468]
B:BD[95.6457] → [95.6457:6468]
B:BD[95.6468] → [78.249:419]
∅:D[78.419] → [95.6621:6627]
∅:D[15.100147] → [95.6621:6627]
B:BD[95.6621] → [95.6621:6627]
```
  if State.next_save and State.next_save < App.getTime() then
    save_to_disk(State)
    State.next_save = nil
  end
end
function schedule_save(State)
  if State.next_save == nil then
    State.next_save = App.getTime() + 3  -- short enough that you're likely to still remember what you did
  end
```
Deletion in edit.lua at line 112 [95.413]
∅:D[27.4414] → [95.6653:6692]
B:BD[95.6653] → [95.6653:6692]
B:BD[95.6692] → [27.4415:4441]
B:BD[27.4441] → [97.446:470]
∅:D[97.470] → [95.6746:6752]
∅:D[27.4487] → [95.6746:6752]
∅:D[15.100241] → [95.6746:6752]
B:BD[95.6746] → [95.6746:6752]
```
  -- make sure to save before quitting
  if State.next_save then
    save_to_disk(State)
  end
```
Deletion in edit.lua at line 177 [95.413]
∅:D[14.2586] → [95.10285:10292]
∅:D[27.6749] → [95.10285:10292]
∅:D[15.102724] → [95.10285:10292]
B:BD[95.10285] → [95.10285:10292]
B:BD[95.10292] → [56.777:806]
```
  else
    Text.textinput(State, t)
```
Deletion in edit.lua at line 178 [95.413]
B:BD[95.10320] → [78.446:469]
```
  schedule_save(State)
```

Deletion in edit.lua at line 226 [95.413]

B:BD[61.6870] → [8.26:36]

∅:D[8.36] → [95.12236:12265]

∅:D[61.6870] → [95.12236:12265]

B:BD[95.12236] → [95.12236:12265]

B:BD[95.12265] → [4.15:122]

∅:D[4.122] → [14.2587:2623]

∅:D[98.834] → [14.2587:2623]

B:BD[27.7943] → [14.2587:2623]

∅:D[14.2623] → [95.12375:12424]

B:BD[95.12375] → [95.12375:12424]

B:BD[95.12424] → [27.7944:8139]

B:BD[27.8139] → [87.1967:2037]

B:BD[99.104] → [99.104:206]

∅:D[99.206] → [78.470:497]

∅:D[61.6968] → [78.470:497]

B:BD[95.12687] → [78.470:497]

∅:D[78.497] → [95.12709:12746]

B:BD[95.12709] → [95.12709:12746]

B:BD[95.12746] → [98.835:942]

∅:D[98.942] → [14.2624:2660]

B:BD[27.8225] → [14.2624:2660]

∅:D[14.2660] → [95.12856:12904]

B:BD[95.12856] → [95.12856:12904]

B:BD[95.12904] → [27.8226:8421]

B:BD[99.296] → [99.296:398]

∅:D[99.398] → [78.498:525]

∅:D[61.7066] → [78.498:525]

B:BD[95.13167] → [78.498:525]

∅:D[78.525] → [95.13189:13197]

B:BD[95.13189] → [95.13189:13197]

  -- undo
  elseif chord == 'C-z' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local event = undo_event(State)
    if event then
      local src = event.before
      State.screen_top1 = deepcopy(src.screen_top)
      State.cursor1 = deepcopy(src.cursor)
      State.selection1 = deepcopy(src.selection)
      patch(State.lines, event.after, event.before)
      patch_placeholders(State.line_cache, event.after, event.before)
      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)
      schedule_save(State)
    end
  elseif chord == 'C-y' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local event = redo_event(State)
    if event then
      local src = event.after
      State.screen_top1 = deepcopy(src.screen_top)
      State.cursor1 = deepcopy(src.cursor)
      State.selection1 = deepcopy(src.selection)
      patch(State.lines, event.before, event.after)
      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)
      schedule_save(State)
    end

Deletion in edit.lua at line 231 [95.413]
B:BD[95.13395] → [95.13395:13432]
B:BD[95.13432] → [98.1051:1158]
∅:D[98.1158] → [26.22975:23040]
B:BD[27.8593] → [26.22975:23040]
∅:D[82.3962] → [95.13588:13640]
∅:D[27.8682] → [95.13588:13640]
∅:D[26.23040] → [95.13588:13640]
∅:D[15.104922] → [95.13588:13640]
B:BD[95.13588] → [95.13588:13640]
B:BD[95.13640] → [78.526:551]
∅:D[78.551] → [95.13660:13689]
B:BD[95.13660] → [95.13660:13689]
B:BD[95.13689] → [4.123:230]
∅:D[4.230] → [95.13768:13904]
∅:D[98.1249] → [95.13768:13904]
∅:D[27.8768] → [95.13768:13904]
∅:D[15.105015] → [95.13768:13904]
B:BD[95.13768] → [95.13768:13904]
B:BD[95.13904] → [27.8769:8812]
B:BD[27.8812] → [14.2661:2709]
∅:D[14.2709] → [95.13982:14136]
B:BD[95.13982] → [95.13982:14136]
B:BD[95.14136] → [59.8631:8665]
∅:D[59.8665] → [95.14165:14176]
B:BD[95.14165] → [95.14165:14176]
B:BD[95.14176] → [59.8666:8706]
∅:D[59.8706] → [95.14209:14219]
B:BD[95.14209] → [95.14209:14219]
```
    end
  elseif chord == 'C-x' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local s = Text.cut_selection(State, State.left, State.right)
    if s then
      App.setClipboardText(s)
    end
    schedule_save(State)
  elseif chord == 'C-v' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    -- We don't have a good sense of when to scroll, so we'll be conservative
    -- and sometimes scroll when we didn't quite need to.
    local before_line = State.cursor1.line
    local before = snapshot(State, before_line)
    local clipboard_data = App.getClipboardText()
    for _,code in utf8.codes(clipboard_data) do
      local c = utf8.char(code)
      if c == '\n' then
        Text.insert_return(State)
      else
        Text.insert_at_cursor(State, c)
      end
```
Deletion in edit.lua at line 232 [95.413]
B:BD[95.14227] → [6.315:360]
∅:D[6.360] → [26.23041:23116]
B:BD[100.1331] → [26.23041:23116]
∅:D[100.1438] → [95.14360:14368]
∅:D[27.8913] → [95.14360:14368]
∅:D[26.23116] → [95.14360:14368]
∅:D[15.105181] → [95.14360:14368]
B:BD[95.14360] → [95.14360:14368]
B:BD[95.14368] → [78.552:577]
B:BD[78.577] → [14.2710:2812]
```
    if Text.cursor_out_of_screen(State) then
      Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
    end
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, before_line, State.cursor1.line)})
```

new fork: browse an immutable text file

Dependencies

In channels

Change contents

File deletion: undo.lua

Deletion in text_tests.lua at line 15 [22.2]

Deletion in text_tests.lua at line 17 [22.2]

Deletion in text_tests.lua at line 566 [22.2]

Deletion in text_tests.lua at line 583 [22.2]

Deletion in text_tests.lua at line 585 [22.2]

Deletion in text_tests.lua at line 680 [22.2]

Deletion in text_tests.lua at line 1164 [22.2]

Deletion in text_tests.lua at line 1166 [22.2]

Deletion in text_tests.lua at line 1288 [22.2]

Deletion in text.lua at line 6 [54.1]

Deletion in text.lua at line 152 [54.1]

Deletion in text.lua at line 155 [54.1]

Replacement in text.lua at line 156 [54.1]

Deletion in text.lua at line 238 [54.1]

Deletion in select.lua at line 94 [22.43980]

Deletion in select.lua at line 95 [22.43980]

Deletion in select.lua at line 96 [22.43980]

Deletion in main_tests.lua at line 46 [93.7]

Deletion in edit.lua at line 68 [95.413]

Deletion in edit.lua at line 109 [95.413]

Deletion in edit.lua at line 112 [95.413]

Deletion in edit.lua at line 177 [95.413]

Deletion in edit.lua at line 178 [95.413]

Deletion in edit.lua at line 226 [95.413]

Deletion in edit.lua at line 231 [95.413]

Deletion in edit.lua at line 232 [95.413]