filemanager2.lua

VERSION = '1.5.2'

local micro = import('micro')
local config = import('micro/config')
local shell = import('micro/shell')
local buffer = import('micro/buffer')
local os = import('os')
local filepath = import('path/filepath')
local regexp = import('regexp')

local icon = dofile(config.ConfigDir .. '/plug/filemanager2/icon.lua')

function Icons()
    return icon.Icons()
end

function GetIcon(filename)
    return icon.GetIcon(filename)
end

function FileIcon(buf)
    return icon.GetIcon(buf.Path)
end

-- Clear out all stuff in Micro's messenger
local function clear_messenger()
    -- messenger:Reset()
    -- messenger:Clear()
end

-- Holds the micro.CurPane() we're manipulating
local tree_view = nil
-- The last bufpane we were using before we open the tree
local last_buf_pane = nil
-- Keeps track of the current working directory
local current_dir = os.Getwd()
-- Keep track of current highest visible indent to resize width appropriately

-- Holds a table of paths -- objects from new_listobj() calls
local scanlist = {}

local tree_width = 30
local line_length_factor = 0.3
local on_set_active_guard = false


-- Get a new object used when adding to scanlist
local function new_listobj(p, d, o, i)
    return {
        ['abspath'] = p,
        ['dirmsg'] = d,
        ['owner'] = o,
        ['indent'] = i,
        -- Since decreasing/increasing is common, we include these with the object
        ['decrease_owner'] = function(self, minus_num)
            self.owner = self.owner - minus_num
        end,
        ['increase_owner'] = function(self, plus_num)
            self.owner = self.owner + plus_num
        end,
    }
end

-- Repeats a string x times, then returns it concatenated into one string
local function repeat_str(str, len)
    -- Do NOT try to concat in a loop, it freezes micro...
    -- instead, use a temporary table to hold values
    local string_table = {}
    for i = 1, len do
        string_table[i] = str
    end
    -- Return the single string of repeated characters
    return table.concat(string_table)
end

-- A check for if a path is a dir
local function is_dir(path)
    -- Used for checking if dir
    local golib_os = import('os')
    -- Returns a FileInfo on the current file/path
    local file_info, stat_error = golib_os.Stat(path)
    -- Wrap in nil check for file/dirs without read permissions
    if file_info ~= nil then
        -- Returns true/false if it's a dir
        return file_info:IsDir()
    else
        -- Couldn't stat the file/dir, usually because no read permissions
        micro.InfoBar():Error('Error checking if is dir: ', stat_error)
        -- Nil since we can't read the path
        return nil
    end
end

-- Turn to relative path if possible
local function try_convert_rel(path)
    local wd, err = os.Getwd()
    if err == nil then
        local relPath, relErr = filepath.Rel(wd, path)
        return relPath
    end
    
    return path
end

-- Returns a list of files (in the target dir) that are ignored by the VCS system (if exists)
-- aka this returns a list of gitignored files (but for whatever VCS is found)
local function get_ignored_files(tar_dir)
    local icons = Icons()

    -- True/false if the target dir returns a non-fatal error when checked with 'git status'
    local function has_git()
        local git_rp_results = shell.ExecCommand('git  -C "' .. tar_dir .. '" rev-parse --is-inside-work-tree')
        return git_rp_results:match('^true%s*$')
    end
    local readout_results = {}
    -- TODO: Support more than just Git, such as Mercurial or SVN
    if has_git() then
        -- If the dir is a git dir, get all ignored in the dir
        local git_ls_results =
            shell.ExecCommand('git -C "' .. tar_dir .. '" ls-files . --ignored --exclude-standard --others --directory')
        -- Cut off the newline that is at the end of each result
        for split_results in string.gmatch(git_ls_results, '([^\r\n]' .. icons['dir'] .. ')') do
            -- git ls-files adds a trailing slash if it's a dir, so we remove it (if it is one)
            readout_results[#readout_results + 1] = (
                string.sub(split_results, -1) == '/' and string.sub(split_results, 1, -2) or split_results
            )
        end
    end

    -- Make sure we return a table
    return readout_results
end

-- Returns the basename of a path (aka a name without leading path)
local function get_basename(path)
    if path == nil then
        micro.Log('Bad path passed to get_basename')
        return nil
    else
        -- Get Go's path lib for a basename callback
        local golib_path = import('filepath')
        return golib_path.Base(path)
    end
end

-- Returns true/false if the file is a dotfile
local function is_dotfile(file_name)
    -- Check if the filename starts with a dot
    if string.sub(file_name, 1, 1) == '.' then
        return true
    else
        return false
    end
end

