feat: defer splicing as late as possible

Right now we splice variables as we parse the request. This is annoying for several resons: variable needs to exist to create the request, so probably we need to run the previous requests before that.

Author: teto

lua/rest-nvim/curl/init.lua

@@ -31,7 +31,6 @@ local function format_curl_cmd(res)
   return cmd
 end
 
-
 -- get_or_create_buf checks if there is already a buffer with the rest run results
 -- and if the buffer does not exists, then create a new one
 M.get_or_create_buf = function()
@@ -230,7 +229,7 @@ end
 M.curl_cmd = function(opts)
   -- plenary's curl module is strange in the sense that with "dry_run" it returns the command
   -- otherwise it starts the request :/
-  local dry_run_opts = vim.tbl_extend("force", opts, { dry_run = true } )
+  local dry_run_opts = vim.tbl_extend("force", opts, { dry_run = true })
   local res = curl[opts.method](dry_run_opts)
   local curl_cmd = format_curl_cmd(res)
 
@@ -242,7 +241,8 @@ M.curl_cmd = function(opts)
     vim.api.nvim_echo({ { "[rest.nvim] Request preview:\n", "Comment" }, { curl_cmd } }, false, {})
     return
   else
-    opts.callback = vim.schedule_wrap(create_callback(curl_cmd, opts.method, opts.url, opts.script_str))
+    opts.callback =
+      vim.schedule_wrap(create_callback(curl_cmd, opts.method, opts.url, opts.script_str))
     curl[opts.method](opts)
   end
 end

lua/rest-nvim/init.lua

@@ -2,19 +2,20 @@ local backend = require("rest-nvim.request")
 local config = require("rest-nvim.config")
 local curl = require("rest-nvim.curl")
 local log = require("plenary.log").new({ plugin = "rest.nvim" })
+local utils = require("rest-nvim.utils")
+local path = require("plenary.path")
 
 local rest = {}
 local Opts = {}
 local defaultRequestOpts = {
-    verbose = false,
-    highlight = false,
-    engine = 'classic'
-  }
+  verbose = false,
+  highlight = false,
+}
 
 local LastOpts = {}
+
 rest.setup = function(user_configs)
   config.set(user_configs or {})
-
 end
 
 -- run will retrieve the required request information from the current buffer
@@ -37,7 +38,7 @@ end
 -- @param string filename to load
 -- @param opts table
 --           1. keep_going boolean keep running even when last request failed
