i.lua - Run a command in a specified directory, then restore cwd

[chrisant996]

This script requires Clink v1.3.13, which adds some new features that make this script possible.

The script adds a new i command that can be typed at the command line (but cannot be used in batch scripts).
The name "i" is short for "in": i dir program args means "in dir, run program args".

The script operates by:

• Internally invoking "pushd dir" to save cwd and change to dir.
• Running "program args".
• Internally invoking "popd" to restore the original current directory.

For convenience, match completion is relative to the specified dir!
So, for example, i .. notepad Tab completes files from ..\, even though .. isn't the current directory yet.

i.lua -- last updated 3/31/2022

-- This script requires Clink v1.3.13 or higher.
--
-- This adds a new command that can be typed at the command line (the command
-- does not work in batch scripts):
--
--      i {dir} {command}
--
-- It runs {command} in {dir}, restoring the current directory afterwards.

if (clink.version_encoded or 0) < 10030013 then
    return
end

--------------------------------------------------------------------------------
-- Customization.
--
-- i_commands
--      You can set the `i_commands` global variable to a list of command names.
--      The `i` behavior will be assigned to each of the command names.
--
--      For example, you might want both `i` and `in` to work:
--          i_commands = "i in"
--
-- i_colors
--      You can set the `i_colors` global variable to a table of color
--      definitions.
--
--          i_colors[true] = Color definition for directory.
--          i_colors[false] = Color definition for not a directory.
--
--      Each color definition is a table with up to two optional fields:
--          i_colors[true] = { name="name of color setting", color="ANSI SGR code" }
--
--      If both name and color are present, then color is appended to the color
--      value fetched by the color setting name.

i_commands = i_commands or "i"

i_colors = i_colors or {
    [true] =    { name="color.executable", color=";4" },
    [false] =   { name="color.unrecognized", color=";4" },
}

--------------------------------------------------------------------------------
-- Functions.

local function i_getcolor(isdir)
    local color = i_colors[isdir]
    if not color then
        return
    end

    local sgr
    if color.name then
        sgr = settings.get(color.name)
    end
    if color.color then
        sgr = (sgr or "")..color.color
    end
    return sgr
end

local i_color
local i_append_color = ";4"

local function i_getdir(line)
    -- Check for "i" command.
    local candidate = line:match("^[ \t]*([^ \t]+)[ \t]+")
    if not candidate then
        return
    end
    local commands = string.explode(i_commands or "i")
    local command_name
    for _,name in ipairs(commands) do
        if candidate == name then
            command_name = name
        end
    end
    if not command_name then
        return
    end
    line = line:gsub("^[ \t]*[^ \t]+[ \t]+", "")

    -- Get dir argument.
    local dir
    if line:sub(1) == '"' then
        dir = line:match("^\"([^\"]+)\"[ \t]*")
        if dir then
            line = line:gsub("^\"[^\"]+\"[ \t]*", "")
        end
    else
        dir = line:match("^([^ \t]+)[ \t]*")
        line = line:gsub("^[^ \t]+[ \t]*", "")
    end

    return dir, line
end

local function i_filter(line)
    local dir
    dir, line = i_getdir(line)
    if not dir then
        return
    end

    -- Check for help flag.
    if dir == "-?" or dir == "--help" then
        print("Runs a command in a directory, restoring the current directory afterwards.")
        print()
        print(clink.upper(command_name).." dir command")
        print()
        print("  dir       Change to dir.")
        print("  command   Command to run in dir.")
        return "", false
    end

    -- Get dir argument.
    if not os.isdir(dir) then
        print('"'..dir..'" is not a directory.')
        return "", false
    end

    -- Return the adjusted command line.
    local lines = {
        " pushd \""..dir.."\" >nul",
        line,
        " popd >nul",
    }
    return lines, false
end

local function i_ondir(arg_index, word, word_index, line_state)
    local info = line_state:getwordinfo(word_index)
    if info and info.offset + info.length < line_state:getcursor() then
        os.chdir(word)
    end
end

local function i_classify(arg_index, word, word_index, line_state, classifications)
    if arg_index == 1 and word ~= "" then
        local color = i_getcolor(os.isdir(word))
        if color and color ~= "" then
            local info = line_state:getwordinfo(word_index)
            classifications:applycolor(info.offset, info.length, color)
        end
    end
end

clink.onfilterinput(i_filter)

clink.argmatcher(table.unpack(string.explode(i_commands or "i")))
:addarg({onarg=i_ondir, clink.dirmatches})
:addflags("-?", "--help")
:setclassifier(i_classify)
:chaincommand()

[pukkandan]

Thanks for this! Not specifically for this script, but more for the idea...

I believe I can modify this to implement a "retry" command (retry cmd runs cmd till exit code is 0). I currently use a script for this, but the command has to be escaped properly for that to work. This method will allow me to completely bypass the need for escaping

[pukkandan]

but without displaying the prompt or the command

This is not really a concern. It's ok if the prompt/command is shown again

also if you set up a loop via handling Lua events, then there is the question about how to interrupt the loop. I.e. Ctrl+C wouldn't be able to interrupt it

This can be a deal breaker. I am thinking some keybinding can be used to toggle a variable that tells the loop to stop running, and also send a ctrl+c to the currently running command. Also, if I remember right (typing from phone rn), ctrl+break always issues a specific error code, so we could watch for that

