Remove support for ambiguous keybindings

doc/help/settings.asciidoc

@@ -191,7 +191,6 @@
|<<hints.uppercase,hints.uppercase>>|Make chars in hint strings uppercase.
|<<history_gap_interval,history_gap_interval>>|The maximum time in minutes between two history items for them to be considered being from the same browsing session.
|<<ignore_case,ignore_case>>|Find text on a page case-insensitively.
|<<input.ambiguous_timeout,input.ambiguous_timeout>>|Timeout (in milliseconds) for ambiguous key bindings.
|<<input.forward_unbound_keys,input.forward_unbound_keys>>|Forward unbound keys to the webview in normal mode.
|<<input.insert_mode.auto_leave,input.insert_mode.auto_leave>>|Leave insert mode if a non-editable element is clicked.
|<<input.insert_mode.auto_load,input.insert_mode.auto_load>>|Automatically enter insert mode if an editable element is focused after loading the page.
@@ -2050,13 +2049,6 @@ Valid values:

Default: +pass:[smart]+

[[input.ambiguous_timeout]]
== input.ambiguous_timeout
Timeout (in milliseconds) for ambiguous key bindings.
If the current input forms both a complete match and a partial match, the complete match will be executed after this time.

Default: +pass:[500]+

[[input.forward_unbound_keys]]
== input.forward_unbound_keys
Forward unbound keys to the webview in normal mode.

qutebrowser/config/configdata.yml

@@ -794,19 +794,6 @@ hints.uppercase:

## input

# FIXME:conf get rid of this?
input.ambiguous_timeout:
  default: 500
  type:
    name: Int
    minval: 0
    maxval: maxint
  desc: >-
    Timeout (in milliseconds) for ambiguous key bindings.

    If the current input forms both a complete match and a partial match, the complete
    match will be executed after this time.

input.forward_unbound_keys:
  default: auto
  type:

qutebrowser/keyinput/basekeyparser.py

@@ -20,7 +20,6 @@
"""Base class for vim-like key sequence parser."""

import re
import functools
import unicodedata

from PyQt5.QtCore import pyqtSignal, QObject
@@ -41,7 +40,6 @@ class BaseKeyParser(QObject):
            partial: No keychain matched yet, but it's still possible in the
                     future.
            definitive: Keychain matches exactly.
            ambiguous: There are both a partial and a definitive match.
            none: No more matches possible.

        Types: type of a key binding.
@@ -59,7 +57,6 @@ class BaseKeyParser(QObject):
        _warn_on_keychains: Whether a warning should be logged when binding
                            keychains in a section which does not support them.
        _keystring: The currently entered key sequence
        _ambiguous_timer: Timer for delayed execution with ambiguous bindings.
        _modename: The name of the input mode associated with this keyparser.
        _supports_count: Whether count is supported
        _supports_chains: Whether keychains are supported
@@ -78,16 +75,13 @@ class BaseKeyParser(QObject):
    do_log = True
    passthrough = False

    Match = usertypes.enum('Match', ['partial', 'definitive', 'ambiguous',
                                     'other', 'none'])
    Match = usertypes.enum('Match', ['partial', 'definitive', 'other', 'none'])
    Type = usertypes.enum('Type', ['chain', 'special'])

    def __init__(self, win_id, parent=None, supports_count=None,
                 supports_chains=False):
        super().__init__(parent)
        self._win_id = win_id
        self._ambiguous_timer = usertypes.Timer(self, 'ambiguous-match')
        self._ambiguous_timer.setSingleShot(True)
        self._modename = None
        self._keystring = ''
        if supports_count is None:
@@ -189,7 +183,6 @@ def _handle_single_key(self, e):
            self._debug_log("Ignoring, no text char")
            return self.Match.none

        self._stop_timers()
        key_mappings = config.val.bindings.key_mappings
        txt = key_mappings.get(txt, txt)
        self._keystring += txt
@@ -207,10 +200,6 @@ def _handle_single_key(self, e):
                self._keystring))
            self.clear_keystring()
            self.execute(binding, self.Type.chain, count)
        elif match == self.Match.ambiguous:
            self._debug_log("Ambiguous match for '{}'.".format(
                self._keystring))
            self._handle_ambiguous_match(binding, count)
        elif match == self.Match.partial:
            self._debug_log("No match for '{}' (added {})".format(
                self._keystring, txt))