---           2. verbose boolean 
+--           2. verbose boolean
 rest.run_file = function(filename, opts)
   log.info("Running file :" .. filename)
   opts = vim.tbl_deep_extend(
@@ -54,38 +55,113 @@ rest.run_file = function(filename, opts)
 
   local requests = backend.buf_list_requests(new_buf)
   for _, req in pairs(requests) do
-    vim.pretty_print("Request:")
-    vim.pretty_print(req)
     rest.run_request(req, opts)
   end
 
   return true
 end
 
+-- replace variables in header values
+local function splice_headers(headers)
+  for name, value in pairs(headers) do
+    headers[name] = utils.replace_vars(value)
+  end
+  return headers
+end
+
+-- return the spliced/resolved filename
+-- @param string the filename w/o variables
+local function load_external_payload(fileimport_string)
+  local fileimport_spliced = utils.replace_vars(fileimport_string)
+  if path:new(fileimport_spliced):is_absolute() then
+    return fileimport_spliced
+  else
+    local file_dirname = vim.fn.expand("%:p:h")
+    local file_name = path:new(path:new(file_dirname), fileimport_spliced)
+    return file_name:absolute()
+  end
+end
+
+
+-- @param headers table  HTTP headers
+-- @param payload table of the form { external = bool, filename_tpl= path, body_tpl = string }
+--                 with body_tpl an array of lines
+local function splice_body(headers, payload)
+  local external_payload = payload.external
+  local lines -- array of strings
+  if external_payload then
+    local importfile = load_external_payload(payload.filename_tpl)
+    if not utils.file_exists(importfile) then
+      error("import file " .. importfile .. " not found")
+    end
+    -- TODO we dont necessarily want to load the file, it can be slow
+    -- https://github.com/rest-nvim/rest.nvim/issues/203
+    lines = utils.read_file(importfile)
+  else
+    lines = payload.body_tpl
+  end
+  local content_type = ""
+  for key, val in pairs(headers) do
+    if string.lower(key) == "content-type" then
+      content_type = val
+      break
+    end
+  end
+  local has_json = content_type:find("application/[^ ]*json")
+
+  local body = ""
+  local vars = utils.read_variables()
+  -- nvim_buf_get_lines is zero based and end-exclusive
+  -- but start_line and stop_line are one-based and inclusive
+  -- magically, this fits :-) start_line is the CRLF between header and body
+  -- which should not be included in the body, stop_line is the last line of the body
+  for _, line in ipairs(lines) do
+    body = body .. utils.replace_vars(line, vars)
+  end
+
+  local is_json, json_body = pcall(vim.json.decode, body)
+
+  if is_json and json_body then
+    if has_json then
+      -- convert entire json body to string.
+      return vim.fn.json_encode(json_body)
+    else
+      -- convert nested tables to string.
+      for key, val in pairs(json_body) do
+        if type(val) == "table" then
+          json_body[key] = vim.fn.json_encode(val)
+        end
+      end
+      return vim.fn.json_encode(json_body)
+    end
+  end
+end
 
 -- run will retrieve the required request information from the current buffer
 -- and then execute curl
 -- @param req table see validate_request to check the expected format
 -- @param opts table
 --           1. keep_going boolean keep running even when last request failed
 rest.run_request = function(req, opts)
-  -- TODO rename result to req
+  -- TODO rename result to request
   local result = req
   opts = vim.tbl_deep_extend(
     "force", -- use value from rightmost map
     defaultRequestOpts,
     opts or {}
   )
 
+  -- body =
+
   Opts = {
     method = result.method:lower(),
     url = result.url,
     -- plenary.curl can't set http protocol version
     -- http_version = result.http_version,
-    headers = result.headers,
+    headers = splice_headers(result.headers),
     raw = config.get("skip_ssl_verification") and vim.list_extend(result.raw, { "-k" })
       or result.raw,
-    body = result.body,
+    body = splice_body(result.headers, result.body),
     dry_run = opts.verbose,
     bufnr = result.bufnr,
     start_line = result.start_line,
@@ -103,18 +179,21 @@ rest.run_request = function(req, opts)
 
   local request_id = vim.loop.now()
   local data = {
-        requestId = request_id,
-        request = req
-      }
+    requestId = request_id,
+    request = req,
+  }
 
   vim.api.nvim_exec_autocmds("User", {
-      pattern = "RestStartRequest",
-      modeline = false,
-      data = data
-    })
+    pattern = "RestStartRequest",
+    modeline = false,
+    data = data,
+  })
   local success_req, req_err = pcall(curl.curl_cmd, Opts)
-  vim.api.nvim_exec_autocmds("User", { pattern = "RestStopRequest", modeline = false,
-      data = vim.tbl_extend("keep", { status = success_req, message = req_err }, data)  })
+  vim.api.nvim_exec_autocmds("User", {
+    pattern = "RestStopRequest",
+    modeline = false,
+    data = vim.tbl_extend("keep", { status = success_req, message = req_err }, data),
+  })
 
   if not success_req then
     vim.api.nvim_err_writeln(
@@ -148,10 +227,10 @@ end
 
 rest.request = backend
 
-rest.select_env = function(path)
+rest.select_env = function(env_file)
   if path ~= nil then
-    vim.validate({ path = { path, "string" } })
-    config.set({ env_file = path })
+    vim.validate({ env_file = { env_file, "string" } })
+    config.set({ env_file = env_file })
   else
     print("No path given")
   end