CommandRegistry

Complexity

Total Complexity

17

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Importance

Changes	8
Bugs	2	Features	0

"""Available window-management commands"""
# Allow MyPy to work without depending on the `typing` package
# (And silence complaints from only using the imported types in comments)
try:
    # pylint: disable=unused-import
    from typing import (Any, Callable, Dict, Iterable, Iterator, List,  # NOQA
                        Optional, Sequence, Tuple, TYPE_CHECKING)
    from mypy_extensions import VarArg, KwArg  # NOQA

    if TYPE_CHECKING:
        from .wm import WindowManager  # NOQA
        from .util import CommandCB

    # FIXME: Replace */** with a dict so I can be strict here
    CommandCBWrapper = Callable[..., Any]

The name CommandCBWrapper does not conform to the constant naming conventions ((([A-Z_][A-Z0-9_]*)|(__.*__))$).

except:  # pylint: disable=bare-except
    pass

This except handler seems to be unused and could be removed.

class CommandRegistry(object):
    """Handles lookup and boilerplate for window management commands.

    Separated from WindowManager so its lifecycle is not tied to a specific
    GDK Screen object.
    """

    extra_state = {}  # type: Dict[str, Any]

    def __init__(self):     # type: () -> None
        self.commands = {}  # type: Dict[str, CommandCBWrapper]
        self.help = {}      # type: Dict[str, str]

    def __iter__(self):  # type: () -> Iterator[str]
        for x in self.commands:

The name x does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

            yield x

    def __str__(self):   # type: () -> str
        return fmt_table(self.help, ('Known Commands', 'desc'), group_by=1)

    def add(self, name, *p_args, **p_kwargs):
        # type: (str, *Any, **Any) -> Callable[[CommandCB], CommandCB]
        # TODO: Rethink the return value of the command function.
        """Decorator to wrap a function in boilerplate and add it to the
            command registry under the given name.

            @param name: The name to know the command by.
            @param p_args: Positional arguments to prepend to all calls made
                via C{name}.
            @param p_kwargs: Keyword arguments to prepend to all calls made
                via C{name}.

            @type name: C{str}
            """

        def decorate(func):  # type: (CommandCB) -> CommandCB
            """Closure used to allow decorator to take arguments"""
            @wraps(func)
            # pylint: disable=missing-docstring
            def wrapper(winman, window=None, *args, **kwargs):
                # TODO: Add a MyPy type signature

                # Get Wnck and GDK window objects
                window = window or winman.screen.get_active_window()
                if isinstance(window, gtk.gdk.Window):
                    win = wnck.window_get(window.xid)  # pylint: disable=E1101
                else:
                    win = window

                # pylint: disable=no-member
                if not win:
                    logging.debug("Received no window object to manipulate.")
                    return None
                elif win.get_window_type() == wnck.WINDOW_DESKTOP:
                    logging.debug("Received desktop window object. Ignoring.")
                    return None
                else:
                    # FIXME: Make calls to win.get_* lazy in case --debug
                    #        wasn't passed.
                    logging.debug("Operating on window 0x%x with title \"%s\" "
                                  "and geometry %r",
                                  win.get_xid(), win.get_name(),
                                  win.get_geometry())

                monitor_id, monitor_geom = winman.get_monitor(window)

                use_area, use_rect = winman.workarea.get(monitor_geom)

                # TODO: Replace this MPlayer safety hack with a properly
                #       comprehensive exception catcher.
                if not use_rect:
                    logging.debug("Received a worthless value for largest "
                                  "rectangular subset of desktop (%r). Doing "
                                  "nothing.", use_rect)
                    return None

                state = {}
                state.update(self.extra_state)
                state.update({
                    "cmd_name": name,
                    "monitor_id": monitor_id,
                    "monitor_geom": monitor_geom,
                    "usable_region": use_area,
                    "usable_rect": use_rect,
                })

                args, kwargs = p_args + args, dict(p_kwargs, **kwargs)
                func(winman, win, state, *args, **kwargs)

            if name in self.commands:
                logging.warn("Redefining existing command: %s", name)
            self.commands[name] = wrapper

            assert func.__doc__, ("Command must have a docstring: %r" % func)
            help_str = func.__doc__.strip().split('\n')[0].split('. ')[0]
            self.help[name] = help_str.strip('.')

            # Return the unwrapped function so decorators can be stacked
            # to define multiple commands using the same code with different
            # arguments
            return func
        return decorate