akkartik/pong.love - Change 3BFFX2I3V7N7QJ4Z6CKICF52IRKMSLT63MMZZ34JZPFYAZELJ4EQC

resolve conflicts

Created by akkartik on July 10, 2024

3BFFX2I3V7N7QJ4Z6CKICF52IRKMSLT63MMZZ34JZPFYAZELJ4EQC

Dependencies

In channels

main

Change contents

Deletion in undo.lua at line 58 [5.1]
B:BD[4.1900] → [4.1900:1962]
```
  -- deep copy lines without cached stuff like text fragments
```
Deletion in undo.lua at line 59 [5.1]
B:BD[4.1977] → [4.1977:2009]
B:BD[4.2009] → [6.141:141]
BD:BD[4.2009] → [6.141:141]
∅:D[6.141] → [7.3:102]
B:BD[7.2] → [7.3:102]
BD:BD[7.2] → [7.3:102]
```
    local line = State.lines[i]
    table.insert(event.lines, {data=line.data})  -- I've forgotten: should we deepcopy(line.data)?
```

Resurrecting zombie bytes in undo.lua at line 59 [5.1]

B:B[7.102] → [4.2010:2331]

BD:B[7.102] → [4.2010:2331]

  end
  return event
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

Insertion in undo.lua at line 59 [5.1]

[4.1977]

[4.2010]

    table.insert(event.lines, deepcopy(State.lines[i]))

Resurrecting zombie bytes in undo.lua at line 73 [5.1]
∅:∅[6.219] → [4.2374:2451]
B:B[4.2374] → [4.2374:2451]
BD:B[4.2374] → [4.2374:2451]
```
  for i=from.end_line,from.start_line,-1 do
    table.remove(lines, i)
  end
```
Resurrecting zombie bytes in undo.lua at line 77 [5.1]
∅:∅[6.305] → [4.2502:2592]
B:B[4.2502] → [4.2502:2592]
BD:B[4.2502] → [4.2502:2592]
```
  for i=1,#to.lines do
    table.insert(lines, to.start_line+i-1, to.lines[i])
  end
end
```

Deletion in undo.lua at line 82 [5.1]

B:BD[4.2592] → [4.2592:2642]

BD:BD[4.2592] → [4.2592:2642]

B:BD[4.2642] → [6.306:383]

∅:D[6.383] → [4.2685:2767]

B:BD[4.2685] → [4.2685:2767]

BD:BD[4.2685] → [4.2685:2767]

B:BD[4.2767] → [6.384:469]

∅:D[6.469] → [4.2818:2904]

B:BD[4.2818] → [4.2818:2904]

BD:BD[4.2818] → [4.2818:2904]

function patch_placeholders(line_cache, from, to)
  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  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, 'failed to patch undo operation')
  for i=1,#to.lines do
    table.insert(line_cache, to.start_line+i-1, {})
  end
end

Resurrecting zombie bytes in undo.lua at line 82 [5.1]

∅:∅[4.2904] → [4.2904:3386]

B:B[4.2904] → [4.2904:3386]

BD:B[4.2904] → [4.2904:3386]

-- 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

Deletion in undo.lua at line 98 [5.1]
B:BD[4.3386] → [6.471:471]
B:BD[8.269] → [9.0:56]
BD:BD[8.269] → [9.0:56]
```
    table.insert(event.lines, deepcopy(State.lines[i]))
```
Solving an order conflict in undo.lua at line 98 [5.1]
[4.3386]
Replacement in text.lua at line 50 [12.1]
B:BD[11.40] → [11.40:65]
```
      -- render fragment
```
[11.40]
[11.65]
```
      -- render screen line
```
Deletion in text.lua at line 94 [12.1]
B:BD[11.1332] → [13.420:420]
B:BD[14.2604] → [15.4:32]
BD:BD[14.2604] → [15.4:32]
BD:BD[14.2604] → [15.4:32]
```
      -- render screen line
```
Solving an order conflict in text.lua at line 94 [12.1]
[11.1332]
[16.222]

Replacement in text.lua at line 211 [12.1]

B:BD[4.89015] → [4.89015:89112]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[4.89015]

[4.89112]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 347 [12.1]

