app.lua

   1 -- love.run: main entrypoint function for LÖVE
   2 --
   3 -- Most apps can just use the default shown in https://love2d.org/wiki/love.run,
   4 -- but we need to override it to:
   5 --   * recover from errors (by switching to the source editor)
   6 --   * run all tests (functions starting with 'test_') on startup, and
   7 --   * save some state that makes it possible to switch between the main app
   8 --     and a source editor, while giving each the illusion of complete
   9 --     control.
  10 function love.run()
  11   App.snapshot_love()
  12   -- Tests always run at the start.
  13   App.run_tests_and_initialize()
  14 --?   print('==')
  15
  16   love.timer.step()
  17   local dt = 0
  18
  19   return function()
  20     if love.event then
  21       love.event.pump()
  22       for name, a,b,c,d,e,f in love.event.poll() do
  23         if name == "quit" then
  24           if not love.quit or not love.quit() then
  25             return a or 0
  26           end
  27         end
  28         xpcall(function() love.handlers[name](a,b,c,d,e,f) end, handle_error)
  29       end
  30     end
  31
  32     dt = love.timer.step()
  33     xpcall(function() App.update(dt) end, handle_error)
  34
  35     love.graphics.origin()
  36     love.graphics.clear(love.graphics.getBackgroundColor())
  37     xpcall(App.draw, handle_error)
  38     love.graphics.present()
  39
  40     love.timer.sleep(0.001)
  41   end
  42 end
  43
  44 function handle_error(err)
  45   Error_message = debug.traceback('Error: ' .. tostring(err), --[[stack frame]]2):gsub('\n[^\n]+$', '')
  46   print(Error_message)
  47   if Current_app == 'run' then
  48     Settings.current_app = 'source'
  49     love.filesystem.write('config', json.encode(Settings))
  50     load_file_from_source_or_save_directory('main.lua')
  51     App.undo_initialize()
  52     App.run_tests_and_initialize()
  53   else
  54     love.event.quit()
  55   end
  56 end
  57
  58 -- The rest of this file wraps around various LÖVE primitives to support
  59 -- automated tests. Often tests will run with a fake version of a primitive
  60 -- that redirects to the real love.* version once we're done with tests.
  61 --
  62 -- Not everything is so wrapped yet. Sometimes you still have to use love.*
  63 -- primitives directly.
  64
  65 App = {}
  66
  67 -- save/restore various framework globals we care about -- only on very first load
  68 function App.snapshot_love()
  69   if Love_snapshot then return end
  70   Love_snapshot = {}
  71   -- save the entire initial font; it doesn't seem reliably recreated using newFont
  72   Love_snapshot.initial_font = love.graphics.getFont()
  73 end
  74
  75 function App.undo_initialize()
  76   love.graphics.setFont(Love_snapshot.initial_font)
  77 end
  78
  79 function App.run_tests_and_initialize()
  80   App.load()
  81   Test_errors = {}
  82   App.run_tests()
  83   if #Test_errors > 0 then
  84     error(('There were %d test failures:\n\n%s'):format(#Test_errors, table.concat(Test_errors)))
  85   end
  86   App.disable_tests()
  87   App.initialize_globals()
  88   App.initialize(love.arg.parseGameArguments(arg), arg)
  89 end
  90
  91 function App.run_tests()
  92   local sorted_names = {}
  93   for name,binding in pairs(_G) do
  94     if name:find('test_') == 1 then
  95       table.insert(sorted_names, name)
  96     end
  97   end
  98   table.sort(sorted_names)
  99   for _,name in ipairs(sorted_names) do
 100     App.initialize_for_test()
 101 --?     print('=== '..name)
 102 --?     _G[name]()
 103     xpcall(_G[name], function(err) prepend_debug_info_to_test_failure(name, err) end)
 104   end
 105   -- clean up all test methods
 106   for _,name in ipairs(sorted_names) do
 107     _G[name] = nil
 108   end
 109 end
 110
 111 function App.initialize_for_test()
 112   App.screen.init{width=100, height=50}
 113   App.screen.contents = {}  -- clear screen
 114   App.filesystem = {}
 115   App.source_dir = ''
 116   App.current_dir = ''
 117   App.save_dir = ''
 118   App.fake_keys_pressed = {}
 119   App.fake_mouse_state = {x=-1, y=-1}
 120   App.initialize_globals()
 121 end
 122
 123 -- App.screen.resize and App.screen.move seem like better names than
 124 -- love.window.setMode and love.window.setPosition respectively. They'll
 125 -- be side-effect-free during tests, and they'll save their results in
 126 -- attributes of App.screen for easy access.
 127
 128 App.screen={}
 129
 130 -- Use App.screen.init in tests to initialize the fake screen.
 131 function App.screen.init(dims)
 132   App.screen.width = dims.width
 133   App.screen.height = dims.height
 134 end
 135
 136 function App.screen.resize(width, height, flags)
 137   App.screen.width = width
 138   App.screen.height = height
 139   App.screen.flags = flags
 140 end
 141
 142 function App.screen.size()
 143   return App.screen.width, App.screen.height, App.screen.flags
 144 end
 145
 146 function App.screen.move(x,y, displayindex)
 147   App.screen.x = x
 148   App.screen.y = y
 149   App.screen.displayindex = displayindex
 150 end
 151
 152 function App.screen.position()
 153   return App.screen.x, App.screen.y, App.screen.displayindex
 154 end
 155
 156 -- If you use App.screen.print instead of love.graphics.print,
 157 -- tests will be able to check what was printed using App.screen.check below.
 158 --
 159 -- One drawback of this approach: the y coordinate used depends on font size,
 160 -- which feels brittle.
 161
 162 function App.screen.print(msg, x,y)
 163   local screen_row = 'y'..tostring(y)
 164 --?   print('drawing "'..msg..'" at y '..tostring(y))
 165   local screen = App.screen
 166   if screen.contents[screen_row] == nil then
 167     screen.contents[screen_row] = {}
 168     for i=0,screen.width-1 do
 169       screen.contents[screen_row][i] = ''
 170     end
 171   end
 172   if x < screen.width then
 173     screen.contents[screen_row][x] = msg
 174   end
 175 end
 176
 177 function App.screen.check(y, expected_contents, msg)
 178 --?   print('checking for "'..expected_contents..'" at y '..tostring(y))
 179   local screen_row = 'y'..tostring(y)
 180   local contents = ''
 181   if App.screen.contents[screen_row] == nil then
 182     error('no text at y '..tostring(y))
 183   end
 184   for i,s in ipairs(App.screen.contents[screen_row]) do
 185     contents = contents..s
 186   end
 187   check_eq(contents, expected_contents, msg)
 188 end
 189
 190 -- If you access the time using App.get_time instead of love.timer.getTime,
 191 -- tests will be able to move the time back and forwards as needed using
 192 -- App.wait_fake_time below.
 193
 194 App.time = 1
 195 function App.get_time()
 196   return App.time
 197 end
 198 function App.wait_fake_time(t)
 199   App.time = App.time + t
 200 end
 201
 202 function App.width(text)
 203   return love.graphics.getFont():getWidth(text)
 204 end
 205
 206 -- If you access the clipboard using App.get_clipboard and App.set_clipboard
 207 -- instead of love.system.getClipboardText and love.system.setClipboardText
 208 -- respectively, tests will be able to manipulate the clipboard by
 209 -- reading/writing App.clipboard.
 210
 211 App.clipboard = ''
 212 function App.get_clipboard()
 213   return App.clipboard
 214 end
 215 function App.set_clipboard(s)
 216   App.clipboard = s
 217 end
 218
 219 -- In tests I mostly send chords all at once to the keyboard handlers.
 220 -- However, you'll occasionally need to check if a key is down outside a handler.
 221 -- If you use App.key_down instead of love.keyboard.isDown, tests will be able to
 222 -- simulate keypresses using App.fake_key_press and App.fake_key_release
 223 -- below. This isn't very realistic, though, and it's up to tests to
 224 -- orchestrate key presses that correspond to the handlers they invoke.
 225
 226 App.fake_keys_pressed = {}
 227 function App.key_down(key)
 228   return App.fake_keys_pressed[key]
 229 end
 230
 231 function App.fake_key_press(key)
 232   App.fake_keys_pressed[key] = true
 233 end
 234 function App.fake_key_release(key)
 235   App.fake_keys_pressed[key] = nil
 236 end
 237
 238 -- Tests mostly will invoke mouse handlers directly. However, you'll
 239 -- occasionally need to check if a mouse button is down outside a handler.
 240 -- If you use App.mouse_down instead of love.mouse.isDown, tests will be able to
 241 -- simulate mouse clicks using App.fake_mouse_press and App.fake_mouse_release
 242 -- below. This isn't very realistic, though, and it's up to tests to
 243 -- orchestrate presses that correspond to the handlers they invoke.
 244
 245 App.fake_mouse_state = {x=-1, y=-1}  -- x,y always set
 246
 247 function App.mouse_move(x,y)
 248   App.fake_mouse_state.x = x
 249   App.fake_mouse_state.y = y
 250 end
 251 function App.mouse_down(mouse_button)
 252   return App.fake_mouse_state[mouse_button]
 253 end
 254 function App.mouse_x()
 255   return App.fake_mouse_state.x
 256 end
 257 function App.mouse_y()
 258   return App.fake_mouse_state.y
 259 end
 260
 261 function App.fake_mouse_press(x,y, mouse_button)
 262   App.fake_mouse_state.x = x
 263   App.fake_mouse_state.y = y
 264   App.fake_mouse_state[mouse_button] = true
 265 end
 266 function App.fake_mouse_release(x,y, mouse_button)
 267   App.fake_mouse_state.x = x
 268   App.fake_mouse_state.y = y
 269   App.fake_mouse_state[mouse_button] = nil
 270 end
 271
 272 -- If you use App.open_for_reading and App.open_for_writing instead of other
 273 -- various Lua and LÖVE helpers, tests will be able to check the results of
 274 -- file operations inside the App.filesystem table.
 275
 276 function App.open_for_reading(filename)
 277   if App.filesystem[filename] then
 278     return {
 279       lines = function(self)
 280                 return App.filesystem[filename]:gmatch('[^\n]+')
 281               end,
 282       read = function(self)
 283                return App.filesystem[filename]
 284              end,
 285       close = function(self)
 286               end,
 287     }
 288   end
 289 end
 290
 291 function App.read_file(filename)
 292   return App.filesystem[filename]
 293 end
 294
 295 function App.open_for_writing(filename)
 296   App.filesystem[filename] = ''
 297   return {
 298     write = function(self, s)
 299               App.filesystem[filename] = App.filesystem[filename]..s
 300             end,
 301     close = function(self)
 302             end,
 303   }
 304 end
 305
 306 function App.write_file(filename, contents)
 307   App.filesystem[filename] = contents
 308   return --[[status]] true
 309 end
 310
 311 function App.mkdir(dirname)
 312   -- nothing in test mode
 313 end
 314
 315 function App.remove(filename)
 316   App.filesystem[filename] = nil
 317 end
 318
 319 -- Some helpers to trigger an event and then refresh the screen. Akin to one
 320 -- iteration of the event loop.
 321
 322 -- all textinput events are also keypresses
 323 -- TODO: handle chords of multiple keys
 324 function App.run_after_textinput(t)
 325   App.keypressed(t)
 326   App.textinput(t)
 327   App.keyreleased(t)
 328   App.screen.contents = {}
 329   App.draw()
 330 end
 331
 332 -- not all keys are textinput
 333 -- TODO: handle chords of multiple keys
 334 function App.run_after_keychord(chord)
 335   App.keychord_press(chord)
 336   App.keyreleased(chord)
 337   App.screen.contents = {}
 338   App.draw()
 339 end
 340
 341 function App.run_after_mouse_click(x,y, mouse_button)
 342   App.fake_mouse_press(x,y, mouse_button)
 343   App.mousepressed(x,y, mouse_button)
 344   App.fake_mouse_release(x,y, mouse_button)
 345   App.mousereleased(x,y, mouse_button)
 346   App.screen.contents = {}
 347   App.draw()
 348 end
 349
 350 function App.run_after_mouse_press(x,y, mouse_button)
 351   App.fake_mouse_press(x,y, mouse_button)
 352   App.mousepressed(x,y, mouse_button)
 353   App.screen.contents = {}
 354   App.draw()
 355 end
 356
 357 function App.run_after_mouse_release(x,y, mouse_button)
 358   App.fake_mouse_release(x,y, mouse_button)
 359   App.mousereleased(x,y, mouse_button)
 360   App.screen.contents = {}
 361   App.draw()
 362 end
 363
 364 -- miscellaneous internal helpers
 365
 366 function App.color(color)
 367   love.graphics.setColor(color.r, color.g, color.b, color.a)
 368 end
 369
 370 function colortable(app_color)
 371   return {app_color.r, app_color.g, app_color.b, app_color.a}
 372 end
 373
 374 -- prepend file/line/test
 375 function prepend_debug_info_to_test_failure(test_name, err)
 376   local err_without_line_number = err:gsub('^[^:]*:[^:]*: ', '')
 377   local stack_trace = debug.traceback('', --[[stack frame]]5)
 378   local file_and_line_number = stack_trace:gsub('stack traceback:\n', ''):gsub(': .*', '')
 379   local full_error = file_and_line_number..':'..test_name..' -- '..err_without_line_number
 380 --?   local full_error = file_and_line_number..':'..test_name..' -- '..err_without_line_number..'\t\t'..stack_trace:gsub('\n', '\n\t\t')
 381   table.insert(Test_errors, full_error)
 382 end
 383
 384 nativefs = require 'nativefs'
 385
 386 local Keys_down = {}
 387
 388 -- call this once all tests are run
 389 -- can't run any tests after this
 390 function App.disable_tests()
 391   -- have LÖVE delegate all handlers to App if they exist
 392   for name in pairs(love.handlers) do
 393     if App[name] then
 394       -- love.keyboard.isDown doesn't work on Android, so emulate it using
 395       -- keypressed and keyreleased events
 396       if name == 'keypressed' then
 397         love.handlers[name] = function(key, scancode, isrepeat)
 398                                 Keys_down[key] = true
 399                                 return App.keypressed(key, scancode, isrepeat)
 400                               end
 401       elseif name == 'keyreleased' then
 402         love.handlers[name] = function(key, scancode)
 403                                 Keys_down[key] = nil
 404                                 return App.keyreleased(key, scancode)
 405                               end
 406       else
 407         love.handlers[name] = App[name]
 408       end
 409     end
 410   end
 411
 412   -- test methods are disallowed outside tests
 413   App.run_tests = nil
 414   App.disable_tests = nil
 415   App.screen.init = nil
 416   App.filesystem = nil
 417   App.time = nil
 418   App.run_after_textinput = nil
 419   App.run_after_keychord = nil
 420   App.keypress = nil
 421   App.keyrelease = nil
 422   App.run_after_mouse_click = nil
 423   App.run_after_mouse_press = nil
 424   App.run_after_mouse_release = nil
 425   App.fake_keys_pressed = nil
 426   App.fake_key_press = nil
 427   App.fake_key_release = nil
 428   App.fake_mouse_state = nil
 429   App.fake_mouse_press = nil
 430   App.fake_mouse_release = nil
 431   -- other methods dispatch to real hardware
 432   App.screen.resize = love.window.setMode
 433   App.screen.size = love.window.getMode
 434   App.screen.move = love.window.setPosition
 435   App.screen.position = love.window.getPosition
 436   App.screen.print = love.graphics.print
 437   App.open_for_reading =
 438       function(filename)
 439         local result = nativefs.newFile(filename)
 440         local ok, err = result:open('r')
 441         if ok then
 442           return result
 443         else
 444           return ok, err
 445         end
 446       end
 447   App.read_file =
 448       function(path)
 449         if not is_absolute_path(path) then
 450           return --[[status]] false, 'Please use an unambiguous absolute path.'
 451         end
 452         local f, err = App.open_for_reading(path)
 453         if err then
 454           return --[[status]] false, err
 455         end
 456         local contents = f:read()
 457         f:close()
 458         return contents
 459       end
 460   App.open_for_writing =
 461       function(filename)
 462         local result = nativefs.newFile(filename)
 463         local ok, err = result:open('w')
 464         if ok then
 465           return result
 466         else
 467           return ok, err
 468         end
 469       end
 470   App.write_file =
 471       function(path, contents)
 472         if not is_absolute_path(path) then
 473           return --[[status]] false, 'Please use an unambiguous absolute path.'
 474         end
 475         local f, err = App.open_for_writing(path)
 476         if err then
 477           return --[[status]] false, err
 478         end
 479         f:write(contents)
 480         f:close()
 481         return --[[status]] true
 482       end
 483   App.files = nativefs.getDirectoryItems
 484   App.mkdir = nativefs.createDirectory
 485   App.remove = nativefs.remove
 486   App.source_dir = love.filesystem.getSource()..'/'
 487   App.current_dir = nativefs.getWorkingDirectory()..'/'
 488   App.save_dir = love.filesystem.getSaveDirectory()..'/'
 489   App.get_time = love.timer.getTime
 490   App.get_clipboard = love.system.getClipboardText
 491   App.set_clipboard = love.system.setClipboardText
 492   App.key_down = function(key) return Keys_down[key] end
 493   App.mouse_move = love.mouse.setPosition
 494   App.mouse_down = love.mouse.isDown
 495   App.mouse_x = love.mouse.getX
 496   App.mouse_y = love.mouse.getY
 497 end