local entry_path = "yazi-enter.yazi/main.lua" local file = assert(io.open(entry_path, "rb")) local source = assert(file:read("*a")) file:close() local capture = [[ capture_find_update { apply = apply_find, success = UPDATE_SUCCESS, failure = UPDATE_FAILURE, clear_error = ERROR_STATUS_CLEAR, } ]] local instrumented_source, replacement_count = source:gsub( "\nreturn {\n\tentry = function", "\n" .. capture .. "\nreturn {\n\tentry = function", 1 ) assert(replacement_count == 1, "Find updater capture point must occur once") local model local exec_handler local plugin_error_reports = 0 local environment = { error = error, getmetatable = getmetatable, pairs = pairs, pcall = pcall, type = type, capture_find_update = function(value) model = value end, ya = { sync = function(callback) return callback end, exec = function(...) return exec_handler(...) end, err = function() plugin_error_reports = plugin_error_reports + 1 end, }, } local chunk = assert(load(instrumented_source, "@" .. entry_path, "t", environment)) chunk() assert(type(model) == "table", "Find updater was not captured") assert(type(model.apply) == "function", "Find updater must be a function") local function assert_equal(actual, expected, label) assert(actual == expected, ("%s: expected %s, got %s"):format(label, tostring(expected), tostring(actual))) end local function assert_request(request, query, policy, label) assert(type(request) == "table", label .. " request must be a table") assert(request ~= policy, label .. " request must be separate from the search policy") assert_equal(request[1], query, label .. " positional query") assert_equal(request[2], nil, label .. " second positional argument") assert_equal(request.previous, policy.previous, label .. " previous option") assert_equal(request.smart, policy.smart, label .. " smart option") assert_equal(request.insensitive, policy.insensitive, label .. " insensitive option") assert_equal(type(request.previous), "boolean", label .. " previous type") assert_equal(type(request.smart), "boolean", label .. " smart type") assert_equal(type(request.insensitive), "boolean", label .. " insensitive type") local expected_keys = { [1] = true, previous = true, smart = true, insensitive = true, } local count = 0 for key in pairs(request) do assert(expected_keys[key], label .. " unexpected request key " .. tostring(key)) count = count + 1 end assert_equal(count, 4, label .. " request field count") end local complete_query = "literal ; $(touch ignored)\0tail.*" local policy = { previous = true, smart = false, insensitive = true, } local calls = {} exec_handler = function(action, request, ...) assert_equal(select("#", ...), 0, "native Find extra argument count") calls[#calls + 1] = { action = action, request = request } return "completed reply" end local result, error_status = model.apply(complete_query, policy) assert_equal(result, model.success, "completed Find result") assert_equal(error_status, model.clear_error, "completed Find error status") assert_equal(#calls, 1, "completed Find call count") assert_equal(calls[1].action, "find_do", "native Find action") assert_request(calls[1].request, complete_query, policy, "completed Find") assert_equal(policy.previous, true, "preserved policy previous") assert_equal(policy.smart, false, "preserved policy smart") assert_equal(policy.insensitive, true, "preserved policy insensitive") assert(not calls[1].action:find(complete_query, 1, true), "query must stay separate from action text") local reply_completed = false local awaited_call exec_handler = function(action, request) awaited_call = { action = action, request = request } local reply = coroutine.yield("manager reply pending") reply_completed = true return reply end local awaited_policy = { previous = false, smart = true, insensitive = false, } local thread = coroutine.create(function() return model.apply("awaited query", awaited_policy) end) local resumed, pending = coroutine.resume(thread) assert_equal(resumed, true, "awaited Find first resume") assert_equal(pending, "manager reply pending", "awaited Find pending marker") assert_equal(coroutine.status(thread), "suspended", "Find updater while reply is pending") assert_equal(reply_completed, false, "Find completion before manager reply") assert_equal(awaited_call.action, "find_do", "awaited native Find action") assert_request(awaited_call.request, "awaited query", awaited_policy, "awaited Find") resumed, result, error_status = coroutine.resume(thread, "manager completed") assert_equal(resumed, true, "awaited Find second resume") assert_equal(coroutine.status(thread), "dead", "Find updater after reply") assert_equal(reply_completed, true, "Find completion after manager reply") assert_equal(result, model.success, "awaited Find result") assert_equal(error_status, model.clear_error, "awaited Find error status") local dispatcher_reported = false local failed_call exec_handler = function(action, request) failed_call = { action = action, request = request } coroutine.yield("manager error pending") dispatcher_reported = true error("native malformed regular expression", 0) end local failed_policy = { previous = false, smart = false, insensitive = false, } thread = coroutine.create(function() return model.apply("[", failed_policy) end) resumed, pending = coroutine.resume(thread) assert_equal(resumed, true, "failed Find first resume") assert_equal(pending, "manager error pending", "failed Find pending marker") assert_equal(coroutine.status(thread), "suspended", "failed Find before manager error") assert_equal(dispatcher_reported, false, "dispatcher report before failed reply") assert_equal(failed_call.action, "find_do", "failed native Find action") assert_request(failed_call.request, "[", failed_policy, "failed Find") resumed, result, error_status = coroutine.resume(thread) assert_equal(resumed, true, "caught Find failure resume") assert_equal(coroutine.status(thread), "dead", "Find updater after caught failure") assert_equal(dispatcher_reported, true, "standard dispatcher error report") assert_equal(result, model.failure, "caught Find result") assert_equal(error_status, "native malformed regular expression", "caught Find error status") assert_equal(plugin_error_reports, 0, "duplicate plugin error reports") exec_handler = function() return nil end result, error_status = model.apply("corrected", failed_policy) assert_equal(result, model.success, "Find result after a caught failure") assert_equal(error_status, model.clear_error, "error status after a caught failure") print("Find update checks passed")