feat: pre-script & handler-scripts

Author: boltlessengineer

lua/rest-nvim/client/curl.lua

@@ -151,10 +151,11 @@ end
 
 ---Execute an HTTP request using cURL
 ---return return nil if execution failed
----@param request Request_ Request data to be passed to cURL
+---@param request Request Request data to be passed to cURL
 ---@return table? info The request information (url, method, headers, body, etc)
 function client.request_(request)
-  local info = {}
+  -- write to `Context.response` without altering the reference
+  local info = request.context.response
   if not found_curl then
     ---@diagnostic disable-next-line need-check-nil
     logger.error("lua-curl could not be found, therefore the cURL client will not work.")

lua/rest-nvim/context.lua

@@ -7,6 +7,8 @@ local M = {}
 ---@class Context
 ---@field vars table<string,string>
 ---@field files string[]
+---@field request? Request
+---@field response? any
 local Context = {}
 Context.__index = Context
 
@@ -40,10 +42,12 @@ local rest_variables = {
 
 ---@return Context
 function Context:new()
+  ---@type Context
   local obj = {
     __index = self,
     vars = {},
     files = {},
+    response = {}, -- create response table here to pass the reference first
   }
   setmetatable(obj, self)
   return obj

lua/rest-nvim/parser/init.lua

@@ -153,36 +153,67 @@ end
 
 ---@param node TSNode
 ---@param source Source
----@param context Context
----@return function
-function M.parse_script(node, source, context)
+---@return string str
+local function parse_script(node, source)
   vim.validate({ node = utils.ts_node_spec(node, "script") })
   local str = vim.treesitter.get_node_text(node, source):sub(3,-3)
-  return script.load(str, context)
+  return str
 end
 
 ---@param script_node TSNode
 ---@param source Source
 ---@param context Context
 function M.parse_pre_request_script(script_node, source, context)
   local node = assert(script_node:named_child(0))
-  M.parse_script(node, source, context)()
+  local str = parse_script(node, source)
+  script.load_prescript(str, context)()
 end
 
 ---@param handler_node TSNode
 ---@param source Source
 ---@param context Context
 function M.parse_request_handler(handler_node, source, context)
   local node = assert(handler_node:named_child(0))
-  return M.parse_script(node, source, context)
+  local str = parse_script(node, source)
+  return script.load_handler(str, context)
+end
+
+---@param node TSNode
+---@param kind? string[]
+---@return TSNode[] siblings
+local function collect_prev_siblings(node, kind)
+  local siblings = {}
+  local n = node:prev_named_sibling()
+  while n and n:type() ~= "request_separator" do
+    if not kind or vim.tbl_contains(kind, n:type()) then
+      table.insert(siblings, 0, n)
+    end
+    n = n:prev_named_sibling()
+  end
+  return siblings
+end
+
+---@param node TSNode
+---@param kind? string[]
+---@return TSNode[] siblings
+local function collect_next_siblings(node, kind)
+  local siblings = {}
+  local n = node:next_named_sibling()
+  while n and n:type() ~= "request_separator" do
+    if not kind or vim.tbl_contains(kind, n:type()) then
+      table.insert(siblings, n)
+    end
+    n = n:next_named_sibling()
+  end
+  return siblings
 end
 
 ---Parse the request node and create Request object. Returns `nil` if parsing
 ---failed.
 ---@param req_node TSNode Tree-sitter request node
 ---@param source Source
 ---@param context? Context
----@return Request_|nil
+---@return Request|nil
 function M.parse(req_node, source, context)
   context = context or Context:new()
   -- request should not include error
@@ -206,14 +237,16 @@ function M.parse(req_node, source, context)
     context,
     config.encode_url and utils.escape or nil
   )
-  local pre_req_scripts = req_node:field("pre_request_script")
-  for _, script_node in ipairs(pre_req_scripts) do
+
+  local pre_script_nodes = collect_prev_siblings(req_node, {"pre_request_script"})
+  for _, script_node in ipairs(pre_script_nodes) do
     M.parse_pre_request_script(script_node, source, context)
   end
