cube-cli 0.3.0__tar.gz → 0.4.1__tar.gz

{cube_cli-0.3.0 → cube_cli-0.4.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cube-cli
-Version: 0.3.0
-Summary: A CLI application for interacting with cube_model
+Version: 0.4.1
+Summary: A CLI application for the 3x3x3 cube
 Requires-Python: >=3.13,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13

{cube_cli-0.3.0 → cube_cli-0.4.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "cube-cli"
-version = "0.3.0"
-description = "A CLI application for interacting with cube_model"
+version = "0.4.1"
+description = "A CLI application for the 3x3x3 cube"
 authors = []
 readme = "README.md"
 repository = "https://github.com/ygale/cube-cli"
@@ -16,7 +16,7 @@ cube = "cube_cli.main:main"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0"
-mypy = "^1.10"
+mypy = ">=1.10,<3.0"
 
 [build-system]
 requires = ["poetry-core"]

{cube_cli-0.3.0 → cube_cli-0.4.1}/src/cube_cli/command.py

@@ -2,13 +2,14 @@
 import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Self
+from typing import ClassVar, Self
 
 from cube_model import Color, Cube, Side, shuffled, solved
 from cube_model.action import Action, ParseError, act, parse_actions
 from cube_model.navigation import all_colors, side_color
 
 from .repl_state import (
+  Alias,
   Exit,
   LoadError,
   ReplState,
@@ -61,13 +62,24 @@ class Command(ABC):
     '''Execute the command against the given REPL state.'''
 
 @dataclass
-class Shuffle(Command):
+class Tabbable:
+  '''Mixin for commands that can be tab-completed in the REPL.'''
+  aliases: ClassVar[list[Alias]] = []
+
+  @classmethod
+  def match(cls, inp: str) -> bool:
+    '''Return True if inp equals the name of one of cls's aliases.'''
+    return any(inp == alias.name for alias in cls.aliases)
+
+@dataclass
+class Shuffle(Tabbable, Command):
   '''Randomize the cube.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='shuffle', min_chars=2)]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return a Shuffle if cmd is "shuffle".'''
-    if cmd == 'shuffle':
+    '''Return a Shuffle if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 
@@ -81,13 +93,14 @@ class Shuffle(Command):
     return None
 
 @dataclass
-class Solve(Command):
+class Solve(Tabbable, Command):
   '''Return the cube to its solved state.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='solve', min_chars=2)]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return a Solve if cmd is "solve".'''
-    if cmd == 'solve':
+    '''Return a Solve if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 
@@ -101,8 +114,9 @@ class Solve(Command):
     return None
 
 @dataclass
-class Load(Command):
+class Load(Tabbable, Command):
   '''Load cube state from a file.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='load', min_chars=2)]
   filename: str | None
 
   @classmethod
@@ -135,8 +149,9 @@ class Load(Command):
     return None
 
 @dataclass
-class Save(Command):
+class Save(Tabbable, Command):
   '''Save cube state to a file.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='save', min_chars=2)]
   filename: str | None
 
   @classmethod
@@ -166,13 +181,14 @@ class Save(Command):
     return None
 
 @dataclass
-class Undo(Command):
+class Undo(Tabbable, Command):
   '''Undo the last command.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='undo', min_chars=2)]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return an Undo if cmd is "undo".'''
-    if cmd == 'undo':
+    '''Return an Undo if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 
@@ -192,13 +208,14 @@ class Undo(Command):
     return None
 
 @dataclass
-class Redo(Command):
+class Redo(Tabbable, Command):
   '''Redo the last undone command.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='redo', min_chars=4)]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return a Redo if cmd is "redo".'''
-    if cmd == 'redo':
+    '''Return a Redo if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 
@@ -218,13 +235,14 @@ class Redo(Command):
     return None
 
 @dataclass
-class Quit(Command):
+class Quit(Tabbable, Command):
   '''Exit the REPL.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='quit'), Alias(name='q')]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return a Quit if cmd is "quit" or "q".'''
