Refactor moonc and overhaul watchers

- Essentially rewrote both SleepWatcher and InotifyWatcher
- Added test suites for both, including an expanded set of filesystem
  stubs in order to test them in isolation from the underlying
  filesystem
    - The filesystem stubs have their own tests, kek

Improvements as a result of these changes:
- Watch mode will remove "orphaned" .lua output files if/when their
  corresponding .moon input files are deleted
    - But it will not remove .lua files that have no corresponding .moon
      file to begin with, in order to avoid e.g. removing vendored Lua
      modules
- Both Watcher types will properly handle creation of new subdirectories
    - There *shouldn't* be any problematic races with this, although
      inotify's lack of recursive directory watching makes it difficult
      to know for sure
- More of the code is tested, and more of the code now *could* be tested
  (but isn't yet)
- Some bugs were fixed

Downsides:
- Somewhat gnarlier tests
- Moar lines of code

docs/command_line.md

@@ -116,17 +116,38 @@ files in the same directories.
 $ moonc my_script1.moon my_script2.moon ...
 ```
 
-You can control where the compiled files are put using the `-t` flag, followed
-by a directory.
+You can control where the compiled files are put using the `-t`/`--output-to`
+flag, followed by a directory.
 
 `moonc` can also take a directory as an argument, and it will recursively scan
 for all MoonScript files and compile them.
 
+If you use `-t` and also specify a directory as argument, then similar to
+`rsync`, handling of whether or not directory names are included in the output
+file paths differs depending on whether or not you specify a trailing `/`.
+
+For example, if you have a folder called `src` containing a file `foo.moon`:
+
+```bash
+$ moonc -t out src
+```
+
+Produces the file `out/src/foo.lua`. Alternatively:
+
+```bash
+$ moonc -t out src/
+```
+
+Produces the file `out/foo.lua`. It does not matter whether or not there is a
+trailing `/` on the `--output-to` directory, only on each of the input
+directories specified.
+
 `moonc` can write to standard out by passing the `-p` flag.
 
 The `-w` flag can be used to enable watch mode. `moonc` will stay running, and
 watch for changes to the input files. If any of them change then they will be
-compiled automatically.
+compiled automatically. Watch mode also works in combination with the `-t`
+flag.
 
 A full list of flags can be seen by passing the `-h` or `--help` flag.
 

moonscript-dev-1.rockspec

@@ -30,6 +30,7 @@ build = {
  ["moonscript.cmd.coverage"] = "moonscript/cmd/coverage.lua",
  ["moonscript.cmd.lint"] = "moonscript/cmd/lint.lua",
  ["moonscript.cmd.moonc"] = "moonscript/cmd/moonc.lua",
+ ["moonscript.cmd.path_handling"] = "moonscript/cmd/path_handling.lua",
  ["moonscript.cmd.watchers"] = "moonscript/cmd/watchers.lua",
  ["moonscript.compile"] = "moonscript/compile.lua",
  ["moonscript.compile.statement"] = "moonscript/compile/statement.lua",

moonscript/cmd/moonc.lua

@@ -134,43 +134,52 @@ handle_watch_loop = function(opts, output_to, input_paths, prefix_map)
  end
  end
  end
- local watcher = create_watcher(input_paths)
- for filename in watcher do
- local target = output_for(output_to, prefix_map, filename, "file")
+ local watcher = create_watcher(output_to, input_paths, prefix_map)
+ for file_tuple in watcher do
+ local event_type, filename, target, path_type
+ event_type, filename, target, path_type = file_tuple[1], file_tuple[2], file_tuple[3], file_tuple[4]
  if opts.o then
  target = opts.o
  end
  if opts.lint then
- local lint = require("moonscript.cmd.lint")
- local success, err = lint.lint_file(filename)
- if success then
- io.stderr:write(success .. "\n\n")
- elseif err then
- io.stderr:write(filename .. "\n" .. err .. "\n\n")
+ if event_type == "changedfile" then
+ local lint = require("moonscript.cmd.lint")
+ local success, err = lint.lint_file(filename)
+ if success then
+ io.stderr:write(success .. "\n\n")
+ elseif err then
+ io.stderr:write(filename .. "\n" .. err .. "\n\n")
+ end
+ elseif event_type == "removed" then
+ remove_orphaned_output(target, path_type)
  end
  else
- local success, err = compile_and_write(filename, target)
- if not success then
- io.stderr:write(table.concat({
- "",
- "Error: " .. filename,
- err,
- "\n"
- }, "\n"))
- elseif success == "build" then
- log_msg("Built", filename, "->", target)
+ if event_type == "changedfile" then
+ local success, err = compile_and_write(filename, target)
+ if not success then
+ io.stderr:write(table.concat({
+ "",
+ "Error: " .. filename,
+ err,
+ "\n"
+ }, "\n"))
+ elseif success == "build" then
+ log_msg("Built", filename, "->", target)
+ end
+ elseif event_type == "removed" then
+ remove_orphaned_output(target, path_type)
  end
  end
  end
  return io.stderr:write("\nQuitting...\n")
 end
-create_watcher = function(input_paths)
+create_watcher = function(output_to, input_paths, prefix_map)
  local watchers = require("moonscript.cmd.watchers")
  local watcher
  if watchers.InotifyWatcher:available() then
- watcher = watchers.InotifyWatcher(input_paths)
+ watcher = watchers.InotifyWatcher(output_to, input_paths, prefix_map)
  else
- watcher = watchers.SleepWatcher(input_paths)
+ watcher = watchers.SleepWatcher(output_to, input_paths, prefix_map)
  end
  return watcher:each_update()
 end

moonscript/cmd/moonc.moon

@@ -126,44 +126,50 @@ handle_watch_loop = (opts, output_to, input_paths, prefix_map) ->
  else
  log_msg "Error removing file", target, err_string
 
- watcher = create_watcher input_paths
+ watcher = create_watcher output_to, input_paths, prefix_map
 
- for filename in watcher
- target = output_for(output_to, prefix_map, filename, "file")
+ for file_tuple in watcher
+ {event_type, filename, target, path_type} = file_tuple
 
  if opts.o
  target = opts.o
 
  if opts.lint
- lint = require "moonscript.cmd.lint"
- success, err = lint.lint_file filename
- if success
- io.stderr\write success .. "\n\n"
- elseif err
- io.stderr\write filename .. "\n" .. err .. "\n\n"
+ if event_type == "changedfile"
+ lint = require "moonscript.cmd.lint"
+ success, err = lint.lint_file filename
+ if success
+ io.stderr\write success .. "\n\n"
+ elseif err
+ io.stderr\write filename .. "\n" .. err .. "\n\n"
+ elseif event_type == "removed"
+ remove_orphaned_output target, path_type
  else
- success, err = compile_and_write filename, target
- if not success
- io.stderr\write table.concat({
- "",
- "Error: " .. filename,
- err,
- "\n",
- }, "\n")
- elseif success == "build"
- log_msg "Built", filename, "->", target
+ if event_type == "changedfile"
+ success, err = compile_and_write filename, target
+ if not success
+ io.stderr\write table.concat({
+ "",
+ "Error: " .. filename,
+ err,
+ "\n",
+ }, "\n")
+ elseif success == "build"
+ log_msg "Built", filename, "->", target
+ elseif event_type == "removed"
+ remove_orphaned_output target, path_type
 
  io.stderr\write "\nQuitting...\n"
 
-create_watcher = (input_paths) ->
+create_watcher = (output_to, input_paths, prefix_map) ->
  watchers = require "moonscript.cmd.watchers"
 
  -- TODO cli argument to force sleep watcher (as it is potentially a little
  -- more reliable)
  watcher = if watchers.InotifyWatcher\available!
- watchers.InotifyWatcher input_paths
+ watchers.InotifyWatcher output_to, input_paths, prefix_map
  else
- watchers.SleepWatcher input_paths
+ watchers.SleepWatcher output_to, input_paths, prefix_map
 
  return watcher\each_update!