feat: quickfix (#293)

* feat: quickfix (not implemented)

* [WIP]: Wed 09 Dec 2020 11:11:30 PM EST

* somewhat working linked list impl

* getting closer

* might be working

* might be working for real

* works and implemented basic example

* dont forget to close prompt

* fix descending and add more tests

* test fixes

* fix test

* more logging

* Fix some more tests

* Fix logging messing up tests

* fix: lint

* fix: multi select stuffs

1 files changed, 143 insertions, 44 deletions

diff --git a/lua/telescope/pickers/_test.lua b/lua/telescope/pickers/_test.lua
index ddd245a..1ab5a97 100644
--- a/lua/telescope/pickers/_test.lua
+++ b/lua/telescope/pickers/_test.lua
@@ -1,10 +1,14 @@
 local assert = require('luassert')
 local builtin = require('telescope.builtin')
+local log = require('telescope.log')
 
 local Job = require("plenary.job")
+local Path = require("plenary.path")
 
 local tester = {}
 
+tester.debug = false
+
 local replace_terms = function(input)
   return vim.api.nvim_replace_termcodes(input, true, false, true)
 end
@@ -15,7 +19,53 @@ local nvim_feed = function(text, feed_opts)
   vim.api.nvim_feedkeys(text, feed_opts, true)
 end
 
-tester.picker_feed = function(input, test_cases, debug)
+local writer = function(val)
+  if type(val) == "table" then
+    val = vim.fn.json_encode(val) .. "\n"
+  end
+
+  if tester.debug then
+    print(val)
+  else
+    io.stderr:write(val)
+  end
+end
+
+local execute_test_case = function(location, key, spec)
+  local ok, actual = pcall(spec[2])
+
+  if not ok then
+    writer {
+      location = 'Error: ' .. location,
+      case = key,
+      expected = 'To succeed and return: ' .. tostring(spec[1]),
+      actual = actual,
+
+      _type = spec._type,
+    }
+  else
+    writer {
+      location = location,
+      case = key,
+      expected = spec[1],
+      actual = actual,
+
+      _type = spec._type,
+    }
+  end
+end
+
+local end_test_cases = function()
+  vim.cmd [[qa!]]
+end
+
+local invalid_test_case = function(k)
+  writer { case = k, expected = '<a valid key>', actual = k }
+
+  end_test_cases()
+end
+
+tester.picker_feed = function(input, test_cases)
   input = replace_terms(input)
 
   return coroutine.wrap(function()
@@ -28,75 +78,66 @@ tester.picker_feed = function(input, test_cases, debug)
       if string.match(char, "%g") then
         coroutine.yield()
       end
+
+      if tester.debug then
+        vim.wait(200)
+      end
     end
 
-    vim.wait(10, function() end)
+    vim.wait(10)
+
+    if tester.debug then
+      coroutine.yield()
+    end
 
-    local timer = vim.loop.new_timer()
-    timer:start(20, 0, vim.schedule_wrap(function()
+    vim.defer_fn(function()
+      if test_cases.post_typed then
+        for k, v in ipairs(test_cases.post_typed) do
+          execute_test_case('post_typed', k, v)
+        end
+      end
+
+      nvim_feed(replace_terms("<CR>"), "")
+    end, 20)
+
+    vim.defer_fn(function()
       if test_cases.post_close then
         for k, v in ipairs(test_cases.post_close) do
-          io.stderr:write(vim.fn.json_encode({ case = k, expected = v[1], actual = v[2]() }))
-          io.stderr:write("\n")
+          execute_test_case('post_close', k, v)
         end
       end
 
-      if debug then
+      if tester.debug then
         return
       end
 
-      vim.defer_fn(function()
-        vim.cmd [[qa!]]
-      end, 10)
-    end))
-
-    if not debug then
-      vim.schedule(function()
-        if test_cases.post_typed then
-          for k, v in ipairs(test_cases.post_typed) do
-            io.stderr:write(vim.fn.json_encode({ case = k, expected = v[1], actual = v[2]() }))
-            io.stderr:write("\n")
-          end
-        end
+      vim.defer_fn(end_test_cases, 20)
+    end, 40)
 
-        nvim_feed(replace_terms("<CR>"), "")
-      end)
-    end
     coroutine.yield()
   end)
 end
 
--- local test_cases = {
---   post_typed = {
---   },
---   post_close = {
---     { "README.md", function() return "README.md" end },
---   },
--- }
-
 local _VALID_KEYS = {
   post_typed = true,
   post_close = true,
 }
 
-tester.builtin_picker = function(key, input, test_cases, opts)
+tester.builtin_picker = function(builtin_key, input, test_cases, opts)
   opts = opts or {}
-  local debug = opts.debug or false
+  tester.debug = opts.debug or false
 
   for k, _ in pairs(test_cases) do
     if not _VALID_KEYS[k] then
-      -- TODO: Make an error type for the json protocol.
-      io.stderr:write(vim.fn.json_encode({ case = k, expected = '<a valid key>', actual = k }))
-      io.stderr:write("\n")
-      vim.cmd [[qa!]]
+      return invalid_test_case(k)
     end
   end
 
   opts.on_complete = {
-    tester.picker_feed(input, test_cases, debug)
+    tester.picker_feed(input, test_cases),
   }
 
-  builtin[key](opts)
+  builtin[builtin_key](opts)
 end
 
 local get_results_from_file = function(file)
@@ -107,11 +148,14 @@ local get_results_from_file = function(file)
       '-u',
       'scripts/minimal_init.vim',
       '-c',
-      'luafile ' .. file
+      string.format(
+        [[lua require("telescope.pickers._test")._execute("%s")]],
+        file
+      ),
     },
   }
 
