akkartik/template-carousel-mobile - Change LRDM35CEK3OHXOTB7TEFJRL7P6PQWO5ZG3F2BVA7DIDFHBPJQ7KAC

app running again

Created by Kartik K. Agaram on November 27, 2022

LRDM35CEK3OHXOTB7TEFJRL7P6PQWO5ZG3F2BVA7DIDFHBPJQ7KAC

Dependencies

In channels

main

Change contents

File deletion: main_tests.lua, run_tests.lua, run_tests.lua

BF:BFD[3.2] → [4.1125:1163]

BF:BFD[4.1163] → [4.7:7]

BFD:BFD[3.2] → [6.178005:178042]

BF:BFD[6.178042] → [4.7:7]

BFD:BFD[3.2] → [7.178068:178105]

BF:BFD[7.178105] → [4.7:7]

B:BD[4.7] → [4.8:73]

∅:D[9.228] → [4.232:309]

∅:D[10.17141] → [4.232:309]

∅:D[11.84758] → [4.232:309]

B:BD[4.232] → [4.232:309]

B:BD[4.309] → [12.4418:4513]

B:BD[12.4513] → [13.2214:2317]

∅:D[9.319] → [4.309:332]

∅:D[14.665] → [4.309:332]

∅:D[13.2317] → [4.309:332]

∅:D[12.4513] → [4.309:332]

B:BD[4.309] → [4.309:332]

B:BD[4.332] → [13.2318:2371]

∅:D[14.719] → [4.332:466]

∅:D[13.2371] → [4.332:466]

B:BD[4.332] → [4.332:466]

∅:D[14.801] → [9.401:489]

∅:D[5.1733] → [9.401:489]

∅:D[13.2453] → [9.401:489]

∅:D[12.4653] → [9.401:489]

B:BD[9.401] → [9.401:489]

B:BD[9.489] → [13.2454:2555]

B:BD[4.466] → [13.2372:2453]

∅:D[9.590] → [4.466:552]

∅:D[14.903] → [4.466:552]

∅:D[5.1840] → [4.466:552]

∅:D[13.2555] → [4.466:552]

∅:D[12.4760] → [4.466:552]

B:BD[4.466] → [4.466:552]

B:BD[4.552] → [15.7:64]

∅:D[16.53] → [15.117:631]

∅:D[10.17201] → [15.117:631]

∅:D[11.84825] → [15.117:631]

B:BD[15.117] → [15.117:631]

∅:D[16.80] → [17.7:99]

∅:D[18.7872] → [17.7:99]

∅:D[19.9279] → [17.7:99]

∅:D[11.85118] → [17.7:99]

B:BD[15.871] → [17.7:99]

∅:D[10.17261] → [17.152:234]

∅:D[11.85185] → [17.152:234]

B:BD[17.152] → [17.152:234]

∅:D[20.197] → [17.306:1001]

B:BD[17.306] → [17.306:1001]

B:BD[4.1120] → [4.1120:1124]

B:BD[17.234] → [11.85186:85266]

B:BD[11.85266] → [20.167:197]

B:BD[17.99] → [10.17202:17261]

B:BD[15.631] → [11.84826:84890]

∅:D[21.8] → [16.54:80]

B:BD[11.85118] → [16.54:80]

B:BD[11.84890] → [18.7644:7872]

B:BD[18.7872] → [21.8:8]

B:BD[15.64] → [10.17142:17201]

B:BD[10.17201] → [16.7:53]

∅:D[9.152] → [11.84560:84592]

∅:D[12.4417] → [11.84560:84592]

B:BD[4.73] → [11.84560:84592]

B:BD[11.84592] → [9.153:228]

B:BD[4.73] → [9.7:48]

B:BD[9.48] → [12.4371:4417]

function test_resize_window()
  io.write('\ntest_resize_window')
  check_eq(App.screen.height, 300, 'F - test_resize_window/baseline/height')
  check_eq(Editor_state.left, Test_margin_left, 'F - test_resize_window/baseline/left_margin')
  check_eq(Editor_state.right, 300 - Test_margin_right, 'F - test_resize_window/baseline/left_margin')
  App.resize(200, 400)
  -- ugly; resize switches to real, non-test margins
  check_eq(App.screen.width, 200, 'F - test_resize_window/width')
  check_eq(App.screen.height, 400, 'F - test_resize_window/height')
  check_eq(Editor_state.right, 200-Margin_right, 'F - test_resize_window/right_margin')
  check_eq(Editor_state.width, 200-Margin_left-Margin_right, 'F - test_resize_window/drawing_width')
  check_eq(Editor_state.left, Margin_left, 'F - test_resize_window/left_margin')
  -- TODO: how to make assertions about when App.update got past the early exit?
end
function test_drop_file()
  io.write('\ntest_drop_file')
  App.filesystem['foo'] = 'abc\ndef\nghi\n'
  local fake_dropped_file = {
    opened = false,
    getFilename = function(self)
                    return 'foo'
                  end,
    open = function(self)
             self.opened = true
           end,
    lines = function(self)
              assert(self.opened)
              return App.filesystem['foo']:gmatch('[^\n]+')
            end,
    close = function(self)
              self.opened = false
            end,
  }
  App.filedropped(fake_dropped_file)
end
function test_drop_file_saves_previous()
  io.write('\ntest_drop_file_saves_previous')
  -- initially editing a file called foo that hasn't been saved to filesystem yet
  -- 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')
end
  Editor_state.lines = load_array{'abc', 'def'}
  Editor_state.filename = 'foo'
  schedule_save(Editor_state)
  App.screen.init{width=Editor_state.left+300, height=300}
  check_eq(#Editor_state.lines, 3, 'F - test_drop_file/#lines')
  edit.draw(Editor_state)
  check_eq(Editor_state.lines[1].data, 'abc', 'F - test_drop_file/lines:1')
  check_eq(Editor_state.lines[2].data, 'def', 'F - test_drop_file/lines:2')
  check_eq(Editor_state.lines[3].data, 'ghi', 'F - test_drop_file/lines:3')
  App.screen.init{width=Editor_state.left+300, height=300}
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  check_eq(App.screen.width, 300, 'F - test_resize_window/baseline/width')
  App.screen.init{width=300, height=300}
  Editor_state = edit.initialize_test_state()

Insertion in main.lua at line 6 [22.2]
[5.1894]
[8.18]
```
require 'live'
```
Deletion in main.lua at line 11 [22.2]
B:BD[8.21] → [5.1932:1953]
∅:D[5.1953] → [8.22:23]
B:BD[7.184452] → [8.22:23]
```
require 'main_tests'
```

Insertion in main.lua at line 35 [22.2]

[5.2459]


  Editor_state = nil  -- not used outside editor tests

Insertion in main.lua at line 39 [22.2]
[5.2502]
[23.1319]
```
  live.initialize(arg)
```
Insertion in main.lua at line 82 [22.2]
[24.46]
[5.5607]
```
  if on.resize then on.resize(w,h) end
```

Replacement in main.lua at line 86 [22.2]

B:BD[5.5643] → [5.5643:5763]

∅:D[5.5763] → [6.188315:188321]

B:BD[6.188315] → [6.188315:188321]

B:BD[6.188321] → [5.5764:6044]

  -- first make sure to save edits on any existing file
  if Editor_state.next_save then
    save_to_disk(Editor_state)
  end
  -- clear the slate for the new file
  App.initialize_globals()
  Editor_state.filename = file:getFilename()
  file:open('r')
  Editor_state.lines = load_from_file(file)
  file:close()
  Text.redraw_all(Editor_state)
  love.window.setTitle('text.love - '..Editor_state.filename)

[5.5643]

[22.183]

  if on.filedropped then on.filedropped() end

Replacement in main.lua at line 90 [22.2]
B:BD[23.1373] → [5.6045:6071]
```
  edit.draw(Editor_state)
```
[23.1373]
[8.46]
```
  if on.draw then on.draw() end
```
Replacement in main.lua at line 100 [22.2]
B:BD[5.6105] → [5.6105:6137]
```
  edit.update(Editor_state, dt)
```
[5.6105]
[5.6137]
```
  if on.update then on.update(dt) end
```
Replacement in main.lua at line 104 [22.2]
B:BD[5.6163] → [5.6163:6189]
```
  edit.quit(Editor_state)
```
[5.6163]
[2.113]
```
  if on.quit then on.quit() end
```

Replacement in main.lua at line 110 [22.2]

B:BD[5.6894] → [5.6894:6955]

  return edit.mouse_pressed(Editor_state, x,y, mouse_button)

[5.6894]

[5.6955]

  if on.mouse_pressed then on.mouse_pressed(x,y, mouse_button) end

Replacement in main.lua at line 115 [22.2]

B:BD[5.7080] → [5.7080:7142]

  return edit.mouse_released(Editor_state, x,y, mouse_button)

[5.7080]

[5.7142]

  if on.mouse_released then on.mouse_released(x,y, mouse_button) end

Insertion in main.lua at line 122 [22.2]
[6.188672]
[25.3]
```
  if on.focus then on.focus(in_focus) end
```
Insertion in main.lua at line 125 [22.2]
[25.8]
[7.188134]
```
-- App.keypressed is defined in keychord.lua
```

Replacement in main.lua at line 133 [22.2]

B:BD[5.7306] → [5.7306:7363]

  return edit.keychord_pressed(Editor_state, chord, key)

[5.7306]

[26.223]

  if on.keychord_pressed then on.keychord_pressed(key, scancode, isrepeat) end

Replacement in main.lua at line 142 [22.2]
B:BD[5.7438] → [5.7438:7479]
```
  return edit.textinput(Editor_state, t)
```
[5.7438]
[27.3116]
```
  if on.textinput then on.textinput(t) end
```

Replacement in main.lua at line 151 [22.2]

B:BD[5.7595] → [5.7595:7651]

  return edit.key_released(Editor_state, key, scancode)

[5.7595]

[7.190712]

  if on.key_released then on.key_released(key, scancode, isrepeat) end

File addition: live.lua (----------)

[3.2]

-- A general architecture for free-wheeling, live programs:
--  on startup:
--    scan both the app directory and the save directory for files with numeric prefixes
--    from the largest numeric prefix found, obtain a manifest
--    load all files (which must start with a numeric prefix) from the manifest)
--
--  then start drawing frames on screen and reacting to events
--
--  events from keyboard and mouse are handled as the app desires
--
--  on incoming messages to a specific file, however, the app must:
--    save the message's value to a specific, unused numeric prefix
--    execute the value
--
--  if a game encounters an error:
--    find the previous version of the definition in the 'head' numeric prefix
--    decrement 'head'
-- namespace for these functions
live = {}
-- state for these functions
Live = {}
-- a namespace of frameworky callbacks
-- these will be modified live
-- TODO: how to make them discoverable?
on = {}
-- ========= on startup, load the version at head
function live.initialize(arg)
  -- version control
  Live.Head = 0
  Live.Next_version = 1
  Live.History = {}  -- array of filename roots corresponding to each numeric prefix
  Live.Manifest = {}  -- mapping from roots to numeric prefixes as of version Live.Head
  live.load_files_so_far()
  if on.load then on.load() end