B:BD[13.944] → [13.944:1037]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[13.944]

[13.1037]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 385 [12.1]

B:BD[4.95856] → [4.95856:95949]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[4.95809]

[13.2092]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 438 [12.1]

B:BD[4.98110] → [4.98110:98205]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[4.98110]

[4.98205]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 567 [12.1]

B:BD[4.102968] → [4.102968:103063]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[4.102968]

[4.103063]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 661 [12.1]

∅:D[13.3665] → [4.105831:105924]

B:BD[4.105831] → [4.105831:105924]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[13.3665]

[4.105924]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in text.lua at line 942 [12.1]
B:BD[4.114721] → [4.114721:114755]
```
--?   print('clearing fragments')
```
[4.114721]
[17.4]
```
--?   print('clearing line caches')
```

Deletion in text.lua at line 993 [12.1]

B:BD[4.115541] → [2.697:697]

B:BD[18.1104] → [15.33:132]

BD:BD[18.1104] → [15.33:132]

B:BD[20.566] → [15.133:228]

BD:BD[20.566] → [15.133:228]

B:BD[21.791] → [15.229:324]

BD:BD[21.791] → [15.229:324]

B:BD[18.1234] → [15.325:422]

BD:BD[18.1234] → [15.325:422]

B:BD[18.1459] → [15.423:520]

BD:BD[18.1459] → [15.423:520]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Solving an order conflict in text.lua at line 993 [12.1]
[4.115541]
[22.790]
Deletion in text.lua at line 994 [12.1]
B:BD[20.3068] → [15.521:616]
BD:BD[20.3068] → [15.521:616]
BD:BD[20.3068] → [15.521:616]
B:BD[23.5911] → [15.617:653]
BD:BD[23.5911] → [15.617:653]
BD:BD[23.5911] → [15.617:653]
```
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
--?   print('clearing line caches')
```

Resurrecting zombie bytes in source_undo.lua at line 55 [25.68]

B:B[24.107] → [10.1784:1902]

BD:B[24.107] → [10.1784:1902]

B:B[24.810] → [10.2012:2333]

BD:B[24.810] → [10.2012:2333]

    lines={},
    start_line=s,
    end_line=e,
    -- no filename; undo history is cleared when filename changes
  }
  end
  return event
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

Deletion in source_undo.lua at line 60 [25.68]
B:BD[10.1902] → [10.1902:1964]
BD:BD[10.1902] → [10.1902:1964]
```
  -- deep copy lines without cached stuff like text fragments
```
Replacement in source_undo.lua at line 61 [25.68]
B:BD[10.1979] → [10.1979:2011]
BD:BD[10.1979] → [10.1979:2011]
∅:D[10.2011] → [24.108:140]
B:BD[25.2077] → [24.108:140]
BD:BD[25.2077] → [24.108:140]
∅:D[7.223] → [24.221:260]
B:BD[24.221] → [24.221:260]
D:D[7.223] → [24.221:260]
BD:BD[24.221] → [24.221:260]
BD:BD[7.223] → [24.221:260]
∅:D[7.356] → [24.750:759]
B:BD[24.750] → [24.750:759]
D:D[7.356] → [24.750:759]
BD:BD[7.356] → [24.750:759]
BD:BD[24.750] → [24.750:759]
∅:D[26.373] → [24.802:810]
B:BD[24.802] → [24.802:810]
D:D[26.373] → [24.802:810]
BD:BD[26.373] → [24.802:810]
BD:BD[24.802] → [24.802:810]
```
    local line = State.lines[i]
    if line.mode == 'text' then
    elseif line.mode == 'drawing' then
    else
    end
```
[10.1979]
[10.2012]
```
    table.insert(event.lines, deepcopy(State.lines[i]))
```
Resurrecting zombie bytes in source_undo.lua at line 75 [25.68]
∅:∅[6.1714] → [10.2376:2453]
B:B[10.2376] → [10.2376:2453]
BD:B[10.2376] → [10.2376:2453]
```
  for i=from.end_line,from.start_line,-1 do
    table.remove(lines, i)
  end
```
Resurrecting zombie bytes in source_undo.lua at line 79 [25.68]
∅:∅[6.1800] → [10.2504:2583]
B:B[10.2504] → [10.2504:2583]
BD:B[10.2504] → [10.2504:2583]
```
  for i=1,#to.lines do
    table.insert(lines, to.start_line+i-1, to.lines[i])
```
Deletion in source_undo.lua at line 81 [25.68]
B:BD[10.2583] → [10.2583:2644]
BD:BD[10.2583] → [10.2583:2644]
B:BD[10.2644] → [6.1801:1878]
∅:D[6.1878] → [10.2687:2763]
B:BD[10.2687] → [10.2687:2763]
BD:BD[10.2687] → [10.2687:2763]
```
  end
end
function patch_placeholders(line_cache, from, to)
  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  for i=from.end_line,from.start_line,-1 do
    table.remove(line_cache, i)
```
Resurrecting zombie bytes in source_undo.lua at line 81 [25.68]
∅:∅[10.2763] → [10.2763:2769]
B:B[10.2763] → [10.2763:2769]
BD:B[10.2763] → [10.2763:2769]
```
  end
```

