#298 Add ability to chose matched rule

tests/test_corrector.py

@@ -0,0 +1,88 @@
+import pytest
+from pathlib import PosixPath, Path
+from mock import Mock
+from thefuck import corrector, conf, types
+from tests.utils import Rule, Command
+from thefuck.corrector import make_corrected_commands, get_corrected_commands
+
+
+def test_load_rule(mocker):
+    match = object()
+    get_new_command = object()
+    load_source = mocker.patch(
+        'thefuck.corrector.load_source',
+        return_value=Mock(match=match,
+                          get_new_command=get_new_command,
+                          enabled_by_default=True,
+                          priority=900,
+                          requires_output=True))
+    assert corrector.load_rule(Path('/rules/bash.py'), settings=Mock(priority={})) \
+           == Rule('bash', match, get_new_command, priority=900)
+    load_source.assert_called_once_with('bash', '/rules/bash.py')
+
+
+class TestGetRules(object):
+    @pytest.fixture(autouse=True)
+    def glob(self, mocker):
+        return mocker.patch('thefuck.corrector.Path.glob', return_value=[])
+
+    def _compare_names(self, rules, names):
+        return [r.name for r in rules] == names
+
+    @pytest.mark.parametrize('conf_rules, rules', [
+        (conf.DEFAULT_RULES, ['bash', 'lisp', 'bash', 'lisp']),
+        (types.RulesNamesList(['bash']), ['bash', 'bash'])])
+    def test_get(self, monkeypatch, glob, conf_rules, rules):
+        glob.return_value = [PosixPath('bash.py'), PosixPath('lisp.py')]
+        monkeypatch.setattr('thefuck.corrector.load_source',
+                            lambda x, _: Rule(x))
+        assert self._compare_names(
+            corrector.get_rules(Path('~'), Mock(rules=conf_rules, priority={})),
+            rules)
+
+
+class TestGetMatchedRules(object):
+    def test_no_match(self):
+        assert list(corrector.get_matched_rules(
+            Command('ls'), [Rule('', lambda *_: False)],
+            Mock(no_colors=True))) == []
+
+    def test_match(self):
+        rule = Rule('', lambda x, _: x.script == 'cd ..')
+        assert list(corrector.get_matched_rules(
+            Command('cd ..'), [rule], Mock(no_colors=True))) == [rule]
+
+    def test_when_rule_failed(self, capsys):
+        all(corrector.get_matched_rules(
+            Command('ls'), [Rule('test', Mock(side_effect=OSError('Denied')),
+                                 requires_output=False)],
+            Mock(no_colors=True, debug=False)))
+        assert capsys.readouterr()[1].split('\n')[0] == '[WARN] Rule test:'
+
+
+class TestGetCorrectedCommands(object):
+    def test_with_rule_returns_list(self):
+        rule = Rule(get_new_command=lambda x, _: [x.script + '!', x.script + '@'],
+                    priority=100)
+        assert list(make_corrected_commands(Command(script='test'), [rule], None)) \
+               == [types.CorrectedCommand(script='test!', priority=100, side_effect=None),
+                   types.CorrectedCommand(script='test@', priority=200, side_effect=None)]
+
+    def test_with_rule_returns_command(self):
+        rule = Rule(get_new_command=lambda x, _: x.script + '!',
+                    priority=100)
+        assert list(make_corrected_commands(Command(script='test'), [rule], None)) \
+               == [types.CorrectedCommand(script='test!', priority=100, side_effect=None)]
+
+
+def test_get_corrected_commands(mocker):
+    command = Command('test', 'test', 'test')
+    rules = [Rule(match=lambda *_: False),
+             Rule(match=lambda *_: True,
+                  get_new_command=lambda x, _: x.script + '!', priority=100),
+             Rule(match=lambda *_: True,
+                  get_new_command=lambda x, _: [x.script + '@', x.script + ';'],
+                  priority=60)]
+    mocker.patch('thefuck.corrector.get_rules', return_value=rules)
+    assert [cmd.script for cmd in get_corrected_commands(command, None, Mock(debug=False))]\
+        == ['test@', 'test!', 'test;']

tests/test_main.py

@@ -1,61 +1,8 @@
 import pytest
 from subprocess import PIPE
-from pathlib import PosixPath, Path
 from mock import Mock
-from thefuck import main, conf, types
-from tests.utils import Rule, Command
-
-
-def test_load_rule(mocker):
-    match = object()
-    get_new_command = object()
-    load_source = mocker.patch(
-        'thefuck.main.load_source',
-        return_value=Mock(match=match,
-                          get_new_command=get_new_command,
-                          enabled_by_default=True,
-                          priority=900,
-                          requires_output=True))
-    assert main.load_rule(Path('/rules/bash.py')) \
-           == Rule('bash', match, get_new_command, priority=900)
-    load_source.assert_called_once_with('bash', '/rules/bash.py')
-
-
-class TestGetRules(object):
-    @pytest.fixture(autouse=True)
-    def glob(self, mocker):
-        return mocker.patch('thefuck.main.Path.glob', return_value=[])
-
-    def _compare_names(self, rules, names):
-        return [r.name for r in rules] == names
-
-    @pytest.mark.parametrize('conf_rules, rules', [
-        (conf.DEFAULT_RULES, ['bash', 'lisp', 'bash', 'lisp']),
-        (types.RulesNamesList(['bash']), ['bash', 'bash'])])
-    def test_get(self, monkeypatch, glob, conf_rules, rules):
-        glob.return_value = [PosixPath('bash.py'), PosixPath('lisp.py')]
-        monkeypatch.setattr('thefuck.main.load_source',
-                            lambda x, _: Rule(x))
-        assert self._compare_names(
-            main.get_rules(Path('~'), Mock(rules=conf_rules, priority={})),
-            rules)
-
-    @pytest.mark.parametrize('priority, unordered, ordered', [
-        ({},
-         [Rule('bash', priority=100), Rule('python', priority=5)],
-         ['python', 'bash']),
-        ({},
-         [Rule('lisp', priority=9999), Rule('c', priority=conf.DEFAULT_PRIORITY)],
-         ['c', 'lisp']),
-        ({'python': 9999},
-         [Rule('bash', priority=100), Rule('python', priority=5)],
-         ['bash', 'python'])])
-    def test_ordered_by_priority(self, monkeypatch, priority, unordered, ordered):
-        monkeypatch.setattr('thefuck.main._get_loaded_rules',
-                            lambda *_: unordered)
-        assert self._compare_names(
-            main.get_rules(Path('~'), Mock(priority=priority)),
-            ordered)
+from thefuck import main
+from tests.utils import Command
 
 
 class TestGetCommand(object):
@@ -79,7 +26,7 @@ class TestGetCommand(object):
 
     def test_get_command_calls(self, Popen):
         assert main.get_command(Mock(env={}),
-            ['thefuck', 'apt-get', 'search', 'vim']) \
+                                ['thefuck', 'apt-get', 'search', 'vim']) \
                == Command('apt-get search vim', 'stdout', 'stderr')
         Popen.assert_called_once_with('apt-get search vim',
                                       shell=True,
@@ -95,80 +42,3 @@ class TestGetCommand(object):
             assert main.get_command(Mock(env={}), args).script == result
         else:
             assert main.get_command(Mock(env={}), args) is None
-
-
-class TestGetMatchedRule(object):
-    def test_no_match(self):
-        assert main.get_matched_rule(
-            Command('ls'), [Rule('', lambda *_: False)],
-            Mock(no_colors=True)) is None
-
-    def test_match(self):
-        rule = Rule('', lambda x, _: x.script == 'cd ..')
-        assert main.get_matched_rule(
-            Command('cd ..'), [rule], Mock(no_colors=True)) == rule
-
-    def test_when_rule_failed(self, capsys):
-        main.get_matched_rule(
-            Command('ls'), [Rule('test', Mock(side_effect=OSError('Denied')))],
-            Mock(no_colors=True, debug=False))
-        assert capsys.readouterr()[1].split('\n')[0] == '[WARN] Rule test:'
-
-
-class TestRunRule(object):
-    @pytest.fixture(autouse=True)
-    def confirm(self, mocker):
-        return mocker.patch('thefuck.main.confirm', return_value=True)
-
-    def test_run_rule(self, capsys):
-        main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
-                      Command(), None)
-        assert capsys.readouterr() == ('new-command\n', '')
-
-    def test_run_rule_with_side_effect(self, capsys):
-        side_effect = Mock()
-        settings = Mock(debug=False)
-        command = Command()
-        main.run_rule(Rule(get_new_command=lambda *_: 'new-command',
-                           side_effect=side_effect),
-                      command, settings)
-        assert capsys.readouterr() == ('new-command\n', '')
-        side_effect.assert_called_once_with(command, settings)
-
-    def test_when_not_comfirmed(self, capsys, confirm):
-        confirm.return_value = False
-        main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
-                      Command(), None)
-        assert capsys.readouterr() == ('', '')
-
-
-class TestConfirm(object):
-    @pytest.fixture
-    def stdin(self, mocker):
-        return mocker.patch('sys.stdin.read', return_value='\n')
-
-    def test_when_not_required(self, capsys):
-        assert main.confirm('command', None, Mock(require_confirmation=False))
-        assert capsys.readouterr() == ('', 'command\n')
-
-    def test_with_side_effect_and_without_confirmation(self, capsys):
-        assert main.confirm('command', Mock(), Mock(require_confirmation=False))
-        assert capsys.readouterr() == ('', 'command (+side effect)\n')
-
-    # `stdin` fixture should be applied after `capsys`
-    def test_when_confirmation_required_and_confirmed(self, capsys, stdin):
-        assert main.confirm('command', None, Mock(require_confirmation=True,
-                                                  no_colors=True))
-        assert capsys.readouterr() == ('', 'command [enter/ctrl+c]')
-
-    # `stdin` fixture should be applied after `capsys`
-    def test_when_confirmation_required_and_confirmed_with_side_effect(self, capsys, stdin):
-        assert main.confirm('command', Mock(), Mock(require_confirmation=True,
-                                                    no_colors=True))
-        assert capsys.readouterr() == ('', 'command (+side effect) [enter/ctrl+c]')
-
-    def test_when_confirmation_required_and_aborted(self, capsys, stdin):
-        stdin.side_effect = KeyboardInterrupt
-        assert not main.confirm('command', None, Mock(require_confirmation=True,
-                                                      no_colors=True))
-        assert capsys.readouterr() == ('', 'command [enter/ctrl+c]Aborted\n')

tests/test_ui.py

@@ -0,0 +1,115 @@
+from mock import Mock
+import pytest
+from itertools import islice
+from thefuck import ui
+from thefuck.types import CorrectedCommand
+
+
+@pytest.fixture
+def patch_getch(monkeypatch):
+    def patch(vals):
+        def getch():
+            for val in vals:
+                if val == KeyboardInterrupt:
+                    raise val
+                else:
+                    yield val
+
+        getch_gen = getch()
+        monkeypatch.setattr('thefuck.ui.getch', lambda: next(getch_gen))
+
+    return patch
+
+
+def test_read_actions(patch_getch):
+    patch_getch([  # Enter:
+                   '\n',
+                   # Enter:
+                   '\r',
+                   # Ignored:
+                   'x', 'y',
+                   # Up:
+                   '\x1b', '[', 'A',
+                   # Down:
+                   '\x1b', '[', 'B',
+                   # Ctrl+C:
+                   KeyboardInterrupt], )
+    assert list(islice(ui.read_actions(), 5)) \
+           == [ui.SELECT, ui.SELECT, ui.PREVIOUS, ui.NEXT, ui.ABORT]
+
+
+def test_command_selector():
+    selector = ui.CommandSelector([1, 2, 3])
+    assert selector.value == 1
+    changes = []
+    selector.on_change(changes.append)
+    selector.next()
+    assert selector.value == 2
+    selector.next()
+    assert selector.value == 3
+    selector.next()
+    assert selector.value == 1
+    selector.previous()
+    assert selector.value == 3
+    assert changes == [1, 2, 3, 1, 3]
+
+
+class TestSelectCommand(object):
+    @pytest.fixture
+    def commands_with_side_effect(self):
+        return [CorrectedCommand('ls', lambda *_: None, 100),
+                CorrectedCommand('cd', lambda *_: None, 100)]
+
+    @pytest.fixture
+    def commands(self):
+        return [CorrectedCommand('ls', None, 100),
+                CorrectedCommand('cd', None, 100)]
+
+    def test_without_commands(self, capsys):
+        assert ui.select_command([], Mock(debug=False, no_color=True)) is None
+        assert capsys.readouterr() == ('', 'No fuck given\n')
+
+    def test_without_confirmation(self, capsys, commands):
+        assert ui.select_command(commands,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=False)) == commands[0]
+        assert capsys.readouterr() == ('', 'ls\n')
+
+    def test_without_confirmation_with_side_effects(self, capsys,
+                                                    commands_with_side_effect):
+        assert ui.select_command(commands_with_side_effect,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=False)) \
+               == commands_with_side_effect[0]
+        assert capsys.readouterr() == ('', 'ls (+side effect)\n')
+
+    def test_with_confirmation(self, capsys, patch_getch, commands):
+        patch_getch(['\n'])
+        assert ui.select_command(commands,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=True)) == commands[0]
+        assert capsys.readouterr() == ('', '\x1b[1K\rls [enter/↑/↓/ctrl+c]\n')
+
+    def test_with_confirmation_abort(self, capsys, patch_getch, commands):
+        patch_getch([KeyboardInterrupt])
+        assert ui.select_command(commands,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=True)) is None
+        assert capsys.readouterr() == ('', '\x1b[1K\rls [enter/↑/↓/ctrl+c]\nAborted\n')
+
+    def test_with_confirmation_with_side_effct(self, capsys, patch_getch,
+                                               commands_with_side_effect):
+        patch_getch(['\n'])
+        assert ui.select_command(commands_with_side_effect,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=True))\
+               == commands_with_side_effect[0]
+        assert capsys.readouterr() == ('', '\x1b[1K\rls (+side effect) [enter/↑/↓/ctrl+c]\n')
+
+    def test_with_confirmation_select_second(self, capsys, patch_getch, commands):
+        patch_getch(['\x1b', '[', 'B', '\n'])
+        assert ui.select_command(commands,
+                                 Mock(debug=False, no_color=True,
+                                      require_confirmation=True)) == commands[1]
+        assert capsys.readouterr() == (
+            '', '\x1b[1K\rls [enter/↑/↓/ctrl+c]\x1b[1K\rcd [enter/↑/↓/ctrl+c]\n')