refactor: remove plenary as a dependency

Author: Massolari

README.md

@@ -10,8 +10,6 @@ https://user-images.githubusercontent.com/12272702/175755866-62be0b6c-31b2-4f45-
 
 - [Features](#features)
 - [Dependencies](#dependencies)
-  - [Required](#required)
-  - [Optional](#optional)
 - [Installation](#installation)
 - [Setup](#setup)
 - [Usage](#usage)
@@ -27,11 +25,7 @@ https://user-images.githubusercontent.com/12272702/175755866-62be0b6c-31b2-4f45-
 
 ## Dependencies
 
-### Required
-
-- [Plenary](https://github.com/nvim-lua/plenary.nvim)
-
-### Optional
+You can use the plugin without any dependencies, but if you have any of the following plugins installed, the plugin will use them to enhance the experience:
 
 - [Telescope](https://github.com/nvim-telescope/telescope.nvim) or [fzf-lua](https://github.com/ibhagwan/fzf-lua)
 

lua/forem-nvim/api.lua

@@ -1,6 +1,4 @@
 local M = {}
-local curl = require("plenary.curl")
-local job = require("plenary.job")
 local notify = require("forem-nvim.notify")
 local article = require("forem-nvim.article")
 
@@ -10,125 +8,197 @@ end
 
 local BASE_URL = "https://dev.to/api"
 
-local function handle_async_error(response)
-  notify.error("Error: " .. tostring(response.body.error))
-end
+---@class Response
+---@field status number
+---@field body table
+
+---@alias Method "GET" | "POST" | "PUT" | "DELETE"
 
+---@param response Response
+---@param on_success fun(body: table)
 function M.handle_error(response, on_success)
   local start_status = string.sub(response.status, 1, 2)
 
   if start_status == "20" then
     on_success(response.body)
   else
-    notify.error("Error: " .. tostring(response.body.error))
+    local error = response
+    if response.body then
+      error = response.body
+      if response.body.error then
+        error = response.body.error
+      end
+    end
+    notify.error("Error: " .. tostring(error))
+  end
+end
+
+---@param out vim.SystemCompleted
+---@return Response
+local function system_completed_to_response(out)
+  local status_code = nil
+  local response_body = nil
+
+  if out.stdout then
+    -- Extract status code from headers
+    status_code = out.stdout:match("HTTP/%d%.?%d?%s+(%d+)")
+
+    -- Extract the body from the response (everything after the headers)
+    response_body = out.stdout:match("\n\n(.*)")
+  end
+
+  local body = nil
+  -- Only attempt to decode if we have a body
+  if response_body and response_body ~= "" then
+    -- Protect against JSON decode errors
+    body = vim.fn.json_decode(response_body)
   end
+
+  return {
+    status = status_code,
+    body = body
+  }
 end
 
-local function request(request_function, endpoint, options)
+---@param method Method
+---@param endpoint string
+---@param options table
+---@param on_exit fun(response: Response)?
+---@return vim.SystemObj
+local function curl(method, endpoint, options, on_exit)
+  local headers = options.headers or {}
+  local request_body = options.body and { "-d", vim.fn.json_encode(options.body) } or {}
+
+  local cmd = vim.iter({
+    "curl",
+    "-X",
+    method,
+    "-i", -- Include headers in the output
+    vim.tbl_map(function(header)
+      return { "-H", header }
+    end, headers),
+    request_body,
+    BASE_URL .. endpoint
+  }):flatten(2):totable()
+
+  return vim.system(cmd, { text = true }, function(out)
+    vim.schedule(function()
+      local response = system_completed_to_response(out)
+      if on_exit then
+        on_exit(response)
+      end
+    end)
+  end)
+end
+
+---@param method Method
+---@param endpoint string
+---@param options table
+---@return Response
+local function request(method, endpoint, options)
   local parameters = vim.tbl_extend(
     "force",
     {
-      url = BASE_URL .. endpoint,
       headers = {
-        ["api-key"] = M.key(),
-        content_type = "application/json",
-        accept = "application/vnd.forem.api-v1+json"
+        "api-key: " .. M.key(),
+        "Content-Type: application/json",
+        "Accept: application/vnd.forem.api-v1+json"
       }
     },
     options
   )
-  local response = request_function(parameters)
-  if response.body then
-    return vim.tbl_extend(
-      "force",
-      response,
-      { body = vim.fn.json_decode(response.body) }
-    )
-  end
+
+  local out = curl(method, endpoint, parameters, nil):wait()
+  local response = system_completed_to_response(out)
+
   return response
 end
 
-local function request_async(method, endpoint, options, on_success, on_error)
-  -- TODO: Check if this could be done with `vim.system`
-  return job:new({
-    command = "curl",
-    args = {
-      "-X",
-      method,
-      "-H",
-      "Content-Type: application/json",
-      "-H",
-      "Accept: application/vnd.forem.api-v1+json",
-      "-H",
-      "api-key: " .. tostring(M.key()),
-      "-d",
-      vim.fn.json_encode(options),
-      BASE_URL .. endpoint
-    },
-    on_exit = function(this_job, code)
-      vim.schedule(function()
-        local result = table.concat(
-          this_job:result(),
-          "\n"
-        )
-        local response = vim.fn.json_decode(result)
-        if code == 0 then
-          on_success(response)
-          return
-        end
-        handle_async_error(response)
-        if on_error then
-          on_error(response)
-        end
-      end)
-    end
-  }):start()
+---@param method Method
+---@param endpoint string
+---@param on_success fun(body: table)
+local function request_async(method, endpoint, on_success)
+  local options = {
+    headers = {
+      "Api-Key: " .. M.key()
+    }
+  }
+
+  curl(method, endpoint, options, function(response)
+    M.handle_error(
+      response,
+      on_success
+    )
+  end
+  )
 end
 
-local function get(endpoint, on_success, on_error)
-  return request_async(
+---@param endpoint string
+---@param on_success fun(body: table)
+local function get(endpoint, on_success)
+  request_async(
     "GET",
     endpoint,
-    {},
-    on_success,
-    on_error
+    on_success
   )
 end
 
+---@param endpoint string
+---@param body table
+---@return Response
 local function put(endpoint, body)
-  return request(curl.put, endpoint, { body = body })
+  return request("PUT", endpoint, { body = body })
 end
 
+---@param endpoint string
+---@param body table
+---@return Response
 local function post(endpoint, body)
-  return request(curl.post, endpoint, { body = body })
+  return request("POST", endpoint, { body = body })
 end
 
-function M.my_articles(on_success, on_error) return get("/articles/me/all", on_success, on_error) end
+---@param on_success fun(body: table)
+function M.my_articles(on_success)
+  return get("/articles/me/all", on_success)
+end
 
+---@param id number
+---@param content string
+---@return Response
 function M.save_article(id, content)
   return put(
     "/articles/" .. tostring(id),
-    vim.fn.json_encode({ article = { body_markdown = content } })
+    { article = { body_markdown = content } }
   )
 end
 
+---@param title string
+---@return Response
 function M.new_article(title)
   return post(
     "/articles",
-    vim.fn.json_encode({ article = { body_markdown = article.get_template(title) } })
+    { article = { body_markdown = article.get_template(title) } }
   )
 end
 
-function M.feed(on_success, on_error) return get("/articles", on_success, on_error) end
+---@param on_success fun(body: table)
+function M.feed(on_success)
+  get("/articles", on_success)
+end
 
-function M.get_article(id, on_success, on_error)
-  return get(
+---@param id number
+---@param on_success fun(body: table)
+function M.get_article(id, on_success)
+  get(
     "/articles/" .. tostring(id),
-    on_success,
-    on_error
+    on_success
   )
 end
 
-function M.get_article_by_path(path, on_success, on_error) return get("/articles/" .. path, on_success, on_error) end
+---@param path string
+---@param on_success fun(body: table)
+function M.get_article_by_path(path, on_success)
+  get("/articles/" .. path, on_success)
+end
 
 return M

lua/forem-nvim/picker.lua

@@ -112,7 +112,8 @@ function M.my_articles(articles)
   vim.ui.select(vim.tbl_map(function(article) return article.title end, articles), {
     prompt = "My Articles",
   }, function(selection)
-    buffer.open_my_article(articles[selection])
+    local article = vim.tbl_filter(function(a) return a.title == selection end, articles)[1]
+    buffer.open_my_article(article)
   end)
 end