end
function live.load_files_so_far()
  print('new edits will go to ' .. love.filesystem.getSaveDirectory())
  local files = {}
  live.append_files_with_numeric_prefix('', files)
  table.sort(files)
  live.check_integrity(files)
  live.append_files_with_numeric_prefix(love.filesystem.getSaveDirectory(), files)
  table.sort(files)
  live.check_integrity(files)
  Live.History = live.load_history(files)
  Live.Next_version = #Live.History + 1
  local head_string = love.filesystem.read('head')
  Live.Head = tonumber(head_string)
  if Live.Head > 0 then
    Live.Manifest = json.decode(love.filesystem.read(live.versioned_manifest(Live.Head)))
  end
  live.load_everything_in_manifest()
end
function live.append_files_with_numeric_prefix(dir, files)
  for _,file in ipairs(love.filesystem.getDirectoryItems(dir)) do
    table.insert(files, file)
  end
end
function live.check_integrity(files)
  local manifest_found, file_found = false, false
  local expected_index = 1
  for _,file in ipairs(files) do
    for numeric_prefix, root in file:gmatch('(%d+)-(.+)') do
      -- only runs once
      local index = tonumber(numeric_prefix)
      -- skip files without numeric prefixes
      if index ~= nil then
        if index < expected_index then
          print(index, expected_index)
        end
        assert(index >= expected_index)
        if index > expected_index then
          assert(index == expected_index+1)
          assert(manifest_found and file_found)
          expected_index = index
          manifest_found, file_found = false, false
        end
        assert(index == expected_index)
        if root == 'manifest' then
          assert(not manifest_found)
          manifest_found = true
        else
          assert(not file_found)
          file_found = true
        end
      end
    end
  end
