feat: kulala_http in markdown blocks, syntax hl, diagnostics + fixes (#600)

* refact: ui/jumps, formatters
* fix(env_manager): fix using vim.ui.select
* fix(parser): grammar for $auth.token vars
* feat(ui): add kulala_http parser to markdown code blocks
* feat(ui): add diagnostics for invalid paths
* fix(cmd): set assert status to false for non-zero response code
* feat(ui): add syntax hl to '@,='
* fix(jump): off by one (#613)

---------

Co-authored-by: Igor Lacerda <igorlfs@ufmg.br>

Author: YaroSpace

docs/docs/getting-started/configuration-options.mdx

@@ -928,7 +928,7 @@ Function called when Kulala LSP attaches to the buffer
     enable = true,
     keymaps = false, -- disabled by default, as Kulala relies on default Neovim LSP keymaps
     formatter = {
-      sort = { -- enable/disable alphabetical sorting in request body
+      sort = { -- enable/disable alphabetical sorting
         metadata = true,
         variables = true,
         commands = true,

lua/kulala/cmd/diagnostics.lua

@@ -29,9 +29,10 @@ local function get_diagnostics(bufnr, parser)
         end_lnum = end_lnum,
         col = col,
         end_col = end_col,
-        severity = 1, -- Error severity in LSP
+        severity = vim.diagnostic.ERROR,
         source = "kulala",
         message = "Parsing error" .. (parent_type and " in " .. parent_type or ""),
+        type = "treesitter",
       })
     end
 
@@ -46,7 +47,16 @@ end
 
 local function update_diagnostics(bufnr)
   local parser = ts.get_parser(bufnr, "kulala_http")
-  local diags = get_diagnostics(bufnr, parser)
+
+  local existing_diags = vim.diagnostic.get(bufnr) or {}
+  local parser_diags = vim
+    .iter(existing_diags)
+    :filter(function(diag)
+      return diag.type == "parser"
+    end)
+    :totable()
+
+  local diags = vim.list_extend(get_diagnostics(bufnr, parser), parser_diags)
   vim.diagnostic.set(kulala_diag_ns(), bufnr, diags, {})
 end
 
@@ -62,4 +72,40 @@ function M.setup(bufnr)
   })
 end
 
+M.add_diagnostics = function(bufnr, message, severity, ls, cs, le, ce)
+  local diags = vim.diagnostic.get(bufnr)
+  ls = math.max(0, ls or 0)
+  le = math.max(0, le or ls or 0)
+
+  if vim.iter(diags):find(function(diag)
+    return diag.message == message and diag.lnum == ls
+  end) then return end
+
+  table.insert(diags, {
+    bufnr = bufnr,
+    lnum = ls,
+    end_lnum = le,
+    col = cs or 0,
+    end_col = ce or cs or 0,
+    severity = severity or vim.diagnostic.ERROR,
+    source = "kulala",
+    message = message,
+    type = "parser",
+  })
+
+  vim.diagnostic.set(kulala_diag_ns(), bufnr, diags, {})
+end
+
+M.clear_diagnostics = function(bufnr, type)
+  local diags = not type and {}
+    or vim
+      .iter(vim.diagnostic.get(bufnr))
+      :filter(function(diag)
+        return diag.type ~= type
+      end)
+      :totable()
+
+  vim.diagnostic.set(kulala_diag_ns(), bufnr, diags, {})
+end
+
 return M

lua/kulala/cmd/formatter.lua

@@ -1,7 +1,5 @@
 local Config = require("kulala.config")
-local Graphql = require("kulala.parser.graphql")
-local Json = require("kulala.utils.json")
-local Xml = require("kulala.utils.xml")
+local Formatter = require("kulala.formatter")
 
 local format_opts = Config.options.lsp.formatter
 format_opts = type(format_opts) == "table" and format_opts or { sort = { json = true } }
@@ -282,23 +280,23 @@ format_rules = {
 
   ["xml_body"] = function(node)
     local body = get_text(node)
-    local formatted = Xml.format(body) or body
+    local formatted = Formatter.xml(body) or body
 
     current_section().request.body = formatted:gsub("\n*$", "")
     return formatted
   end,
 
   ["json_body"] = function(node)
     local json = get_text(node)
-    local formatted = Json.format(json, { sort = format_opts.sort.json }) or json
+    local formatted = Formatter.json(json, { sort = format_opts.sort.json }) or json
 
     current_section().request.body = formatted:gsub("\n*$", "")
     return formatted
   end,
 
   ["graphql_body"] = function(node)
     local body = get_text(node)
-    local formatted = Graphql.format(body, { sort = format_opts.sort.json }) or body
+    local formatted = Formatter.graphql(body, { sort = format_opts.sort.json }) or body
 
     current_section().request.body = formatted:gsub("\n*$", "")
     return formatted
@@ -364,10 +362,11 @@ M.format = function(buffer, params)
   params = params or {}
   buf = buffer or vim.api.nvim_get_current_buf()
 
-  local diag = vim.diagnostic.get(buf)
-  if #diag > 0 and vim.fn.input("Document contains errors.  Do you still want to format it? (y/n): ") ~= "y" then
-    return
-  end
+  local diag = vim.iter(vim.diagnostic.get(buf) or {}):find(function(d)
+    return d.type == "treesitter"
+  end)
+
+  if diag and vim.fn.input("Document contains errors.  Do you still want to format it? (y/n): ") ~= "y" then return end
 
   local lang = "kulala_http"
   local tree = ts.get_parser(buf, lang):parse()[1]

lua/kulala/cmd/init.lua

@@ -65,7 +65,7 @@ function queue.run_next(self)
 
     if not (status and cb_status) then
       self:reset()
-      Logger.error(("Errors running a scheduled task: %s %s"):format(errors or "", cb_errors), 1, true)
+      Logger.error(("Errors running a scheduled task: %s %s"):format(errors or "", cb_errors), 1, { report = true })
     end
 
     self.done = self.done + 1
@@ -147,6 +147,7 @@ local function set_request_stats(response)
   response.stats = Json.parse(response.stats) or {}
   response.response_code = tonumber(response.stats.response_code) or response.code
   response.status = response.code == 0 and response.response_code < 400
+  response.assert_status = response.status and response.assert_status
 
   return response
 end
@@ -179,7 +180,7 @@ local function save_response(request_status, parsed_request)
 
   local responses = DB.global_update().responses
   if #responses > 0 and responses[#responses].id == id and responses[#responses].code == -1 then
-    table.remove(responses) -- remove the last response if it's the same request and status was unfinished
+    table.remove(responses) -- remove the last response if it's the same request and status was unfinished (for chunked response)
   end
 
   ---@type Response
@@ -261,7 +262,7 @@ local function process_errors(request, request_status, processing_errors)
   )
 
   Logger.error(message, 2)
-  _ = processing_errors and Logger.error(processing_errors, 2, true)
+  _ = processing_errors and Logger.error(processing_errors, 2, { report = true })
 
   request_status.errors = processing_errors and request_status.errors .. "\n" .. processing_errors
     or request_status.errors

lua/kulala/cmd/lsp.lua

@@ -356,8 +356,8 @@ local sources = {
   auth_configs = auth_configs,
   methods = { Lsp_sources.methods, "Method" },
   schemes = { Lsp_sources.schemes, "Scheme" },
-  header_names = { Lsp_sources.header_names, "Header" },
-  header_values = { Lsp_sources.header_values, "Header" },
+  header_names = { Lsp_sources.header_names, "Header name" },
+  header_values = { Lsp_sources.header_values, "Header value" },
   metadata = { Lsp_sources.metadata, "Metadata" },
   curl = { Lsp_sources.curl, "Curl" },
   grpc = { Lsp_sources.grpc, "Grpc" },
@@ -398,7 +398,8 @@ local function source_type(params)
   if find_upwards(params.position.line, "query.*{") or find_upwards(params.position.line, "mutation.*{") then
     return { "graphql", "urls" }
   end
-  if find_upwards(params.position.line, "{%%") then return { "scripts", "urls", "headers_names", "header_values" } end
+
+  if find_upwards(params.position.line, "{%%") then return { "scripts", "urls", "header_names", "header_values" } end
 
   return { "commands", "methods", "schemes", "urls", "header_names", "snippets" }
 end
@@ -693,7 +694,10 @@ local function new_server()
         _ = handlers[method] and handler(nil, handlers[method](params))
       end, debug.traceback)
 
-      if not status then require("kulala.logger").error("Errors in Kulala LSP:\n" .. (error or ""), 2, true) end
+      if not status then
+        require("kulala.logger").error("Errors in Kulala LSP:\n" .. (error or ""), 2, { report = true })
+      end
+
       return true
     end
 

lua/kulala/config/defaults.lua

@@ -100,6 +100,9 @@ local M = {
     ---@type table<string, string|vim.api.keyset.highlight>
     syntax_hl = {
       ["@punctuation.bracket.kulala_http"] = "Number",
+      ["@character.special.kulala_http"] = "Special",
+      ["@operator.kulala_http"] = "Special",
+      ["@variable.kulala_http"] = "String",
     },
 
     -- enable/disable request summary in the output window

lua/kulala/formatter/init.lua

@@ -1,4 +1,7 @@
+local Config = require("kulala.config")
+local Graphql = require("kulala.parser.graphql")
 local Logger = require("kulala.logger")
+local Shell = require("kulala.cmd.shell_utils")
 
 local M = {}
 
@@ -7,25 +10,66 @@ M.format = function(formatter, contents, opts)
     verbose = true,
   })
 
