No OneTemporary
Actions

Size

16 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lua/ivy/libivy.lua b/lua/ivy/libivy.lua
	index f9f8857..36946dc 100644
	--- a/lua/ivy/libivy.lua
	+++ b/lua/ivy/libivy.lua
	@@ -1,43 +1,71 @@
	local library_path = (function()
	local root = string.sub(debug.getinfo(1).source, 2, #"/libivy.lua" * -1)
	local release_path = root .. "../../target/release"
	return package.searchpath("libivyrs", release_path .. "/?.so;" .. release_path .. "/?.dylib;")
	end)()

	local ffi = require "ffi"
	local ok, ivy_c = pcall(ffi.load, library_path)
	if not ok then
	vim.api.nvim_err_writeln(
	"libivyrs.so not found! Please ensure you have complied the shared library."
	.. " For more info refer to the documentation, https://github.com/AdeAttwood/ivy.nvim#compiling"
	)

	return
	end

	ffi.cdef [[
	void ivy_init(const char*);
	char* ivy_cwd();
	int ivy_match(const char, const char);
	char* ivy_files(const char, const char);
	+
	+ int ivy_files_iter(const char, const char);
	+ int ivy_files_iter_len(int);
	+ char* ivy_files_iter_at(int, int);
	+ void ivy_files_iter_delete(int);
	]]

	+local iter_mt = {
	+ __len = function(self)
	+ return self.length
	+ end,
	+ __index = function(self, index)
	+ -- Pass in our index -1. This will map lua's one based indexing to zero
	+ -- based indexing that we are using in the rust lib.
	+ local item = ffi.string(ivy_c.ivy_files_iter_at(self.id, index - 1))
	+ return { content = item }
	+ end,
	+ __newindex = function(_, _, _)
	+ error("attempt to update a read-only table", 2)
	+ end,
	+ __gc = function(self)
	+ ivy_c.ivy_files_iter_delete(self.id)
	+ end,
	+}
	+
	local libivy = {}

	libivy.ivy_init = function(dir)
	ivy_c.ivy_init(dir)
	end

	libivy.ivy_cwd = function()
	return ffi.string(ivy_c.ivy_cwd())
	end

	libivy.ivy_match = function(pattern, text)
	return ivy_c.ivy_match(pattern, text)
	end

	libivy.ivy_files = function(pattern, base_dir)
	- return ffi.string(ivy_c.ivy_files(pattern, base_dir))
	+ local iter_id = ivy_c.ivy_files_iter(pattern, base_dir)
	+ local iter_len = ivy_c.ivy_files_iter_len(iter_id)
	+ local iter = { id = iter_id, length = iter_len }
	+ setmetatable(iter, iter_mt)
	+
	+ return iter
	end

	return libivy
	diff --git a/lua/ivy/libivy_test.lua b/lua/ivy/libivy_test.lua
	index c7fe89b..fe18455 100644
	--- a/lua/ivy/libivy_test.lua
	+++ b/lua/ivy/libivy_test.lua
	@@ -1,27 +1,46 @@
	local libivy = require "ivy.libivy"

	it("should run a simple match", function(t)
	local score = libivy.ivy_match("term", "I am a serch term")

	if score <= 0 then
	t.error("Score should not be less than 0 found " .. score)
	end
	end)

	it("should find a dot file", function(t)
	local current_dir = libivy.ivy_cwd()
	- local matches = libivy.ivy_files(".github/workflows/ci.yml", current_dir)
	+ local results = libivy.ivy_files(".github/workflows/ci.yml", current_dir)

	- local results = {}
	- for line in string.gmatch(matches, "[^\r\n]+") do
	- table.insert(results, line)
	+ if results.length ~= 2 then
	+ t.error("Incorrect number of results found " .. results.length)
	end

	- if #results ~= 2 then
	- t.error "Incorrect number of results"
	+ if results[2].content ~= ".github/workflows/ci.yml" then
	+ t.error("Invalid matches: " .. results[2].content)
	+ end
	+end)
	+
	+it("will allow you to access the length via the metatable", function(t)
	+ local current_dir = libivy.ivy_cwd()
	+ local results = libivy.ivy_files(".github/workflows/ci.yml", current_dir)
	+
	+ local mt = getmetatable(results)
	+
	+ if results.length ~= mt.__len(results) then
	+ t.error "The `length` property does not match the __len metamethod"
	+ end
	+end)
	+
	+it("will create an iterator", function(t)
	+ local iter = libivy.ivy_files(".github/workflows/ci.yml", libivy.ivy_cwd())
	+ local mt = getmetatable(iter)
	+
	+ if type(mt["__index"]) ~= "function" then
	+ t.error "The iterator does not have an __index metamethod"
	end

	- if results[2] ~= ".github/workflows/ci.yml" then
	- t.error("Invalid matches: " .. results[2])
	+ if type(mt["__len"]) ~= "function" then
	+ t.error "The iterator does not have an __len metamethod"
	end
	end)
	diff --git a/lua/ivy/window.lua b/lua/ivy/window.lua
	index c53d6e1..087e94b 100644
	--- a/lua/ivy/window.lua
	+++ b/lua/ivy/window.lua
	@@ -1,147 +1,167 @@
	-- Constent options that will be used for the keymaps
	local opts = { noremap = true, silent = true, nowait = true }

	-- All of the base chars that will be used for an "input" operation on the
	-- prompt
	-- stylua: ignore
	local chars = {
	"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W",
	"X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
	"u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "<", ">", "`", "@", "#", "~", "!",
	"\"", "$", "%", "^", "&", "/", "(", ")", "=", "+", "*", "-", "_", ".", ",", ";", ":", "?", "\\", "\|", "'", "{", "}",
	"[", "]", " ",
	}

	local function string_to_table(lines)
	local matches = {}
	for line in lines:gmatch "[^\r\n]+" do
	table.insert(matches, { content = line })
	end

	return matches
	end

	+local function get_items_length(items)
	+ local mt = getmetatable(items)
	+ if mt ~= nil and mt.__len ~= nil then
	+ return mt.__len(items)
	+ end
	+
	+ return #items
	+end
	+
	+local function call_gc(items)
	+ local mt = getmetatable(items)
	+ if mt ~= nil and mt.__gc ~= nil then
	+ return mt.__gc(items)
	+ end
	+end
	+
	local window = {}

	window.index = 0
	window.origin = nil
	window.window = nil
	window.buffer = nil
	window.origin_buffer = nil

	window.initialize = function()
	window.make_buffer()
	end

	window.make_buffer = function()
	window.origin = vim.api.nvim_get_current_win()
	window.origin_buffer = vim.api.nvim_win_get_buf(0)

	vim.api.nvim_command "botright split new"
	window.buffer = vim.api.nvim_win_get_buf(0)
	window.window = vim.api.nvim_get_current_win()

	vim.api.nvim_win_set_option(window.window, "number", false)
	vim.api.nvim_win_set_option(window.window, "relativenumber", false)
	vim.api.nvim_win_set_option(window.window, "signcolumn", "no")

	vim.api.nvim_buf_set_option(window.buffer, "filetype", "ivy")
	vim.api.nvim_buf_set_var(window.buffer, "bufftype", "nofile")

	for index = 1, #chars do
	local char = chars[index]
	if char == "'" then
	char = "\\'"
	end
	if char == "\\" then
	char = "\\\\\\\\"
	end
	vim.api.nvim_buf_set_keymap(window.buffer, "n", chars[index], "<cmd>lua vim.ivy.input('" .. char .. "')<CR>", opts)
	end

	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-c>", "<cmd>lua vim.ivy.destroy()<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-u>", "<cmd>lua vim.ivy.search('')<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-n>", "<cmd>lua vim.ivy.next()<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-p>", "<cmd>lua vim.ivy.previous()<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-M-n>", "<cmd>lua vim.ivy.next(); vim.ivy.checkpoint()<CR>", opts)
	vim.api.nvim_buf_set_keymap(
	window.buffer,
	"n",
	"<C-M-p>",
	"<cmd>lua vim.ivy.previous(); vim.ivy.checkpoint()<CR>",
	opts
	)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<CR>", "<cmd>lua vim.ivy.complete(vim.ivy.action.EDIT)<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-v>", "<cmd>lua vim.ivy.complete(vim.ivy.action.VSPLIT)<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-s>", "<cmd>lua vim.ivy.complete(vim.ivy.action.SPLIT)<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<BS>", "<cmd>lua vim.ivy.input('BACKSPACE')<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<Left>", "<cmd>lua vim.ivy.input('LEFT')<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<Right>", "<cmd>lua vim.ivy.input('RIGHT')<CR>", opts)
	vim.api.nvim_buf_set_keymap(window.buffer, "n", "<C-w>", "<cmd>lua vim.ivy.input('DELETE_WORD')<CR>", opts)
	end

	window.get_current_selection = function()
	local line = vim.api.nvim_buf_get_lines(window.buffer, window.index, window.index + 1, true)
	if line == nil then
	line = { "" }
	end

	return line[1]
	end

	window.get_buffer = function()
	if window.buffer == nil then
	window.make_buffer()
	end

	return window.buffer
	end

	window.update = function()
	vim.api.nvim_win_set_cursor(window.window, { window.index + 1, 0 })
	end

	window.set_items = function(items)
	if type(items) == "string" then
	items = string_to_table(items)
	end

	+ local items_length = get_items_length(items)
	+
	-- TODO(ade): Validate the items are in the correct format. This also need to
	-- come with some descriptive messages and possible help.

	-- Display no items text if there are no items to dispaly
	- if #items == 0 then
	+ if items_length == 0 then
	+ items_length = 1
	items = { { content = "-- No Items --" } }
	end

	- local items_length = #items
	window.index = items_length - 1

	for index = 1, items_length do
	vim.api.nvim_buf_set_lines(window.buffer, index - 1, -1, false, { items[index].content })
	end

	-- Limit the results window size to 10 so when there are lots of results the
	-- window does not take up the hole terminal
	local line_count = items_length
	if line_count > 10 then
	line_count = 10
	end

	vim.api.nvim_win_set_height(window.window, line_count)
	window.update()
	+
	+ call_gc(items)
	end

	window.destroy = function()
	if type(window.buffer) == "number" then
	vim.api.nvim_buf_delete(window.buffer, { force = true })
	end

	window.buffer = nil
	window.window = nil
	window.origin = nil
	window.origin_buffer = nil
	window.index = 0
	end

	return window
	diff --git a/lua/ivy/window_test.lua b/lua/ivy/window_test.lua
	index c42b380..dcad637 100644
	--- a/lua/ivy/window_test.lua
	+++ b/lua/ivy/window_test.lua
	@@ -1,23 +1,33 @@
	local vim_mock = require "ivy.vim_mock"
	local window = require "ivy.window"

	before_each(function()
	vim_mock.reset()
	end)

	it("can initialize and destroy the window", function(t)
	window.initialize()

	t.assert_equal(10, window.get_buffer())
	t.assert_equal(10, window.buffer)

	window.destroy()
	t.assert_equal(nil, window.buffer)
	end)

	it("can set items", function(t)
	window.initialize()

	window.set_items { { content = "Line one" } }
	t.assert_equal("Line one", window.get_current_selection())
	end)
	+
	+it("will set the items when a string is passed in", function(t)
	+ window.initialize()
	+
	+ local items = table.concat({ "One", "Two", "Three" }, "\n")
	+ window.set_items(items)
	+
	+ local lines = table.concat(vim_mock.get_lines()[window.buffer], "\n")
	+ t.assert_equal(items, lines)
	+end)
	diff --git a/rust/lib.rs b/rust/lib.rs
	index 6d9ba73..a4ac000 100644
	--- a/rust/lib.rs
	+++ b/rust/lib.rs
	@@ -1,107 +1,179 @@
	mod finder;
	mod matcher;
	mod sorter;

	use std::collections::HashMap;
	use std::ffi::CStr;
	use std::ffi::CString;
	use std::os::raw::{c_char, c_int};
	use std::sync::Mutex;
	use std::sync::OnceLock;

	+// A store to the singleton instance of the ivy struct. This must not be accessed directly it must
	+// be use via the Ivy::global() function. Accessing this directly may cause a panic if its been
	+// initialized correctly.
	+static INSTANCE: OnceLock<Mutex<Ivy>> = OnceLock::new();
	+
	struct Ivy {
	+ // The file cache so we don't have to keep iterating the filesystem. The map key is the root
	+ // directory that has been search and the value an a vector containing all of the files that as
	+ // in the root. The value will be relative from the root.
	pub file_cache: HashMap<String, Vec<String>>,
	+ // The sequence number of the last iterator created. This will use as a pointer value to the
	+ // iterator so we can access it though lua and rust without having to copy strings.
	+ pub iter_sequence: i32,
	+ // A store of all the iterators that have been created. The key is the sequence number and the
	+ // value is the vector of matches that were matched in the search.
	+ pub iter_map: HashMap<i32, Vec<CString>>,
	}

	-static INSTANCE: OnceLock<Mutex<Ivy>> = OnceLock::new();
	-
	impl Ivy {
	- pub fn new() -> Self {
	- Self {
	- file_cache: HashMap::new(),
	- }
	- }
	-
	+ // Get the global instance of the ivy struct. This will initialize the struct if it has not
	+ // initialized yet.
	pub fn global() -> &'static Mutex<Ivy> {
	- INSTANCE.get_or_init(\|\| Mutex::new(Ivy::new()))
	+ INSTANCE.get_or_init(\|\| {
	+ Mutex::new(Ivy {
	+ file_cache: HashMap::new(),
	+ iter_sequence: 0,
	+ iter_map: HashMap::new(),
	+ })
	+ })
	}
	}

	fn to_string(input: *const c_char) -> String {
	unsafe { CStr::from_ptr(input) }
	.to_str()
	.unwrap()
	.to_string()
	}

	fn get_files(directory: &String) -> Vec<String> {
	let mut ivy = Ivy::global().lock().unwrap();
	if !ivy.file_cache.contains_key(directory) {
	let finder_options = finder::Options {
	directory: directory.clone(),
	};

	ivy.file_cache
	.insert(directory.clone(), finder::find_files(finder_options));
	}

	return ivy.file_cache.get(directory).unwrap().to_vec();
	}

	#[no_mangle]
	pub extern "C" fn ivy_init(c_base_dir: *const c_char) {
	let directory = to_string(c_base_dir);
	get_files(&directory);
	}

	#[no_mangle]
	pub extern "C" fn ivy_cwd() -> *const c_char {
	return CString::new(std::env::current_dir().unwrap().to_str().unwrap())
	.unwrap()
	.into_raw();
	}

	#[no_mangle]
	pub extern "C" fn ivy_match(c_pattern: const c_char, c_text: const c_char) -> c_int {
	let pattern = to_string(c_pattern);
	let text = to_string(c_text);

	inner_match(pattern, text)
	}

	pub fn inner_match(pattern: String, text: String) -> i32 {
	let m = matcher::Matcher::new(pattern);

	m.score(text.as_str()) as i32
	}

	+// Create a new iterator that will iterate over all the files in the given directory that match a
	+// pattern. It will return the pointer to the iterator so it can be retrieve later. The iterator
	+// can be deleted with `ivy_files_iter_delete`
	+#[no_mangle]
	+pub extern "C" fn ivy_files_iter(c_pattern: const c_char, c_base_dir: const c_char) -> i32 {
	+ let directory = to_string(c_base_dir);
	+ let pattern = to_string(c_pattern);
	+
	+ let files = get_files(&directory);
	+
	+ let mut ivy = Ivy::global().lock().unwrap();
	+
	+ // Convert the matches into CStrings so we can pass the pointers out while still maintaining
	+ // ownership. If we didn't do this the CString would be dropped and the pointer would be freed
	+ // while its being used externally.
	+ let sorter_options = sorter::Options::new(pattern);
	+ let matches = sorter::sort_strings(sorter_options, files)
	+ .into_iter()
	+ .map(\|m\| CString::new(m.content.as_str()).unwrap())
	+ .collect::<Vec<CString>>();
	+
	+ ivy.iter_sequence += 1;
	+ let new_sequence = ivy.iter_sequence;
	+ ivy.iter_map.insert(new_sequence, matches);
	+
	+ new_sequence
	+}
	+
	+// Delete the iterator with the given id. This will free the memory used by the iterator that was
	+// created with `ivy_files_iter`
	+#[no_mangle]
	+pub extern "C" fn ivy_files_iter_delete(iter_id: i32) {
	+ let mut ivy = Ivy::global().lock().unwrap();
	+ ivy.iter_map.remove(&iter_id);
	+}
	+
	+// Returns the length of a given iterator. This will return the number of items that were matched
	+// when the iterator was created with `ivy_files_iter`
	+#[no_mangle]
	+pub extern "C" fn ivy_files_iter_len(iter_id: i32) -> i32 {
	+ let ivy = Ivy::global().lock().unwrap();
	+
	+ let items = ivy.iter_map.get(&iter_id).unwrap();
	+ items.len() as i32
	+}
	+
	+// Returns the item at the given index in the iterator. This will return the full match that was
	+// given in the iterator. This will return a pointer to the string so it can be used in lua.
	+#[no_mangle]
	+pub extern "C" fn ivy_files_iter_at(iter_id: i32, index: i32) -> *const c_char {
	+ let ivy = Ivy::global().lock().unwrap();
	+
	+ let items = ivy.iter_map.get(&iter_id).unwrap();
	+ let item = items.get(index as usize).unwrap();
	+
	+ item.as_ptr()
	+}
	+
	#[no_mangle]
	pub extern "C" fn ivy_files(c_pattern: const c_char, c_base_dir: const c_char) -> *const c_char {
	let pattern = to_string(c_pattern);
	let directory = to_string(c_base_dir);

	let output = inner_files(pattern, directory);

	CString::new(output).unwrap().into_raw()
	}

	pub fn inner_files(pattern: String, base_dir: String) -> String {
	let mut output = String::new();

	// Bail out early if the pattern is empty; it's never going to find anything
	if pattern.is_empty() {
	return output;
	}

	let files = get_files(&base_dir);

	let sorter_options = sorter::Options::new(pattern);

	let files = sorter::sort_strings(sorter_options, files);
	for file in files.iter() {
	output.push_str(&file.content);
	output.push('\n');
	}

	output
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Sep 10, 5:22 PM (7 h, 25 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 9039
Default Alt Text: (16 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions