Skip to content

autocompletions

CompletionType

Constants for common completion types

Source code in /home/runner/work/arc/arc/arc/autocompletions.py 
46
47
48
49
50
51
52
53
class CompletionType:
    """Constants for common completion types"""

    FILE = "file"
    DIR = "dir"
    USERS = "users"
    GROUPS = "groups"
    PLAIN = "plain"

ShellCompletion

Source code in /home/runner/work/arc/arc/arc/autocompletions.py 
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
class ShellCompletion:
    template: t.ClassVar[str]
    shells: dict[str, type["ShellCompletion"]] = {}

    def __init__(self, command: Command, info: CompletionInfo):
        self.command = command
        self.info = info
        self.command_name = self.command.name

    def __init_subclass__(cls, name: str) -> None:
        ShellCompletion.shells[name] = cls

    @property
    def completion_vars(self) -> dict[str, t.Any]:
        return {
            "name_exe": "python cli.py"
            if os.getenv("ARC_DEVELOPMENT")
            else self.command_name,
            "name_com": self.command_name,
            "func_name": f"_{self.command_name}_completions".replace("-", "_"),
            "completion_var": self.completion_var,
        }

    @property
    def completion_var(self) -> str:
        return f"_{self.command_name}_complete".upper().replace("-", "_")

    def should_complete(self) -> bool:
        return os.getenv(self.completion_var) is not None

    def source(self) -> str:
        """Returns the script for the paricular lanuage"""
        return self.template.format(**self.completion_vars)

    def complete(self) -> str:
        """Actually provides the completions"""
        return ""

    def format_completion(self, comp: Completion) -> str:
        return ""

    @classmethod
    def run(cls, shell: str, command: Command) -> str:
        info = CompletionInfo.from_env()
        if shell not in cls.shells:
            raise errors.ArgumentError(
                f"Unsupported shell: {shell}. "
                f"Supported shells: {Join.with_comma(cls.shells)}"
            )
        comp: ShellCompletion = cls.shells[shell](command, info)

        with open("completions.log", "w+") as f, redirect_stderr(f):
            res = comp.complete() if comp.should_complete() else comp.source()
            f.write("\n")
            f.write(" ".join(info.words))
            f.write("\n")
            f.write(res)
            f.write("\n\n")

        return res

complete()

Actually provides the completions

Source code in /home/runner/work/arc/arc/arc/autocompletions.py 
 98
 99
100
def complete(self) -> str:
    """Actually provides the completions"""
    return ""

source()

Returns the script for the paricular lanuage

Source code in /home/runner/work/arc/arc/arc/autocompletions.py 
94
95
96
def source(self) -> str:
    """Returns the script for the paricular lanuage"""
    return self.template.format(**self.completion_vars)

get_completions(obj, info, *args, **kwargs)

Gets the completions for a particular object that supports the CompletionProtocol

Source code in /home/runner/work/arc/arc/arc/autocompletions.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
def get_completions(
    obj: CompletionProtocol,
    info: CompletionInfo,
    *args: t.Any,
    **kwargs: t.Any,
) -> list[Completion]:
    """Gets the completions for a particular object that supports the `CompletionProtocol`"""
    comps = obj.__completions__(info, *args, **kwargs)
    if comps is None:
        comps = []
    else:
        comps = list(comps)
    return comps