-  if type(formatter) == "function" then
-    return formatter(contents)
-  elseif type(formatter) == "table" then
-    local cmd = formatter
+  if type(formatter) == "function" then return formatter(contents) end
+  if not type(formatter) == "table" then return contents end
 
-    local status, result = pcall(function()
-      return vim.system(cmd, { stdin = contents, text = true }):wait()
-    end)
+  local executable = formatter[1]
 
-    if not status or result.code ~= 0 then
-      _ = opts.verbose
-        and Logger.warn(("Error running external formatter: %s"):format(not status and result or result.stderr))
-      return contents
-    end
+  if vim.fn.executable(executable) == 0 then
+    _ = opts.versbose and Logger.warn("Formatting failed: " .. executable .. " is not available.")
+    return contents
+  end
+
+  local result = Shell.run(formatter, {
+    sync = true,
+    stdin = contents,
+    err_msg = "Failed to format with " .. executable,
+    abort_on_stderr = true,
+  })
+
+  if not result or result.code ~= 0 or result.stderr ~= "" or result.stdout == "" then return contents end
+
+  return result.stdout
+end
+
+M.json = function(contents, opts)
+  local formatter = Config.get().contenttypes["application/json"]
+  if not formatter then return contents end
+
+  opts = vim.tbl_deep_extend("keep", opts or {}, { sort = true })
+  _ = opts.sort and formatter and table.insert(formatter.formatter, 2, "--sort-keys")
+
+  contents = type(contents) == "table" and vim.json.encode(contents, opts) or contents
 
-    return result.stdout
+  return M.format(formatter.formatter, contents, opts)
+end
+
+M.graphql = function(contents, opts)
+  local formatter = Config.get().contenttypes["application/graphql"]
+  if not formatter then return contents end
+
+  local _, json = Graphql.get_json(contents)
+  if not json then return contents end
+
+  local formatted = M.format(formatter.formatter, json.query, opts)
+
+  if json.variables and next(json.variables) then
+    formatted = formatted .. "\n" .. M.json(json.variables, { sort = opts.sort })
   end
 
-  return contents
+  return formatted
+end
+
+M.html = function(contents, opts)
+  local formatter = Config.get().contenttypes["application/html"]
+  if not formatter then return contents end
+  return M.format(formatter.formatter, contents, opts)
+end
+
+M.xml = function(contents, opts)
+  local formatter = Config.get().contenttypes["application/xml"]
+  if not formatter then return contents end
+  return M.format(formatter.formatter, contents, opts)
 end
 
 return M

lua/kulala/init.lua

@@ -5,7 +5,6 @@ local Fmt = require("kulala.cmd.fmt")
 local Fs = require("kulala.utils.fs")
 local GLOBALS = require("kulala.globals")
 local Graphql = require("kulala.graphql")
-local JUMPS = require("kulala.jumps")
 local Logger = require("kulala.logger")
 local ScriptsUtils = require("kulala.parser.scripts.utils")
 local UI = require("kulala.ui")
@@ -55,11 +54,11 @@ M.version = function()
 end
 
 M.jump_next = function()
-  JUMPS.jump_next()
+  UI:jump_next()
 end
 
 M.jump_prev = function()
-  JUMPS.jump_prev()
+  UI:jump_prev()
 end
 
 M.toggle_view = function()

lua/kulala/jumps/init.lua

@@ -16,8 +16,10 @@ local function generate_bug_report(message)
   if choice == 1 then require("kulala.logger.bug_report").generate_bug_report(message) end
 end
 
-M.log = function(message, level)
+M.log = function(message, level, opts)
+  opts = vim.tbl_extend("force", default_options, opts or {})
   level = level or log_levels.INFO
+
   local notify = vim.notify
 
   if not vim.fn.has("gui_running") then
@@ -26,21 +28,23 @@ M.log = function(message, level)
     notify = vim.schedule_wrap(vim.notify)
   end
 
-  notify(message, level, default_options)
+  notify(message, level, opts)
 end
 
-M.info = function(message)
-  _ = debug_level() > 2 and M.log(message, log_levels.INFO)
+M.info = function(message, opts)
+  _ = debug_level() > 2 and M.log(message, log_levels.INFO, opts)
 end
 
-M.warn = function(message)
-  _ = debug_level() > 1 and M.log(message, log_levels.WARN)
+M.warn = function(message, opts)
+  _ = debug_level() > 1 and M.log(message, log_levels.WARN, opts)
 end
 
 ---@param message string
 ---@param lines_no number|nil -- no of error lines to show
 ---@param report boolean|nil -- whether to generate a bug report
-M.error = function(message, lines_no, report)
+M.error = function(message, lines_no, opts)
+  opts = opts or {}
+
   local debug = debug_level()
   if debug == 0 then return end
 
@@ -50,7 +54,7 @@ M.error = function(message, lines_no, report)
 
   M.log(message, log_levels.ERROR)
 
-  if require("kulala.config").options.generate_bug_report or report then generate_bug_report(message) end
+  if require("kulala.config").options.generate_bug_report or opts.report then generate_bug_report(message) end
 end
 
 return M