feat(curl): basic curl command parser

boltlessengineer · boltlessengineer · commit 0cc65a9e0e5f · 2024-08-24T19:15:14.000Z
diff --git a/lua/rest-nvim/parser/curl.lua b/lua/rest-nvim/parser/curl.lua
@@ -0,0 +1,140 @@
+---@mod rest-nvim.parser.curl rest.nvim curl parsing module
+---
+---@brief [[
+---
+--- rest.nvim curl command parsing module
+--- rest.nvim uses `tree-sitter-bash` as a core parser to parse raw curl commands
+---
+---@brief ]]
+
+local curl_parser = {}
+
+local utils = require("rest-nvim.utils")
+local logger = require("rest-nvim.logger")
+
+---@param node TSNode Tree-sitter request node
+---@param source Source
+function curl_parser.parse_command(node, source)
+    assert(node:type() == "command")
+    assert(utils.ts_field_text(node, "name", source) == "curl")
+    local arg_nodes = node:field("argument")
+    if #arg_nodes < 1 then
+        logger.error("can't parse curl command with 0 arguments")
+        return
+    end
+    local args = {}
+    for _, arg_node in ipairs(arg_nodes) do
+        local arg_type = arg_node:type()
+        if arg_type == "word" then
+            table.insert(args, vim.treesitter.get_node_text(arg_node, source))
+        elseif arg_type == "raw_string" then
+            -- FIXME: expand escaped sequences like `\n`
+            table.insert(args, vim.treesitter.get_node_text(arg_node, source):sub(2, -2))
+        else
+            logger.error(("can't parse argument type: '%s'"):format(arg_type))
+            return
+        end
+    end
+    return args
+end
+
+-- -X, --request
+-- The request method to use.
+-- -H, --header
+-- The request header to include in the request.
+-- -u, --user | --basic | --digest
+-- The user's credentials to be provided with the request, and the authorization method to use.
+-- -d, --data, --data-ascii | --data-binary | --data-raw | --data-urlencode
+-- The data to be sent in a POST request.
+-- -F, --form
+-- The multipart/form-data message to be sent in a POST request.
+-- --url
+-- The URL to fetch (mostly used when specifying URLs in a config file).
+-- -i, --include
+-- Defines whether the HTTP response headers are included in the output.
+-- -v, --verbose
+-- Enables the verbose operating mode.
+-- -L, --location
+-- Enables resending the request in case the requested page has moved to a different location.
+
+---@param args string[]
+function curl_parser.parse_arguments(args)
+    local iter = vim.iter(args)
+    ---@type rest.Request
+    local req = {
+        -- TODO: add this to rest.Request type
+        meta = {
+            redirect = false,
+        },
+        url = "",
+        method = "GET",
+        headers = {},
+        cookies = {},
+        handlers = {},
+    }
+    local function any(value, list)
+        return vim.list_contains(list, value)
+    end
+    while true do
+        local arg = iter:next()
+        if not arg then
+            break
+        end
+        if any(arg, { "-X", "--request" }) then
+            req.method = iter:next()
+        elseif any(arg, { "-H", "--header" }) then
+            local pair = iter:next()
+            local key, value = pair:match("(%S+):%s*(.*)")
+            if not key then
+                logger.error("can't parse header:" .. pair)
+            else
+                key = key:lower()
+                req.headers[key] = req.headers[key] or {}
+                if value then
+                    table.insert(req.headers[key], value)
+                end
+            end
+        -- TODO: handle more arguments
+        -- elseif any(arg, { "-u", "--user" }) then
+        -- elseif arg == "--basic" then
+        -- elseif arg == "--digest" then
+        elseif any(arg, { "-d", "--data", "--data-ascii", "--data-raw" }) then
+            -- handle external body with `@` syntax
+            local body = iter:next()
+            if arg ~= "--data-raw" and body:sub(1, 1) == "@" then
+                req.body = {
+                    __TYPE = "external",
+                    data = {
+                        name = "",
+                        path = body:sub(2),
+                    },
+                }
+            else
+                req.body = {
+                    __TYPE = "raw",
+                    data = body
+                }
+            end
+        -- elseif arg == "--data-binary" then
+        -- elseif any(arg, { "-F", "--form" }) then
+        elseif arg == "--url" then
+            req.url = iter:next()
+        elseif any(arg, { "-L", "--location" }) then
+            req.meta.redirect = true
+        elseif arg:match("^-%a+$") then
+            local flags_iter = vim.gsplit(arg:sub(2), "")
+            for flag in flags_iter do
+                if flag == "L" then
+                    req.meta.redirect = true
+                end
+            end
+        elseif req.url == "" and not vim.startswith(arg, "-") then
+            req.url = arg
+        else
+            logger.warn("unknown argument: " .. arg)
+        end
+    end
+    return req
+end
+
+return curl_parser
diff --git a/lua/rest-nvim/parser/init.lua b/lua/rest-nvim/parser/init.lua
@@ -32,15 +32,6 @@ local NAMED_REQUEST_QUERY = vim.treesitter.query.parse(
 ]]
 )
 