-    if cmd in ('quit', 'q'):
+    '''Return a Quit if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 
@@ -271,13 +289,14 @@ Commands:
   quit, q     Exit cube.'''
 
 @dataclass
-class Help(Command):
+class Help(Tabbable, Command):
   '''Print a summary of available commands.'''
+  aliases: ClassVar[list[Alias]] = [Alias(name='help'), Alias(name='?')]
 
   @classmethod
   def parse(cls, cmd: str) -> Self | None:
-    '''Return a Help if cmd is "help" or "?".'''
-    if cmd in ('help', '?'):
+    '''Return a Help if cmd matches one of its aliases.'''
+    if cls.match(cmd):
       return cls()
     return None
 

{cube_cli-0.3.0 → cube_cli-0.4.1}/src/cube_cli/repl.py

@@ -3,11 +3,56 @@ import readline
 
 from cube_model import Cube, solved
 
-from .command import Command, Quit, all_commands
+from .command import Command, Quit, Tabbable, all_commands
 from .print import print_cube
-from .repl_state import Exit, LoadError, ReplState
+from .repl_state import Alias, Exit, LoadError, ReplState
 from .save_load import SaveError, load
 
+# All tab completion candidates
+_COMPLETIONS: list[str] = sorted(a.name
+  for c in all_commands if issubclass(c, Tabbable)
+  for a in c.aliases)
+
+# Do not tab complete if it might be a Move.
+# Avoid comprehension due to mypy bug.
+_NON_COMPLETIONS: set[str] = set()
+cmd: type[Command]
+alias: Alias
+for cmd in all_commands:
+  if issubclass(cmd, Tabbable):
+    for alias in cmd.aliases:
+      if alias.min_chars > 1:
+        _NON_COMPLETIONS.add(alias.name[:alias.min_chars - 1])
+
+# Cached tab completion candidates for a specific input text
+_matches: list[str] = []
+
+def _complete(text: str, state: int) -> str | None:
+  '''Readline completer for REPL commands.
+
+  Matches text against _COMPLETIONS case-insensitively, always
+  returning lower-case completions. Returns no completions at all
+  if text is a prefix of any entry in _NON_COMPLETIONS.
+  '''
+  global _matches
+  text_lower: str = text.lower()
+  if state == 0:
+    if any(nc.startswith(text_lower) for nc in _NON_COMPLETIONS):
+      _matches = []
+    else:
+      _matches = [c for c in _COMPLETIONS if c.startswith(text_lower)]
+  if state < len(_matches):
+    return _matches[state]
+  return None
+
+def _setup_readline() -> None:
+  '''Register the REPL's tab completer with readline.'''
+  readline.set_completer(_complete)
+  if readline.__doc__ is not None and 'libedit' in readline.__doc__:
+    readline.parse_and_bind('bind ^I rl_complete')
+  else:
+    readline.parse_and_bind('tab: complete')
+
 def parse_command(inp: str) -> Command | None:
   '''Try each command type in order; return the first match.'''
   cmd_type: type[Command]
@@ -35,6 +80,7 @@ def repl(filename: str | None) -> None:
   If filename is given, load it as the initial cube state. If the
   load fails, fall back to a solved cube and report the error.
   '''
+  _setup_readline()
   cmd: Command | None
   rs: ReplState = _initial_state(filename)
   while True:
@@ -53,6 +99,7 @@ def repl(filename: str | None) -> None:
       inp: str = input(
         'Command (? for help, q to quit): ').strip()
     except EOFError:
+      print()
       cmd = Quit()
     else:
       cmd = parse_command(inp)

{cube_cli-0.3.0 → cube_cli-0.4.1}/src/cube_cli/repl_state.py

@@ -21,6 +21,16 @@ class LoadError:
   filename: str
   msg: str
 
+@dataclass
+class Alias:
+  '''A name by which a Tabbable command can be invoked in the REPL.
+
+  min_chars is the minimum number of characters of name that must
+  be typed before tab completion will offer it.
+  '''
+  name: str
+  min_chars: int = 1
+
 def _invert_action(action: Action) -> Action:
   '''Return the inverse of a single action.