thefuck-leeguoo 3.41__py2.py3-none-any.whl

thefuck/rules/git_clone_missing.py

@@ -0,0 +1,42 @@
+'''
+Rule: git_clone_missing
+
+Correct missing `git clone` command when pasting a git URL
+
+```sh
+>>> https://github.com/nvbn/thefuck.git
+git clone https://github.com/nvbn/thefuck.git
+```
+
+Author: Miguel Guthridge
+'''
+from six.moves.urllib import parse
+from thefuck.utils import which
+
+
+def match(command):
+    # We want it to be a URL by itself
+    if len(command.script_parts) != 1:
+        return False
+    # Ensure we got the error we expected
+    if which(command.script_parts[0]) or not (
+        'No such file or directory' in command.output
+        or 'not found' in command.output
+        or 'is not recognised as' in command.output
+    ):
+        return False
+    url = parse.urlparse(command.script, scheme='ssh')
+    # HTTP URLs need a network address
+    if not url.netloc and url.scheme != 'ssh':
+        return False
+    # SSH needs a username and a splitter between the path
+    if url.scheme == 'ssh' and not (
+        '@' in command.script
+        and ':' in command.script
+    ):
+        return False
+    return url.scheme in ['http', 'https', 'ssh']
+
+
+def get_new_command(command):
+    return 'git clone ' + command.script

thefuck/rules/git_commit_add.py

@@ -0,0 +1,17 @@
+from thefuck.utils import eager, replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (
+        "commit" in command.script_parts
+        and "no changes added to commit" in command.output
+    )
+
+
+@eager
+@git_support
+def get_new_command(command):
+    for opt in ("-a", "-p"):
+        yield replace_argument(command.script, "commit", "commit {}".format(opt))

thefuck/rules/git_commit_amend.py

@@ -0,0 +1,11 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('commit' in command.script_parts)
+
+
+@git_support
+def get_new_command(command):
+    return 'git commit --amend'

thefuck/rules/git_commit_reset.py

@@ -0,0 +1,11 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('commit' in command.script_parts)
+
+
+@git_support
+def get_new_command(command):
+    return 'git reset HEAD~'

thefuck/rules/git_diff_no_index.py

@@ -0,0 +1,16 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    files = [arg for arg in command.script_parts[2:]
+             if not arg.startswith('-')]
+    return ('diff' in command.script
+            and '--no-index' not in command.script
+            and len(files) == 2)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'diff', 'diff --no-index')

thefuck/rules/git_diff_staged.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('diff' in command.script and
+            '--staged' not in command.script)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'diff', 'diff --staged')

thefuck/rules/git_fix_stash.py

@@ -0,0 +1,37 @@
+from thefuck import utils
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    if command.script_parts and len(command.script_parts) > 1:
+        return (command.script_parts[1] == 'stash'
+                and 'usage:' in command.output)
+    else:
+        return False
+
+
+# git's output here is too complicated to be parsed (see the test file)
+stash_commands = (
+    'apply',
+    'branch',
+    'clear',
+    'drop',
+    'list',
+    'pop',
+    'save',
+    'show')
+
+
+@git_support
+def get_new_command(command):
+    stash_cmd = command.script_parts[2]
+    fixed = utils.get_closest(stash_cmd, stash_commands, fallback_to_first=False)
+
+    if fixed is not None:
+        return replace_argument(command.script, stash_cmd, fixed)
+    else:
+        cmd = command.script_parts[:]
+        cmd.insert(2, 'save')
+        return ' '.join(cmd)

thefuck/rules/git_flag_after_filename.py

@@ -0,0 +1,31 @@
+import re
+from thefuck.specific.git import git_support
+
+error_pattern = "fatal: bad flag '(.*?)' used after filename"
+error_pattern2 = "fatal: option '(.*?)' must come before non-option arguments"
+
+
+@git_support
+def match(command):
+    return re.search(error_pattern, command.output) or re.search(error_pattern2, command.output)
+
+
+@git_support
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+
+    # find the bad flag
+    bad_flag = match(command).group(1)
+    bad_flag_index = command_parts.index(bad_flag)
+
+    # find the filename
+    for index in reversed(range(bad_flag_index)):
+        if command_parts[index][0] != '-':
+            filename_index = index
+            break
+
+    # swap them
+    command_parts[bad_flag_index], command_parts[filename_index] = \
+    command_parts[filename_index], command_parts[bad_flag_index]  # noqa: E122
+
+    return u' '.join(command_parts)

thefuck/rules/git_help_aliased.py

@@ -0,0 +1,12 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return 'help' in command.script and ' is aliased to ' in command.output
+
+
+@git_support
+def get_new_command(command):
+    aliased = command.output.split('`', 2)[2].split("'", 1)[0].split(' ', 1)[0]
+    return 'git help {}'.format(aliased)

thefuck/rules/git_hook_bypass.py

