feat: run request by name

Author: boltlessengineer

lua/rest-nvim/commands.lua

@@ -39,6 +39,7 @@ local commands = {}
 local dotenv = require("rest-nvim.dotenv")
 local request = require("rest-nvim.request")
 local logger = require("rest-nvim.logger")
+local parser = require("rest-nvim.parser")
 
 
 ---@type table<string, RestCmd>
@@ -47,12 +48,27 @@ local rest_command_tbl = {
     -- TODO: run request by name
     impl = function(args, opts)
       if #args > 1 then
-        vim.notify("Running request by name isn't supported yet", vim.log.levels.INFO)
+        vim.notify("Running multiple request isn't supported yet", vim.log.levels.WARN)
+        return
+      elseif #args == 1 then
+        -- TODO: get request by name
+        request.run_by_name(args[1])
         return
       end
       -- TODO: open result window here (use `:horizontal`)
       request.run()
     end,
+    ---@return string[]
+    complete = function (args)
+      local names = parser.get_request_names(0)
+      local matches = vim.iter(names):filter(function (name)
+        return name:find("^" .. vim.pesc(args))
+      end):map(function (name)
+        name = name:gsub("%s+", "\\ ")
+        return name
+      end):totable()
+      return matches
+    end
   },
   last = {
     impl = function(_, _)

lua/rest-nvim/parser/init.lua

@@ -16,6 +16,19 @@ local config = require("rest-nvim.config")
 ---@field __TYPE BodyType
 ---@field data any
 
+local NAMED_REQUEST_QUERY = vim.treesitter.query.parse("http", [[
+(section
+  (request_separator
+    value: (_) @name)
+  request: (_)) @request
+(section
+  (comment
+    name: (_) @keyword
+    value: (_) @name
+    (#eq? @keyword "name"))
+  request: (_)) @request
+]])
+
 ---@param node TSNode
 ---@param field string
 ---@param source Source
@@ -105,7 +118,6 @@ function M.parse_body(body_node, source, context)
       name = get_node_field_text(body_node, "name", source),
       path = path,
     }
-    vim.print(body.data.path)
   elseif body.__TYPE == "graphql" then
     logger.error("graphql body is not supported yet")
   end
@@ -129,10 +141,16 @@ function M.create_context(source)
   return ctx
 end
 
----@return TSNode? node TSNode with type `request_section`
+---@return TSNode? node TSNode with type `section`
 function M.get_cursor_request_node()
   local node = vim.treesitter.get_node()
-  return node and utils.ts_find(node, "request_section")
+  if node then
+    node = utils.ts_find(node, "section")
+    if not node or #node:field("request") < 1 then
+      return
+    end
+  end
+  return node
 end
 
 ---@return TSNode[]
@@ -148,6 +166,22 @@ function M.get_all_request_node()
   return reqs
 end
 
+---@return TSNode?
+function M.get_request_node_by_name(name)
+  local source = 0
+  local _, tree = utils.ts_parse_source(source)
+  local query = NAMED_REQUEST_QUERY
+  for id, node, _metadata, _match in query:iter_captures(tree:root(), source) do
+    local capture_name = query.captures[id]
+    if capture_name == "name" and vim.treesitter.get_node_text(node, source) == name then
+      local find = utils.ts_find(node, "section")
+      if find then
+        return find
+      end
+    end
+  end
+end
+
 ---@param vd_node TSNode
 ---@param source Source
 ---@param ctx Context
@@ -186,34 +220,19 @@ function M.parse_request_handler(handler_node, source, context)
   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)
+---@param source Source
+---@return string[]
+function M.get_request_names(source)
+  local _, tree = utils.ts_parse_source(source)
+  local query = NAMED_REQUEST_QUERY
+  local result = {}
+  for id, node, _metadata, _match in query:iter_captures(tree:root(), source) do
+    local capture_name = query.captures[id]
+    if capture_name == "name" then
+      table.insert(result, vim.treesitter.get_node_text(node, source))
     end
-    n = n:next_named_sibling()
   end
-  return siblings
+  return result
 end
 
 ---Parse the request node and create Request object. Returns `nil` if parsing
@@ -223,7 +242,7 @@ end
 ---@param context? Context
 ---@return Request|nil
 function M.parse(node, source, context)
-  assert(node:type() == "request_section")
+  assert(node:type() == "section")
   context = context or Context:new()
   -- request should not include error
   if node:has_error() then
@@ -235,11 +254,14 @@ function M.parse(node, source, context)
     logger.error("request section doesn't have request node")
     return nil
   end
+  local body
   local body_node = req_node:field("body")[1]
-  local body = body_node and M.parse_body(body_node, source, context)
-  if body_node and not body then
-    logger.error("parsing body failed")
-    return nil
+  if body_node then
+    body = M.parse_body(body_node, source, context)
+    if not body then
+      logger.error("parsing body failed")
+      return nil
+    end
   end
   local method = get_node_field_text(req_node, "method", source)
   if not method then
@@ -252,15 +274,19 @@ function M.parse(node, source, context)
     config.encode_url and utils.escape or nil
   )
 