Deletion in source_undo.lua at line 82 [25.68]

B:BD[10.2769] → [6.1879:1964]

∅:D[6.1964] → [10.2820:2901]

B:BD[10.2820] → [10.2820:2901]

BD:BD[10.2820] → [10.2820:2901]

  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')
  for i=1,#to.lines do
    table.insert(line_cache, to.start_line+i-1, {})
  end

Resurrecting zombie bytes in source_undo.lua at line 82 [25.68]

∅:∅[10.2901] → [10.2901:3388]

B:B[10.2901] → [10.2901:3388]

BD:B[10.2901] → [10.2901:3388]

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

Deletion in source_undo.lua at line 100 [25.68]
B:BD[10.3388] → [6.1966:1966]
B:BD[25.2045] → [3.6:62]
BD:BD[25.2045] → [3.6:62]
```
    table.insert(event.lines, deepcopy(State.lines[i]))
```
Solving an order conflict in source_undo.lua at line 100 [25.68]
[10.3388]

Replacement in source_text.lua at line 292 [25.83786]

B:BD[11.4100] → [11.4100:4197]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[11.4100]

[11.4197]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 430 [25.83786]

B:BD[13.6057] → [13.6057:6150]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[13.6057]

[13.6150]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 479 [25.83786]

B:BD[11.10993] → [11.10993:11086]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[11.10946]

[13.7711]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 541 [25.83786]

B:BD[28.387] → [28.387:482]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[28.387]

[28.482]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 687 [25.83786]

B:BD[28.5889] → [28.5889:5984]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[28.5889]

[28.5984]

    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 832 [25.83786]

∅:D[13.10064] → [28.10971:11064]

B:BD[28.10971] → [28.10971:11064]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[13.10064]

[28.11064]

  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Replacement in source_text.lua at line 1121 [25.83786]
B:BD[28.20551] → [28.20551:20585]
```
--?   print('clearing fragments')
```
[28.20551]
[28.20585]
```
--?   print('clearing line caches')
```
Deletion in source_text.lua at line 1174 [25.83786]
B:BD[28.21703] → [2.1395:1395]
B:BD[29.2025] → [3.65:164]
BD:BD[29.2025] → [3.65:164]
BD:BD[29.2025] → [3.65:164]
B:BD[30.2531] → [3.165:260]
BD:BD[30.2531] → [3.165:260]
B:BD[25.146550] → [3.649:685]
BD:BD[25.146550] → [3.649:685]
BD:BD[25.146550] → [3.649:685]
B:BD[30.6538] → [3.553:648]
BD:BD[30.6538] → [3.553:648]
BD:BD[30.6538] → [3.553:648]
B:BD[29.4881] → [3.455:552]
BD:BD[29.4881] → [3.455:552]
BD:BD[29.4881] → [3.455:552]
B:BD[29.4150] → [3.357:454]
BD:BD[29.4150] → [3.357:454]
BD:BD[29.4150] → [3.357:454]
B:BD[25.108993] → [3.261:356]
BD:BD[25.108993] → [3.261:356]
BD:BD[25.108993] → [3.261:356]
```
      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
--?   print('clearing line caches')
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
    Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
  Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
```
Solving an order conflict in source_text.lua at line 1174 [25.83786]
[28.21703]