end
function live.load_history(files)
  local result = {}
  for _,file in ipairs(files) do
    for numeric_prefix, root in file:gmatch('(%d+)-(.+)') do
      -- only runs once
      local index = tonumber(numeric_prefix)
      -- skip
      if index ~= nil then
        if root ~= 'manifest' then
          assert(index == #result+1)
          table.insert(result, root)
        end
      end
    end
  end
  return result
end
function live.load_everything_in_manifest()
  for k,v in pairs(Live.Manifest) do
    if k ~= 'parent' then
      local root, index = k, v
      local filename = live.versioned_filename(index, root)
      local buf = love.filesystem.read(filename)
      assert(buf and buf ~= '')
      live.eval(buf)
    end
  end
end
function live.versioned_filename(index, root)
  return ('%04d-%s'):format(index, root)
end
function live.versioned_manifest(index)
  return ('%04d-manifest'):format(index)
end
-- ========= on each frame, check for messages and alter the app as needed
function live.update(dt)
  if Current_time - Live.Previous_read > 0.1 then
    local buf = live.receive()
    if buf then
      live.run(buf)
    end
    Live.Previous_read = Current_time
  end
end
-- look for a message from outside, and return nil if there's nothing
function live.receive()
  local f = io.open(love.filesystem.getUserDirectory()..'/_love_akkartik_app')
  if f == nil then return nil end
  local result = f:read('*a')
  f:close()
  if result == '' then return nil end  -- empty file == no message
  print('<='..color(--[[bold]]1, --[[blue]]4))
  print(result)
  print(reset_terminal())
  -- we can't unlink files, so just clear them
  local clear = io.open(love.filesystem.getUserDirectory()..'/_love_akkartik_app', 'w')
  clear:close()
  return result
end
function live.send(msg)
  local f = io.open(love.filesystem.getUserDirectory()..'/_love_akkartik_driver', 'w')
  if f == nil then return end
  f:write(msg)
  f:close()
  print('=>'..color(0, --[[green]]2))
  print(msg)
  print(reset_terminal())
end
-- args:
--   format: 0 for normal, 1 for bold
--   color: 0-15
function color(format, color)
  return ('\027[%d;%dm'):format(format, 30+color)
end
function reset_terminal()
  return '\027[m'
end
-- define or undefine top-level bindings
function live.run(buf)
  local cmd = buf:match('^%S+')
  assert(cmd)
  print('command is '..cmd)
  if cmd == 'QUIT' then
    love.event.quit(1)
  elseif cmd == 'MANIFEST' then
    live.send(json.encode(Live.Manifest))
  elseif cmd == 'DELETE' then
    local binding = buf:match('^%S+%s+(%S+)')
    Live.Manifest[binding] = nil
    live.eval(binding..' = nil')
    local next_filename = live.versioned_filename(Live.Next_version, binding)
    love.filesystem.write(next_filename, '')
    table.insert(Live.History, binding)
    Live.Manifest.parent = Live.Head
    local manifest_filename = live.versioned_manifest(Live.Next_version)
    love.filesystem.write(manifest_filename, json.encode(Live.Manifest))
    Live.Head = Live.Next_version
    love.filesystem.write('head', tostring(Live.Head))
    Live.Next_version = Live.Next_version + 1
  elseif cmd == 'GET' then
    local binding = buf:match('^%S+%s+(%S+)')
    live.send(live.get_binding(binding))
  -- other commands go here
  else
    local binding = cmd
    local next_filename = live.versioned_filename(Live.Next_version, binding)
    love.filesystem.write(next_filename, buf)
    table.insert(Live.History, binding)
    Live.Manifest[binding] = Live.Next_version
    Live.Manifest.parent = Live.Head
    local manifest_filename = live.versioned_manifest(Live.Next_version)
    love.filesystem.write(manifest_filename, json.encode(Live.Manifest))
    Live.Head = Live.Next_version
    love.filesystem.write('head', tostring(Live.Head))
    Live.Next_version = Live.Next_version + 1
    local status, err = live.eval(buf)
    if not status then
      -- roll back
      Live.Head = Live.Manifest.parent
      local previous_manifest_filename = live.versioned_manifest(Live.Head)
      Live.Manifest = json.decode(love.filesystem.read(previous_manifest_filename))
      -- throw an error
      live.send('ERROR '..tostring(err))
    end
  end
end
function live.get_binding(name)
  if Live.Manifest[name] then
    return love.filesystem.read(live.versioned_filename(Live.Manifest[name], name))
  end
end
-- Wrapper for Lua's weird evaluation model.
-- Lua is persnickety about expressions vs statements, so we need to do some
-- extra work to get the result of an evaluation.
-- return values:
--  all well -> true, ...
--  load failed -> nil, error message
--  run failed -> false, error message
function live.eval(buf)
  -- We assume a program is either correct with 'return' prefixed xor not.
  -- Is this correct? Who knows! But the Lua REPL does this as well.
  local f = load('return '..buf, 'REPL')
  if f then
    return pcall(f)
  end
  local f, err = load(buf, 'REPL')
  if f then
    return pcall(f)
  else
    return nil, err
  end
end
-- ========= on error, pause the app and wait for messages
function live.run()
  love.load(love.arg.parseGameArguments(arg), arg)
  love.timer.step()
  local dt = 0
  return function()
    local status, result = xpcall(live.try_run, live.handle_error)
    return result
  end
end
-- one iteration of the event loop
-- return nil to continue the event loop, non-nil to quit
-- from https://love2d.org/wiki/love.run
function live.try_run()
  if love.event then
    love.event.pump()
    for name, a,b,c,d,e,f in love.event.poll() do
      if name == 'quit' then
        if not love.quit() then
          return a or 0
        end
      end
      love.handlers[name](a,b,c,d,e,f)
    end
  end
  -- update
  dt = love.timer.step()
  love.update(dt)
  -- draw before update to give it a chance to mutate state
  love.graphics.origin()
  love.graphics.clear(love.graphics.getBackgroundColor())
  love.draw()
  love.graphics.present()
  love.timer.sleep(0.001)
  -- returning nil continues the loop
end
-- return nil to continue the event loop, non-nil to quit
function live.handle_error(err)
  local msg = tostring(err)
  -- draw a pause indicator on screen
  love.graphics.setColor(1,0,0)
  love.graphics.rectangle('fill', 10,10, 3,10)
  love.graphics.rectangle('fill', 16,10, 3,10)
  love.graphics.present()
  -- print stack trace here just in case we ran the app through a terminal
  local stack_trace = debug.traceback('Error: ' .. tostring(msg), --[[stack frame]]2):gsub('\n[^\n]+$', '')
  print(stack_trace)
  print('Look in the driver for options to investigate further.')
  print("(You probably can't close the app window at this point. If you don't have the driver set up, you might need to force-quit.)")
  -- send stack trace to driver and wait for a response
  live.send('ERROR '..stack_trace)
  local buf
  repeat
    buf = live.receive()
  until buf
  if buf == 'QUIT' then
    return true
  end
  live.run(buf)
end

File addition: head (----------)
[3.2]
```
0
```

app running again

Dependencies

In channels

Change contents

File deletion: main_tests.lua, run_tests.lua, run_tests.lua

Insertion in main.lua at line 6 [22.2]

Deletion in main.lua at line 11 [22.2]

Insertion in main.lua at line 35 [22.2]

Insertion in main.lua at line 39 [22.2]

Insertion in main.lua at line 82 [22.2]

Replacement in main.lua at line 86 [22.2]

Replacement in main.lua at line 90 [22.2]

Replacement in main.lua at line 100 [22.2]

Replacement in main.lua at line 104 [22.2]

Replacement in main.lua at line 110 [22.2]

Replacement in main.lua at line 115 [22.2]

Insertion in main.lua at line 122 [22.2]

Insertion in main.lua at line 125 [22.2]

Replacement in main.lua at line 133 [22.2]

Replacement in main.lua at line 142 [22.2]

Replacement in main.lua at line 151 [22.2]

File addition: live.lua (----------)

File addition: head (----------)