341 lines
14 KiB
Python
Executable File
341 lines
14 KiB
Python
Executable File
#! /usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
|
||
# git-date.py --- Find Git commits around some date in one or more repositories.
|
||
# Copyright (c) 2021, Florent Rougon
|
||
# All rights reserved.
|
||
#
|
||
# Redistribution and use in source and binary forms, with or without
|
||
# modification, are permitted provided that the following conditions are met:
|
||
#
|
||
# 1. Redistributions of source code must retain the above copyright notice,
|
||
# this list of conditions and the following disclaimer.
|
||
# 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
# this list of conditions and the following disclaimer in the documentation
|
||
# and/or other materials provided with the distribution.
|
||
#
|
||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
# POSSIBILITY OF SUCH DAMAGE.
|
||
#
|
||
# The views and conclusions contained in the software and documentation are
|
||
# those of the authors and should not be interpreted as representing official
|
||
# policies, either expressed or implied, of the FlightGear project.
|
||
|
||
# The idea and some Git-fu of this script are from Edward d'Auvergne:
|
||
# <https://sourceforge.net/p/flightgear/mailman/message/37004175/>.
|
||
|
||
import argparse
|
||
import locale
|
||
import os
|
||
import re
|
||
import subprocess
|
||
import sys
|
||
from collections import namedtuple, OrderedDict
|
||
|
||
PROGNAME = os.path.basename(sys.argv[0])
|
||
PROGVERSION = "0.2"
|
||
COPYRIGHT = "Copyright (c) 2021, Florent Rougon"
|
||
LICENSE_SUMMARY = """\
|
||
This program is free software. It comes without any warranty, to
|
||
the extent permitted by applicable law. See the top of {progname}
|
||
for more details on the licensing conditions.""".format(progname=PROGNAME)
|
||
|
||
# Very simple Repository type
|
||
Repository = namedtuple('Repository', ['label', 'path'])
|
||
|
||
|
||
class CommitFinder:
|
||
|
||
def __init__(self, branch, date):
|
||
self.branch = branch
|
||
self.date = date
|
||
|
||
def findCommit(self, repo_path):
|
||
"""Return a commit ID that belongs to 'repo_path'."""
|
||
args = ["git", "rev-list", "--max-count=1",
|
||
"--before={}".format(self.date), self.branch]
|
||
p = subprocess.run(args, cwd=repo_path, capture_output=True,
|
||
check=True, encoding="utf-8")
|
||
return p.stdout.strip()
|
||
|
||
def action(self, repositories):
|
||
"""Act on one or more repositories.
|
||
|
||
'repositories' should be an OrderedDict whose keys are
|
||
repository labels and values Repository objects.
|
||
|
||
"""
|
||
for label, repo in repositories.items():
|
||
commitId = self.findCommit(repo.path)
|
||
if params.let_me_breathe: self.print("-" * 78)
|
||
if not params.checkout: # the output would be redundant
|
||
if params.only_label:
|
||
# Useful with --show-commits
|
||
# --show-commits-option='--no-patch'
|
||
# --show-commits-option='--format=oneline'
|
||
self.print("{}: ".format(label), end='')
|
||
else:
|
||
self.print("{}: {}".format(label, commitId))
|
||
if params.let_me_breathe: self.print()
|
||
|
||
if params.show_commits:
|
||
args = ["git", "-c", "pager.show=false", "show"] + \
|
||
params.show_commits_options + [commitId]
|
||
subprocess.run(args, cwd=repo.path, check=True)
|
||
|
||
if params.checkout:
|
||
args = ["git", "checkout", commitId]
|
||
self.print("{}: checking out commit {}...".format(label,
|
||
commitId))
|
||
subprocess.run(args, cwd=repo.path, check=True)
|
||
|
||
if params.let_me_breathe: self.print()
|
||
|
||
def print(self, *args, **kwargs):
|
||
"""Wrapper for print() that defaults to flushing the output stream.
|
||
|
||
This is particularly useful when stdout is fully buffered (e.g.,
|
||
when piping the output of the script through a pager). Without
|
||
this 'flush=True' setting, output from Git commands would bypass
|
||
the high-level buffering layer in sys.stdout and could come out
|
||
before the output of some *later* non-flushed print()
|
||
statements.
|
||
"""
|
||
print(*args, flush=True, **kwargs)
|
||
|
||
|
||
def parseConfigFile(cfgFile, configFileOptSpecified, recognizedParams):
|
||
namespace = argparse.Namespace()
|
||
l = {}
|
||
if configFileOptSpecified or os.path.exists(cfgFile):
|
||
# Read the configuration file (i.e., execute it)
|
||
with open(cfgFile, "r") as f:
|
||
exec(f.read(), {"OrderedDict": OrderedDict}, l)
|
||
|
||
for p in recognizedParams:
|
||
if p in l:
|
||
setattr(namespace, p, l[p])
|
||
|
||
return namespace
|
||
|
||
|
||
def processCommandLineAndConfigFile():
|
||
defaultCfgFile = os.path.join(os.getenv('HOME'), ".config", PROGNAME,
|
||
"config.py")
|
||
parser = argparse.ArgumentParser(
|
||
usage="""\
|
||
%(prog)s [OPTION ...] DATE [REPOSITORY...]
|
||
Find Git commits before DATE in one or more repositories.""",
|
||
description="""\
|
||
Print information about, and possibly check out the most recent commit
|
||
before DATE in each of the specified repositories. By default, commits
|
||
are searched for in the 'next' branch, however this can be changed using
|
||
the --branch option or the 'branch' variable in the configuration file.
|
||
DATE can be in any date format accepted by Git (see the examples below).
|
||
|
||
If option --repo-args-are-just-paths has been given, each REPOSITORY
|
||
argument is literally treated as a path to a repository. Otherwise, each
|
||
REPOSITORY argument that has the form LABEL=PATH defines a repository
|
||
rooted at PATH with associated LABEL (using this special syntax is not
|
||
mandatory, but allows {progname} to refer to your repositories using the
|
||
provided labels, which is more user-friendly in general).
|
||
|
||
Examples (the backslashes just introduce continuation lines):
|
||
|
||
# One output line per repository (terse)
|
||
{progname} "2021-02-28 23:12:00" SG=/path/to/SG \\
|
||
FG=/path/to/FG FGData=/path/to/FGData
|
||
|
||
# Ditto without providing the repository labels
|
||
{progname} "2021-02-28 23:12:00" /path/to/SG \\
|
||
/path/to/FG /path/to/FGData
|
||
|
||
# Run 'git show' with the specified options for each commit found.
|
||
{progname} --let-me-breathe --show-commits \\
|
||
--show-commits-option='--no-patch' \\
|
||
--show-commits-option='--format=medium' \\
|
||
'2021-02-28 23:12:00' SG=/path/to/SG \\
|
||
FG=/path/to/FG FGData=/path/to/FGData
|
||
|
||
# Run 'git checkout' for each commit found.
|
||
{progname} --checkout --let-me-breathe "2021-01-01" SG=/path/to/SG \\
|
||
FG=/path/to/FG FGData=/path/to/FGData
|
||
|
||
# For each repository, print the label, commit ID and one-line description.
|
||
{progname} --only-label --show-commits \\
|
||
--show-commits-option='--no-patch' \\
|
||
--show-commits-option='--format=oneline' \\
|
||
"2021-02-28" SG=/path/to/SG \\
|
||
FG=/path/to/FG FGData=/path/to/FGData
|
||
|
||
Note: --show-commits et al. may be used in conjunction with --checkout
|
||
if so desired.
|
||
|
||
If $HOME/.config/{progname}/config.py exists or if the --config-file option
|
||
has been given, a configuration file is read. This file is executed by
|
||
the Python interpreter and must therefore adhere to Python 3 syntax.
|
||
Here is a sample configuration file:
|
||
|
||
------------------------------------------------------------------------------
|
||
branch = 'release/2020.3'
|
||
# checkout = True
|
||
# show_commits = True
|
||
# show_commits_options = ['--no-patch', '--format=medium']
|
||
# let_me_breathe = True
|
||
# only_label = True
|
||
# repo_args_are_just_paths = True
|
||
|
||
# collections.OrderedDict is available for use here:
|
||
repositories = OrderedDict(
|
||
SimGear = "/path/to/simgear",
|
||
FlightGear = "/path/to/flightgear",
|
||
FGData = "/path/to/fgdata")
|
||
|
||
# Same list of repositories but without user-defined labels:
|
||
# repositories = [
|
||
# "/path/to/simgear",
|
||
# "/path/to/flightgear",
|
||
# "/path/to/fgdata"]
|
||
------------------------------------------------------------------------------
|
||
|
||
Command-line options take precedence over their counterparts found in
|
||
the configuration file. On the other hand, REPOSITORY arguments *extend*
|
||
the list of repositories that may be defined in the configuration file
|
||
using the 'repositories' variable.""".format(progname=PROGNAME),
|
||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||
# I want --help but not -h (it might be useful for something else)
|
||
add_help=False)
|
||
|
||
parser.add_argument('--repo-args-are-just-paths',
|
||
action='store_true', help="""\
|
||
don't try to recognize and special-case LABEL=PATH syntax for
|
||
repository arguments; treat them literally as paths and simply assign
|
||
labels 'Repo 1', 'Repo 2', etc., to the specified repositories""")
|
||
parser.add_argument('-b', '--branch', default="next", help="""\
|
||
search history of BRANCH (default: %(default)s)""")
|
||
parser.add_argument('-c', '--checkout', action='store_true', help="""\
|
||
run 'git checkout' for the commit that was found in each repository""")
|
||
# This option is actually handled by configFileOptParser because we want to
|
||
# treat it before all other options.
|
||
parser.add_argument('--config-file', metavar="FILE", default=defaultCfgFile,
|
||
help="""\
|
||
load configuration from FILE (default: %(default)s)""")
|
||
parser.add_argument('-s', '--show-commits', action='store_true', help="""\
|
||
run 'git show' for the commit that was found in each repository""")
|
||
parser.add_argument('-S', '--show-commits-option', action='append',
|
||
dest='show_commits_options', help="""\
|
||
option passed to 'git show' when --show-commits is used (may be
|
||
specified multiple times, as in: --show-commits-option='--no-patch'
|
||
--show-commits-option='--format=medium')""")
|
||
parser.add_argument('--let-me-breathe', action='store_true', help="""\
|
||
add blank lines and other separators to make the output hopefully more
|
||
readable when Git prints a lot of things""")
|
||
parser.add_argument('--only-label', action='store_true', help="""\
|
||
don't print the commit ID after the repository label (this is useful
|
||
when the Git output coming next already contains the commit ID)""")
|
||
parser.add_argument('date', metavar="DATE", help="""\
|
||
find commits before this date""")
|
||
parser.add_argument('cmdRepos', metavar="REPOSITORY", nargs='*',
|
||
help="""\
|
||
path to a repository to act on (actually, each REPOSITORY argument may be
|
||
of the form LABEL=PATH in order to assign a label to the repository).
|
||
There can be an arbitrary number of these arguments.""")
|
||
parser.add_argument('--help', action="help",
|
||
help="display this message and exit")
|
||
parser.add_argument('--version', action='version',
|
||
version="{name} version {version}\n{copyright}\n\n"
|
||
"{license}".format(
|
||
name=PROGNAME, version=PROGVERSION,
|
||
copyright=COPYRIGHT,
|
||
license=LICENSE_SUMMARY))
|
||
|
||
# Find which config file to read and note whether the --config-file option
|
||
# was given.
|
||
configFileOptParser = argparse.ArgumentParser(add_help=False)
|
||
configFileOptParser.add_argument('--config-file')
|
||
ns, remaining = configFileOptParser.parse_known_args()
|
||
if ns.config_file is not None:
|
||
configFileOptSpecified = True
|
||
else:
|
||
configFileOptSpecified = False
|
||
ns.config_file = defaultCfgFile
|
||
|
||
recognizedParams = ("repo_args_are_just_paths", "branch", "checkout",
|
||
"show_commits", "show_commits_options",
|
||
"let_me_breathe", "only_label", "repositories")
|
||
# Read the config file into 'params' (an argparse.Namespace object)
|
||
params = parseConfigFile(ns.config_file, configFileOptSpecified,
|
||
recognizedParams)
|
||
|
||
# Process the rest of the command-line
|
||
parser.parse_args(namespace=params)
|
||
if "repositories" not in params:
|
||
params.repositories = []
|
||
|
||
# Prepare the list of repositories based on the config file and the command
|
||
# line arguments.
|
||
params.repositories = initListOfRepositories(
|
||
params.repositories, params.cmdRepos, params.repo_args_are_just_paths)
|
||
|
||
if not params.repositories:
|
||
sys.exit(f"{PROGNAME}: no repository was specified, neither in the "
|
||
"configuration file\nnor on the command line; exiting.")
|
||
return params
|
||
|
||
|
||
# Returns an OrderedDict whose keys are repository labels and values Repository
|
||
# objects.
|
||
def initListOfRepositories(reposFromCfgFile, reposFromCmdLineArgs,
|
||
repoArgsAreJustPaths):
|
||
res = OrderedDict()
|
||
reposLeftToAdd = []
|
||
|
||
if isinstance(reposFromCfgFile, OrderedDict):
|
||
for label, path in reposFromCfgFile.items():
|
||
res[label] = Repository(label, path)
|
||
elif isinstance(reposFromCfgFile, list):
|
||
reposLeftToAdd.extend(reposFromCfgFile)
|
||
else:
|
||
sys.exit(f"{PROGNAME}: in the configuration file, 'repositories' must "
|
||
"be either an\nOrderedDict or a list.")
|
||
|
||
repoNum = len(res)
|
||
for elt in reposLeftToAdd + reposFromCmdLineArgs:
|
||
repoNum += 1
|
||
mo = re.match(r"^(?P<label>\w+)=(?P<path>.*)", elt)
|
||
if mo is None or repoArgsAreJustPaths:
|
||
label = "Repo {}".format(repoNum)
|
||
path = elt
|
||
else:
|
||
label, path = mo.group("label", "path")
|
||
res[label] = Repository(label, path)
|
||
|
||
return res
|
||
|
||
|
||
def main():
|
||
global params
|
||
|
||
locale.setlocale(locale.LC_ALL, '')
|
||
# Require Python 3.6 or later because we rely on the retained order for
|
||
# keyword arguments passed to the OrderedDict constructor.
|
||
if sys.hexversion < 0x030600F0:
|
||
sys.exit(f"{PROGNAME}: exiting because Python >= 3.6 is required.")
|
||
|
||
params = processCommandLineAndConfigFile()
|
||
commitFinder = CommitFinder(params.branch, params.date)
|
||
commitFinder.action(params.repositories)
|
||
sys.exit(0)
|
||
|
||
|
||
if __name__ == "__main__": main()
|