@@ -0,0 +1,27 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+hooked_commands = ("am", "commit", "push")
+
+
+@git_support
+def match(command):
+    return any(
+        hooked_command in command.script_parts for hooked_command in hooked_commands
+    )
+
+
+@git_support
+def get_new_command(command):
+    hooked_command = next(
+        hooked_command
+        for hooked_command in hooked_commands
+        if hooked_command in command.script_parts
+    )
+    return replace_argument(
+        command.script, hooked_command, hooked_command + " --no-verify"
+    )
+
+
+priority = 1100
+requires_output = False

thefuck/rules/git_lfs_mistype.py

@@ -0,0 +1,18 @@
+import re
+from thefuck.utils import get_all_matched_commands, replace_command
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    '''
+    Match a mistyped command
+    '''
+    return 'lfs' in command.script and 'Did you mean this?' in command.output
+
+
+@git_support
+def get_new_command(command):
+    broken_cmd = re.findall(r'Error: unknown command "([^"]*)" for "git-lfs"', command.output)[0]
+    matched = get_all_matched_commands(command.output, ['Did you mean', ' for usage.'])
+    return replace_command(command, broken_cmd, matched)

thefuck/rules/git_main_master.py

@@ -0,0 +1,16 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return "'master'" in command.output or "'main'" in command.output
+
+
+@git_support
+def get_new_command(command):
+    if "'master'" in command.output:
+        return command.script.replace("master", "main")
+    return command.script.replace("main", "master")
+
+
+priority = 1200

thefuck/rules/git_merge.py

@@ -0,0 +1,18 @@
+import re
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('merge' in command.script
+            and ' - not something we can merge' in command.output
+            and 'Did you mean this?' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    unknown_branch = re.findall(r'merge: (.+) - not something we can merge', command.output)[0]
+    remote_branch = re.findall(r'Did you mean this\?\n\t([^\n]+)', command.output)[0]
+
+    return replace_argument(command.script, unknown_branch, remote_branch)

thefuck/rules/git_merge_unrelated.py

@@ -0,0 +1,12 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('merge' in command.script
+            and 'fatal: refusing to merge unrelated histories' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return command.script + ' --allow-unrelated-histories'

thefuck/rules/git_not_command.py

@@ -0,0 +1,18 @@
+import re
+from thefuck.utils import get_all_matched_commands, replace_command
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (" is not a git command. See 'git --help'." in command.output
+            and ('The most similar command' in command.output
+                 or 'Did you mean' in command.output))
+
+
+@git_support
+def get_new_command(command):
+    broken_cmd = re.findall(r"git: '([^']*)' is not a git command",
+                            command.output)[0]
+    matched = get_all_matched_commands(command.output, ['The most similar command', 'Did you mean'])
+    return replace_command(command, broken_cmd, matched)

thefuck/rules/git_pull.py

@@ -0,0 +1,16 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return 'pull' in command.script and 'set-upstream' in command.output
+
+
+@git_support
+def get_new_command(command):
+    line = command.output.split('\n')[-3].strip()
+    branch = line.split(' ')[-1]
+    set_upstream = line.replace('<remote>', 'origin')\
+                       .replace('<branch>', branch)
+    return shell.and_(set_upstream, command.script)

thefuck/rules/git_pull_clone.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('fatal: Not a git repository' in command.output
+            and "Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set)." in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'pull', 'clone')

thefuck/rules/git_pull_uncommitted_changes.py

@@ -0,0 +1,14 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('pull' in command.script
+            and ('You have unstaged changes' in command.output
+                 or 'contains uncommitted changes' in command.output))
+
+
+@git_support
+def get_new_command(command):
+    return shell.and_('git stash', 'git pull', 'git stash pop')

thefuck/rules/git_push.py

@@ -0,0 +1,44 @@
+import re
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('push' in command.script_parts
+            and 'git push --set-upstream' in command.output)
+
+
+def _get_upstream_option_index(command_parts):
+    if '--set-upstream' in command_parts:
+        return command_parts.index('--set-upstream')
+    elif '-u' in command_parts:
+        return command_parts.index('-u')
+    else:
+        return None
+
+
+@git_support
+def get_new_command(command):
+    # If --set-upstream or -u are passed, remove it and its argument. This is
+    # because the remaining arguments are concatenated onto the command suggested
+    # by git, which includes --set-upstream and its argument
+    command_parts = command.script_parts[:]
+    upstream_option_index = _get_upstream_option_index(command_parts)
+
+    if upstream_option_index is not None:
+        command_parts.pop(upstream_option_index)
+
+        # In case of `git push -u` we don't have next argument:
+        if len(command_parts) > upstream_option_index:
+            command_parts.pop(upstream_option_index)
+    else:
+        # the only non-qualified permitted options are the repository and refspec; git's
+        # suggestion include them, so they won't be lost, but would be duplicated otherwise.
+        push_idx = command_parts.index('push') + 1
+        while len(command_parts) > push_idx and command_parts[len(command_parts) - 1][0] != '-':
+            command_parts.pop(len(command_parts) - 1)
+
+    arguments = re.findall(r'git push (.*)', command.output)[-1].replace("'", r"\'").strip()
+    return replace_argument(" ".join(command_parts), 'push',
+                            'push {}'.format(arguments))

thefuck/rules/git_push_different_branch_names.py

@@ -0,0 +1,12 @@
+import re
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return "push" in command.script and "The upstream branch of your current branch does not match" in command.output
+
+
+@git_support
+def get_new_command(command):
+    return re.findall(r'^ +(git push [^\s]+ [^\s]+)', command.output, re.MULTILINE)[0]

thefuck/rules/git_push_force.py

@@ -0,0 +1,18 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('push' in command.script
+            and '! [rejected]' in command.output
+            and 'failed to push some refs to' in command.output
+            and 'Updates were rejected because the tip of your current branch is behind' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'push', 'push --force-with-lease')
+
+
+enabled_by_default = False

thefuck/rules/git_push_pull.py

@@ -0,0 +1,20 @@
+from thefuck.shells import shell
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('push' in command.script and
+            '! [rejected]' in command.output and
+            'failed to push some refs to' in command.output and
+            ('Updates were rejected because the tip of your'
+             ' current branch is behind' in command.output or
+             'Updates were rejected because the remote '
+             'contains work that you do' in command.output))
+
+
+@git_support
+def get_new_command(command):
+    return shell.and_(replace_argument(command.script, 'push', 'pull'),
+                      command.script)

thefuck/rules/git_push_without_commits.py

@@ -0,0 +1,12 @@
+import re
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return bool(re.search(r"src refspec \w+ does not match any", command.output))
+
+
+def get_new_command(command):
+    return shell.and_('git commit -m "Initial commit"', command.script)

thefuck/rules/git_rebase_merge_dir.py

@@ -0,0 +1,17 @@
+from thefuck.utils import get_close_matches
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rebase' in command.script and
+            'It seems that there is already a rebase-merge directory' in command.output and
+            'I wonder if you are in the middle of another rebase' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    command_list = ['git rebase --continue', 'git rebase --abort', 'git rebase --skip']
+    rm_cmd = command.output.split('\n')[-4]
+    command_list.append(rm_cmd.strip())
+    return get_close_matches(command.script, command_list, 4, 0)

thefuck/rules/git_rebase_no_changes.py

@@ -0,0 +1,13 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (
+        {'rebase', '--continue'}.issubset(command.script_parts) and
+        'No changes - did you forget to use \'git add\'?' in command.output
+    )
+
+
+def get_new_command(command):
+    return 'git rebase --skip'

thefuck/rules/git_remote_delete.py

@@ -0,0 +1,13 @@
+import re
+
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return "remote delete" in command.script
+
+
+@git_support
+def get_new_command(command):
+    return re.sub(r"delete", "remove", command.script, 1)

thefuck/rules/git_remote_seturl_add.py

@@ -0,0 +1,12 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('set-url' in command.script
+            and 'fatal: No such remote' in command.output)
+
+
+def get_new_command(command):
+    return replace_argument(command.script, 'set-url', 'add')

thefuck/rules/git_rm_local_modifications.py

@@ -0,0 +1,19 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rm ' in command.script and
+            'error: the following file has local modifications' in command.output and
+            'use --cached to keep the file, or -f to force removal' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    index = command_parts.index('rm') + 1
+    command_parts.insert(index, '--cached')
+    command_list = [u' '.join(command_parts)]
+    command_parts[index] = '-f'
+    command_list.append(u' '.join(command_parts))
+    return command_list

thefuck/rules/git_rm_recursive.py

@@ -0,0 +1,16 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rm ' in command.script
+            and "fatal: not removing '" in command.output
+            and "' recursively without -r" in command.output)
+
+
+@git_support
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    index = command_parts.index('rm') + 1
+    command_parts.insert(index, '-r')
+    return u' '.join(command_parts)

thefuck/rules/git_rm_staged.py

@@ -0,0 +1,19 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rm ' in command.script and
+            'error: the following file has changes staged in the index' in command.output and
+            'use --cached to keep the file, or -f to force removal' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    index = command_parts.index('rm') + 1
+    command_parts.insert(index, '--cached')
+    command_list = [u' '.join(command_parts)]
+    command_parts[index] = '-f'
+    command_list.append(u' '.join(command_parts))
+    return command_list

thefuck/rules/git_stash.py

@@ -0,0 +1,15 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    # catches "Please commit or stash them" and "Please, commit your changes or
+    # stash them before you can switch branches."
+    return 'or stash them' in command.output
+
+
+@git_support
+def get_new_command(command):
+    formatme = shell.and_('git stash', '{}')
+    return formatme.format(command.script)

thefuck/rules/git_stash_pop.py

@@ -0,0 +1,18 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('stash' in command.script
+            and 'pop' in command.script
+            and 'Your local changes to the following files would be overwritten by merge' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return shell.and_('git add --update', 'git stash pop', 'git reset .')
+
+
+# make it come before the other applicable rules
+priority = 900

thefuck/rules/git_tag_force.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('tag' in command.script_parts
+            and 'already exists' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'tag', 'tag --force')

thefuck/rules/git_two_dashes.py

@@ -0,0 +1,14 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('error: did you mean `' in command.output
+            and '` (with two dashes ?)' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    to = command.output.split('`')[1]
+    return replace_argument(command.script, to[1:], to)