nvim-oxi for blink.cmp providers?

[davehorner]

Im working on neovide/neovide#3108

I would really like to demonstrate a nvim-oxi provider and having some trouble with GPT mixing oxi and macros and Table vs Dictionary, to be honest I'm confused and theres not a lot of code.

use nvim_oxi as oxi;
use oxi::api;
// use oxi::types::Object;
use oxi::Result;
use oxi::Dictionary;
use oxi::Function;
use mlua::prelude::*;
// use crate::oxi::mlua::Value::Table;
// use nvim_oxi::mlua::Table;
// use nvim_oxi::api::types::CommandArgs;
use crate::oxi::Object;
// use crate::oxi::mlua::Table;
use nvim_oxi::api::{self, opts::*, types::*, Window};
use nvim_oxi::{print, Dictionary, Function};
use mlua::prelude::LuaFunction;
use nvim_oxi::{mlua, print, Result};
 use crate::mlua::Table;
static ANIMALS: &[&str] = &[
    "ant","bear","cat","dog","elephant","frog","giraffe","hippo",
    "iguana","jaguar","kangaroo","lemur","monkey","newt","octopus",
    "penguin","quail","rabbit","snake","tiger","urchin","vulture",
    "wolf","xenops","yak","zebra",
];

static COLORS: &[&str] = &[
    "red","orange","yellow","green","blue","indigo","violet",
    "pink","black","white","gray","brown","cyan","magenta",
    "lime","teal","lavender",
];

/// This function runs at startup and registers a user command and keymaps.
/// We don't need it for blink.cmp, but shows you how to expose commands if desired.
#[nvim_oxi::plugin]
fn api() -> Result<Dictionary> {
    // register a :SetNative <animals|colors> command
    let opts = api::opts::CreateCommandOpts::builder()
        .nargs(CommandNArgs::ZeroOrOne)
        .desc("Set native blink_cmp_oxi provider to animals or colors")
        .build();
    let set_native = |args: CommandArgs| {
        let p = args.args.unwrap_or_default();
        crate::set_provider(p);
        // Ok(())
        Ok::<(), E>(())
    };
    api::create_user_command("SetNative", set_native, &opts)?;

    // return an empty table
    Ok(Dictionary::new())
}

/// Global state: which list the native source should use
static mut CURRENT: &str = "animals";

/// Called from Lua via require('neovide_blink_cmp_oxi').set_provider("colors")
#[nvim_oxi::module]
fn neovide_blink_cmp_oxi() -> Result<Dictionary> {
    let m = Dictionary::from_iter([
    ("new", Object::from(new_source.into())),
    ("set_provider",  Function::from_fn(set_provider).into()),
]);
    Ok(m)
}

/// Change the global provider
fn set_provider(provider: String) {
    unsafe {
        CURRENT = Box::leak(provider.into_boxed_str());
    }
}

/// Our blink.cmp Source type
pub struct Source;

impl Source {
    /// blink.cmp will call this to create your source
#[nvim_oxi::plugin]
    fn new(_opts: Table) -> Result<Source> {
        Ok(Source)
    }

    /// which characters trigger this source
    #[nvim_oxi::method]
    fn get_trigger_characters(&self) -> Vec<String> {
        vec!{}
    }

    /// blink.cmp will call this to fetch completions
    #[nvim_oxi::method]
    fn get_completions(&self, _ctx: Table) -> Result<Dictionary> {
        // choose items based on CURRENT
        let items = unsafe {
            if CURRENT == "colors" {
                COLORS
            } else {
                ANIMALS
            }
        };

        // build the blink.cmp CompletionItemKind.Text constant
        let kind_text = oxi::mlua! {
            return require("blink.cmp.types").CompletionItemKind.Text
        }?;

            let mut result = Dictionary::new();
        let mut list = Vec::new();

        for &w in items {
            let mut itm = Dictionary::new();
            itm.insert("label", w.into());
itm.insert("kind", kind_text.clone());
itm.insert("insertText", w.into());
            list.push(Object::from(itm));
        }

        result.insert("items", list.into());
        result.insert("is_incomplete_backward", false.into());
result.insert("is_incomplete_forward", false.into());
        Ok(result)
    }
}

any suggestions on better ways to be doing this?