Replacement in source_edit.lua at line 56 [25.152503]

B:BD[10.145585] → [4.116570:116651]

∅:D[4.116651] → [10.145686:145799]

B:BD[10.145686] → [10.145686:145799]

    --   fragments: snippets of the line guaranteed to not straddle screen lines
    --   screen_line_starting_pos: optional array of grapheme indices if it wraps over more than one screen line

[10.145515]

[10.145799]

    --   screen_line_starting_pos: optional array of codepoint indices if it wraps over more than one screen line

Deletion in source_edit.lua at line 68 [25.152503]
B:BD[10.146472] → [13.11340:11340]
B:BD[25.153568] → [3.690:804]
BD:BD[25.153568] → [3.690:804]
```
    --   screen_line_starting_pos: optional array of codepoint indices if it wraps over more than one screen line
```
Solving an order conflict in source_edit.lua at line 68 [25.152503]
[10.146472]
[30.7811]
Deletion in source_edit.lua at line 277 [25.152503]
B:BD[25.158465] → [3.805:904]
BD:BD[25.158465] → [3.805:904]
```
      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
```

Replacement in source_edit.lua at line 402 [25.152503]

B:BD[19.12267] → [19.12267:12364]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks

[19.12267]

[19.12364]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Deletion in source_edit.lua at line 444 [25.152503]
B:BD[10.152333] → [10.152333:152403]
B:BD[10.152403] → [19.13322:13322]
```
      patch_placeholders(State.line_cache, event.after, event.before)
```
Resurrecting zombie bytes in source_edit.lua at line 444 [25.152503]
∅:∅[19.13322] → [24.21582:21671]
∅:∅[31.19700] → [24.21582:21671]
∅:∅[10.152403] → [24.21582:21671]
B:B[25.161237] → [24.21582:21671]
BD:B[25.161237] → [24.21582:21671]
```
      -- invalidate various cached bits of lines
      State.lines.current_drawing = nil
```

Replacement in source_edit.lua at line 446 [25.152503]

B:BD[24.21671] → [10.152404:152506]

      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)

[24.21671]

[10.152506]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Deletion in source_edit.lua at line 455 [25.152503]
B:BD[10.152855] → [31.19702:19702]
B:BD[24.21671] → [3.905:1004]
BD:BD[24.21671] → [3.905:1004]
```
      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
```
Solving an order conflict in source_edit.lua at line 455 [25.152503]
[10.152855]
[32.25968]

Replacement in source_edit.lua at line 459 [25.152503]

B:BD[24.21761] → [10.152908:153010]

      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)

[24.21761]

[10.153010]

      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks

Deletion in source_edit.lua at line 496 [25.152503]
B:BD[10.154330] → [33.586:586]
B:BD[24.21761] → [3.1005:1104]
BD:BD[24.21761] → [3.1005:1104]
```
      Text.redraw_all(State)  -- if we're scrolling, reclaim all line caches to avoid memory leaks
```
Solving an order conflict in source_edit.lua at line 496 [25.152503]
[10.154330]
[24.21762]
Deletion in edit.lua at line 277 [35.413]
B:BD[34.6353] → [34.6353:6450]
BD:BD[34.6353] → [34.6353:6450]
```
      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
```

Resurrecting zombie bytes in edit.lua at line 278 [35.413]

∅:∅[3.1221] → [34.6450:6765]

B:B[34.6450] → [34.6450:6765]

BD:B[34.6450] → [34.6450:6765]

    elseif chord == 'return' then
      State.search_term = nil
      State.search_backup = nil
    elseif chord == 'backspace' then
      local len = utf8.len(State.search_term)
      local byte_offset = Text.offset(State.search_term, len)
      State.search_term = string.sub(State.search_term, 1, byte_offset-1)

Resurrecting zombie bytes in edit.lua at line 288 [35.413]

∅:∅[36.1073] → [34.6765:7604]

B:B[34.6765] → [34.6765:7604]

BD:B[34.6765] → [34.6765:7604]

B:B[34.7711] → [34.7711:7991]