-  -- FIXME: use query instead
-  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)
+  local name
+  local handlers = {}
+  for child, _ in node:iter_children() do
+    local node_type = child:type()
+    if node_type == "pre_request_script" then
+      M.parse_pre_request_script(child, source, context)
+    elseif node_type == "res_handler_script" then
+      table.insert(handlers, M.parse_request_handler(child, source, context))
+    elseif node_type == "request_separator" then
+      name = get_node_field_text(child, "value", source)
+    end
   end
-  local handler_nodes = collect_next_siblings(req_node, {"res_handler_script"})
-  local handlers = vim.iter(handler_nodes):map(function (n)
-    return M.parse_request_handler(n, source, context)
-  end):totable()
+
   local headers = parse_headers(req_node, source, context)
   -- HACK: check if url doesn't have host
   if headers["host"] and url[1] == "/" then
@@ -269,6 +295,7 @@ function M.parse(node, source, context)
   end
   ---@type Request
   return {
+    name = name,
     context = context,
     method = method,
     url = url,

lua/rest-nvim/request.lua

@@ -24,7 +24,6 @@ local response = require("rest-nvim.response")
 local rest_nvim_last_request = nil
 
 ---@param req Request
----@return boolean ok
 local function run_request(req)
   logger.debug("run_request")
   local client = require("rest-nvim.client.curl.cli")
@@ -59,18 +58,17 @@ local function run_request(req)
     -- NOTE: wrap with schedule to set vim variable outside of lua callback loop
     vim.schedule(ui.update)
   end)
-  -- FIXME: use future instead of returning true here
-  return true
+  -- FIXME: return future to pass the command state
 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")
-    return false
+    vim.notify("failed to find request at cursor position", vim.log.levels.ERROR)
+    return
   end
   local ctx = parser.create_context(0)
   if vim.b._rest_nvim_env_file then
@@ -79,28 +77,52 @@ function M.run()
   local req = parser.parse(req_node, 0, ctx)
   if not req then
     logger.error("failed to parse request")
-    return false
+    vim.notify("failed to parse request", vim.log.levels.ERROR)
+    return
+  end
+  local highlight = config.highlight
+  if highlight.enable then
+    utils.ts_highlight_node(0, req_node, require("rest-nvim.api").namespace)
+  end
+  run_request(req)
+end
+
+---@param name string
+function M.run_by_name(name)
+  local req_node = parser.get_request_node_by_name(name)
+  if not req_node then
+    logger.error("failed to find request by name: " .. name)
+    vim.notify("failed to find request by name: " .. name, vim.log.levels.ERROR)
+    return
+  end
+  local ctx = parser.create_context(0)
+  if vim.b._rest_nvim_env_file then
+    ctx:load_file(vim.b._rest_nvim_env_file)
+  end
+  local req = parser.parse(req_node, 0, ctx)
+  if not req then
+    logger.error("failed to parse request")
+    vim.notify("failed to parse request", vim.log.levels.ERROR)
+    return
   end
   local highlight = config.highlight
   if highlight.enable then
     utils.ts_highlight_node(0, req_node, require("rest-nvim.api").namespace)
   end
-  return run_request(req)
+  run_request(req)
 end
 
 ---run last request
----@return boolean ok
 function M.run_last()
   local req = rest_nvim_last_request
   if not req then
     vim.notify("No last request found", vim.log.levels.WARN)
     return false
   end
-  return run_request(req)
+  run_request(req)
 end
 
 ---run all requests in current file with same context
----@return boolean ok
 function M.run_all()
   local reqs = parser.get_all_request_node()
   local ctx = parser.create_context(0)
@@ -110,13 +132,13 @@ function M.run_all()
       vim.notify("Parsing request failed. See `:Rest logs` for more info", vim.log.levels.ERROR)
       return false
     end
+    -- FIXME: wait for previous request ends
     local ok = run_request(req)
     if not ok then
       vim.notify("Running request failed. See `:Rest logs` for more info", vim.log.levels.ERROR)
-      return false
+      return
     end
   end
-  return true
 end
 
 return M

spec/api_spec.lua

@@ -201,4 +201,17 @@ X-DATE: {{$date}}
     assert.same(nil, vim.env["bar"])
     assert.same("old", vim.env["baz"])
   end)
+  it("capture all request names", function ()
+    local source = [[
+### first named request
+GET http://localhost:80
+### request separator that isn't a request name
+###
+# @name=second named request
+# additional comments
+GET http://localhost:80
+]]
+    local names = parser.get_request_names(source)
+    assert.same({"first named request", "second named request"}, names)
+  end)
 end)