-  j:sync()
+  j:sync(1000)
 
   local results = j:stderr_result()
   local result_table = {}
@@ -122,10 +166,27 @@ local get_results_from_file = function(file)
   return result_table
 end
 
+
+local asserters = {
+  _default = assert.are.same,
+
+  are = assert.are.same,
+  are_not = assert.are_not.same,
+}
+
+
 local check_results = function(results)
   -- TODO: We should get all the test cases here that fail, not just the first one.
   for _, v in ipairs(results) do
-    assert.are.same(v.expected, v.actual)
+    local assertion = asserters[v._type or 'default']
+
+    assertion(
+      v.expected,
+      v.actual,
+      string.format("Test Case: %s // %s",
+        v.location,
+        v.case)
+    )
   end
 end
 
@@ -144,14 +205,52 @@ tester.run_string = function(contents)
   vim.fn.delete(tempname)
 
   check_results(result_table)
-  -- assert.are.same(result_table.expected, result_table.actual)
 end
 
 tester.run_file = function(filename)
   local file = './lua/tests/pickers/' .. filename .. '.lua'
 
+  if not Path:new(file):exists() then
+    assert.are.same("<An existing file>", file)
+  end
+
   local result_table = get_results_from_file(file)
-  assert.are.same(result_table.expected, result_table.actual)
+
+  check_results(result_table)
 end
 
+tester.not_ = function(val)
+  val._type = 'are_not'
+  return val
+end
+
+tester._execute = function(filename)
+  -- Important so that the outputs don't get mixed
+  log.use_console = false
+
+  vim.cmd(string.format("luafile %s", filename))
+
+  local f = loadfile(filename)
+  if not f then
+    writer {
+      location = 'Error: ' .. filename,
+      case = filename,
+      expected = 'To succeed',
+      actual = nil,
+    }
+  end
+
+  local ok, msg = pcall(f)
+  if not ok then
+    writer {
+      location = "Error: " .. msg,
+      case = msg,
+      expected = msg,
+    }
+  end
+
+  end_test_cases()
+end
+
+
 return tester