"""Strip styles if disallowed by ru.ALLOW_STYLE. Otherwise return an ANSI object.

# We only use prompt-toolkit to write to a terminal. Therefore

# we only have to check if ALLOW_STYLE is Never.

if ru.ALLOW_STYLE == ru.AllowStyle.NEVER:

raw_text = text.value if isinstance(text, ANSI) else text

return su.strip_style(raw_text)

# String must be an ANSI object for prompt-toolkit to render ANSI style sequences.

"""Completer that delegates to cmd2's completion logic."""

def __init__(

self,

cmd_app: 'Cmd',

custom_settings: utils.CustomCompletionSettings | None = None,

) -> None:

"""Initialize prompt_toolkit based completer class."""

self.cmd_app = cmd_app

self.custom_settings = custom_settings

def get_completions(self, document: Document, _complete_event: object) -> Iterable[Completion]:

"""Get completions for the current input."""

# Find the beginning of the current word based on delimiters

line = document.text

cursor_pos = document.cursor_position

# Define delimiters for completion to match cmd2/readline behavior

delimiters = BASE_DELIMITERS

delimiters += "".join(self.cmd_app.statement_parser.terminators)

# Find last delimiter before cursor to determine the word being completed

begidx = 0

for i in range(cursor_pos - 1, -1, -1):

if line[i] in delimiters:

begidx = i + 1

break

endidx = cursor_pos

text = line[begidx:endidx]

completions = self.cmd_app.complete(

text, line=line, begidx=begidx, endidx=endidx, custom_settings=self.custom_settings

)

if completions.completion_error:

print_formatted_text(pt_filter_style(completions.completion_error))

return

# Print completion table if present

if completions.completion_table:

print_formatted_text(pt_filter_style("\n" + completions.completion_table))

# Print hint if present and settings say we should

if completions.completion_hint and (self.cmd_app.always_show_hint or not completions):

print_formatted_text(pt_filter_style(completions.completion_hint))

if not completions:

return

# The length of the user's input minus any shortcut.

search_text_length = len(text) - completions._search_text_offset

# If matches require quoting but the word isn't quoted yet, we insert the

# opening quote directly into the buffer. We do this because if any completions

# change text before the cursor (like prepending a quote), prompt-toolkit will

# not return a common prefix to the command line. By modifying the buffer

# and returning early, we trigger a new completion cycle where the quote

# is already present, allowing for proper common prefix calculation.

if completions._add_opening_quote and search_text_length > 0:

buffer = get_app().current_buffer

buffer.cursor_left(search_text_length)

buffer.insert_text(completions._quote_char)

buffer.cursor_right(search_text_length)

return

# Return the completions

for item in completions:

# Set offset to the start of the current word to overwrite it with the completion

start_position = -len(text)

match_text = item.text

# If we need a quote but didn't interrupt (because text was empty),

# prepend the quote here so it's included in the insertion.

if completions._add_opening_quote:

match_text = (

match_text[: completions._search_text_offset]

+ completions._quote_char

+ match_text[completions._search_text_offset :]

)

# Finalize if there's only one match

if len(completions) == 1 and completions.allow_finalization:

# Close any open quote

if completions._quote_char:

match_text += completions._quote_char

# Add trailing space if the cursor is at the end of the line

if endidx == len(line):

match_text += " "

yield Completion(

match_text,

start_position=start_position,

display=pt_filter_style(item.display),

display_meta=pt_filter_style(item.display_meta),

"""A non-persistent, in-memory history buffer for prompt-toolkit.

def __init__(self, history_strings: Iterable[str] | None = None) -> None:

"""Initialize the instance."""

super().__init__()

if history_strings:

for string in history_strings:

self.append_string(string)

# Mark that self._loaded_strings is populated.

self._loaded = True

def append_string(self, string: str) -> None:

"""Override to filter our consecutive duplicates."""

# History is sorted newest to oldest, so we compare to the first element.

if string and (not self._loaded_strings or self._loaded_strings[0] != string):

super().append_string(string)

def store_string(self, string: str) -> None:

"""No-op: Persistent history data is stored in cmd_app.history."""

def load_history_strings(self) -> Iterable[str]:

"""Yield strings from newest to oldest."""

yield from self._loaded_strings

def clear(self) -> None:

"""Clear the UI history navigation data."""

"""Lexer that highlights cmd2 command names, aliases, and macros."""

def __init__(

self,

cmd_app: 'Cmd',

command_color: str = 'ansigreen',

alias_color: str = 'ansicyan',

macro_color: str = 'ansimagenta',

flag_color: str = 'ansired',

argument_color: str = 'ansiyellow',

) -> None:

"""Initialize the Lexer.

super().__init__()

self.cmd_app = cmd_app

self.command_color = command_color

self.alias_color = alias_color

self.macro_color = macro_color

self.flag_color = flag_color

self.argument_color = argument_color

def lex_document(self, document: Document) -> Callable[[int], Any]:

"""Lex the document."""

# Get redirection tokens and terminators to avoid highlighting them as values

exclude_tokens = set(constants.REDIRECTION_TOKENS)

exclude_tokens.update(self.cmd_app.statement_parser.terminators)

arg_pattern = re.compile(r'(\s+)|(--?[^\s\'"]+)|("[^"]*"?|\'[^\']*\'?)|([^\s\'"]+)')

def highlight_args(text: str, tokens: list[tuple[str, str]]) -> None:

"""Highlight arguments in a string."""

for m in arg_pattern.finditer(text):

space, flag, quoted, word = m.groups()

match_text = m.group(0)

if space:

tokens.append(('', match_text))

elif flag:

tokens.append((self.flag_color, match_text))

elif (quoted or word) and match_text not in exclude_tokens:

tokens.append((self.argument_color, match_text))

else:

tokens.append(('', match_text))

def get_line(lineno: int) -> list[tuple[str, str]]:

"""Return the tokens for the given line number."""

line = document.lines[lineno]

tokens: list[tuple[str, str]] = []

# No syntax highlighting if styles are disallowed

if ru.ALLOW_STYLE == ru.AllowStyle.NEVER:

tokens.append(('', line))

return tokens

# Only attempt to match a command on the first line

if lineno == 0:

# Use cmd2's command pattern to find the first word (the command)

match = self.cmd_app.statement_parser._command_pattern.search(line)

if match:

# Group 1 is the command, Group 2 is the character(s) that terminated the command match

command = match.group(1)

cmd_start = match.start(1)

cmd_end = match.end(1)

# Add any leading whitespace

if cmd_start > 0:

tokens.append(('', line[:cmd_start]))

if command:

# Determine the style for the command

shortcut_found = False

for shortcut, _ in self.cmd_app.statement_parser.shortcuts:

if command.startswith(shortcut):

# Add the shortcut with the command style

tokens.append((self.command_color, shortcut))

# If there's more in the command word, it's an argument

if len(command) > len(shortcut):

tokens.append((self.argument_color, command[len(shortcut) :]))

shortcut_found = True

break

if not shortcut_found:

style = ''

if command in self.cmd_app.get_all_commands():

style = self.command_color

elif command in self.cmd_app.aliases:

style = self.alias_color

elif command in self.cmd_app.macros:

style = self.macro_color

# Add the command with the determined style

tokens.append((style, command))

# Add the rest of the line as arguments

if cmd_end < len(line):

highlight_args(line[cmd_end:], tokens)

else:

# No command match found on the first line

tokens.append(('', line))

else:

# All other lines are treated as arguments

highlight_args(line, tokens)

return tokens