BD:B[34.7711] → [34.7711:7991]

    elseif chord == 'down' then
      State.cursor1.pos = State.cursor1.pos+1
      Text.search_next(State)
    elseif chord == 'up' then
      Text.search_previous(State)
    end
    return
  elseif chord == 'C-f' then
    State.search_term = ''
    State.search_backup = {
      cursor={line=State.cursor1.line, pos=State.cursor1.pos},
      screen_top={line=State.screen_top1.line, pos=State.screen_top1.pos},
    }
  -- zoom
  elseif chord == 'C-=' then
    edit.update_font_settings(State, State.font_height+2)
    Text.redraw_all(State)
  elseif chord == 'C--' then
    if State.font_height > 2 then
      edit.update_font_settings(State, State.font_height-2)
      Text.redraw_all(State)
    end
  elseif chord == 'C-0' then
    edit.update_font_settings(State, 20)
    Text.redraw_all(State)
  -- undo
  elseif chord == 'C-z' then
    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)

Deletion in edit.lua at line 322 [35.413]

B:BD[34.7991] → [34.7991:8163]

BD:BD[34.7991] → [34.7991:8163]

      patch_placeholders(State.line_cache, event.after, event.before)
      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)

Resurrecting zombie bytes in edit.lua at line 323 [35.413]

∅:∅[3.1321] → [34.8163:8227]

B:B[34.8163] → [34.8163:8227]

BD:B[34.8163] → [34.8163:8227]

B:B[34.8334] → [34.8334:8613]

BD:B[34.8334] → [34.8334:8613]

      schedule_save(State)
    end
  elseif chord == 'C-y' then
    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)

Deletion in edit.lua at line 333 [35.413]

B:BD[34.8613] → [34.8613:8715]

BD:BD[34.8613] → [34.8613:8715]

      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)

Resurrecting zombie bytes in edit.lua at line 334 [35.413]

∅:∅[3.1421] → [34.8715:9064]

B:B[34.8715] → [34.8715:9064]

BD:B[34.8715] → [34.8715:9064]

B:B[34.9171] → [34.9171:9339]

BD:B[34.9171] → [34.9171:9339]

B:B[34.9446] → [34.9446:10211]

BD:B[34.9446] → [34.9446:10211]

B:B[34.10318] → [34.10318:10509]

BD:B[34.10318] → [34.10318:10509]

      schedule_save(State)
    end
  -- clipboard
  elseif chord == 'C-a' then
    State.selection1 = {line=1, pos=1}
    State.cursor1 = {line=#State.lines, pos=utf8.len(State.lines[#State.lines].data)+1}
  elseif chord == 'C-c' then
    local s = Text.selection(State)
    if s then
      App.set_clipboard(s)
    end
  elseif chord == 'C-x' then
    local s = Text.cut_selection(State, State.left, State.right)
    if s then
      App.set_clipboard(s)
    end
    schedule_save(State)
  elseif chord == 'C-v' then
    -- 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.get_clipboard()
    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
    end
    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)})
  -- dispatch to text
  else
    Text.keychord_press(State, chord)
  end
end
function edit.key_release(State, key, scancode)
end
function edit.update_font_settings(State, font_height)
  State.font_height = font_height

Resurrecting zombie bytes in edit.lua at line 382 [35.413]

∅:∅[37.1696] → [34.10575:11061]

B:B[34.10575] → [34.10575:11061]

BD:B[34.10575] → [34.10575:11061]

  State.line_height = math.floor(font_height*1.3)
end
--== some methods for tests
-- Insulate tests from some key globals so I don't have to change the vast
-- majority of tests when they're modified for the real app.
Test_margin_left = 25
Test_margin_right = 0
function edit.initialize_test_state()
  -- if you change these values, tests will start failing
  return edit.initialize_state(
      15,  -- top margin
      Test_margin_left,
      App.screen.width - Test_margin_right,

Resurrecting zombie bytes in edit.lua at line 400 [35.413]

∅:∅[37.1738] → [34.11115:11471]

B:B[34.11115] → [34.11115:11471]

BD:B[34.11115] → [34.11115:11471]

      15)  -- line height
end
-- all text_input events are also keypresses
-- TODO: handle chords of multiple keys
function edit.run_after_text_input(State, t)
  edit.keychord_press(State, t)
  edit.text_input(State, t)
  edit.key_release(State, t)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
