chore: make public api consistent

Summary:

Right now we have two ways to access the public api we have `require('ivy')`
and `vim.ivy. Each way has a different api that will cause some confusion.

Now both apis are the same so anyone that wants to integrate with ivy can do so
without having to figure out what one they need to use.

Test Plan:

The unit tests cover most of the work, I have also been using this locally for
quite some time now with now issues.

README.md

@@ -21,6 +21,7 @@ git clone https://github.com/AdeAttwood/ivy.nvim ~/.config/nvim/pack/bundle/star
 ### Plugin managers
 
 Using [lazy.nvim](https://github.com/folke/lazy.nvim)
+
 ```lua
 {
     "AdeAttwood/ivy.nvim",
@@ -28,6 +29,31 @@ Using [lazy.nvim](https://github.com/folke/lazy.nvim)
 },
 ```
 
+Using [mini.deps](https://github.com/echasnovski/mini.deps)
+
+```lua
+local deps = require "mini.deps"
+deps.later(function() -- Or `deps.now` if you want this to be loaded immediately
+  local build = function(args)
+    local obj = vim
+      .system(
+        { "cargo", "build", "--release", string.format("%s%s%s", "--manifest-path=", args.path, "/Cargo.toml") },
+        { text = true }
+      )
+      :wait()
+    vim.print(vim.inspect(obj))
+  end
+
+  deps.add {
+    source = "AdeAttwood/ivy.nvim",
+    hooks = {
+      post_install = build,
+      post_checkout = build,
+    },
+  }
+end)
+```
+
 TODO: Add more plugin managers
 
 ### Setup / Configuration
@@ -36,19 +62,19 @@ Ivy can be configured with minimal config that will give you all the defaults
 provided by Ivy.
 
 ```lua
-require('ivy').setup()
+require("ivy").setup()
 ```
 
 With Ivy you can configure your own backends.
 
 ```lua
-require('ivy').setup {
+require("ivy").setup {
   backends = {
     -- A backend module that will be registered
     "ivy.backends.buffers",
     -- Using a table so you can configure a custom keymap overriding the
     -- default one.
-    { "ivy.backends.files", { keymap = "<C-p>" } }
+    { "ivy.backends.files", { keymap = "<C-p>" } },
   },
 }
 ```
@@ -59,7 +85,7 @@ function, this can be used to load backends before or after the setup function
 is called.
 
 ```lua
-require('ivy').register_backend("ivy.backends.files")
+require("ivy").register_backend "ivy.backends.files"
 ```
 
 ### Compiling
@@ -116,27 +142,31 @@ customized when you register it.
 
 Action can be run on selected candidates provide functionality
 
-| Action         | Key Map     | Description                                                                    |
-| -------------- | ----------- | ------------------------------------------------------------------------------ |
-| Complete       | \<CR\>      |Run the completion function, usually this will be opening a file               |
-| Vertical Split | \<C-v\>     |Run the completion function in a new vertical split                            |
-| Split          | \<C-s\>     |Run the completion function in a new split                                     |
-| Destroy        | \<C-c\>     |Close the results window                                                       |
-| Clear          | \<C-u\>     |Clear the results window                                                       |
-| Delete word    | \<C-w\>     |Delete the word under the cursor                                               |
-| Next           | \<C-n\>     |Move to the next candidate                                                     |
-| Previous       | \<C-p\>     |Move to the previous candidate                                                 |
-| Next Checkpoint| \<C-M-n\>   |Move to the next candidate and keep Ivy open and focussed                      |
-| Previous Checkpoint| \<C-M-n\>|Move to the previous candidate and keep Ivy open and focussed                 |
+| Action              | Key Map   | Description                                                      |
+| ------------------- | --------- | ---------------------------------------------------------------- |
+| Complete            | \<CR\>    | Run the completion function, usually this will be opening a file |
+| Vertical Split      | \<C-v\>   | Run the completion function in a new vertical split              |
+| Split               | \<C-s\>   | Run the completion function in a new split                       |
+| Destroy             | \<C-c\>   | Close the results window                                         |
+| Clear               | \<C-u\>   | Clear the results window                                         |
+| Delete word         | \<C-w\>   | Delete the word under the cursor                                 |
+| Next                | \<C-n\>   | Move to the next candidate                                       |
+| Previous            | \<C-p\>   | Move to the previous candidate                                   |
+| Next Checkpoint     | \<C-M-n\> | Move to the next candidate and keep Ivy open and focussed        |
+| Previous Checkpoint | \<C-M-n\> | Move to the previous candidate and keep Ivy open and focussed    |
 
 Add your own keymaps for an action by adding a `ftplugin/ivy.lua` file in your config.
 Just add a simple keymap like this:
 
 ```lua
-vim.api.nvim_set_keymap( "n", "<esc>", "<cmd>lua vim.ivy.destroy()<CR>", { noremap = true, silent = true, nowait = true })
+vim.api.nvim_set_keymap(
+  "n",
+  "<esc>",
+  "<cmd>lua vim.ivy.destroy()<CR>",
+  { noremap = true, silent = true, nowait = true }
+)
 ```
 
-
 ## API
 
 ### ivy.run
@@ -190,7 +220,9 @@ vertical split action it will open the buffer in a new `vsplit`
     end,
     -- Action callback that will be called on the completion or checkpoint actions.
     -- The currently selected item is passed in as the result.
-    function(result) vim.cmd("edit " .. result) end
+    function(result)
+      vim.cmd("edit " .. result)
+    end
   )
 ```
 

lua/ivy/controller.lua

@@ -1,9 +1,7 @@
 local window = require "ivy.window"
 local prompt = require "ivy.prompt"
-local utils = require "ivy.utils"
 
 local controller = {}
-controller.action = utils.actions
 
 controller.items = nil
 controller.callback = nil

lua/ivy/init.lua

@@ -1,11 +1,28 @@
 local controller = require "ivy.controller"
+local libivy = require "ivy.libivy"
 local config = require "ivy.config"
+local utils = require "ivy.utils"
 local register_backend = require "ivy.register_backend"
 
 local ivy = {}
+
+ivy.action = utils.actions
+ivy.utils = utils
+
+ivy.match = libivy.ivy_match
+
 ivy.run = controller.run
 ivy.register_backend = register_backend
 
+ivy.checkpoint = controller.checkpoint
+ivy.paste = controller.paste
+ivy.complete = controller.complete
+ivy.destroy = controller.destroy
+ivy.input = controller.input
+ivy.next = controller.next
+ivy.previous = controller.previous
+ivy.search = controller.search
+
 -- Private variable to check if ivy has been setup, this is to prevent multiple
 -- setups of ivy. This is only exposed for testing purposes.
 ---@private

plugin/ivy.lua

@@ -1,9 +1,9 @@
-local controller = require "ivy.controller"
+local api = require "ivy"
 
 -- Put the controller in to the vim global so we can access it in mappings
 -- better without requires. You can call controller commands like `vim.ivy.xxx`.
 -- luacheck: ignore
-vim.ivy = controller
+vim.ivy = api
 
 vim.paste = (function(overridden)
   return function(lines, phase)