neovim/test/unit/api/helpers.lua

local helpers = require('test.unit.helpers')(nil)
local eval_helpers = require('test.unit.eval.helpers')

local cimport = helpers.cimport
local to_cstr = helpers.to_cstr
local ffi = helpers.ffi

local list_type = eval_helpers.list_type
local dict_type = eval_helpers.dict_type
local func_type = eval_helpers.func_type
local nil_value = eval_helpers.nil_value
local int_type = eval_helpers.int_type
local flt_type = eval_helpers.flt_type
local type_key = eval_helpers.type_key

local api = cimport('./src/nvim/api/private/defs.h',
                    './src/nvim/api/private/helpers.h',
                    './src/nvim/memory.h')

local obj2lua

local obj2lua_tab = nil

local function init_obj2lua_tab()
  if obj2lua_tab then
    return
  end
  obj2lua_tab = {
    [tonumber(api.kObjectTypeArray)] = function(obj)
      local ret = {[type_key]=list_type}
      for i = 1,tonumber(obj.data.array.size) do
        ret[i] = obj2lua(obj.data.array.items[i - 1])
      end
      if ret[1] then
        ret[type_key] = nil
      end
      return ret
    end,
    [tonumber(api.kObjectTypeDictionary)] = function(obj)
      local ret = {}
      for i = 1,tonumber(obj.data.dictionary.size) do
        local kv_pair = obj.data.dictionary.items[i - 1]
        ret[ffi.string(kv_pair.key.data, kv_pair.key.size)] = obj2lua(kv_pair.value)
      end
      return ret
    end,
    [tonumber(api.kObjectTypeBoolean)] = function(obj)
      if obj.data.boolean == false then
        return false
      else
        return true
      end
    end,
    [tonumber(api.kObjectTypeNil)] = function(_)
      return nil_value
    end,
    [tonumber(api.kObjectTypeFloat)] = function(obj)
      return tonumber(obj.data.floating)
    end,
    [tonumber(api.kObjectTypeInteger)] = function(obj)
      return {[type_key]=int_type, value=tonumber(obj.data.integer)}
    end,
    [tonumber(api.kObjectTypeString)] = function(obj)
      return ffi.string(obj.data.string.data, obj.data.string.size)
    end,
  }
end

obj2lua = function(obj)
  init_obj2lua_tab()
  return ((obj2lua_tab[tonumber(obj['type'])] or function(obj_inner)
    assert(false, 'Converting ' .. tostring(tonumber(obj_inner['type'])) .. ' is not implementing yet')
  end)(obj))
end

local obj = function(typ, data)
  return ffi.gc(ffi.new('Object', {['type']=typ, data=data}),
                api.api_free_object)
end

local lua2obj

local lua2obj_type_tab = {
  [int_type] = function(l)
    return obj(api.kObjectTypeInteger, {integer=l.value})
  end,
  [flt_type] = function(l)
    return obj(api.kObjectTypeFloat, {floating=l})
  end,
  [list_type] = function(l)
    local len = #l
    local arr = obj(api.kObjectTypeArray, {array={
      size=len,
      capacity=len,
      items=ffi.cast('Object *', api.xmalloc(len * ffi.sizeof('Object'))),
    }})
    for i = 1, len do
      arr.data.array.items[i - 1] = ffi.gc(lua2obj(l[i]), nil)
    end
    return arr
  end,
  [dict_type] = function(l)
    local kvs = {}
    for k, v in pairs(l) do
      if type(k) == 'string' then
        kvs[#kvs + 1] = {k, v}
      end
    end
    local len = #kvs
    local dct = obj(api.kObjectTypeDictionary, {dictionary={
      size=len,
      capacity=len,
      items=ffi.cast('KeyValuePair *',
                     api.xmalloc(len * ffi.sizeof('KeyValuePair'))),
    }})
    for i = 1, len do
      local key, val = unpack(kvs[i])
      dct.data.dictionary.items[i - 1] = ffi.new(
          'KeyValuePair', {key=ffi.gc(lua2obj(key), nil).data.string,
                           value=ffi.gc(lua2obj(val), nil)})
    end
    return dct
  end,
}

lua2obj = function(l)
  if type(l) == 'table' then
    if l[type_key] then
      return lua2obj_type_tab[l[type_key]](l)
    else
      if l[1] then
        return lua2obj_type_tab[list_type](l)
      else
        return lua2obj_type_tab[dict_type](l)
      end
    end
  elseif type(l) == 'number' then
    return lua2obj_type_tab[flt_type](l)
  elseif type(l) == 'boolean' then
    return obj(api.kObjectTypeBoolean, {boolean=l})
  elseif type(l) == 'string' then
    return obj(api.kObjectTypeString, {string={
      size=#l,
      data=api.xmemdupz(to_cstr(l), #l),
    }})
  elseif l == nil or l == nil_value then
    return obj(api.kObjectTypeNil, {integer=0})
  end
end

return {
  list_type=list_type,
  dict_type=dict_type,
  func_type=func_type,
  int_type=int_type,
  flt_type=flt_type,

  nil_value=nil_value,

  type_key=type_key,

  obj2lua=obj2lua,
  lua2obj=lua2obj,
}