-- not all keys are text_input

Resurrecting zombie bytes in edit.lua at line 418 [35.413]

∅:∅[38.5245] → [34.11587:11811]

B:B[34.11587] → [34.11587:11811]

BD:B[34.11587] → [34.11587:11811]

  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_click(State, x,y, mouse_button)
  App.fake_mouse_press(x,y, mouse_button)
  edit.mouse_press(State, x,y, mouse_button)

Resurrecting zombie bytes in edit.lua at line 427 [35.413]

∅:∅[30.9188] → [34.11811:12430]

B:B[34.11811] → [34.11811:12430]

BD:B[34.11811] → [34.11811:12430]

  App.fake_mouse_release(x,y, mouse_button)
  edit.mouse_release(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_press(State, x,y, mouse_button)
  App.fake_mouse_press(x,y, mouse_button)
  edit.mouse_press(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_release(State, x,y, mouse_button)
  App.fake_mouse_release(x,y, mouse_button)
  edit.mouse_release(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end

resolve conflicts

Dependencies

In channels

Change contents

Deletion in undo.lua at line 58 [5.1]

Deletion in undo.lua at line 59 [5.1]

Resurrecting zombie bytes in undo.lua at line 59 [5.1]

Insertion in undo.lua at line 59 [5.1]

Resurrecting zombie bytes in undo.lua at line 73 [5.1]

Resurrecting zombie bytes in undo.lua at line 77 [5.1]

Deletion in undo.lua at line 82 [5.1]

Resurrecting zombie bytes in undo.lua at line 82 [5.1]

Deletion in undo.lua at line 98 [5.1]

Solving an order conflict in undo.lua at line 98 [5.1]

Replacement in text.lua at line 50 [12.1]

Deletion in text.lua at line 94 [12.1]

Solving an order conflict in text.lua at line 94 [12.1]

Replacement in text.lua at line 211 [12.1]

Replacement in text.lua at line 347 [12.1]

Replacement in text.lua at line 385 [12.1]

Replacement in text.lua at line 438 [12.1]

Replacement in text.lua at line 567 [12.1]

Replacement in text.lua at line 661 [12.1]

Replacement in text.lua at line 942 [12.1]

Deletion in text.lua at line 993 [12.1]

Solving an order conflict in text.lua at line 993 [12.1]

Deletion in text.lua at line 994 [12.1]

Resurrecting zombie bytes in source_undo.lua at line 55 [25.68]

Deletion in source_undo.lua at line 60 [25.68]

Replacement in source_undo.lua at line 61 [25.68]

Resurrecting zombie bytes in source_undo.lua at line 75 [25.68]

Resurrecting zombie bytes in source_undo.lua at line 79 [25.68]

Deletion in source_undo.lua at line 81 [25.68]

Resurrecting zombie bytes in source_undo.lua at line 81 [25.68]

Deletion in source_undo.lua at line 82 [25.68]

Resurrecting zombie bytes in source_undo.lua at line 82 [25.68]

Deletion in source_undo.lua at line 100 [25.68]

Solving an order conflict in source_undo.lua at line 100 [25.68]

Replacement in source_text.lua at line 292 [25.83786]

Replacement in source_text.lua at line 430 [25.83786]

Replacement in source_text.lua at line 479 [25.83786]

Replacement in source_text.lua at line 541 [25.83786]

Replacement in source_text.lua at line 687 [25.83786]

Replacement in source_text.lua at line 832 [25.83786]

Replacement in source_text.lua at line 1121 [25.83786]

Deletion in source_text.lua at line 1174 [25.83786]

Solving an order conflict in source_text.lua at line 1174 [25.83786]

Replacement in source_edit.lua at line 56 [25.152503]

Deletion in source_edit.lua at line 68 [25.152503]

Solving an order conflict in source_edit.lua at line 68 [25.152503]

Deletion in source_edit.lua at line 277 [25.152503]

Replacement in source_edit.lua at line 402 [25.152503]

Deletion in source_edit.lua at line 444 [25.152503]

Resurrecting zombie bytes in source_edit.lua at line 444 [25.152503]