-- Structures the output of the scanned directory content to be used in the scanlist table
-- This is useful for both initial creation of the tree, and when nesting with uncompress_target()
local function get_scanlist(dir, ownership, indent_n)
    local icons = Icons()

    local golib_ioutil = import('ioutil')
    -- Gets a list of all the files in the current dir
    local dir_scan, scan_error = golib_ioutil.ReadDir(dir)

    -- dir_scan will be nil if the directory is read-protected (no permissions)
    if dir_scan == nil then
        micro.InfoBar():Error('Error scanning dir: ', scan_error)
        return nil
    end

    -- The list of files to be returned (and eventually put in the view)
    local results = {}
    local files = {}

    local function get_results_object(file_name)
        local abs_path = filepath.Join(dir, file_name)
        local dirmsg = (is_dir(abs_path) and icons['dir'] or GetIcon(file_name))

        return new_listobj(abs_path, dirmsg, ownership, indent_n)
    end

    -- Save so we don't have to rerun GetOption a bunch
    local show_dotfiles = config.GetGlobalOption('filemanager2.showdotfiles')
    local show_ignored = config.GetGlobalOption('filemanager2.showignored')
    local folders_first = config.GetGlobalOption('filemanager2.foldersfirst')

    -- The list of VCS-ignored files (if any)
    -- Only bother getting ignored files if we're not showing ignored
    local ignored_files = (not show_ignored and get_ignored_files(dir) or {})
    -- True/false if the file is an ignored file
    local function is_ignored_file(filename)
        for i = 1, #ignored_files do
            if ignored_files[i] == filename then
                return true
            end
        end
        return false
    end

    -- Hold the current scan's filename in most of the loops below
    local filename

    for i = 1, #dir_scan do
        local showfile = true
        filename = dir_scan[i]:Name()
        -- If we should not show dotfiles, and this is a dotfile, don't show
        if not show_dotfiles and is_dotfile(filename) then
            showfile = false
        end
        -- If we should not show ignored files, and this is an ignored file, don't show
        if not show_ignored and is_ignored_file(filename) then
            showfile = false
        end
        if showfile then
            -- This file is good to show, proceed
            if folders_first and not is_dir(filepath.Join(dir, filename)) then
                -- If folders_first and this is a file, add it to (temporary) files
                files[#files + 1] = get_results_object(filename)
            else
                -- Otherwise, add to results
                results[#results + 1] = get_results_object(filename)
            end
        end
    end
    if #files > 0 then
        -- Append any files to results, now that all folders have been added
        -- files will be > 0 only if folders_first and there are files
        for i = 1, #files do
            results[#results + 1] = files[i]
        end
    end

    -- Return the list of scanned files
    return results
end

-- A short "get y" for when acting on the scanlist
-- Needed since we don't store the first 3 visible indicies in scanlist
local function get_safe_y(optional_y)
    -- Default to 0 so we can check against and see if it's bad
    local y = 0
    -- Make the passed y optional
    if optional_y == nil then
        -- Default to cursor's Y loc if nothing was passed, instead of declaring another y
        optional_y = tree_view.Cursor.Loc.Y
    end
    -- 0/1/2 would be the top "dir, separator, .." so check if it's past
    if optional_y > 2 then
        -- -2 to conform to our scanlist, since zero-based Go index & Lua's one-based
        y = tree_view.Cursor.Loc.Y - 2
    end
    return y
end

-- Joins the target dir's leading path to the passed name
local function dirname_and_join(path, join_name)
    -- The leading path to the dir we're in
    local leading_path = filepath.Dir(path)
    -- Joins with OS-specific slashes
    return filepath.Join(leading_path, join_name)
end

-- Hightlights the line when you move the cursor up/down
local function select_line(last_y)
    -- Make last_y optional
    if last_y ~= nil then
        -- Don't let them move past ".." by checking the result first
        if last_y > 1 then
            -- If the last position was valid, move back to it
            tree_view.Cursor.Loc.Y = last_y
        end
    elseif tree_view.Cursor.Loc.Y < 2 then
        -- Put the cursor on the ".." if it's above it
        tree_view.Cursor.Loc.Y = 2
    end

    -- Puts the cursor back in bounds (if it isn't) for safety
    tree_view.Cursor:Relocate()

    -- Makes sure the cursor is visible (if it isn't)
    -- (false) means no callback
    tree_view:Center()

    -- Highlight the current line where the cursor is
    tree_view.Cursor:SelectLine()
end

-- Simple true/false if scanlist is currently empty
local function scanlist_is_empty()
    if next(scanlist) == nil then
        return true
    else
        return false
    end
end

local function refresh_view()
    local icons = Icons()

    clear_messenger()

    -- Delete everything in the view/buffer
    tree_view.Buf.EventHandler:Remove(tree_view.Buf:Start(), tree_view.Buf:End())

    -- Insert the top 3 things that are always there
    -- Current dir
    local highest_length = 1
    if config.GetGlobalOption('filemanager2.workingdir') then
        tree_view.Buf.EventHandler:Insert(buffer.Loc(0, 0), current_dir .. '\n')
        highest_length = string.len(current_dir)
    else
        tree_view.Buf.EventHandler:Insert(buffer.Loc(0, 0), '\n')
    end
    
    -- An ASCII separator
    tree_view.Buf.EventHandler:Insert(buffer.Loc(0, 1), repeat_str('─', tree_view:GetView().Width) .. '\n')
    
    -- The ".." and use a newline if there are things in the current dir
    tree_view.Buf.EventHandler:Insert(buffer.Loc(0, 2), (#scanlist > 0 and '..\n' or '..'))

    -- Holds the current basename of the path (purely for display)
    local display_content

    -- NOTE: might want to not do all these concats in the loop, it can get slow
    for i = 1, #scanlist do
        -- The first 3 indicies are the dir/separator/"..", so skip them
        if scanlist[i].dirmsg == icons['dir'] or scanlist[i].dirmsg == icons['dir_open'] then
            -- Add the + or - to the left to signify if it's compressed or not
            -- Add a forward slash to the right to signify it's a dir
            display_content = scanlist[i].dirmsg .. ' ' .. get_basename(scanlist[i].abspath) .. '/'
        else
            -- Use the basename from the full path for display
            -- Two spaces to align with any directories, instead of being "off"
            display_content = scanlist[i].dirmsg .. '  ' .. get_basename(scanlist[i].abspath)
        end

        if scanlist[i].owner > 0 then
            -- Add a space and repeat it * the indent number
            display_content = repeat_str(' ', 2 * scanlist[i].indent) .. display_content
        end

        -- Newlines are needed for all inserts except the last
        -- If you insert a newline on the last, it leaves a blank spot at the bottom
        if i < #scanlist then
            display_content = display_content .. '\n'
        end
        
        if string.len(display_content) > highest_length then
            highest_length = string.len(display_content)
        end

        -- Insert line-by-line to avoid out-of-bounds on big folders
        -- +2 so we skip the 0/1/2 positions that hold the top dir/separator/..
        tree_view.Buf.EventHandler:Insert(buffer.Loc(0, i + 2), display_content)
    end

    -- Update pane width
    tree_view:ResizePane(tree_width + highest_length * line_length_factor)

    -- Update ASCII separator again
    tree_view.Buf.EventHandler:Replace(buffer.Loc(0, 1), buffer.Loc(99999, 1), 
        repeat_str('─', tree_view:GetView().Width * 0.85))

    -- Resizes all views after messing with ours
    tree_view:Tab():Resize()
end

-- Moves the cursor to the ".." in tree_view
local function move_cursor_top()
    -- 2 is the position of the ".."
    tree_view.Cursor.Loc.Y = 2

    -- select the line after moving
    select_line()
end

local function refresh_and_select()
    -- Save the cursor position before messing with the view..
    -- because changing contents in the view causes the Y loc to move
    local last_y = tree_view.Cursor.Loc.Y
    -- Actually refresh
    refresh_view()
    -- Moves the cursor back to it's original position
    select_line(last_y)
end

-- Find everything nested under the target, and remove it from the scanlist
local function compress_target(y, delete_y)
    local icons = Icons()

    -- Can't compress the top stuff, or if there's nothing there, so exit early
    if y == 0 or scanlist_is_empty() then
        return
    end
    -- Check if the target is a dir, since files don't have anything to compress
    -- Also make sure it's actually an uncompressed dir by checking the gutter message
    if scanlist[y].dirmsg == icons['dir_open'] then
        local target_index, delete_index
        -- Add the original target y to stuff to delete
        local delete_under = { [1] = y }
        local new_table = {}
        local del_count = 0
        -- Loop through the whole table, looking for nested content, or stuff with ownership == y...
        -- and delete matches. y+1 because we want to start under y, without actually touching y itself.
        for i = 1, #scanlist do
            delete_index = false
            -- Don't run on y, since we don't always delete y
            if i ~= y then
                -- On each loop, check if the ownership matches
                for x = 1, #delete_under do
                    -- Check for something belonging to a thing to delete
                    if scanlist[i].owner == delete_under[x] then
                        -- Delete the target if it has an ownership to our delete target
                        delete_index = true
                        -- Keep count of total deleted (can't use #delete_under because it's for deleted dir count)
                        del_count = del_count + 1
                        -- Check if an uncompressed dir
                        if scanlist[i].dirmsg == icons['dir_open'] then
                            -- Add the index to stuff to delete, since it holds nested content
                            delete_under[#delete_under + 1] = i
                        end
                        
                        -- Nothing else to do, so break this inner loop
                        break
                    end
                end
            end
            if not delete_index then
                -- Save the index in our new table
                new_table[#new_table + 1] = scanlist[i]
            end
        end

        scanlist = new_table

        if del_count > 0 then
            -- Ownership adjusting since we're deleting an index
            for i = y + 1, #scanlist do
                -- Don't touch root file/dirs
                if scanlist[i].owner > y then
                    -- Minus ownership, on everything below i, the number deleted
                    scanlist[i]:decrease_owner(del_count)
                end
            end
        end

        -- If not deleting, then update the gutter message to be + to signify compressed
        if not delete_y then
            -- Update the dir message
            scanlist[y].dirmsg = icons['dir']
        end
    elseif config.GetGlobalOption('filemanager2.compressparent') and not delete_y then
        goto_parent_dir()
        -- Prevent a pointless refresh of the view
        return
    end

    -- Put outside check above because we call this to delete targets as well
    if delete_y then
        local second_table = {}
        -- Quickly remove y
        for i = 1, #scanlist do
            if i == y then
                -- Reduce everything's ownership by 1 after y
                for x = i + 1, #scanlist do
                    -- Don't touch root file/dirs
                    if scanlist[x].owner > y then
                        -- Minus 1 since we're just deleting y
                        scanlist[x]:decrease_owner(1)
                    end
                end
            else
                -- Put everything but y into the temporary table
                second_table[#second_table + 1] = scanlist[i]
            end
        end
        -- Put everything (but y) back into scanlist, with adjusted ownership values
        scanlist = second_table
    end

    refresh_and_select()
end

-- Prompts the user for deletion of a file/dir when triggered
-- Not local so Micro can access it
function prompt_delete_at_cursor()
    local icons = Icons()

    local y = get_safe_y()
    -- Don't let them delete the top 3 index dir/separator/..
    if y == 0 or scanlist_is_empty() then
        micro.InfoBar():Error('You can\'t delete that')
        -- Exit early if there's nothing to delete
        return
    end

    micro.InfoBar():YNPrompt(
        'Do you want to delete the '
            .. (scanlist[y].dirmsg == icons['dir'] and 'dir' or 'file')
            .. ' "'
            .. scanlist[y].abspath
            .. '"? ',
        function(yes, canceled)
            if yes and not canceled then
                -- Use Go's os.Remove to delete the file
                local go_os = import('os')
                -- Delete the target (if its a dir then the children too)
                local remove_log = go_os.RemoveAll(scanlist[y].abspath)
                if remove_log == nil then
                    micro.InfoBar():Message('Filemanager2 deleted: ', scanlist[y].abspath)
                    -- Remove the target (and all nested) from scanlist[y + 1]
                    -- true to delete y
                    compress_target(get_safe_y(), true)
                else
                    micro.InfoBar():Error('Failed deleting file/dir: ', remove_log)
                end
            else
                micro.InfoBar():Message('Nothing was deleted')
            end
        end
    )
end

-- Changes the current dir in the top of the tree..
-- then scans that dir, and prints it to the view
local function update_current_dir(path)
    -- Clear the highest since this is a full refresh
    -- Set the width back to tree_width
    tree_view:ResizePane(tree_width)
    -- Update the current dir to the new path
    current_dir = path

    -- Get the current working dir's files into our list of files
    -- 0 ownership because this is a scan of the base dir
    -- 0 indent because this is the base dir
    local scan_results = get_scanlist(path, 0, 0)
    -- Safety check with not-nil
    if scan_results ~= nil then
        -- Put in the new scan stuff
        scanlist = scan_results
    else
        -- If nil, just empty it
        scanlist = {}
    end

    refresh_view()
    -- Since we're going into a new dir, move cursor to the ".." by default
    move_cursor_top()
end

-- (Tries to) go back one "step" from the current directory
local function go_back_dir()
    -- Use Micro's dirname to get everything but the current dir's path
    local one_back_dir = filepath.Dir(current_dir)
    -- Try opening, assuming they aren't at "root", by checking if it matches last dir
    if one_back_dir ~= current_dir then
        -- If filepath.Dir returns different, then they can move back..
        -- so we update the current dir and refresh
        update_current_dir(one_back_dir)
    end
end

function open_pane_if_exist(path)
    local cleanFilepath = filepath.Clean(path)
    local wd, wdErr = os.Getwd()
    for i = 1, #micro.Tabs().List do
        for j = 1, #micro.Tabs().List[i].Panes do
            local currentPane = micro.Tabs().List[i].Panes[j]
            local currentBuf = currentPane.Buf
            
            -- if currentBuf ~= nil then
            --     micro.Log("cleanFilepath:", cleanFilepath)
            --     micro.Log("currentBuf.AbsPath:", currentBuf.AbsPath)
            --     micro.Log("currentBuf.Path:", currentBuf.Path)
            -- end
            
            if currentBuf ~= nil and currentBuf.AbsPath ~= "" and currentBuf.AbsPath ~= nil then
                local calculatedAbsPath = filepath.Abs(cleanFilepath)
                if not filepath.IsAbs(cleanFilepath) and wdErr == nil then
                    local absPath, absErr = filepath.Abs(filepath.Join(wd, cleanFilepath))
                    -- micro.Log("absPath:", absPath)
                    if absErr == nil then
                        calculatedAbsPath = absPath
                    end
                end
                -- micro.Log("calculatedAbsPath:", calculatedAbsPath)
                
                if  filepath.Clean(currentBuf.AbsPath) == calculatedAbsPath or
                    filepath.Clean(currentBuf.AbsPath) == cleanFilepath or 
                    filepath.Clean(currentBuf.Path) == cleanFilepath then

                    -- NOTE: SetActive functions has index starting at 0 instead lol
                    micro.Tabs():SetActive(i - 1)
                    micro.Tabs().List[i]:SetActive(j - 1)
                    return true
                end
            end
        end
    end
    
    return false
end

-- Stat a path to check if it exists, returning true/false
local function path_exists(path)
    local go_os = import('os')
    -- Stat the file/dir path we created
    -- file_stat should be non-nil, and stat_err should be nil on success
    local file_stat, stat_err = go_os.Stat(path)
    -- Check if what we tried to create exists
    if stat_err ~= nil then
        -- true/false if the file/dir exists
        return go_os.IsExist(stat_err)
    elseif file_stat ~= nil then
        -- Assume it exists if no errors
        return true
    end
    return false
end


local function is_path_dir(path)
    -- Stat the file/dir path we created
    -- file_stat should be non-nil, and stat_err should be nil on success
    local file_stat, stat_err = os.Stat(path)
    if stat_err ~= nil then
        return false
    elseif file_stat ~= nil then
        -- Assume it exists if no errors
        return file_stat:IsDir()
    end
    return false
end


function smart_new_tab(path)
    local cleanFilepath = filepath.Clean(path)
    
    -- If current pane is empty, we can open in it
    if not path_exists(last_buf_pane.Buf.AbsPath) or is_path_dir(last_buf_pane.Buf.AbsPath) then
        if #last_buf_pane.Buf:Bytes() == 0 then
            last_buf_pane:OpenCmd({cleanFilepath})
            return
        end
    end
    
    -- Otherwise find if there's any existing panes
    if open_pane_if_exist(cleanFilepath) then
        return
    end
    
    -- If not just open it
    local currentActiveIndex = micro.Tabs():Active()
    last_buf_pane:NewTabCmd({cleanFilepath})
    
    on_set_active_guard = true
        last_buf_pane:TabMoveCmd({tostring(currentActiveIndex + 2)})
    on_set_active_guard = false
end

-- Tries to open the current index
-- If it's the top dir indicator, or separator, nothing happens
-- If it's ".." then it tries to go back a dir
-- If it's a dir then it moves into the dir and refreshes
-- If it's actually a file, open it in a new vsplit
-- THIS EXPECTS ZERO-BASED Y
local function try_open_at_y(y, force_cd)
    local icons = Icons()

    -- 2 is the zero-based index of ".."
    if y == 2 then
        go_back_dir()
    elseif y > 2 and not scanlist_is_empty() then
        -- -2 to conform to our scanlist "missing" first 3 indicies
        y = y - 2
        if scanlist[y].dirmsg == icons['dir'] or scanlist[y].dirmsg == icons['dir_open'] then
            -- if passed path is a directory, update the current dir to be one deeper..
            if force_cd then
                update_current_dir(scanlist[y].abspath)
            else
                toggle_compress(y)
            end
        else
            local open_path = scanlist[y].abspath
            
            if config.GetGlobalOption('filemanager2.relativepath') then
                open_path = try_convert_rel(scanlist[y].abspath)
            end
            
            -- If it's a file, then open it
            micro.InfoBar():Message('Filemanager2 opened ', open_path)
            open_path = filepath.Clean(open_path)
            if config.GetGlobalOption('filemanager2.newtab') then
                smart_new_tab(open_path)
            else
                micro.CurPane():VSplitIndex(buffer.NewBufferFromFile(open_path), true)
            end

            -- Resizes all views after opening a file
            -- tabs[curTab + 1]:Resize()
        end
    else
        micro.InfoBar():Error('Can\'t open that')
    end
end

-- Opens the dir's contents nested under itself
function uncompress_target(y)
    local icons = Icons()

    -- Exit early if on the top 3 non-list items
    if y == 0 or scanlist_is_empty() then
        return
    end
    -- Only uncompress if it's a dir and it's not already uncompressed
    if scanlist[y].dirmsg == icons['dir'] then
        -- Get a new scanlist with results from the scan in the target dir
        local scan_results = get_scanlist(scanlist[y].abspath, y, scanlist[y].indent + 1)
        -- Don't run any of this if there's nothing in the dir we scanned, pointless
        if scan_results ~= nil then
            -- Will hold all the old values + new scan results
            local new_table = {}
            -- By not inserting in-place, some unexpected results can be avoided
            -- Also, table.insert actually moves values up (???) instead of down
            for i = 1, #scanlist do
                -- Put the current val into our new table
                new_table[#new_table + 1] = scanlist[i]
                if i == y then
                    -- Fill in the scan results under y
                    for x = 1, #scan_results do
                        new_table[#new_table + 1] = scan_results[x]
                    end
                    -- Basically "moving down" everything below y, so ownership needs to increase on everything
                    for inner_i = y + 1, #scanlist do
                        -- When root not pushed by inserting, don't change its ownership
                        -- This also has a dual-purpose to make it not effect root file/dirs
                        -- since y is always >= 3
                        if scanlist[inner_i].owner > y then
                            -- Increase each indicies ownership by the number of scan results inserted
                            scanlist[inner_i]:increase_owner(#scan_results)
                        end
                    end
                end
            end

            -- Update our scanlist with the new values
            scanlist = new_table
        end

        -- Change to minus to signify it's uncompressed
        scanlist[y].dirmsg = icons['dir_open']
        refresh_and_select()
    end
end

function toggle_compress(y)
    local icons = Icons()

    -- Exit early if on the top 3 non-list items
    if y == 0 or scanlist_is_empty() then
        return
    end
    -- Only uncompress if it's a dir and it's not already uncompressed
    if scanlist[y].dirmsg == icons['dir'] then
        uncompress_target(y)
    elseif scanlist[y].dirmsg == icons['dir_open'] then
        compress_target(y, false)
    end
end

local function try_uncompress_path(path)
    local clean_path = filepath.Clean(path)
    
    -- Convert to abs path if not
    if not filepath.IsAbs(clean_path) then
        local wd, wd_err = os.Getwd()
        
        if wd_err ~= nil then
            return
        end
        
        local abs_path, abs_err = filepath.Abs(filepath.Join(wd, clean_path))
        if abs_err == nil then
            clean_path = absPath
        end
    end
    
    -- Iterate each item in scanlist until we find the path we want, uncompress dir in the process
    local y = 0
    local j = 1
    while(j <= #scanlist)
    do
        if  scanlist[j].dirmsg == Icons()['dir'] and 
            string.find(clean_path, scanlist[j].abspath, 1, true) then
            
            uncompress_target(j)
        end
        if scanlist[j].abspath == clean_path then
            y = j
            break
        end
        j = j + 1
    end
    
    -- Move cursor to the final target
    if y > 0 then
        tree_view.Cursor.Loc.Y = y + 2  -- +2 to account for header lines
        select_line()
    end
end

-- Prompts for a new name, then renames the file/dir at the cursor's position
-- Not local so Micro can use it
function rename_at_cursor(bp, args)
    if micro.CurPane() ~= tree_view then
        micro.InfoBar():Message('Rename only works with the cursor in the tree!')
        return
    end

    -- Safety check they actually passed a name
    if #args < 1 then
        micro.InfoBar():Error('When using "rename" you need to input a new name')
        return
    end

    local new_name = args[1]

    -- +1 since Go uses zero-based indices
    local y = get_safe_y()
    -- Check if they're trying to rename the top stuff
    if y == 0 then
        -- Error since they tried to rename the top stuff
        micro.InfoBar():Message('You can\'t rename that!')
        return
    end

    -- The old file/dir's path
    local old_path = scanlist[y].abspath
    -- Join the path into their supplied rename, so that we have an absolute path
    local new_path = dirname_and_join(old_path, new_name)
    -- Use Go's os package for renaming the file/dir
    local golib_os = import('os')
    -- Actually rename the file
    local log_out = golib_os.Rename(old_path, new_path)
    -- Output the log, if any, of the rename
    if log_out ~= nil then
        micro.Log('Rename log: ', log_out)
    end

    -- Check if the rename worked
    if not path_exists(new_path) then
        micro.InfoBar():Error('Path doesn\'t exist after rename!')
        return
    end

    -- NOTE: doesn't alphabetically sort after refresh, but it probably should
    -- Replace the old path with the new path
    scanlist[y].abspath = new_path
    -- Refresh the tree with our new name
    refresh_and_select()
end

-- Prompts the user for the file/dir name, then creates the file/dir using Go's os package
local function create_filedir(filedir_name, make_dir, do_copy)
    local icons = Icons()
    local create_or_copy = (do_copy and {"copy"} or {"create"})[1]

    if micro.CurPane() ~= tree_view then
        micro.InfoBar():Message('You can\'t ' .. create_or_copy .. ' a file/dir if your cursor ' .. 
                                'isn\'t in the tree!')
        return
    end

    -- Safety check they passed a name
    if filedir_name == nil then
        micro.InfoBar():Error('You need to input a name!')
        return
    end

    -- The target they're trying to create on top of/in/at/whatever
    local y = get_safe_y()
    -- Holds the path passed to Go for the eventual new file/dir
    local filedir_path
    -- A true/false if scanlist is empty
    local scanlist_empty = scanlist_is_empty()

    -- Check there's actually anything in the list, and that they're not on the ".."
    if not scanlist_empty and y ~= 0 then
        -- If they're inserting on a folder, don't strip its path
        if scanlist[y].dirmsg == icons['dir'] or scanlist[y].dirmsg == icons['dir_open'] then
            -- Join our new file/dir onto the dir if we are creating new files
            if not do_copy then
                filedir_path = filepath.Join(scanlist[y].abspath, filedir_name)
            -- Otherwise just use current directory
            else
                filedir_path = dirname_and_join(scanlist[y].abspath, filedir_name)
            end
        else
            -- The current index is a file, so strip its name and join ours onto it
            filedir_path = dirname_and_join(scanlist[y].abspath, filedir_name)
        end
    else
        -- if nothing in the list, or cursor is on top of "..", use the current dir
        filedir_path = filepath.Join(current_dir, filedir_name)
    end

    -- Check if the name is already taken by a file/dir
    if path_exists(filedir_path) then
        micro.InfoBar():Error('You can\'t ' .. create_or_copy .. ' a file/dir with a pre-existing name')
        return
    end

    
    local golib_os = import('os')
    
    -- If the parent directory of target doesn't exist, create it
    if not path_exists(filepath.Dir(filedir_path)) then
        local err = golib_os.MkdirAll(filepath.Dir(filedir_path), golib_os.ModePerm)
        if err ~= nil then
            micro.InfoBar():Error(err)
        end
    end

    local runtime = import('runtime')
    -- Copy file/dir in shell
    if do_copy then
        if scanlist_empty or y == 0 then
            micro.InfoBar():Error('Nothing is selected for copying')
            return
        end
        
        local is_selected_dir = false
        if scanlist[y].dirmsg == icons['dir'] or scanlist[y].dirmsg == icons['dir_open'] then
            is_selected_dir = true
        end
        
        -- NOTE: Surprising, go doesn't have a method for copying stuff until 2024... wow.
        local copy_cmd = ""
        if is_selected_dir then
            if runtime.GOOS == "windows" then
                copy_cmd = "xcopy \"" .. scanlist[y].abspath .. "\" \"" .. filedir_path .. "\" /s /i /e /h /y"
            -- Unix
            else
                copy_cmd = "cp -R \"" .. scanlist[y].abspath .. "\" \"" .. filedir_path .. "\""
            end
        else
            if runtime.GOOS == "windows" then
                copy_cmd = "cmd /s /v:on /c copy \"" .. scanlist[y].abspath .. "\" \"" .. filedir_path .. "\" /y"
            -- Unix
            else
                copy_cmd = "cp \"" .. scanlist[y].abspath .. "\" \"" .. filedir_path .. "\""
            end
        end
        local output, err = shell.RunCommand(copy_cmd)
        if err ~= nil then
            micro.InfoBar():Error(err, " with command " .. copy_cmd .. " with output " .. output)
            return
        end
    -- Use Go's os package for creating the files
    else
        -- Create the dir or file
        if make_dir then
            -- Creates the dir
            golib_os.Mkdir(filedir_path, golib_os.ModePerm)
            micro.Log('Filemanager2 created directory: ' .. filedir_path)
        else
            -- Creates the file
            golib_os.Create(filedir_path)
            micro.Log('Filemanager2 created file: ' .. filedir_path)
        end
    end

    -- If the file we tried to make doesn't exist, fail
    if not path_exists(filedir_path) then
        micro.InfoBar():Error('The file/dir creation failed')
        return
    end

    -- Update directory
    local opened_dirs = {}
    for i = 1, #scanlist do
        if scanlist[i].dirmsg == Icons()['dir_open'] then
            opened_dirs[scanlist[i].abspath] = true
        end
    end
    
    update_current_dir(os.Getwd())
    for i = 1, #scanlist do
        if opened_dirs[scanlist[i].abspath] ~= nil then
            uncompress_target(i)
        end
    end
    if path_exists(filedir_path) then
        try_uncompress_path(filedir_path)
    end
end

-- Triggered with "touch filename"
function new_file(bp, args)
    -- Safety check they actually passed a name
    if #args < 1 then
        micro.InfoBar():Error('When using "touch" you need to input a file name')
        return
    end

    local file_name = args[1]

    -- False because not a dir
    create_filedir(file_name, false, false)
end

-- Triggered with "mkdir dirname"
function new_dir(bp, args)
    -- Safety check they actually passed a name
    if #args < 1 then
        micro.InfoBar():Error('When using "mkdir" you need to input a dir name')
        return
    end

    local dir_name = args[1]

    -- True because dir
    create_filedir(dir_name, true, false)
end

function copy(bp, args)
    -- Safety check they actually passed a name
    if #args < 1 then
        micro.InfoBar():Error('When using "cp" you need to input the new file/dir name')
        return
    end

    local new_name = args[1]
    create_filedir(new_name, true, true)
end

-- open_tree setup's the view
local function open_tree()
    last_buf_pane = micro.CurPane()
    
    -- Find the left most pane
    local left_most_index = 1
    local min_x = last_buf_pane:Tab().Panes[1]:BufView().X
    for i = 1, #last_buf_pane:Tab().Panes do
        if last_buf_pane:Tab().Panes[i]:BufView().X < min_x then
            left_most_index = i
            min_x = last_buf_pane:Tab().Panes[i]:BufView().X
        end
    end
    
    -- Open a new Vsplit (on the very left)
    last_buf_pane:Tab().Panes[left_most_index]:VSplitIndex(buffer.NewBuffer('', 'filemanager2'), false)
    -- Save the new view so we can access it later
    tree_view = micro.CurPane()

    -- Set the width of tree_view to tree_width & lock it
    tree_view:ResizePane(tree_width)
    -- Set the type to unsavable
    -- tree_view.Buf.Type = buffer.BTLog
    tree_view.Buf.Type.Scratch = true
    tree_view.Buf.Type.Readonly = true

    -- Set the various display settings, but only on our view (by using SetLocalOption instead of SetOption)
    -- NOTE: Micro requires the true/false to be a string
    -- Softwrap long strings (the file/dir paths)
    tree_view.Buf:SetOptionNative('softwrap', true)
    -- No line numbering
    tree_view.Buf:SetOptionNative('ruler', false)
    -- Is this needed with new non-savable settings from being "vtLog"?
    tree_view.Buf:SetOptionNative('autosave', false)
    -- Don't show the statusline to differentiate the view from normal views
    tree_view.Buf:SetOptionNative('statusformatr', '')
    tree_view.Buf:SetOptionNative('statusformatl', 'filemanager2')
    tree_view.Buf:SetOptionNative('scrollbar', false)

    -- Fill the scanlist, and then print its contents to tree_view
    update_current_dir(os.Getwd())
    if config.GetGlobalOption('filemanager2.showcurrent') then
        -- If there's a valid buffer path, uncompress the tree to reach it
        if path_exists(last_buf_pane.Buf.AbsPath) then
            try_uncompress_path(last_buf_pane.Buf.AbsPath)
        end
    end
end

function onBufPaneOpen(bp)
    if tree_view ~= nil and bp ~= tree_view then
        tree_view:ResizePane(tree_width)
    end
end

function onSetActive(bp)
    if bp == tree_view then
        return
    end
    
    if on_set_active_guard then
        return
    end
    on_set_active_guard = true
    
    local tree_same_tab = true
    
    if  tree_view ~= nil and 
        tree_view:Tab() ~= bp:Tab() and 
        config.GetGlobalOption('filemanager2.persist') then
        
        tree_same_tab = false
        toggle_tree(bp)
        local activeIdx = 1
        for i = 1, #bp:Tab().Panes do
            if bp:Tab().Panes[i] == bp then
                activeIdx = i
                break
            end
        end
        bp:Tab():SetActive(activeIdx - 1)
    end
    
    if  tree_view ~= nil and 
        config.GetGlobalOption('filemanager2.showcurrent') and 
        not tree_same_tab then
        
        -- If there's a valid buffer path, uncompress the tree to reach it
        if  bp.Buf.AbsPath ~= "" and 
            path_exists(bp.Buf.AbsPath) and 
            not is_path_dir(bp.Buf.AbsPath) then
            
            -- Fill the scanlist, and then print its contents to tree_view
            update_current_dir(os.Getwd())
            try_uncompress_path(bp.Buf.AbsPath)
        end
    end
    
    on_set_active_guard = false
end

function onQuit(bp)
    if tree_view ~= nil and bp ~= tree_view and #tree_view:Tab().Panes > 1 then
        tree_view:ResizePane(tree_width)
    end
    
    return true
end


-- close_tree will close the tree plugin view and release memory.
local function close_tree()
    if tree_view ~= nil then
        local view_to_close = tree_view
        tree_view = nil
        view_to_close:Unsplit()
        clear_messenger()
    end
end

-- toggle_tree will toggle the tree view visible (create) and hide (delete).
function toggle_tree(bp)
    if tree_view == nil then
        open_tree()
    else
        -- If the file tree share the same tab, close the tree, 
        -- otherwise just move the tree to current tab
        if bp:Tab() == tree_view:Tab() then
            close_tree()
        else
            close_tree()
            open_tree()
        end
    end
end

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Functions exposed specifically for the user to bind
-- Some are used in callbacks as well
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

function uncompress_at_cursor()
    if micro.CurPane() == tree_view then
        uncompress_target(get_safe_y())
    end
end

function compress_at_cursor()
    if micro.CurPane() == tree_view then
        -- False to not delete y
        compress_target(get_safe_y(), false)
    end
end

-- Goes up 1 visible directory (if any)
-- Not local so it can be bound
function goto_prev_dir()
    local icons = Icons()

    if micro.CurPane() ~= tree_view or scanlist_is_empty() then
        return
    end

    local cur_y = get_safe_y()
    -- If they try to run it on the ".." do nothing
    if cur_y ~= 0 then
        local move_count = 0
        for i = cur_y - 1, 1, -1 do
            move_count = move_count + 1
            -- If a dir, stop counting
            if scanlist[i].dirmsg == icons['dir'] or scanlist[i].dirmsg == icons['dir_open'] then
                -- Jump to its parent (the ownership)
                tree_view.Cursor:UpN(move_count)
                select_line()
                break
            end
        end
    end
end

-- Goes down 1 visible directory (if any)
-- Not local so it can be bound
function goto_next_dir()
    local icons = Icons()

    if micro.CurPane() ~= tree_view or scanlist_is_empty() then
        return
    end

    local cur_y = get_safe_y()
    local move_count = 0
    -- If they try to goto_next on "..", pretends the cursor is valid
    if cur_y == 0 then
        cur_y = 1
        move_count = 1
    end
    -- Only do anything if it's even possible for there to be another dir
    if cur_y < #scanlist then
        for i = cur_y + 1, #scanlist do
            move_count = move_count + 1
            -- If a dir, stop counting
            if scanlist[i].dirmsg == icons['dir'] or scanlist[i].dirmsg == icons['dir_open'] then
                -- Jump to its parent (the ownership)
                tree_view.Cursor:DownN(move_count)
                select_line()
                break
            end
        end
    end
end

-- Goes to the parent directory (if any)
-- Not local so it can be keybound
function goto_parent_dir()
    if micro.CurPane() ~= tree_view or scanlist_is_empty() then
        return
    end

    local cur_y = get_safe_y()
    -- Check if the cursor is even in a valid location for jumping to the owner
    if cur_y > 0 then
        -- Jump to its parent (the ownership)
        tree_view.Cursor:UpN(cur_y - scanlist[cur_y].owner)
        select_line()
    end
end

function try_open_at_cursor()
    if micro.CurPane() ~= tree_view or scanlist_is_empty() then
        return
    end

    try_open_at_y(tree_view.Cursor.Loc.Y, false)
end

function try_expand_or_open_at_cursor()
    try_open_at_y(tree_view.Cursor.Loc.Y, true)
end

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Shorthand functions for actions to reduce repeat code
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-- Used to fail certain actions that we shouldn't allow on the tree_view
local function false_if_tree(view)
    if view == tree_view then
        return false
    end
end

-- Select the line at the cursor
local function selectline_if_tree(view)
    if view == tree_view then
        select_line()
    end
end

-- Move the cursor to the top, but don't allow the action
local function aftermove_if_tree(view)
    if view == tree_view then
        if tree_view.Cursor.Loc.Y < 2 then
            -- If it went past the "..", move back onto it
            tree_view.Cursor:DownN(2 - tree_view.Cursor.Loc.Y)
        end
        select_line()
    end
end

local function clearselection_if_tree(view)
    if view == tree_view then
        -- Clear the selection when doing a find, so it doesn't copy the current line
        tree_view.Cursor:ResetSelection()
    end
end

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- All the events for certain Micro keys go below here
-- Other than things we flat-out fail
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-- Close current
function preQuit(view)
    if view == tree_view then
        -- A fake quit function
        close_tree()
        -- Don't actually "quit", otherwise it closes everything without saving for some reason
        return false
    elseif tree_view ~= nil and view:Tab() == tree_view:Tab() then
        close_tree()
    end
    return true
end

-- Close all
function preQuitAll(view)
    close_tree()
end

-- FIXME: Workaround for the weird 2-index movement on cursordown
function preCursorDown(view)
    if view == tree_view then
        tree_view.Cursor:Down()
        select_line()
        -- Don't actually go down, as it moves 2 indicies for some reason
        return false
    end
end

-- Up
function onCursorUp(view)
    selectline_if_tree(view)
end

-- Alt-Shift-{
-- Go to target's parent directory (if exists)
function preParagraphPrevious(view)
    if view == tree_view then
        goto_prev_dir()
        -- Don't actually do the action
        return false
    end
end

-- Alt-Shift-}
-- Go to next dir (if exists)
function preParagraphNext(view)
    if view == tree_view then
        goto_next_dir()
        -- Don't actually do the action
        return false
    end
end

-- PageUp
function onCursorPageUp(view)
    aftermove_if_tree(view)
end

-- Ctrl-Up
function onCursorStart(view)
    aftermove_if_tree(view)
end

-- PageDown
function onCursorPageDown(view)
    selectline_if_tree(view)
end

-- Ctrl-Down
function onCursorEnd(view)
    selectline_if_tree(view)
end

function onNextSplit(view)
    selectline_if_tree(view)
end

function onPreviousSplit(view)
    selectline_if_tree(view)
end

-- On click, open at the click's y
function onMousePress(view)
    if view == tree_view then
        -- Try to open whatever is at the click's y index
        -- Will go into/back dirs based on what's clicked, nothing gets expanded
        if config.GetGlobalOption('filemanager2.clickexpand') then
            try_open_at_y(tree_view.Cursor.Loc.Y, false)
        else
            try_open_at_y(tree_view.Cursor.Loc.Y, true)
        end
        -- Don't actually allow the mousepress to trigger, so we avoid highlighting stuff
        return false
    end
end

-- Up
function preCursorUp(view)
    if view == tree_view then
        -- Disallow selecting past the ".." in the tree
        if tree_view.Cursor.Loc.Y == 2 then
            return false
        end
    end
end

-- Left
function preCursorLeft(view)
    if view == tree_view then
        -- +1 because of Go's zero-based index
        -- False to not delete y
        compress_target(get_safe_y(), false)
        -- Don't actually move the cursor, as it messes with selection
        return false
    end
end

-- Right
function preCursorRight(view)
    if view == tree_view then
        -- +1 because of Go's zero-based index
        uncompress_target(get_safe_y())
        -- Don't actually move the cursor, as it messes with selection
        return false
    end
end

-- Workaround for tab getting inserted into opened files
-- Ref https://github.com/zyedidia/micro/issues/992
local tab_pressed = false

-- Tab
function preIndentSelection(view)
    if view == tree_view then
        tab_pressed = true
        -- Open the file
        -- Using tab instead of enter, since enter won't work with Readonly
        try_open_at_y(tree_view.Cursor.Loc.Y, true)
        -- Don't actually insert a tab
        return false
    end
end

-- Workaround for tab getting inserted into opened files
-- Ref https://github.com/zyedidia/micro/issues/992
function preInsertTab(view)
    if tab_pressed then
        tab_pressed = false
        return false
    end
end
function preInsertNewline(view)
    if view == tree_view then
        try_open_at_y(tree_view.Cursor.Loc.Y, true)
        return false
    end
    return true
end
-- CtrlL
function onJumpLine(view)
    -- Highlight the line after jumping to it
    -- Also moves you to index 3 (2 in zero-base) if you went to the first 2 lines
    aftermove_if_tree(view)
end

-- ShiftUp
function preSelectUp(view)
    if view == tree_view then
        -- Go to the file/dir's parent dir (if any)
        goto_parent_dir()
        -- Don't actually selectup
        return false
    end
end

-- CtrlF
function preFind(view)
    -- Since something is always selected, clear before a find
    -- Prevents copying the selection into the find input
    clearselection_if_tree(view)
end

-- FIXME: doesn't work for whatever reason
function onFind(view)
    -- Select the whole line after a find, instead of just the input txt
    selectline_if_tree(view)
end

-- CtrlN after CtrlF
function onFindNext(view)
    selectline_if_tree(view)
end

-- CtrlP after CtrlF
function onFindPrevious(view)
    selectline_if_tree(view)
end

-- NOTE: This is a workaround for "cd" not having its own callback
local precmd_dir

function preCommandMode(view)
    precmd_dir = os.Getwd()
end

-- Update the current dir when using "cd"
function onCommandMode(view)
    local new_dir = os.Getwd()
    -- Only do anything if the tree is open, and they didn't cd to nothing
    if tree_view ~= nil and new_dir ~= precmd_dir and new_dir ~= current_dir then
        update_current_dir(new_dir)
    end
end

------------------------------------------------------------------
-- Fail a bunch of useless actions
-- Some of these need to be removed (read-only makes some useless)
------------------------------------------------------------------

function preStartOfLine(view)
    return false_if_tree(view)
end

function preStartOfText(view)
    return false_if_tree(view)
end

function preEndOfLine(view)
    return false_if_tree(view)
end

function preMoveLinesDown(view)
    return false_if_tree(view)
end

function preMoveLinesUp(view)
    return false_if_tree(view)
end

function preWordRight(view)
    return false_if_tree(view)
end

function preWordLeft(view)
    return false_if_tree(view)
end

function preSelectDown(view)
    return false_if_tree(view)
end

function preSelectLeft(view)
    return false_if_tree(view)
end

function preSelectRight(view)
    return false_if_tree(view)
end

function preSelectWordRight(view)
    return false_if_tree(view)
end

function preSelectWordLeft(view)
    return false_if_tree(view)
end

function preSelectToStartOfLine(view)
    return false_if_tree(view)
end

function preSelectToStartOfText(view)
    return false_if_tree(view)
end

function preSelectToEndOfLine(view)
    return false_if_tree(view)
end

function preSelectToStart(view)
    return false_if_tree(view)
end

function preSelectToEnd(view)
    return false_if_tree(view)
end

function preDeleteWordLeft(view)
    return false_if_tree(view)
end

function preDeleteWordRight(view)
    return false_if_tree(view)
end

function preOutdentSelection(view)
    return false_if_tree(view)
end

function preOutdentLine(view)
    return false_if_tree(view)
end

function preSave(view)
    return false_if_tree(view)
end

function preCut(view)
    return false_if_tree(view)
end

function preCutLine(view)
    return false_if_tree(view)
end

function preDuplicateLine(view)
    return false_if_tree(view)
end

function prePaste(view)
    return false_if_tree(view)
end

function prePastePrimary(view)
    return false_if_tree(view)
end

function preMouseMultiCursor(view)
    return false_if_tree(view)
end

function preSpawnMultiCursor(view)
    return false_if_tree(view)
end

function preSelectAll(view)
    return false_if_tree(view)
end

function init()
    -- Let the user disable showing of dotfiles like ".editorconfig" or ".DS_STORE"
    config.RegisterCommonOption('filemanager2', 'showdotfiles', true)
    -- Let the user disable showing files ignored by the VCS (i.e. gitignored)
    config.RegisterCommonOption('filemanager2', 'showignored', true)
    -- Let the user disable going to parent directory via left arrow key when file selected (not directory)
    config.RegisterCommonOption('filemanager2', 'compressparent', true)
    -- Let the user choose to list sub-folders first when listing the contents of a folder
    config.RegisterCommonOption('filemanager2', 'foldersfirst', true)
    -- Lets the user have the filetree auto-open any time Micro is opened
    -- false by default, as it's a rather noticeable user-facing change
    config.RegisterCommonOption('filemanager2', 'openonstart', false)
    -- Use nerd fonts icons
    config.RegisterCommonOption('filemanager2', 'nerdfonts', false)
    -- Shows the current file directory
    config.RegisterCommonOption('filemanager2', 'showcurrent', true)
    -- Use relative path is possible
    config.RegisterCommonOption('filemanager2', 'relativepath', true)
    -- Open on new tab?
    config.RegisterCommonOption('filemanager2', 'newtab', true)
    -- Default tree width
    config.RegisterCommonOption('filemanager2', 'treewidth', 30)
    config.RegisterCommonOption('filemanager2', 'lengthfactor', 0.3)
    -- Persistent filemanager
    config.RegisterCommonOption('filemanager2', 'persist', true)
    -- Show working directory path or not
    config.RegisterCommonOption('filemanager2', 'workingdir', true)
    -- Expand instead of changing directory when clicking on directory
    config.RegisterCommonOption('filemanager2', 'clickexpand', true)
    
    -- Use file icon in status bar
    micro.SetStatusInfoFn('filemanager2.FileIcon')

    -- Open/close the tree view
    config.MakeCommand('tree', toggle_tree, config.NoComplete)
    -- Rename the file/dir under the cursor
    config.MakeCommand('rename', rename_at_cursor, config.NoComplete)
    -- Create a new file
    config.MakeCommand('touch', new_file, config.NoComplete)
    -- Create a new dir
    config.MakeCommand('mkdir', new_dir, config.NoComplete)
    -- Delete a file/dir, and anything contained in it if it's a dir
    config.MakeCommand('rm', prompt_delete_at_cursor, config.NoComplete)
    -- Copy the file/dir under the cursor
    config.MakeCommand('cp', copy, config.NoComplete)
    
    -- Adds colors to the ".." and any dir's in the tree view via syntax highlighting
    -- TODO: Change it to work with git, based on untracked/changed/added/whatever
    config.AddRuntimeFile('filemanager2', config.RTSyntax, 'syntax/filemanager2.yaml')

    tree_width = config.GetGlobalOption('filemanager2.treewidth')
    line_length_factor = config.GetGlobalOption('filemanager2.lengthfactor')

    -- NOTE: This must be below the syntax load command or coloring won't work
    -- Just auto-open if the option is enabled
    -- This will run when the plugin first loads
    if config.GetGlobalOption('filemanager2.openonstart') then
        -- Check for safety on the off-chance someone's init.lua breaks this
        if tree_view == nil then
            open_tree()
            -- Puts the cursor back in the empty view that initially spawns
            -- This is so the cursor isn't sitting in the tree view at startup
            micro.CurPane():NextSplit()
        else
            -- Log error so they can fix it
            micro.Log(
                'Warning: filemanager2.openonstart was enabled, but somehow the tree was already open so the option was ignored.'
            )
        end
    end
end