[chrisant996]

but without displaying the prompt or the command

This is not really a concern. It's ok if the prompt/command is shown again

In that case, you can do it already.

[UPDATED]

The onfilterinput would need to be something similar to this:

local retry
clink.onfilterinput(function (line)
    if not retry then
        -- Check for `retry blahblah` command.
        if line:match("^[ \t]*retry[ \t]+") then
            retry = line:gsub("^([ \t]*retry[ \t]+)", "")
        end
    end
    if retry then
        -- If there's a command to retry, return it now.
        return retry, false
    end
end)

clink.onbeginedit(function ()
    if retry then
        if os.geterrorlevel() ~= 0 then
            -- Non-zero exit code?  Then send Enter key, without clearing `retry`.
            return "sendenterkey.bat", false
        else
            retry = nil
        end
    end
end)

And the sendenterkey.bat would be something similar to this:

@if (@CodeSection == @Batch) @then
::===============  Batch Part  ======================
@echo off
cscript //nologo //E:JScript "%~F0"
goto :EOF
//=============== JScript Part ======================
@end
var WshShell = WScript.CreateObject("WScript.Shell");
WshShell.SendKeys("{ENTER}");
WshShell.Quit;

But it will misbehave if keys/lines are already queued ahead of the {ENTER}.

also if you set up a loop via handling Lua events, then there is the question about how to interrupt the loop. I.e. Ctrl+C wouldn't be able to interrupt it

This can be a deal breaker. I am thinking some keybinding can be used to toggle a variable that tells the loop to stop running, and also send a ctrl+c to the currently running command. Also, if I remember right (typing from phone rn), ctrl+break always issues a specific error code, so we could watch for that

That cannot be hooked up in a generalized way that always works, because it relies on scripts doing special actions themselves. Also, it would create a big problem for keeping input and queued lines and $T macro lines all happening in the correct order. Because you're suggesting that some key bindings would "jump the queue", or maybe clear everything else queued ahead of them. So would there be a special magic key binding command to "throw away all queued keys and queued keyboard macros and queued command lines and queued $T strings"? Or would it only throw away certain things, etc.

What I will investigate this weekend is the possibility of hooking up Ctrl+Break to do asynchronous interruptions (Ctrl+C won't work reliably for that, due to how console input works, since in order to handle key binding support it's necessary to turn off built-in "input processing".

[pukkandan]

Turns out we were overthinking the whole issue. We can capture the whole line in lua, quote it and pass it to an actual script.

local REPEAT = 'repeat.py'
local REPEAT_CMD = 'python.exe D:\\Programs\\Scripts\\' .. REPEAT
local PASSTHROUGH = {
    ['retry']  = REPEAT_CMD .. ' -0',
    ['repeat'] = REPEAT_CMD,
}

local function quote_arg(arg)
    return '"' .. arg:gsub('(\\+)"', '%1%1"'):gsub('"', '""') .. '"'
end

local function split_cmd(line)
    local candidate = line:match('^[ \t]*([^ \t]+)[ \t]+')
    if not candidate then
        return
    end
    local cmd
    for key, value in pairs(PASSTHROUGH) do
        if value and candidate == key then
            cmd = value
        end
    end
    if not cmd then
        return
    end
    line = line:gsub('^[ \t]*[^ \t]+[ \t]+', '')
    return cmd, line
end

clink.onfilterinput(function (line)
    cmd, line = split_cmd(line)
    if not cmd then
        return
    end
    cmd = cmd .. ' ' .. quote_arg(line)
    print('Calling: ' .. cmd)
    return {cmd}, false
end)


clink.argmatcher(REPEAT)
    :addflags('-q', '-h', '-b', '-0', '--quiet', '--till-success')
    :addarg()
for key, _ in pairs(PASSTHROUGH) do
    clink.argmatcher(key):chaincommand()
end

I did not want to bother with escaping the command to be compatible with call. So I replaced the retry.cmd with a simple python script instead

import argparse
import subprocess


def parse_args(args=None):
    parser = argparse.ArgumentParser(description='Repeat a command')
    parser.add_argument('command', metavar='CMD', help='The command to run')
    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true', help='Do not print to console')
    parser.add_argument('-0', '--till-success', dest='till', action='store_const', const='success',
                        help='Repeat the command only until it succeeds')
    return parser.parse_args(args)


def NO_OP(*_, **__):
    pass


def main():
    """Retry a command till it succeeds"""
    args = parse_args()
    out = NO_OP if args.quiet else print

    while True:
        out(f'Running: {args.command}')
        proc = subprocess.Popen(args.command)
        try:
            proc.communicate()
            return_code = proc.returncode
        except KeyboardInterrupt:
            return_code = 0xc000013a
        if args.till == 'success':
            if not return_code:
                return
            out(f'Command failed with error code {return_code}. Retrying...\n')
        else:
            assert args.till is None
            out(f'Command exited with error code {return_code}\n')


if __name__ == '__main__':
    raise SystemExit(main())

Edit: updated scripts

[chrisant996]

Oh! Haha, yes, so true. Nice job. 😎

[chrisant996]

v1.3.18 will have clink.onprovideline() which can be used to return a command string that will be used immediately, without invoking the input line editor. And Ctrl-Break is able to interrupt infinite loops that may result from mistakes in scripts.

[chrisant996]

The i.lua script is now part of clink-gizmos.