----@param node TSNode
----@param field string
----@param source Source
----@return string|nil
-local function get_node_field_text(node, field, source)
-    local n = node:field(field)[1]
-    return n and vim.treesitter.get_node_text(n, source) or nil
-end
-
 ---@param src string
 ---@param context rest.Context
 ---@param encoder? fun(s:string):string
@@ -67,8 +58,8 @@ local function parse_headers(req_node, source, context)
     end)
     local header_nodes = req_node:field("header")
     for _, node in ipairs(header_nodes) do
-        local key = assert(get_node_field_text(node, "name", source))
-        local value = get_node_field_text(node, "value", source)
+        local key = assert(utils.ts_field_text(node, "name", source))
+        local value = utils.ts_field_text(node, "value", source)
         key = expand_variables(key, context):lower()
         if value then
             value = expand_variables(value, context)
@@ -110,6 +101,7 @@ local function parse_urlencoded_form(str)
                 logger.error(("Error while parsing query '%s' from urlencoded form '%s'"):format(query_pairs, str))
                 return nil
             end
+            -- TODO: encode value here
             return vim.trim(key) .. "=" .. vim.trim(value)
         end)
         :join("&")
@@ -126,7 +118,7 @@ function parser.parse_body(content_type, body_node, source, context)
     ---@cast body rest.Request.Body
     if node_type == "external_body" then
         body.__TYPE = "external"
-        local path = assert(get_node_field_text(body_node, "path", source))
+        local path = assert(utils.ts_field_text(body_node, "path", source))
         if type(source) ~= "number" then
             logger.error("can't parse external body on non-existing http file")
             return
@@ -137,7 +129,7 @@ function parser.parse_body(content_type, body_node, source, context)
         basepath = basepath:gsub("^" .. vim.pesc(vim.uv.cwd() .. "/"), "")
         path = vim.fs.normalize(vim.fs.joinpath(basepath, path))
         body.data = {
-            name = get_node_field_text(body_node, "name", source),
+            name = utils.ts_field_text(body_node, "name", source),
             path = path,
         }
     elseif node_type == "json_body" or content_type == "application/json" then
@@ -252,8 +244,8 @@ end
 ---@param ctx rest.Context
 function parser.parse_variable_declaration(vd_node, source, ctx)
     vim.validate({ node = utils.ts_node_spec(vd_node, "variable_declaration") })
-    local name = assert(get_node_field_text(vd_node, "name", source))
-    local value = vim.trim(assert(get_node_field_text(vd_node, "value", source)))
+    local name = assert(utils.ts_field_text(vd_node, "name", source))
+    local value = vim.trim(assert(utils.ts_field_text(vd_node, "value", source)))
     value = expand_variables(value, ctx)
     ctx:set_global(name, value)
 end
@@ -265,8 +257,8 @@ end
 local function parse_script(node, source)
     local lang = "javascript"
     local prev_node = utils.ts_upper_node(node)
