Improvements on executing lua code from python + code simplifications (#48)

* funcs.luaeval -> exec_lua

Uses 'native' lua instead of parsed/indirection throught viml function

* Restructure connections + rplugin

This makes python code call lua without going through viml,
Which might make things faster and remove some indirections.

* Don't need to get that again

* Remove 'math.random' calls

This avoids port number collisions and callback session overwrites

* Split responsabilities of core.send

* Fix API doc attribute name mismatch

* Add LRU to session

* Don't fire autocmd multiple times

* Add fn to call from viml

* Allow running auto-require for tests

* Simplify handler fn

* Thin Session

* ease random

* Avoid random by creating id

* Use ulids (but make uuids available)

* Simplify some more stuff

* Add missing dep + remove fn

* Add back function for compatibility

* Update ulid doc

* Simplify some more

* Fix viml register callback

* Make connections use keys instead of indexes

This allows to pin things to connections

* Drop comments from ulid

Author: hkupty

API.md

@@ -1,42 +1,42 @@
 # acid.connections
 low-level connection handler
 
-## `acid.connections.add(this, addr)`
+## `acid.connections.add(addr)`
 Stores connection for reuse later
 
-this **(table)**: Connections object.
-
 addr **({string,string})**: Address tuple with ip and port.
 
 
-## `acid.connections.select(this, pwd, ix)`
+## `acid.connections.select(pwd, ix)`
 Elects selected connection as primary (thus default) for a certain address
 
-this **(table)**: Connections object.
-
 pwd **(string)**: path (usually project root).
  Assumed to be neovim's `pwd`.
 
 ix **(int)**: index of the stored connection
 
 
-## `acid.connections.unselect(this, pwd)`
+## `acid.connections.unselect(pwd)`
 Dissociates the connection for the given path
 
-this **(table)**: Connections object.
-
 pwd **(string)**: path (usually project root).
 
 
-## `acid.connections.get(this, pwd)`
+## `acid.connections.get(pwd)`
 Return active connection for the given path
 
-this **(table)**: Connections object.
-
 pwd **(string)**: path (usually project root).
 
 
-**({string,string})** Connection tuple with ip and port.
+**({string,string})** Connection tuple with ip and port or nil.
+
+
+## `acid.connections.set(pwd, addr)`
+Add and select the given connection for given path.
+
+pwd **(string)**: path (usually project root).
+
+addr **({string,string})**: tuple with ip and port or nil.
 
 
 ---
@@ -54,6 +54,11 @@ obj **(table)**: Payload to be sent to the nrepl.
 handler **(function)**: Handler function to deal with the response.
 
 
+---
+
+# extra.ulid
+generates the time-based part of a `ulid`.
+
 ---
 
 # acid.features
@@ -214,11 +219,9 @@ cmd: A command (op + payload + handler) to be executed.
 conn: A connection where this command will be run.
 
 
-## `acid.callback(session, ret)`
+## `acid.callback(ret)`
 Callback proxy for handling command responses
 
-session: Session ID for matching response with request
-
 ret: The response from nrepl
 
 

lua/acid/connections.lua

@@ -2,91 +2,112 @@
 
 --- low-level connection handler
 -- @module acid.connections
-local nvim = vim.api
 local utils = require("acid.utils")
 
 local connections = {
   store = {},
   current = {},
 }
 
+local pwd_to_key = function(pwd)
+  if not utils.ends_with(pwd, "/") then
+    return pwd .. "/"
+  end
+  return pwd
+end
+
 --- Stores connection for reuse later
--- @tparam table this Connections object.
 -- @tparam {string,string} addr Address tuple with ip and port.
-connections.add = function(this, addr)
-  table.insert(this.store, addr)
-  return #this.store
+connections.add = function(addr)
+  local uuid = utils.uuid()
+  connections.store[uuid] = addr
+  return uuid
 end
 
-connections.remove = function(this, addr)
+connections.remove = function(addr)
   local ix
-  for i, v in ipairs(this.store) do
+
+  -- Remove current connections first
+  -- Then remove remaining
+  for pwd, v in pairs(connections.current) do
     if v[2] == addr[2] and v[1] == addr[1] then
-      ix = i
-      break
+      ix = connections.current[pwd]
+      connections.store[ix] = nil
+      connections.current[pwd] = nil
     end
   end
-  table.remove(connections.store, ix)
 
-  for pwd, v in pairs(this.current) do
+  for i, v in ipairs(connections.store) do
     if v[2] == addr[2] and v[1] == addr[1] then
-      this.current[pwd] = nil
+      connections.store[i] = nil
     end
   end
 end
 
 --- Elects selected connection as primary (thus default) for a certain address
--- @tparam table this Connections object.
 -- @tparam string pwd path (usually project root).
 -- Assumed to be neovim's `pwd`.
 -- @tparam int ix index of the stored connection
-connections.select = function(this, pwd, ix)
-  if not utils.ends_with(pwd, "/") then
-    pwd = pwd .. "/"
-  end
+connections.select = function(pwd, ix)
+  pwd = pwd_to_key(pwd)
 
-  this.current[pwd] = ix
+  connections.current[pwd] = ix
 end
 
 --- Dissociates the connection for the given path
--- @tparam table this Connections object.
 -- @tparam string pwd path (usually project root).
-connections.unselect = function(this, pwd)
-  if not utils.ends_with(pwd, "/") then
-    pwd = pwd .. "/"
-  end
+connections.unselect = function(pwd)
+  pwd = pwd_to_key(pwd)
 
   -- TODO Potentially wrong
-  this.current[pwd] = nil
+  connections.current[pwd] = nil
 end
 
 --- Return active connection for the given path
--- @tparam table this Connections object.
 -- @tparam string pwd path (usually project root).
--- @treturn {string,string} Connection tuple with ip and port.
-connections.get = function(this, pwd)
-  if not utils.ends_with(pwd, "/") then
-    pwd = pwd .. "/"
-  end
+-- @treturn {string,string} Connection tuple with ip and port or nil.
+connections.get = function(pwd)
+  pwd = pwd_to_key(pwd)
 
-  local ix = tonumber(this.current[pwd])
+  local ix = connections.current[pwd]
 
   if ix == nil then
-    local port_file = pwd .. '.nrepl-port'
-    if nvim.nvim_call_function('filereadable', {port_file}) == 1 then
-      local port = nvim.nvim_call_function('readfile', {port_file})
-      ix = this:add({'127.0.0.1', port[1]})
-      this:select(pwd, ix)
+    return nil
+  end
+
+  return connections.store[ix]
+end
+
+connections.search = function(pwd)
+  pwd = pwd_to_key(pwd)
+  local fpath = vim.api.nvim_call_function("findfile", {pwd .. ".nrepl-port"})
+  if fpath ~= "" then
+    local portno = table.concat(vim.api.nvim_call_function("readfile", {fpath}), "")
+    local conn = {"127.0.0.1", utils.trim(portno)}
+    return connections.add(conn)
+  end
+  return nil
+end
+
+connections.attempt_get = function(pwd)
+  local conn = connections.get(pwd)
+  if conn == nil then
+    local ix = connections.search(pwd)
+    if ix ~= nil then
+      connections.select(pwd, ix)
+      conn = connections.store[ix]
     else
-      if #this.store >= 1 then
-        ix = #this.store
-      else
-        return
-      end
+      return nil
     end
   end
+  return conn
+end
 
-  return this.store[ix]
+--- Add and select the given connection for given path.
+-- @tparam string pwd path (usually project root).
+-- @tparam {string,string} addr tuple with ip and port or nil.
+connections.set = function(pwd, addr)
+  connections.select(pwd, connections.add(addr))
 end
 
 return connections

lua/acid/core.lua

@@ -8,7 +8,7 @@ local utils = require("acid.utils")
 local log = require("acid.log")
 
 local core = {
-  indirection = {}
+  indirection = setmetatable({}, utils.LRU(10))
 }
 
 --- Forward messages to the nrepl and registers the handler.
@@ -21,37 +21,30 @@ core.send = function(conn, obj, handler)
     return
   end
 
-  local session = math.random(10000, 99999)
   local pwd = vim.api.nvim_call_function("getcwd", {})
 
-  conn = conn or connections:get(pwd)
-  local new_conn
+  conn = conn or connections.attempt_get(pwd)
 
   if conn == nil then
-    local fpath = vim.api.nvim_call_function("findfile", {".nrepl-port"})
-    if fpath == "" then
-      log.msg("No active connection to a nrepl session. Aborting")
-      return
-    end
-    local portno = table.concat(vim.api.nvim_call_function("readfile", {fpath}), "")
-    conn = {"127.0.0.1", utils.trim(portno)}
-    new_conn = true
+    log.msg("No active connection to a nrepl session. Aborting")
   end
 
+  if obj.id == nil then
+    obj.id = utils.ulid()
+  end
+
+  core.register_callback(conn, handler, obj.id)
+
+  vim.api.nvim_call_function("AcidSendNrepl", {obj, conn})
+
+end
+
+core.register_callback = function(conn, handler, session)
   core.indirection[session] = {
     fn = handler,
     conn = conn
   }
-
-  vim.api.nvim_call_function("AcidSendNrepl", {obj,
-      "require('acid').callback(" .. session .. ", _A)",
-      conn,
-      "lua"
-    })
-
-  if new_conn then
-    connections:select(pwd, connections:add(new_conn))
-  end
+  return session
 end
 
 return core

lua/acid/extra/ulid.lua

@@ -0,0 +1,88 @@
+-- luacheck: globals vim
+---
+-- Module for creating Universally Unique Lexicographically Sortable Identifiers.
+--
+-- Modeled after the [ulid implementation by alizain](https://github.com/alizain/ulid). Please checkout the
+-- documentation there for the design and characteristics of ulid.
+--
+-- **IMPORTANT**: the standard Lua versions, based on the standard C library are
+-- unfortunately very weak regarding time functions and randomizers.
+-- So make sure to set it up properly!
+--
+--see https://github.com/Tieske/ulid.lua
+--copyright Copyright 2016-2017 Thijs Schreijer
+--license [mit](https://opensource.org/licenses/MIT)
+--author Thijs Schreijer
+
+
+-- Crockford's Base32 https://en.wikipedia.org/wiki/Base32
+local ENCODING = {
+  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+  "A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "M",
+  "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"
+}
+local ENCODING_LEN = #ENCODING
+local TIME_LEN = 10
+local RANDOM_LEN = 16
+
+local floor = math.floor
+local concat = table.concat
+local random = math.random
+local now
+
+if package.loaded["socket"] and package.loaded["socket"].gettime then
+  -- LuaSocket
+  now = package.loaded["socket"].gettime
+else
+  now = function() return vim.api.nvim_call_function("localtime", {}) end
+end
+
+math.randomseed(now())
+
+--- generates the time-based part of a `ulid`.
+-- @param[opt] time time to generate the string from, in seconds since
+-- unix epoch, with millisecond precision (defaults to now)
+-- @param[opt] len the length of the time-based string to return (defaults to 10)
+-- @return time-based part of `ulid` string
+local function encode_time(time, len)
+  time = floor((time or now()) * 1000)
+  len = len or TIME_LEN
+
+  local result = {}
+  for i = len, 1, -1 do
+    local mod = time % ENCODING_LEN
+    result[i] = ENCODING[mod + 1]
+    time = (time - mod) / ENCODING_LEN
+  end
+  return concat(result)
+end
+
+--- generates the random part of a `ulid`.
+-- @param[opt] len the length of the random string to return (defaults to 16)
+-- @return random part of `ulid` string
+local function encode_random(len)
+  len = len or RANDOM_LEN
+  local result = {}
+  for i = 1, len do
+    result[i] = ENCODING[floor(random() * ENCODING_LEN) + 1]
+  end
+  return concat(result)
+end
+
+local function ulid(time)
+  return encode_time(time) .. encode_random()
+end
+
+local _M = {
+    ulid = ulid,
+    encode_time = encode_time,
+    encode_random = encode_random,
+    set_time_func = set_time_func,
+    set_random_func = set_random_func,
+  }
+
+return setmetatable(_M, {
+    __call = function(_, ...)
+      return ulid(...)
+    end
+  })

lua/acid/forms.lua

@@ -31,7 +31,7 @@ forms.get_form_boundaries = function()
   return {
     from = from,
     to = to,
-    bufnr = vim.api.nvim_get_current_buf()
+    bufnr = curpos[1]
   }
 end