| # Copyright 2021 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Provides some helpers for interacting with git.""" |
| |
| import re |
| import subprocess |
| |
| class Git: |
| """A class which provides helpers for interacting with git.""" |
| def __init__(self, path='.'): |
| self._cmd = ['git', '-C', path] |
| |
| def _run(self, cmd, stdin=None): |
| """Runs a git command with the appropriate working dir. |
| |
| Args: |
| cmd: The command to run (in array fmt, ie: ['log', '--oneline']). |
| stdin: Optionally provide stdin input to the command. |
| |
| Returns: |
| (returncode,stdout,stderr) from the command |
| """ |
| run_cmd = self._cmd + cmd |
| ret = subprocess.run(run_cmd, stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, input=stdin, |
| encoding='UTF-8') |
| return (ret.returncode, ret.stdout, ret.stderr) |
| |
| @staticmethod |
| def _generate_remote_name(remote): |
| """Generates a remote name unique for the given url. |
| |
| The result is the remote url without the protocol and special |
| characters. This allows us to resolve git://git.kernel.org and |
| https://git.kernel.org as the same remote. |
| |
| Args: |
| remote: The remote tree's URL (including protocol). |
| |
| Returns: |
| The unique remote name. |
| """ |
| name = re.sub(r'([a-z]*\://)|\W', '', remote, flags=re.I) |
| return f'fl-{name}' |
| |
| def fetch_refspec_from_remote(self, remote, refspec): |
| """Fetches the given refspec from the given remote. |
| |
| Args: |
| remote: The remote tree's URL (including protocol). |
| refspec: The remote refspec to fetch. |
| |
| Returns: |
| True if the fetch was successful, False otherwise. |
| """ |
| remote_name = Git._generate_remote_name(remote) |
| # Ignore failures from remote add since the remote might already exist. |
| self._run(['remote', 'add', remote_name, remote]) |
| ret, *_ = self._run(['fetch', remote_name, refspec]) |
| return ret == 0 |
| |
| def get_commits_in_range(self, start, end, include_merges=False): |
| """Get a list of commits between start and end. |
| |
| Args: |
| start: The range's beginning refspec. |
| end: The range's ending refspec. |
| include_merges: Should the results include merge commits? |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| cmd = ['log', '--format=%H'] |
| if not include_merges: |
| cmd += ['--no-merges'] |
| ret, commits, _ = self._run(cmd + [f'{start}..{end}']) |
| if ret != 0: |
| return None |
| |
| return commits.splitlines() |
| |
| def commit_in_local_branch(self, commit, common_ancestor=None, |
| include_cherry_picks=False): |
| """Look for the given commit in the local branch. |
| |
| Args: |
| commit: The commit to look for. |
| common_ancestor: The common ancestor between local and upstream. |
| include_cherry_picks: Search cherry-picked commits as well. |
| |
| Returns: |
| True if the commit is found in the local branch, False otherwise. |
| """ |
| ret, *_ = self._run(['merge-base', '--is-ancestor', commit, 'HEAD']) |
| if ret == 0: |
| return True |
| |
| if not include_cherry_picks: |
| return False |
| |
| # Get the affected files to narrow down the grep below |
| ret, files, _ = self._run(['diff-tree', '--no-commit-id', '--name-only', |
| '-r', commit]) |
| if ret != 0: |
| return False |
| |
| # Inspect the last 10 commits to each file and pick the file which has |
| # the oldest for the grep below. This will hopefully more often than |
| # not choose the least active file (ie: smallest history) to speed up |
| # the grep below. We could of course just count all the commits, but |
| # that would take a long time and probably [hand waving] take more time |
| # overall than grepping a random file from the commit. |
| lru = ('', -1) |
| for f in files.splitlines(): |
| ret, changes, _ = self._run(['log', '-10', '--format=%ct', commit, |
| '--', f]) |
| if ret != 0 or not changes: |
| continue |
| |
| oldest = changes.splitlines()[-1] |
| if lru[1] == -1 or oldest < lru[1]: |
| lru = (f, oldest) |
| |
| cmd = ['log', '--extended-regexp', '--grep', |
| f'(cherry.picked from( commit)? {commit})'] |
| if common_ancestor: |
| cmd += [f'{common_ancestor}..'] |
| if lru[1] != -1: |
| cmd += ['--', lru[0]] |
| ret, commits, _ = self._run(cmd) |
| if ret == 0 and commits: |
| return True |
| |
| return False |
| |
| def cherry_pick(self, commit, skip_empty=False): |
| """Cherry picks a commit into the local branch. |
| |
| Args: |
| commit: The hash of the commit to be cherry-picked. |
| skip_empty: Detect if the cherry-pick is empty and skip it. |
| |
| Returns: |
| (ret, skipped) ret will be True on success, skipped will be True if |
| the patch is skipped. |
| """ |
| ret, _, err = self._run(['cherry-pick', '-s', '-x', commit]) |
| if ret == 0: |
| return (True, False) |
| |
| if not skip_empty: |
| return (False, False) |
| |
| if 'The previous cherry-pick is now empty' not in err: |
| return (False, False) |
| |
| # Double check we don't have any local changes |
| ret, files, _ = self._run(['status', '-s', '-uno']) |
| if ret != 0 or files != '': |
| return (False, False) |
| |
| ret, *_ = self._run(['cherry-pick', '--skip']) |
| return (ret == 0, ret == 0) |
| |
| def get_conflicting_files(self): |
| """Returns a list of conflicting files in the local git tree. |
| |
| Returns: |
| A list of files with conflicts. |
| """ |
| ret, files, _ = self._run(['status', '-s']) |
| if ret != 0: |
| return [] |
| |
| conflicts = [] |
| for f in files.splitlines(): |
| if not f.startswith('UU'): |
| continue |
| conflicts.append(f.split(' ')[1]) |
| |
| return conflicts |
| |
| def get_commit_message(self, commit='HEAD'): |
| """Returns the commit message for the given commit. |
| |
| Args: |
| commit: The hash of the commit to be shown |
| |
| Returns: |
| (ret, message) ret will be True on success, message will have the |
| commit message. |
| """ |
| ret, message, _ = self._run(['show', '--quiet', '--format=%B', commit]) |
| return (ret == 0, message) |
| |
| def set_commit_message(self, message): |
| """Amends the commit at HEAD with the given commit message. |
| |
| Args: |
| message: Message to use for the commit at HEAD. |
| |
| Returns: |
| True if successful, False otherwise. |
| """ |
| ret, *_ = self._run(['commit', '--amend', '-F', '-'], stdin=message) |
| return (ret == 0, message) |
| |
| def generate_change_id(self, commit='HEAD'): |
| """Generates the Change-Id value for the commit at HEAD |
| |
| Args: |
| commit: The hash of the commit to generate the Change-Id for. |
| |
| Returns: |
| (ret, change_id) ret will be True on success, change_id is the |
| Change-Id for the commit at HEAD. |
| """ |
| obj = '' |
| |
| ret, stdout, _ = self._run(['write-tree']) |
| if ret == 0 and stdout: |
| obj += f'tree {stdout}' |
| |
| ret, stdout, _ = self._run(['rev-parse', f'{commit}^0']) |
| if ret == 0 and stdout: |
| obj += f'parent {stdout}' |
| |
| ret, stdout, _ = self._run(['var', 'GIT_AUTHOR_IDENT']) |
| if ret == 0 and stdout: |
| obj += f'author {stdout}' |
| |
| ret, stdout, _ = self._run(['var', 'GIT_COMMITTER_IDENT']) |
| if ret == 0 and stdout: |
| obj += f'committer {stdout}' |
| |
| ret, commit_msg = self.get_commit_message(commit) |
| if ret: |
| obj += f'\n{commit_msg}' |
| |
| ret, stdout, _ = self._run(['hash-object', '-t', 'commit', '--stdin'], |
| stdin=obj) |
| return (ret == 0, f'I{stdout.strip()}') |
| |
| def show(self, commit): |
| """Returns the 'git show' output for the given commit. |
| |
| Args: |
| commit: The commit to show. |
| |
| Returns: |
| A string with the 'git show' output. |
| """ |
| _, output, _ = self._run(['show', commit]) |
| return output |
| |
| def commit_diff(self, commit, path): |
| """Returns the changes to a given file in the given commit. |
| |
| Args: |
| commit: The commit to return the diff for. |
| path: The file path to limit the diff with. |
| |
| Returns: |
| The diff introduced in commit. |
| """ |
| ret, output, _ = self._run(['diff-tree', '-p', commit, '--', path]) |
| if ret != 0: |
| return '' |
| |
| # Split out the header goop in the first 5 lines |
| return '\n'.join(output.splitlines()[5:]) |
| |
| def blame(self, path, refspec=None): |
| """Returns the 'git blame' output for the given path at refspec. |
| |
| Args: |
| path: The path of the file being blamed. |
| refspec: The git refspec to inspect the file at. |
| |
| Returns: |
| A string with the 'git blame' output. |
| """ |
| cmd = ['blame'] |
| if refspec: |
| cmd += [refspec] |
| cmd += ['--', path] |
| _, output, _ = self._run(cmd) |
| return output |