-    if prev_node and prev_node:type() == "comment" and get_node_field_text(prev_node, "name", source) == "lang" then
-        local value = get_node_field_text(prev_node, "value", source)
+    if prev_node and prev_node:type() == "comment" and utils.ts_field_text(prev_node, "name", source) == "lang" then
+        local value = utils.ts_field_text(prev_node, "value", source)
         if value then
             lang = value
         end
@@ -369,7 +361,7 @@ function parser.parse(node, source, ctx)
         local start_row = node:range()
         parser.eval_context(source, ctx, start_row)
     end
-    local method = get_node_field_text(req_node, "method", source)
+    local method = utils.ts_field_text(req_node, "method", source)
     if not method then
         logger.info("no method provided, falling back to 'GET'")
         method = "GET"
@@ -384,7 +376,7 @@ function parser.parse(node, source, ctx)
     for child, _ in node:iter_children() do
         local child_type = child:type()
         if child_type == "request" then
-            url = expand_variables(assert(get_node_field_text(req_node, "url", source)), ctx, utils.escape)
+            url = expand_variables(assert(utils.ts_field_text(req_node, "url", source)), ctx, utils.escape)
             url = url:gsub("\n%s+", "")
         elseif child_type == "pre_request_script" then
             parser.parse_pre_request_script(child, source, ctx)
@@ -394,9 +386,9 @@ function parser.parse(node, source, ctx)
                 table.insert(handlers, handler)
             end
         elseif child_type == "request_separator" then
-            name = get_node_field_text(child, "value", source)
-        elseif child_type == "comment" and get_node_field_text(child, "name", source) == "name" then
-            name = get_node_field_text(child, "value", source) or name
+            name = utils.ts_field_text(child, "value", source)
+        elseif child_type == "comment" and utils.ts_field_text(child, "name", source) == "name" then
+            name = utils.ts_field_text(child, "value", source) or name
         elseif child_type == "variable_declaration" then
             parser.parse_variable_declaration(child, source, ctx)
         end
@@ -450,7 +442,7 @@ function parser.parse(node, source, ctx)
         name = name,
         method = method,
         url = url,
-        http_version = get_node_field_text(req_node, "version", source),
+        http_version = utils.ts_field_text(req_node, "version", source),
         headers = headers,
         cookies = {},
         body = body,
diff --git a/lua/rest-nvim/utils.lua b/lua/rest-nvim/utils.lua
@@ -238,6 +238,15 @@ function utils.ts_upper_node(node)
     return min_node
 end
 
+---@param node TSNode
+---@param field string
+---@param source Source
+---@return string|nil
+function utils.ts_field_text(node, field, source)
+    local n = node:field(field)[1]
+    return n and vim.treesitter.get_node_text(n, source) or nil
+end
+
 ---@param node TSNode
 ---@param expected_type string
 ---@return table
diff --git a/spec/parser/curl_parser_spec.lua b/spec/parser/curl_parser_spec.lua
@@ -0,0 +1,36 @@
+---@module 'luassert'
+
+require("spec.minimal_init")
+
+local parser = require("rest-nvim.parser.curl")
+local utils = require("rest-nvim.utils")
+
+describe("curl cli parser", function()
+    it("parse curl command", function()
+        local source = [[
+        curl -sSL -X POST https://example.com \
+            -H 'Content-Type: application/json' \
+            -d '{ "foo": 123 }'
+        ]]
+        local _, tree = utils.ts_parse_source(source, "bash")
+        local curl_node = assert(tree:root():child(0))
+        local args = parser.parse_command(curl_node, source)
+        assert(args)
+        assert.same({
+            method = "POST",
+            url = "https://example.com",
+            headers = {
+                ["content-type"] = { "application/json" },
+            },
+            body = {
+                __TYPE = "raw",
+                data = '{ "foo": 123 }',
+            },
+            meta = {
+                redirect = true,
+            },
+            cookies = {},
+            handlers = {},
+        }, parser.parse_arguments(args))
+    end)
+end)