@@ -230,11 +219,9 @@ def _match_key(self, cmd_input):

        Return:
            A tuple (matchtype, binding).
                matchtype: Match.definitive, Match.ambiguous, Match.partial or
                           Match.none
                binding: - None with Match.partial/Match.none
                         - The found binding with Match.definitive/
                           Match.ambiguous
                matchtype: Match.definitive, Match.partial or Match.none.
                binding: - None with Match.partial/Match.none.
                         - The found binding with Match.definitive.
        """
        # A (cmd_input, binding) tuple (k, v of bindings) or None.
        definitive_match = None
@@ -252,58 +239,13 @@ def _match_key(self, cmd_input):
            elif binding.startswith(cmd_input):
                partial_match = True
                break
        if definitive_match is not None and partial_match:
            return (self.Match.ambiguous, definitive_match[1])
        elif definitive_match is not None:
        if definitive_match is not None:
            return (self.Match.definitive, definitive_match[1])
        elif partial_match:
            return (self.Match.partial, None)
        else:
            return (self.Match.none, None)

    def _stop_timers(self):
        """Stop a delayed execution if any is running."""
        if self._ambiguous_timer.isActive() and self.do_log:
            log.keyboard.debug("Stopping delayed execution.")
        self._ambiguous_timer.stop()
        try:
            self._ambiguous_timer.timeout.disconnect()
        except TypeError:
            # no connections
            pass

    def _handle_ambiguous_match(self, binding, count):
        """Handle an ambiguous match.

        Args:
            binding: The command-string to execute.
            count: The count to pass.
        """
        self._debug_log("Ambiguous match for '{}'".format(self._keystring))
        time = config.val.input.ambiguous_timeout
        if time == 0:
            # execute immediately
            self.clear_keystring()
            self.execute(binding, self.Type.chain, count)
        else:
            # execute in `time' ms
            self._debug_log("Scheduling execution of {} in {}ms".format(
                binding, time))
            self._ambiguous_timer.setInterval(time)
            self._ambiguous_timer.timeout.connect(
                functools.partial(self.delayed_exec, binding, count))
            self._ambiguous_timer.start()

    def delayed_exec(self, command, count):
        """Execute a delayed command.

        Args:
            command/count: As if passed to self.execute()
        """
        self._debug_log("Executing delayed command now!")
        self.clear_keystring()
        self.execute(command, self.Type.chain, count)

    def handle(self, e):
        """Handle a new keypress and call the respective handlers.

tests/end2end/features/keyinput.feature

@@ -7,11 +7,13 @@ Feature: Keyboard input
    # :clear-keychain

    Scenario: Clearing the keychain
        When I run :bind foo message-error test12
        And I run :bind bar message-info test12-2
        And I press the keys "fo"
        When I run :bind ,foo message-error test12
        And I run :bind ,bar message-info test12-2
        And I press the keys ",fo"
        And I run :clear-keychain
        And I press the keys "bar"
        And I press the keys ",bar"
        And I run :unbind ,foo
        And I run :unbind ,bar
        Then the message "test12-2" should be shown

    # input.forward_unbound_keys

tests/unit/keyinput/test_basekeyparser.py

@@ -37,7 +37,6 @@ def keyparser(key_config_stub):
        0, supports_count=True, supports_chains=True)
    kp.execute = mock.Mock()
    yield kp
    assert not kp._ambiguous_timer.isActive()


@pytest.fixture
@@ -242,51 +241,15 @@ def test_0_press(self, handle_text, keyparser):
            'message-info 0', keyparser.Type.chain, None)
        assert keyparser._keystring == ''

    def test_ambiguous_keychain(self, qapp, handle_text, config_stub,
                                keyparser):
        config_stub.val.input.ambiguous_timeout = 100
        timer = keyparser._ambiguous_timer
        assert not timer.isActive()
        # We start with 'a' where the keychain gives us an ambiguous result.
        # Then we check if the timer has been set up correctly
        handle_text((Qt.Key_A, 'a'))
        assert not keyparser.execute.called
        assert timer.isSingleShot()
        assert timer.interval() == 100
        assert timer.isActive()
        # Now we type an 'x' and check 'ax' has been executed and the timer
        # stopped.
        handle_text((Qt.Key_X, 'x'))
        keyparser.execute.assert_called_once_with(
            'message-info ax', keyparser.Type.chain, None)
        assert not timer.isActive()
        assert keyparser._keystring == ''

    def test_ambiguous_keychain_no_timeout(self, handle_text, config_stub,
                                           keyparser):
        config_stub.val.input.ambiguous_timeout = 0
    def test_ambiguous_keychain(self, handle_text, keyparser):
        handle_text((Qt.Key_A, 'a'))
        assert keyparser.execute.called
        assert not keyparser._ambiguous_timer.isActive()

    def test_invalid_keychain(self, handle_text, keyparser):
        handle_text((Qt.Key_B, 'b'))
        handle_text((Qt.Key_C, 'c'))
        assert keyparser._keystring == ''

    def test_ambiguous_delayed_exec(self, handle_text, config_stub, qtbot,
                                    keyparser):
        config_stub.val.input.ambiguous_timeout = 100

        # 'a' is an ambiguous result.
        handle_text((Qt.Key_A, 'a'))
        assert not keyparser.execute.called
        assert keyparser._ambiguous_timer.isActive()
        # We wait for the timeout to occur.
        with qtbot.waitSignal(keyparser.keystring_updated):
            pass
        assert keyparser.execute.called


class TestCount: