| #!/usr/bin/env python | |
| # | |
| # ======- git-llvm - LLVM Git Help Integration ---------*- python -*--========# | |
| # | |
| # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| # See https://llvm.org/LICENSE.txt for license information. | |
| # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| # | |
| # ==------------------------------------------------------------------------==# | |
| """ | |
| git-llvm integration | |
| ==================== | |
| This file provides integration for git. | |
| """ | |
| from __future__ import print_function | |
| import argparse | |
| import collections | |
| import os | |
| import re | |
| import shutil | |
| import subprocess | |
| import sys | |
| import time | |
| assert sys.version_info >= (2, 7) | |
| try: | |
| dict.iteritems | |
| except AttributeError: | |
| # Python 3 | |
| def iteritems(d): | |
| return iter(d.items()) | |
| else: | |
| # Python 2 | |
| def iteritems(d): | |
| return d.iteritems() | |
| try: | |
| # Python 3 | |
| from shlex import quote | |
| except ImportError: | |
| # Python 2 | |
| from pipes import quote | |
| # It's *almost* a straightforward mapping from the monorepo to svn... | |
| LLVM_MONOREPO_SVN_MAPPING = { | |
| d: (d + '/trunk') | |
| for d in [ | |
| 'clang-tools-extra', | |
| 'compiler-rt', | |
| 'debuginfo-tests', | |
| 'dragonegg', | |
| 'klee', | |
| 'libc', | |
| 'libclc', | |
| 'libcxx', | |
| 'libcxxabi', | |
| 'libunwind', | |
| 'lld', | |
| 'lldb', | |
| 'llgo', | |
| 'llvm', | |
| 'openmp', | |
| 'parallel-libs', | |
| 'polly', | |
| 'pstl', | |
| ] | |
| } | |
| LLVM_MONOREPO_SVN_MAPPING.update({'clang': 'cfe/trunk'}) | |
| LLVM_MONOREPO_SVN_MAPPING.update({'': 'monorepo-root/trunk'}) | |
| SPLIT_REPO_NAMES = {'llvm-' + d: d + '/trunk' | |
| for d in ['www', 'zorg', 'test-suite', 'lnt']} | |
| VERBOSE = False | |
| QUIET = False | |
| dev_null_fd = None | |
| def eprint(*args, **kwargs): | |
| print(*args, file=sys.stderr, **kwargs) | |
| def log(*args, **kwargs): | |
| if QUIET: | |
| return | |
| print(*args, **kwargs) | |
| def log_verbose(*args, **kwargs): | |
| if not VERBOSE: | |
| return | |
| print(*args, **kwargs) | |
| def die(msg): | |
| eprint(msg) | |
| sys.exit(1) | |
| def ask_confirm(prompt): | |
| # Python 2/3 compatibility | |
| try: | |
| read_input = raw_input | |
| except NameError: | |
| read_input = input | |
| while True: | |
| query = read_input('%s (y/N): ' % (prompt)) | |
| if query.lower() not in ['y','n', '']: | |
| print('Expect y or n!') | |
| continue | |
| return query.lower() == 'y' | |
| def split_first_path_component(d): | |
| # Assuming we have a git path, it'll use slashes even on windows...I hope. | |
| if '/' in d: | |
| return d.split('/', 1) | |
| else: | |
| return (d, None) | |
| def get_dev_null(): | |
| """Lazily create a /dev/null fd for use in shell()""" | |
| global dev_null_fd | |
| if dev_null_fd is None: | |
| dev_null_fd = open(os.devnull, 'w') | |
| return dev_null_fd | |
| def shell(cmd, strip=True, cwd=None, stdin=None, die_on_failure=True, | |
| ignore_errors=False, text=True): | |
| # Escape args when logging for easy repro. | |
| quoted_cmd = [quote(arg) for arg in cmd] | |
| log_verbose('Running in %s: %s' % (cwd, ' '.join(quoted_cmd))) | |
| err_pipe = subprocess.PIPE | |
| if ignore_errors: | |
| # Silence errors if requested. | |
| err_pipe = get_dev_null() | |
| start = time.time() | |
| p = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=err_pipe, | |
| stdin=subprocess.PIPE, | |
| universal_newlines=text) | |
| stdout, stderr = p.communicate(input=stdin) | |
| elapsed = time.time() - start | |
| log_verbose('Command took %0.1fs' % elapsed) | |
| if p.returncode == 0 or ignore_errors: | |
| if stderr and not ignore_errors: | |
| eprint('`%s` printed to stderr:' % ' '.join(quoted_cmd)) | |
| eprint(stderr.rstrip()) | |
| if strip: | |
| if text: | |
| stdout = stdout.rstrip('\r\n') | |
| else: | |
| stdout = stdout.rstrip(b'\r\n') | |
| if VERBOSE: | |
| for l in stdout.splitlines(): | |
| log_verbose("STDOUT: %s" % l) | |
| return stdout | |
| err_msg = '`%s` returned %s' % (' '.join(quoted_cmd), p.returncode) | |
| eprint(err_msg) | |
| if stderr: | |
| eprint(stderr.rstrip()) | |
| if die_on_failure: | |
| sys.exit(2) | |
| raise RuntimeError(err_msg) | |
| def git(*cmd, **kwargs): | |
| return shell(['git'] + list(cmd), **kwargs) | |
| def svn(cwd, *cmd, **kwargs): | |
| return shell(['svn'] + list(cmd), cwd=cwd, **kwargs) | |
| def program_exists(cmd): | |
| if sys.platform == 'win32' and not cmd.endswith('.exe'): | |
| cmd += '.exe' | |
| for path in os.environ["PATH"].split(os.pathsep): | |
| if os.access(os.path.join(path, cmd), os.X_OK): | |
| return True | |
| return False | |
| def get_default_rev_range(): | |
| # Get the newest common ancestor between HEAD and our upstream branch. | |
| upstream_rev = git('merge-base', 'HEAD', '@{upstream}', ignore_errors=True) | |
| if not upstream_rev: | |
| eprint("Warning: git-llvm assumes that origin/master is the upstream " | |
| "branch but git does not.") | |
| eprint("To make this warning go away: git branch -u origin/master") | |
| eprint("To avoid this warning when creating branches: " | |
| "git checkout -b MyBranchName origin/master") | |
| upstream_rev = git('merge-base', 'HEAD', 'origin/master') | |
| return '%s..' % upstream_rev | |
| def get_revs_to_push(rev_range): | |
| if not rev_range: | |
| rev_range = get_default_rev_range() | |
| # Use git show rather than some plumbing command to figure out which revs | |
| # are in rev_range because it handles single revs (HEAD^) and ranges | |
| # (foo..bar) like we want. | |
| return git('show', '--reverse', '--quiet', | |
| '--pretty=%h', rev_range).splitlines() | |
| def clean_svn(svn_repo): | |
| svn(svn_repo, 'revert', '-R', '.') | |
| # Unfortunately it appears there's no svn equivalent for git clean, so we | |
| # have to do it ourselves. | |
| for line in svn(svn_repo, 'status', '--no-ignore').split('\n'): | |
| if not line.startswith('?'): | |
| continue | |
| filename = line[1:].strip() | |
| filepath = os.path.abspath(os.path.join(svn_repo, filename)) | |
| abs_svn_repo = os.path.abspath(svn_repo) | |
| # Safety check that the directory we are about to delete is | |
| # actually within our svn staging dir. | |
| if not filepath.startswith(abs_svn_repo): | |
| die("Path to clean (%s) is not in svn staging dir (%s)" | |
| % (filepath, abs_svn_repo)) | |
| if os.path.isdir(filepath): | |
| shutil.rmtree(filepath) | |
| else: | |
| os.remove(filepath) | |
| def svn_init(svn_root): | |
| if not os.path.exists(svn_root): | |
| log('Creating svn staging directory: (%s)' % (svn_root)) | |
| os.makedirs(svn_root) | |
| svn(svn_root, 'checkout', '--depth=empty', | |
| 'https://llvm.org/svn/llvm-project/', '.') | |
| log("svn staging area ready in '%s'" % svn_root) | |
| if not os.path.isdir(svn_root): | |
| die("Can't initialize svn staging dir (%s)" % svn_root) | |
| def fix_eol_style_native(rev, svn_sr_path, files): | |
| """Fix line endings before applying patches with Unix endings | |
| SVN on Windows will check out files with CRLF for files with the | |
| svn:eol-style property set to "native". This breaks `git apply`, which | |
| typically works with Unix-line ending patches. Work around the problem here | |
| by doing a dos2unix up front for files with svn:eol-style set to "native". | |
| SVN will not commit a mass line ending re-doing because it detects the line | |
| ending format for files with this property. | |
| """ | |
| # Skip files that don't exist in SVN yet. | |
| files = [f for f in files if os.path.exists(os.path.join(svn_sr_path, f))] | |
| # Use ignore_errors because 'svn propget' prints errors if the file doesn't | |
| # have the named property. There doesn't seem to be a way to suppress that. | |
| eol_props = svn(svn_sr_path, 'propget', 'svn:eol-style', *files, | |
| ignore_errors=True) | |
| crlf_files = [] | |
| if len(files) == 1: | |
| # No need to split propget output on ' - ' when we have one file. | |
| if eol_props.strip() in ['native', 'CRLF']: | |
| crlf_files = files | |
| else: | |
| for eol_prop in eol_props.split('\n'): | |
| # Remove spare CR. | |
| eol_prop = eol_prop.strip('\r') | |
| if not eol_prop: | |
| continue | |
| prop_parts = eol_prop.rsplit(' - ', 1) | |
| if len(prop_parts) != 2: | |
| eprint("unable to parse svn propget line:") | |
| eprint(eol_prop) | |
| continue | |
| (f, eol_style) = prop_parts | |
| if eol_style == 'native': | |
| crlf_files.append(f) | |
| if crlf_files: | |
| # Reformat all files with native SVN line endings to Unix format. SVN | |
| # knows files with native line endings are text files. It will commit | |
| # just the diff, and not a mass line ending change. | |
| shell(['dos2unix'] + crlf_files, ignore_errors=True, cwd=svn_sr_path) | |
| def split_subrepo(f, git_to_svn_mapping): | |
| # Given a path, splits it into (subproject, rest-of-path). If the path is | |
| # not in a subproject, returns ('', full-path). | |
| subproject, remainder = split_first_path_component(f) | |
| if subproject in git_to_svn_mapping: | |
| return subproject, remainder | |
| else: | |
| return '', f | |
| def get_all_parent_dirs(name): | |
| parts = [] | |
| head, tail = os.path.split(name) | |
| while head: | |
| parts.append(head) | |
| head, tail = os.path.split(head) | |
| return parts | |
| def svn_push_one_rev(svn_repo, rev, git_to_svn_mapping, dry_run): | |
| def split_status(x): | |
| x = x.split('\t') | |
| return x[1], x[0] | |
| files_status = [split_status(x) for x in | |
| git('diff-tree', '--no-commit-id', '--name-status', | |
| '--no-renames', '-r', rev).split('\n')] | |
| if not files_status: | |
| raise RuntimeError('Empty diff for rev %s?' % rev) | |
| # Split files by subrepo | |
| subrepo_files = collections.defaultdict(list) | |
| for f, st in files_status: | |
| subrepo, remainder = split_subrepo(f, git_to_svn_mapping) | |
| subrepo_files[subrepo].append((remainder, st)) | |
| status = svn(svn_repo, 'status', '--no-ignore') | |
| if status: | |
| die("Can't push git rev %s because status in svn staging dir (%s) is " | |
| "not empty:\n%s" % (rev, svn_repo, status)) | |
| svn_dirs_to_update = set() | |
| for sr, files_status in iteritems(subrepo_files): | |
| svn_sr_path = git_to_svn_mapping[sr] | |
| for f, _ in files_status: | |
| svn_dirs_to_update.add( | |
| os.path.dirname(os.path.join(svn_sr_path, f))) | |
| # We also need to svn update any parent directories which are not yet | |
| # present | |
| parent_dirs = set() | |
| for dir in svn_dirs_to_update: | |
| parent_dirs.update(get_all_parent_dirs(dir)) | |
| parent_dirs = set(dir for dir in parent_dirs | |
| if not os.path.exists(os.path.join(svn_repo, dir))) | |
| svn_dirs_to_update.update(parent_dirs) | |
| # Sort by length to ensure that the parent directories are passed to svn | |
| # before child directories. | |
| sorted_dirs_to_update = sorted(svn_dirs_to_update, key=len) | |
| # SVN update only in the affected directories. | |
| svn(svn_repo, 'update', '--depth=files', *sorted_dirs_to_update) | |
| for sr, files_status in iteritems(subrepo_files): | |
| svn_sr_path = os.path.join(svn_repo, git_to_svn_mapping[sr]) | |
| if os.name == 'nt': | |
| fix_eol_style_native(rev, svn_sr_path, | |
| [f for f, _ in files_status]) | |
| # We use text=False (and pass '--binary') so that we can get an exact | |
| # diff that can be passed as-is to 'git apply' without any line ending, | |
| # encoding, or other mangling. | |
| diff = git('show', '--binary', rev, '--', | |
| *(os.path.join(sr, f) for f, _ in files_status), | |
| strip=False, text=False) | |
| # git is the only thing that can handle its own patches... | |
| if sr == '': | |
| prefix_strip = '-p1' | |
| else: | |
| prefix_strip = '-p2' | |
| try: | |
| shell(['git', 'apply', prefix_strip, '-'], cwd=svn_sr_path, | |
| stdin=diff, die_on_failure=False, text=False) | |
| except RuntimeError as e: | |
| eprint("Patch doesn't apply: maybe you should try `git pull -r` " | |
| "first?") | |
| sys.exit(2) | |
| # Handle removed files and directories. We need to be careful not to | |
| # remove directories just because they _look_ empty in the svn tree, as | |
| # we might be missing sibling directories in the working copy. So, only | |
| # remove parent directories if they're empty on both the git and svn | |
| # sides. | |
| maybe_dirs_to_remove = set() | |
| for f, st in files_status: | |
| if st == 'D': | |
| maybe_dirs_to_remove.update(get_all_parent_dirs(f)) | |
| svn(svn_sr_path, 'remove', f) | |
| elif not (st == 'A' or st == 'M' or st == 'T'): | |
| # Add is handled below, and nothing needs to be done for Modify. | |
| # (FIXME: Type-change between symlink and file might need some | |
| # special handling, but let's ignore that for now.) | |
| die("Unexpected git status for %r: %r" % (f, st)) | |
| maybe_dirs_to_remove = sorted(maybe_dirs_to_remove, key=len) | |
| for f in maybe_dirs_to_remove: | |
| if(not os.path.exists(os.path.join(svn_sr_path, f)) and | |
| git('ls-tree', '-d', rev, os.path.join(sr, f)) == ''): | |
| svn(svn_sr_path, 'remove', f) | |
| status_lines = svn(svn_repo, 'status', '--no-ignore').split('\n') | |
| for l in status_lines: | |
| f = l[1:].strip() | |
| if l.startswith('?') or l.startswith('I'): | |
| svn(svn_repo, 'add', '--no-ignore', f) | |
| # Now we're ready to commit. | |
| commit_msg = git('show', '--pretty=%B', '--quiet', rev) | |
| if not dry_run: | |
| commit_args = ['commit', '-m', commit_msg] | |
| if '--force-interactive' in svn(svn_repo, 'commit', '--help'): | |
| commit_args.append('--force-interactive') | |
| log(svn(svn_repo, *commit_args)) | |
| log('Committed %s to svn.' % rev) | |
| else: | |
| log("Would have committed %s to svn, if this weren't a dry run." % rev) | |
| def cmd_push(args): | |
| '''Push changes back to SVN: this is extracted from Justin Lebar's script | |
| available here: https://github.com/jlebar/llvm-repo-tools/ | |
| Note: a current limitation is that git does not track file rename, so they | |
| will show up in SVN as delete+add. | |
| ''' | |
| # Get the git root | |
| git_root = git('rev-parse', '--show-toplevel') | |
| if not os.path.isdir(git_root): | |
| die("Can't find git root dir") | |
| # Push from the root of the git repo | |
| os.chdir(git_root) | |
| # Get the remote URL, and check if it's one of the standalone repos. | |
| git_remote_url = git('ls-remote', '--get-url', 'origin') | |
| git_remote_url = git_remote_url.rstrip('.git').rstrip('/') | |
| git_remote_repo_name = git_remote_url.rsplit('/', 1)[-1] | |
| split_repo_path = SPLIT_REPO_NAMES.get(git_remote_repo_name) | |
| if split_repo_path: | |
| git_to_svn_mapping = {'': split_repo_path} | |
| else: | |
| # Default to the monorepo mapping | |
| git_to_svn_mapping = LLVM_MONOREPO_SVN_MAPPING | |
| # We need a staging area for SVN, let's hide it in the .git directory. | |
| dot_git_dir = git('rev-parse', '--git-common-dir') | |
| # Not all versions of git support --git-common-dir and just print the | |
| # unknown command back. If this happens, fall back to --git-dir | |
| if dot_git_dir == '--git-common-dir': | |
| dot_git_dir = git('rev-parse', '--git-dir') | |
| svn_root = os.path.join(dot_git_dir, 'llvm-upstream-svn') | |
| svn_init(svn_root) | |
| rev_range = args.rev_range | |
| dry_run = args.dry_run | |
| revs = get_revs_to_push(rev_range) | |
| if not args.force and not revs: | |
| die('Nothing to push: No revs in range %s.' % rev_range) | |
| log('%sPushing %d %s commit%s:\n%s' % | |
| ('[DryRun] ' if dry_run else '', len(revs), | |
| 'split-repo (%s)' % split_repo_path | |
| if split_repo_path else 'monorepo', | |
| 's' if len(revs) != 1 else '', | |
| '\n'.join(' ' + git('show', '--oneline', '--quiet', c) | |
| for c in revs))) | |
| # Ask confirmation if multiple commits are about to be pushed | |
| if not args.force and len(revs) > 1: | |
| if not ask_confirm("Are you sure you want to create %d commits?" % len(revs)): | |
| die("Aborting") | |
| for r in revs: | |
| clean_svn(svn_root) | |
| svn_push_one_rev(svn_root, r, git_to_svn_mapping, dry_run) | |
| def lookup_llvm_svn_id(git_commit_hash): | |
| # Use --format=%b to get the raw commit message, without any extra | |
| # whitespace. | |
| commit_msg = git('log', '-1', '--format=%b', git_commit_hash, | |
| ignore_errors=True) | |
| if len(commit_msg) == 0: | |
| die("Can't find git commit " + git_commit_hash) | |
| # If a commit has multiple "llvm-svn:" lines (e.g. if the commit is | |
| # reverting/quoting a previous commit), choose the last one, which should | |
| # be the authoritative one. | |
| svn_match_iter = re.finditer('^llvm-svn: (\d{5,7})$', commit_msg, | |
| re.MULTILINE) | |
| svn_match = None | |
| for m in svn_match_iter: | |
| svn_match = m.group(1) | |
| if svn_match: | |
| return int(svn_match) | |
| die("Can't find svn revision in git commit " + git_commit_hash) | |
| def cmd_svn_lookup(args): | |
| '''Find the SVN revision id for a given git commit hash. | |
| This is identified by 'llvm-svn: NNNNNN' in the git commit message.''' | |
| # Get the git root | |
| git_root = git('rev-parse', '--show-toplevel') | |
| if not os.path.isdir(git_root): | |
| die("Can't find git root dir") | |
| # Run commands from the root | |
| os.chdir(git_root) | |
| log('r' + str(lookup_llvm_svn_id(args.git_commit_hash))) | |
| def git_hash_by_svn_rev(svn_rev): | |
| '''Find the git hash for a given svn revision. | |
| This check is paranoid: 'llvm-svn: NNNNNN' could exist on its own line | |
| somewhere else in the commit message. Look in the full log message to see | |
| if it's actually on the last line. | |
| Since this check is expensive (we're searching every single commit), limit | |
| to the past 10k commits (about 5 months). | |
| ''' | |
| possible_hashes = git( | |
| 'log', '--format=%H', '--grep', '^llvm-svn: %d$' % svn_rev, | |
| 'HEAD~10000...HEAD').split('\n') | |
| matching_hashes = [h for h in possible_hashes | |
| if lookup_llvm_svn_id(h) == svn_rev] | |
| if len(matching_hashes) > 1: | |
| die("svn revision r%d has ambiguous commits: %s" % ( | |
| svn_rev, ', '.join(matching_hashes))) | |
| elif len(matching_hashes) < 1: | |
| die("svn revision r%d matches no commits" % svn_rev) | |
| return matching_hashes[0] | |
| def cmd_revert(args): | |
| '''Revert a commit by either SVN id (rNNNNNN) or git hash. This also | |
| populates the git commit message with both the SVN revision and git hash of | |
| the change being reverted.''' | |
| # Get the git root | |
| git_root = git('rev-parse', '--show-toplevel') | |
| if not os.path.isdir(git_root): | |
| die("Can't find git root dir") | |
| # Run commands from the root | |
| os.chdir(git_root) | |
| # Check for a client branch first. | |
| open_files = git('status', '-uno', '-s', '--porcelain') | |
| if len(open_files) > 0: | |
| die("Found open files. Please stash and then revert.\n" + open_files) | |
| # If the revision looks like rNNNNNN (or with a callsign, e.g. rLLDNNNNNN), | |
| # use that. Otherwise, look for it in the git commit. | |
| svn_match = re.match('^r[A-Z]*(\d{5,7})$', args.revision) | |
| if svn_match: | |
| # If the revision looks like rNNNNNN, use that as the svn revision, and | |
| # grep through git commits to find which one corresponds to that svn | |
| # revision. | |
| svn_rev = int(svn_match.group(1)) | |
| git_hash = git_hash_by_svn_rev(svn_rev) | |
| else: | |
| # Otherwise, this looks like a git hash, so we just need to grab the | |
| # svn revision from the end of the commit message. Get the actual git | |
| # hash in case the revision is something like "HEAD~1" | |
| git_hash = git('rev-parse', '--verify', args.revision + '^{commit}') | |
| svn_rev = lookup_llvm_svn_id(git_hash) | |
| msg = git('log', '-1', '--format=%s', git_hash) | |
| log_verbose('Ready to revert r%d (%s): "%s"' % (svn_rev, git_hash, msg)) | |
| revert_args = ['revert', '--no-commit', git_hash] | |
| # TODO: Running --edit doesn't seem to work, with errors that stdin is not | |
| # a tty. | |
| commit_args = [ | |
| 'commit', '-m', 'Revert ' + msg, | |
| '-m', 'This reverts r%d (git commit %s)' % (svn_rev, git_hash)] | |
| if args.dry_run: | |
| log("Would have run the following commands, if this weren't a" | |
| "dry run:\n" | |
| '1) git %s\n2) git %s' % ( | |
| ' '.join(quote(arg) for arg in revert_args), | |
| ' '.join(quote(arg) for arg in commit_args))) | |
| return | |
| git(*revert_args) | |
| commit_log = git(*commit_args) | |
| log('Created revert of r%d: %s' % (svn_rev, commit_log)) | |
| log("Run 'git llvm push -n' to inspect your changes and " | |
| "run 'git llvm push' when ready") | |
| if __name__ == '__main__': | |
| if not program_exists('svn'): | |
| die('error: git-llvm needs svn command, but svn is not installed.') | |
| argv = sys.argv[1:] | |
| p = argparse.ArgumentParser( | |
| prog='git llvm', formatter_class=argparse.RawDescriptionHelpFormatter, | |
| description=__doc__) | |
| subcommands = p.add_subparsers(title='subcommands', | |
| description='valid subcommands', | |
| help='additional help') | |
| verbosity_group = p.add_mutually_exclusive_group() | |
| verbosity_group.add_argument('-q', '--quiet', action='store_true', | |
| help='print less information') | |
| verbosity_group.add_argument('-v', '--verbose', action='store_true', | |
| help='print more information') | |
| parser_push = subcommands.add_parser( | |
| 'push', description=cmd_push.__doc__, | |
| help='push changes back to the LLVM SVN repository') | |
| parser_push.add_argument( | |
| '-n', | |
| '--dry-run', | |
| dest='dry_run', | |
| action='store_true', | |
| help='Do everything other than commit to svn. Leaves junk in the svn ' | |
| 'repo, so probably will not work well if you try to commit more ' | |
| 'than one rev.') | |
| parser_push.add_argument( | |
| '-f', | |
| '--force', | |
| action='store_true', | |
| help='Do not ask for confirmation when pushing multiple commits.') | |
| parser_push.add_argument( | |
| 'rev_range', | |
| metavar='GIT_REVS', | |
| type=str, | |
| nargs='?', | |
| help="revs to push (default: everything not in the branch's " | |
| 'upstream, or not in origin/master if the branch lacks ' | |
| 'an explicit upstream)') | |
| parser_push.set_defaults(func=cmd_push) | |
| parser_revert = subcommands.add_parser( | |
| 'revert', description=cmd_revert.__doc__, | |
| help='Revert a commit locally.') | |
| parser_revert.add_argument( | |
| 'revision', | |
| help='Revision to revert. Can either be an SVN revision number ' | |
| "(rNNNNNN) or a git commit hash (anything that doesn't look " | |
| 'like an SVN revision number).') | |
| parser_revert.add_argument( | |
| '-n', | |
| '--dry-run', | |
| dest='dry_run', | |
| action='store_true', | |
| help='Do everything other than perform a revert. Prints the git ' | |
| 'revert command it would have run.') | |
| parser_revert.set_defaults(func=cmd_revert) | |
| parser_svn_lookup = subcommands.add_parser( | |
| 'svn-lookup', description=cmd_svn_lookup.__doc__, | |
| help='Find the llvm-svn revision for a given commit.') | |
| parser_svn_lookup.add_argument( | |
| 'git_commit_hash', | |
| help='git_commit_hash for which we will look up the svn revision id.') | |
| parser_svn_lookup.set_defaults(func=cmd_svn_lookup) | |
| args = p.parse_args(argv) | |
| VERBOSE = args.verbose | |
| QUIET = args.quiet | |
| # Python3 workaround, for when not arguments are provided. | |
| # See https://bugs.python.org/issue16308 | |
| try: | |
| func = args.func | |
| except AttributeError: | |
| # No arguments or subcommands were given. | |
| parser.print_help() | |
| parser.exit() | |
| # Dispatch to the right subcommand | |
| args.func(args) |