Merge pull request #648 from python-cmd2/attributes

Converted class attributes to instance attributes

Author: tleonhardt

CHANGELOG.md

@@ -1,4 +1,4 @@
-## 0.9.12 (TBD, 2019)
+## 0.9.12 (March TBD, 2019)
 * Enhancements
     * Added ability to include command name placeholders in the message printed when trying to run a disabled command.
         * See docstring for ``disable_command()`` or ``disable_category()`` for more details.
@@ -15,7 +15,11 @@
         * ``do_help()`` - when no help information can be found
         * ``default()`` - in all cases since this is called when an invalid command name is run
         * ``_report_disabled_command_usage()`` - in all cases since this is called when a disabled command is run
-    * Removed *** from beginning of error messages printed by `do_help()` and `default()`.
+    * Removed *** from beginning of error messages printed by `do_help()` and `default()`
+    * Significantly refactored ``cmd.Cmd`` class so that all class attributes got converted to instance attributes, also:
+        * Added ``allow_redirection``, ``terminators``, ``multiline_commands``, and ``shortcuts`` as optional arguments 
+        to ``cmd.Cmd.__init__()`
+        * A few instance attributes were moved inside ``StatementParser`` and properties were created for accessing them
 
 ## 0.9.11 (March 13, 2019)
 * Bug Fixes

README.md

@@ -185,9 +185,9 @@ Instructions for implementing each feature follow.
 
 - Multi-line commands
 
-    Any command accepts multi-line input when its name is listed in `Cmd.multiline_commands`.
-    The program will keep expecting input until a line ends with any of the characters
-    in `Cmd.terminators` .  The default terminators are `;` and `/n` (empty newline).
+    Any command accepts multi-line input when its name is listed the `multiline_commands` optional argument to 
+    `cmd2.Cmd.__init`. The program will keep expecting input until a line ends with any of the characters listed in the 
+    `terminators` optional argument to `cmd2.Cmd.__init__()`  .  The default terminators are `;` and `/n` (empty newline).
 
 - Special-character shortcut commands (beyond cmd's "@" and "!")
 
@@ -239,14 +239,12 @@ class CmdLineApp(cmd2.Cmd):
     MUMBLE_LAST = ['right?']
 
     def __init__(self):
-        self.multiline_commands = ['orate']
         self.maxrepeats = 3
-
-        # Add stuff to shortcuts before calling base class initializer
-        self.shortcuts.update({'&': 'speak'})
+        shortcuts = dict(self.DEFAULT_SHORTCUTS)
+        shortcuts.update({'&': 'speak'})
 
         # Set use_ipython to True to enable the "ipy" command which embeds and interactive IPython shell
-        super().__init__(use_ipython=False)
+        super().__init__(use_ipython=False, multiline_commands=['orate'], shortcuts=shortcuts)
 
         # Make maxrepeats settable at runtime
         self.settable['maxrepeats'] = 'max repetitions for speak command'

cmd2/clipboard.py

@@ -10,7 +10,7 @@
 try:
     from pyperclip.exceptions import PyperclipException
 except ImportError:  # pragma: no cover
-    # noinspection PyUnresolvedReferences
+    # noinspection PyUnresolvedReferences,PyProtectedMember
     from pyperclip import PyperclipException
 
 # Can we access the clipboard?  Should always be true on Windows and Mac, but only sometimes on Linux

cmd2/cmd2.py

@@ -68,7 +68,7 @@
     if rl_type == RlType.PYREADLINE:
 
         # Save the original pyreadline display completion function since we need to override it and restore it
-        # noinspection PyProtectedMember
+        # noinspection PyProtectedMember,PyUnresolvedReferences
         orig_pyreadline_display = readline.rl.mode._display_completions
 
     elif rl_type == RlType.GNU:
@@ -104,6 +104,7 @@ def __subclasshook__(cls, C):
 
 # Python 3.4 require contextlib2 for temporarily redirecting stderr and stdout
 if sys.version_info < (3, 5):
+    # noinspection PyUnresolvedReferences
     from contextlib2 import redirect_stdout
 else:
     from contextlib import redirect_stdout
@@ -310,52 +311,14 @@ class Cmd(cmd.Cmd):
 
     Line-oriented command interpreters are often useful for test harnesses, internal tools, and rapid prototypes.
     """
-    # Attributes used to configure the StatementParser, best not to change these at runtime
-    multiline_commands = []
-    shortcuts = {'?': 'help', '!': 'shell', '@': 'load', '@@': '_relative_load'}
-    terminators = [constants.MULTILINE_TERMINATOR]
-
-    # Attributes which are NOT dynamically settable at runtime
-    allow_cli_args = True       # Should arguments passed on the command-line be processed as commands?
-    allow_redirection = True    # Should output redirection and pipes be allowed
-    default_to_shell = False    # Attempt to run unrecognized commands as shell commands
-    quit_on_sigint = False      # Quit the loop on interrupt instead of just resetting prompt
-    reserved_words = []
-
-    # Attributes which ARE dynamically settable at runtime
-    colors = constants.COLORS_TERMINAL
-    continuation_prompt = '> '
-    debug = False
-    echo = False
-    editor = os.environ.get('EDITOR')
-    if not editor:
-        if sys.platform[:3] == 'win':
-            editor = 'notepad'
-        else:
-            # Favor command-line editors first so we don't leave the terminal to edit
-            for editor in ['vim', 'vi', 'emacs', 'nano', 'pico', 'gedit', 'kate', 'subl', 'geany', 'atom']:
-                if utils.which(editor):
-                    break
-    feedback_to_output = False  # Do not include nonessentials in >, | output by default (things like timing)
-    locals_in_py = False
-    quiet = False  # Do not suppress nonessential output
-    timing = False  # Prints elapsed time for each command
-
-    # To make an attribute settable with the "do_set" command, add it to this ...
-    settable = {'colors': 'Allow colorized output (valid values: Terminal, Always, Never)',
-                'continuation_prompt': 'On 2nd+ line of input',
-                'debug': 'Show full error stack on error',
-                'echo': 'Echo command issued into output',
-                'editor': 'Program used by ``edit``',
-                'feedback_to_output': 'Include nonessentials in `|`, `>` results',
-                'locals_in_py': 'Allow access to your application in py via self',
-                'prompt': 'The prompt issued to solicit input',
-                'quiet': "Don't print nonessential feedback",
-                'timing': 'Report execution times'}
+    DEFAULT_SHORTCUTS = {'?': 'help', '!': 'shell', '@': 'load', '@@': '_relative_load'}
+    DEFAULT_EDITOR = utils.find_editor()
 
     def __init__(self, completekey: str = 'tab', stdin=None, stdout=None, persistent_history_file: str = '',
                  persistent_history_length: int = 1000, startup_script: Optional[str] = None, use_ipython: bool = False,
-                 transcript_files: Optional[List[str]] = None) -> None:
+                 transcript_files: Optional[List[str]] = None, allow_redirection: bool = True,
+                 multiline_commands: Optional[List[str]] = None, terminators: Optional[List[str]] = None,
+                 shortcuts: Optional[Dict[str, str]] = None) -> None:
         """An easy but powerful framework for writing line-oriented command interpreters, extends Python's cmd package.
 
         :param completekey: (optional) readline name of a completion key, default to Tab
@@ -366,6 +329,9 @@ def __init__(self, completekey: str = 'tab', stdin=None, stdout=None, persistent
         :param startup_script: (optional) file path to a a script to load and execute at startup
         :param use_ipython: (optional) should the "ipy" command be included for an embedded IPython shell
         :param transcript_files: (optional) allows running transcript tests when allow_cli_args is False
+        :param allow_redirection: (optional) should output redirection and pipes be allowed
+        :param multiline_commands: (optional) list of commands allowed to accept multi-line input
+        :param shortcuts: (optional) dictionary containing shortcuts for commands
         """
         # If use_ipython is False, make sure the do_ipy() method doesn't exit
         if not use_ipython:
@@ -384,31 +350,56 @@ def __init__(self, completekey: str = 'tab', stdin=None, stdout=None, persistent
         # Call super class constructor
         super().__init__(completekey=completekey, stdin=stdin, stdout=stdout)
 
+        # Attributes which should NOT be dynamically settable at runtime
+        self.allow_cli_args = True  # Should arguments passed on the command-line be processed as commands?
+        self.default_to_shell = False  # Attempt to run unrecognized commands as shell commands
+        self.quit_on_sigint = False  # Quit the loop on interrupt instead of just resetting prompt
+
+        # Attributes which ARE dynamically settable at runtime
+        self.colors = constants.COLORS_TERMINAL
+        self.continuation_prompt = '> '
+        self.debug = False
+        self.echo = False
+        self.editor = self.DEFAULT_EDITOR
+        self.feedback_to_output = False  # Do not include nonessentials in >, | output by default (things like timing)
+        self.locals_in_py = False
+        self.quiet = False  # Do not suppress nonessential output
+        self.timing = False  # Prints elapsed time for each command
+
+        # To make an attribute settable with the "do_set" command, add it to this ...
+        self.settable = {'colors': 'Allow colorized output (valid values: Terminal, Always, Never)',
+                         'continuation_prompt': 'On 2nd+ line of input',
+                         'debug': 'Show full error stack on error',
+                         'echo': 'Echo command issued into output',
+                         'editor': 'Program used by ``edit``',
+                         'feedback_to_output': 'Include nonessentials in `|`, `>` results',
+                         'locals_in_py': 'Allow access to your application in py via self',
+                         'prompt': 'The prompt issued to solicit input',
+                         'quiet': "Don't print nonessential feedback",
+                         'timing': 'Report execution times'}
+
         # Commands to exclude from the help menu and tab completion
         self.hidden_commands = ['eof', 'eos', '_relative_load']
 
         # Commands to exclude from the history command
         self.exclude_from_history = '''history edit eof eos'''.split()
 
         # Command aliases and macros
-        self.aliases = dict()
         self.macros = dict()
 
-        self._finalize_app_parameters()
-
         self.initial_stdout = sys.stdout
         self.history = History()
         self.pystate = {}
         self.py_history = []
         self.pyscript_name = 'app'
-        self.keywords = self.reserved_words + self.get_all_commands()
-        self.statement_parser = StatementParser(
-            allow_redirection=self.allow_redirection,
-            terminators=self.terminators,
-            multiline_commands=self.multiline_commands,
-            aliases=self.aliases,
-            shortcuts=self.shortcuts,
-        )
+
+        if shortcuts is None:
+            shortcuts = self.DEFAULT_SHORTCUTS
+        shortcuts = sorted(shortcuts.items(), reverse=True)
+        self.statement_parser = StatementParser(allow_redirection=allow_redirection,
+                                                terminators=terminators,
+                                                multiline_commands=multiline_commands,
+                                                shortcuts=shortcuts)
         self._transcript_files = transcript_files
 
         # Used to enable the ability for a Python script to quit the application
@@ -568,10 +559,25 @@ def visible_prompt(self) -> str:
         """
         return utils.strip_ansi(self.prompt)
 
-    def _finalize_app_parameters(self) -> None:
-        """Finalize the shortcuts"""
-        # noinspection PyUnresolvedReferences
-        self.shortcuts = sorted(self.shortcuts.items(), reverse=True)
+    @property
+    def aliases(self) -> Dict[str, str]:
+        """Read-only property to access the aliases stored in the StatementParser."""
+        return self.statement_parser.aliases
+
+    @property
+    def shortcuts(self) -> Tuple[Tuple[str, str]]:
+        """Read-only property to access the shortcuts stored in the StatementParser."""
+        return self.statement_parser.shortcuts
+
+    @property
+    def allow_redirection(self) -> bool:
+        """Getter for the allow_redirection property that determines whether or not redirection of stdout is allowed."""
+        return self.statement_parser.allow_redirection
+
+    @allow_redirection.setter
+    def allow_redirection(self, value: bool) -> None:
+        """Setter for the allow_redirection property that determines whether or not redirection of stdout is allowed."""
+        self.statement_parser.allow_redirection = value
 
     def decolorized_write(self, fileobj: IO, msg: str) -> None:
         """Write a string to a fileobject, stripping ANSI escape sequences if necessary
@@ -728,6 +734,7 @@ def reset_completion_defaults(self) -> None:
         if rl_type == RlType.GNU:
             readline.set_completion_display_matches_hook(self._display_matches_gnu_readline)
         elif rl_type == RlType.PYREADLINE:
+            # noinspection PyUnresolvedReferences
             readline.rl.mode._display_completions = self._display_matches_pyreadline
 
     def tokens_for_completion(self, line: str, begidx: int, endidx: int) -> Tuple[List[str], List[str]]:
@@ -1355,6 +1362,7 @@ def _display_matches_pyreadline(self, matches: List[str]) -> None:  # pragma: no
 
             # Print the header if one exists
             if self.completion_header:
+                # noinspection PyUnresolvedReferences
                 readline.rl.mode.console.write('\n' + self.completion_header)
 
             # Display matches using actual display function. This also redraws the prompt and line.
@@ -2203,6 +2211,7 @@ def _cmdloop(self) -> bool:
                     readline.set_completion_display_matches_hook(None)
                     rl_basic_quote_characters.value = old_basic_quotes
                 elif rl_type == RlType.PYREADLINE:
+                    # noinspection PyUnresolvedReferences
                     readline.rl.mode._display_completions = orig_pyreadline_display
 
             self.cmdqueue.clear()
@@ -2822,7 +2831,8 @@ def cmdenvironment(self) -> str:
         Commands may be terminated with: {}
         Arguments at invocation allowed: {}
         Output redirection and pipes allowed: {}"""
-        return read_only_settings.format(str(self.terminators), self.allow_cli_args, self.allow_redirection)
+        return read_only_settings.format(str(self.statement_parser.terminators), self.allow_cli_args,
+                                         self.allow_redirection)
 
     def show(self, args: argparse.Namespace, parameter: str = '') -> None:
         """Shows current settings of parameters.
@@ -3047,6 +3057,7 @@ def py_quit():
                     # Save cmd2 history
                     saved_cmd2_history = []
                     for i in range(1, readline.get_current_history_length() + 1):
+                        # noinspection PyArgumentList
                         saved_cmd2_history.append(readline.get_history_item(i))
 
                     readline.clear_history()
@@ -3079,6 +3090,7 @@ def py_quit():
                         if rl_type == RlType.GNU:
                             readline.set_completion_display_matches_hook(None)
                         elif rl_type == RlType.PYREADLINE:
+                            # noinspection PyUnresolvedReferences
                             readline.rl.mode._display_completions = self._display_matches_pyreadline
 
                         # Save off the current completer and set a new one in the Python console
@@ -3116,6 +3128,7 @@ def py_quit():
                         # Save py's history
                         self.py_history.clear()
                         for i in range(1, readline.get_current_history_length() + 1):
+                            # noinspection PyArgumentList
                             self.py_history.append(readline.get_history_item(i))
 
                         readline.clear_history()
@@ -3193,10 +3206,12 @@ def do_ipy(self, _: argparse.Namespace) -> None:
             exit_msg = 'Leaving IPython, back to {}'.format(sys.argv[0])
 
             if self.locals_in_py:
-                def load_ipy(self, app):
+                # noinspection PyUnusedLocal
+                def load_ipy(cmd2_instance, app):
                     embed(banner1=banner, exit_msg=exit_msg)
                 load_ipy(self, bridge)
             else:
+                # noinspection PyUnusedLocal
                 def load_ipy(app):
                     embed(banner1=banner, exit_msg=exit_msg)
                 load_ipy(bridge)
@@ -3598,6 +3613,7 @@ def async_alert(self, alert_msg: str, new_prompt: Optional[str] = None) -> None:
                 if rl_type == RlType.GNU:
                     sys.stderr.write(terminal_str)
                 elif rl_type == RlType.PYREADLINE:
+                    # noinspection PyUnresolvedReferences
                     readline.rl.mode.console.write(terminal_str)
 
                 # Redraw the prompt and input lines

cmd2/history.py

@@ -128,12 +128,12 @@ def get(self, index: Union[int, str]) -> HistoryItem:
     #    \s*$                          match any whitespace at the end of the input. This is here so
     #                                  you don't have to trim the input
     #
-    spanpattern = re.compile(r'^\s*(?P<start>-?[1-9]{1}\d*)?(?P<separator>:|(\.{2,}))?(?P<end>-?[1-9]{1}\d*)?\s*$')
+    spanpattern = re.compile(r'^\s*(?P<start>-?[1-9]\d*)?(?P<separator>:|(\.{2,}))?(?P<end>-?[1-9]\d*)?\s*$')
 
     def span(self, span: str) -> List[HistoryItem]:
         """Return an index or slice of the History list,
 
-        :param raw: string containing an index or a slice
+        :param span: string containing an index or a slice
         :return: a list of HistoryItems
 
         This method can accommodate input in any of these forms: