146 lines
4.6 KiB
Python
146 lines
4.6 KiB
Python
import os
|
|
import sys
|
|
import yaml
|
|
import subprocess
|
|
from typing import Tuple, List, Callable, Dict
|
|
from . import common
|
|
|
|
|
|
class Color:
|
|
"""
|
|
Terminal color
|
|
"""
|
|
red = '\x1b[31m' # local diverges from remote
|
|
green = '\x1b[32m' # local == remote
|
|
yellow = '\x1b[33m' # local is behind
|
|
blue = '\x1b[34m'
|
|
purple = '\x1b[35m' # local is ahead
|
|
cyan = '\x1b[36m'
|
|
white = '\x1b[37m' # no remote branch
|
|
end = '\x1b[0m'
|
|
|
|
|
|
def get_info_funcs() -> List[Callable[[str], str]]:
|
|
"""
|
|
Return the functions to generate `gita ll` information. All these functions
|
|
take the repo path as input and return the corresponding information as str.
|
|
See `get_path`, `get_repo_status`, `get_common_commit` for examples.
|
|
"""
|
|
info_items, to_display = get_info_items()
|
|
return [info_items[k] for k in to_display]
|
|
|
|
|
|
def get_info_items() -> Tuple[Dict[str, Callable[[str], str]], List[str]]:
|
|
"""
|
|
Return the available information items for display in the `gita ll`
|
|
sub-command, and the ones to be displayed.
|
|
It loads custom information functions and configuration if they exist.
|
|
"""
|
|
# default settings
|
|
info_items = {'branch': get_repo_status,
|
|
'commit_msg': get_commit_msg,
|
|
'path': get_path, }
|
|
display_items = ['branch', 'commit_msg']
|
|
|
|
# custom settings
|
|
root = common.get_config_dir()
|
|
src_fname = os.path.join(root, 'extra_repo_info.py')
|
|
yml_fname = os.path.join(root, 'info.yml')
|
|
if os.path.isfile(src_fname):
|
|
sys.path.append(root)
|
|
from extra_repo_info import extra_info_items
|
|
info_items.update(extra_info_items)
|
|
if os.path.isfile(yml_fname):
|
|
with open(yml_fname, 'r') as stream:
|
|
display_items = yaml.load(stream, Loader=yaml.FullLoader)
|
|
display_items = [x for x in display_items if x in info_items]
|
|
return info_items, display_items
|
|
|
|
|
|
def get_path(path):
|
|
return Color.cyan + path + Color.end
|
|
|
|
|
|
def get_head(path: str) -> str:
|
|
result = subprocess.run('git rev-parse --abbrev-ref HEAD'.split(),
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL,
|
|
universal_newlines=True,
|
|
cwd=path)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def run_quiet_diff(args: List[str]) -> bool:
|
|
"""
|
|
Return the return code of git diff `args` in quiet mode
|
|
"""
|
|
result = subprocess.run(
|
|
['git', 'diff', '--quiet'] + args,
|
|
stderr=subprocess.DEVNULL,
|
|
)
|
|
return result.returncode
|
|
|
|
|
|
def get_common_commit() -> str:
|
|
"""
|
|
Return the hash of the common commit of the local and upstream branches.
|
|
"""
|
|
result = subprocess.run('git merge-base @{0} @{u}'.split(),
|
|
stdout=subprocess.PIPE,
|
|
universal_newlines=True)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def has_untracked() -> bool:
|
|
"""
|
|
Return True if untracked file/folder exists
|
|
"""
|
|
result = subprocess.run('git ls-files -zo --exclude-standard'.split(),
|
|
stdout=subprocess.PIPE)
|
|
return bool(result.stdout)
|
|
|
|
|
|
def get_commit_msg(path: str) -> str:
|
|
"""
|
|
Return the last commit message.
|
|
"""
|
|
# `git show-branch --no-name HEAD` is faster than `git show -s --format=%s`
|
|
result = subprocess.run('git show-branch --no-name HEAD'.split(),
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL,
|
|
universal_newlines=True,
|
|
cwd=path)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def get_repo_status(path: str) -> str:
|
|
head = get_head(path)
|
|
dirty, staged, untracked, color = _get_repo_status(path)
|
|
return f'{color}{head+" "+dirty+staged+untracked:<10}{Color.end}'
|
|
|
|
|
|
def _get_repo_status(path: str) -> Tuple[str]:
|
|
"""
|
|
Return the status of one repo
|
|
"""
|
|
os.chdir(path)
|
|
dirty = '*' if run_quiet_diff([]) else ''
|
|
staged = '+' if run_quiet_diff(['--cached']) else ''
|
|
untracked = '_' if has_untracked() else ''
|
|
|
|
diff_returncode = run_quiet_diff(['@{u}', '@{0}'])
|
|
has_no_remote = diff_returncode == 128
|
|
has_no_diff = diff_returncode == 0
|
|
if has_no_remote:
|
|
color = Color.white
|
|
elif has_no_diff:
|
|
color = Color.green
|
|
else:
|
|
common_commit = get_common_commit()
|
|
outdated = run_quiet_diff(['@{u}', common_commit])
|
|
if outdated:
|
|
diverged = run_quiet_diff(['@{0}', common_commit])
|
|
color = Color.red if diverged else Color.yellow
|
|
else: # local is ahead of remote
|
|
color = Color.purple
|
|
return dirty, staged, untracked, color
|