-  local handlers = vim.iter(req_node:field("handler_script")):map(function (node)
+  local handler_nodes = collect_next_siblings(req_node, {"res_handler_script"})
+  local handlers = vim.iter(handler_nodes):map(function (node)
     return M.parse_request_handler(node, source, context)
   end):totable()
-  ---@type Request_
+  ---@type Request
   return {
     context = context,
     method = method,

lua/rest-nvim/request.lua

@@ -7,7 +7,7 @@ local utils  = require("rest-nvim.utils")
 local logger = require("rest-nvim.logger")
 local config = require("rest-nvim.config")
 
----@class Request_
+---@class Request
 ---@field context Context
 ---@field name? string The request identifier
 ---@field method string The request method
@@ -17,12 +17,13 @@ local config = require("rest-nvim.config")
 ---@field body? ReqBody
 ---@field handlers fun()[]
 
----@type Request_|nil
+---@type Request|nil
 local rest_nvim_last_request = nil
 
----@param req Request_
+---@param req Request
 ---@return boolean ok
 local function run_request(req)
+  logger.debug("run_request")
   local client = require("rest-nvim.client.curl")
   rest_nvim_last_request = req
 
@@ -32,11 +33,13 @@ local function run_request(req)
     logger.error("request failed")
     return false
   end
+  logger.debug("request success")
 
   -- run request handler scripts
-  -- TODO: run them with response info
   vim.iter(req.handlers):each(function (f) f() end)
 
+  logger.debug("handler end")
+
   -- update result UI
   local result = require("rest-nvim.result")
   local result_buf = result.get_or_create_buf()
@@ -47,6 +50,7 @@ end
 ---run request in current cursor position
 ---@return boolean ok
 function M.run()
+  logger.info("starting request")
   local req_node = parser.get_cursor_request_node()
   if not req_node then
     logger.error("failed to find request at cursor position")

lua/rest-nvim/script.lua

@@ -6,66 +6,108 @@ local M = {}
 
 -- TODO: fill script environment
 
+---@class RestEnvRequestVariables
+---@field set fun(key:string,value:string)
+---@field get fun(key:string):string
+
+---@param ctx Context
+---@retrun RestPreScriptEnv
+function M.create_prescript_env(ctx)
+  ---@class RestPreScriptEnv
+  local env = {
+    ---@class RestPreScriptEnvRequest
+    request = {
+      ---@type RestEnvRequestVariables
+      variables = {
+        ---sets request-local variable
+        set = function (key, value)
+          ctx:set(key, value)
+        end,
+        ---retrieves variable in current request scope
+        get = function (key)
+          return ctx:resolve(key)
+        end,
+      }
+    },
+    vim = vim
+  }
+  return env
+end
+
 ---@param ctx Context
----@return ScriptEnv
-function M.create_env(ctx)
-  ---@class ScriptEnv
+---@return RestHandlerEnv
+function M.create_handler_env(ctx)
+  ---@class RestHandlerEnv
   local env = {
-    ---@class ScriptEnvClient
+    ---@class RestHandlerEnvClient
     client = {
       test = function () end,
       assert = function () end,
-      ---@class ScriptEnvClientGlobal
+      ---@type RestEnvRequestVariables
       global = {
-        ---@param key string
-        ---@param value string
+        ---set global variable (this overwrites `vim.env`)
         set = function (key, value)
           vim.env[key] = value
         end,
-        ---@param key string
-        ---@return string value
+        ---get global variable (return empty string if variable doesn't exist)
         get = function (key)
-          return ctx:resolve(key)
+          return vim.env[key] or ""
         end,
       },
     },
-    ---@class ScriptEnvRequest
+    ---@class RestHandlerEnvRequest
     request = {
       body = {},
       environment = {},
       headers = {},
       method = "GET",
       url = "",
-      ---@class ScriptEnvRequestVariables
+      ---@type RestEnvRequestVariables
       variables = {
         ---sets request-local variable
-        ---@param key string
-        ---@param value string
         set = function (key, value)
           ctx:set(key, value)
         end,
+        ---retrieves variable in current request scope
+        get = function (key)
+          return ctx:resolve(key)
+        end,
       }
     },
-    ---@class ScriptEnvResponse
-    response = nil,
+    ---@class RestHandlerEnvResponse
+    response = ctx.response,
       -- body
       -- headers
       -- status
       -- content_type
+    vim = vim
   }
   return env
 end
 
----load script for current context
 ---@param script string
+---@param env table
 ---@return function
-function M.load(script, context)
-  local env = M.create_env(context)
+function M.load(script, env)
   local f, error_msg = load(script, "script_variable", "bt", env)
   if error_msg then
     logger.error(error_msg)
   end
   return assert(f)
 end
 
+---@param script string
+---@param ctx Context
+---@return function
+function M.load_prescript(script, ctx)
+  return M.load(script, M.create_prescript_env(ctx))
+end
+
+---@param script string
+---@param ctx Context
+---@return function
+function M.load_handler(script, ctx)
+  return M.load(script, M.create_handler_env(ctx))
+end
+
 return M