visidata 2.11.1__py3-none-any.whl → 3.0.1__py3-none-any.whl

visidata/apps/vgit/gitsheet.py

@@ -0,0 +1,161 @@
+import io
+
+from visidata import AttrDict, vd, Path, asyncthread, Sheet
+
+
+class GitSheet(Sheet):
+    @property
+    def gitargstr(self):
+        return ' '.join(self.gitargs)
+
+    def git(self, subcmd, *args, **kwargs):
+        'For non-modifying commands; not logged except in debug mode'
+        sh = vd.importExternal('sh')
+        args = list(subcmd.split()) + list(args)
+        vd.debug('git ' + ' '.join(str(x) for x in args))
+        return sh.git(*args,
+                      _cwd=self.gitRootPath,
+                      **kwargs)
+
+    def loggit(self, subcmd, *args, **kwargs):
+        'Run git command with *args*, and post a status message.'
+        import sh
+        args = list(subcmd.split()) + list(args)
+        vd.warning('git ' + ' '.join(str(x) for x in args))
+        return sh.git(*args,
+                      _cwd=self.gitRootPath,
+                      **kwargs)
+
+    def git_all(self, *args, **kwargs):
+        'Return entire output of git command.'
+        sh = vd.importExternal('sh')
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            out = self.git('--no-pager',
+                      *args,
+                      _decode_errors='replace',
+                      _bg_exc=False,
+                      **kwargs)
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+            out = e.stdout
+
+        return out
+
+    def git_lines(self, subcmd, *args, **kwargs):
+        'Generator of stdout lines from given git command'
+        sh = vd.importExternal('sh')
+        err = io.StringIO()
+        args = list(subcmd.split()) + list(args)
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            for line in self.git('--no-pager',
+                            *args,
+                            _decode_errors='replace',
+                            _iter=True,
+                            _bg_exc=False,
+                            _err=err,
+                            **kwargs):
+                yield line[:-1]  # remove EOL
+
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+
+        errlines = err.getvalue().splitlines()
+        if errlines:
+            vd.warning('git stderr: ' + '\n'.join(errlines))
+
+
+    def git_iter(self, subcmd, *args, sep='\0', **kwargs):
+        'Generator of chunks of stdout from given git command *subcmd*, delineated by sep character.'
+        sh = vd.importExternal('sh')
+        import sh
+        err = io.StringIO()
+
+        args = list(subcmd.split()) + list(args)
+        bufsize = 512
+        chunks = []
+        try:
+            vd.debug('git ' + ' '.join(str(x) for x in args))
+            for data in self.git('--no-pager',
+                               *args,
+                               _decode_errors='replace',
+                               _out_bufsize=bufsize,
+                               _iter=True,
+                               _bg_exc=False,
+                               _err=err,
+                               **kwargs):
+                while True:
+                    i = data.find(sep)
+                    if i < 0:
+                        break
+                    chunks.append(data[:i])
+                    data = data[i+1:]
+                    yield ''.join(chunks)
+                    chunks.clear()
+
+                chunks.append(data)
+        except sh.ErrorReturnCode as e:
+            vd.warning('git '+' '.join(str(x) for x in args), 'error=%s' % e.exit_code)
+
+        if chunks:
+            yield ''.join(chunks)
+
+        errlines = err.getvalue().splitlines()
+        if errlines:
+            vd.warning('git stderr: ' + '\n'.join(errlines))
+
+    @asyncthread
+    def modifyGit(self, *args, **kwargs):
+        'Run git command that modifies the repo'
+        vd.warning('git ' + ' '.join(str(x) for x in args))
+        ret = self.git_all(*args, **kwargs)
+        vd.status(ret)
+
+        if isinstance(self.source, GitSheet):
+            self.source.reload()
+
+        self.reload()
+
+    @property
+    def gitRootSheet(self):
+        if isinstance(self.source, GitSheet):
+            return self.source.gitRootSheet
+        return self
+
+    def iterload(self):
+        for line in self.git_lines(*self.gitargs):
+            yield AttrDict(line=line)
+
+
+@GitSheet.lazy_property
+def gitRootPath(self):
+    'Return Path of git root (nearest ancestor directory with a .git/)'
+    def _getRepoPath(p):
+        'Return path at p or above which has .git subdir'
+        if p.joinpath('.git').exists():
+            return p
+        if str(p) in ['/','']:
+            return None
+        return _getRepoPath(p.resolve().parent)
+
+    p = _getRepoPath(self.gitRootSheet.source)
+    if p:
+       return p
+
+
+@GitSheet.lazy_property
+def branch(self):
+    return self.git('rev-parse', '--abbrev-ref', 'HEAD').strip()
+
+
+GitSheet.options.disp_note_none = ''
+GitSheet.options.disp_status_fmt = '{sheet.progressStatus}‹{sheet.branchStatus}› {sheet.name}| '
+
+GitSheet.addCommand('gi', 'git-exec', 'cmdstr=input("gi", type="git"); vd.push(GitSheet(cmdstr, gitargs=cmdstr.split()))', 'execute git command')
+
+GitSheet.addCommand('Alt+g', 'menu-git', 'pressMenu("Git")', '')
+
+vd.addMenuItems('''
+    Git > Execute command > git-exec
+''')

{vgit → visidata/apps/vgit}/grep.py

@@ -4,13 +4,13 @@ from .gitsheet import GitSheet
 
 
 @VisiData.api
-def git_grep(vd, args):
-    return GitGrep(args[0], regex=args[0], source=Path('.'))
+def git_grep(vd, p, args):
+    return GitGrep(args[0], regex=args[0], source=p)
 
 
 class GitGrep(GitSheet):
     rowtype = 'results' # rowdef: list(file, line, line_contents)
-    help = '''
+    guide = '''
         # vgit grep
         Each row on this sheet is a line matching the regex pattern `{sheet.regex}` in the tracked files of the current directory.
 
@@ -27,10 +27,11 @@ class GitGrep(GitSheet):
         tmp = (self.topRowIndex, self.cursorRowIndex)
         for line in self.git_lines('grep', '--no-color', '-z', '--line-number', '--ignore-case', self.regex):
 #            line = line.replace(ESC+'[1;31m', '[:green]')
-#            line = line.replace(ESC+'[m', '[:]')
+#            line = line.replace(ESC+'[m', '[/]')
             yield list(line.split('\0'))
         self.topRowIndex, self.cursorRowIndex = tmp
 
 
-GitSheet.addCommand('g/', 'git-grep', 'rex=input("git grep: "); vd.push(GitGrep(rex, regex=rex, source=sheet))', 'find in all files in this repo'),
+GitSheet.addCommand('g/', 'git-grep', 'rex=inputRegex("git grep: "); vd.push(GitGrep(rex, regex=rex, source=sheet))', 'find in all files in this repo')
 GitGrep.addCommand('Ctrl+O', 'sysopen-row', 'launchExternalEditorPath(Path(cursorRow[0]), linenum=cursorRow[1]); reload()', 'open this file in $EDITOR')
+GitGrep.bindkey('Enter', 'sysopen-row')

visidata/apps/vgit/log.py

@@ -0,0 +1,81 @@
+import functools
+
+from visidata import vd, VisiData, Column, ItemColumn, date, RowColorizer, asyncthread, Progress, AttrDict
+
+from .gitsheet import GitSheet
+
+
+@VisiData.api
+def git_log(vd, p, *args):
+    return GitLogSheet('git-log', source=p, gitargs=args)
+
+# rowdef: (commit_hash, refnames, author, author_date, body, notes)
+class GitLogSheet(GitSheet):
+    guide = '''
+# git log {sheet.gitargstr}
+{sheet.cursorRow.message}
+    '''
+    GIT_LOG_FORMAT = ['%H', '%D', '%an <%ae>', '%ai', '%B', '%N']
+    rowtype = 'commits'  # rowdef: AttrDict
+    defer = True
+    savesToSource = True
+    columns = [
+        ItemColumn('commitid', width=8),
+        ItemColumn('refnames', width=12),
+        ItemColumn('message', type=str.strip, setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --message', v), width=50),
+        ItemColumn('author', setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --author', v)),
+        ItemColumn('author_date', type=date, setter=lambda c,r,v: c.sheet.git('commit --amend --no-edit --quiet --date', v)),
+        ItemColumn('notes', setter=lambda c,r,v: c.sheet.git('notes add --force --message', v, r.commitid)),
+    ]
+    colorizers = [
+            RowColorizer(5, 'color_vgit_unpushed', lambda s,c,r,v: r and not s.inRemoteBranch(r.commitid)),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @functools.lru_cache()
+    def inRemoteBranch(self, commitid):
+        return self.git_all('branch -r --contains', commitid, _ok_code=[0, 1])
+
+    def iterload(self):
+        lines = self.git_iter('log --no-color -z', '--pretty=format:' + '%x1f'.join(self.GIT_LOG_FORMAT), *self.gitargs)
+        for record in Progress(tuple(lines)):
+            r = record.split('\x1f')
+            yield AttrDict(
+                commitid=r[0],
+                refnames=r[1],
+                author=r[2],
+                author_date=r[3],
+                message=r[4],
+                notes=r[5],
+            )
+
+    def openRow(self, row):
+        'open this commit'
+        return getCommitSheet(row[0][:7], self, row[0])
+
+    @asyncthread
+    def commit(self, path, adds, mods, dels):
+
+        assert not adds
+        assert not dels
+
+        for row, rowmods in mods.values():
+            for col, val in rowmods.values():
+                vd.callNoExceptions(col.putValue, row, val)
+
+        self.reload()
+        self.resetDeferredCommit()
+
+
+GitLogSheet.addCommand(None, 'delete-row', 'error("delete is not supported")')
+GitLogSheet.addCommand(None, 'add-row', 'error("commits cannot be added")')
+#GitLogSheet.addCommand('x', 'git-pick', 'git("cherry-pick", cursorRow.commitid)', 'cherry-pick this commit onto current branch')
+#GitLogSheet.addCommand('r', 'git-reset-here', 'git("update-ref", "refs/heads/"+source, cursorRow[0])', 'reset this branch to this commit')
+
+GitSheet.addCommand('', 'git-log', 'vd.push(git_log(gitRootPath, branch))', 'push log of current branch')
+
+vd.addMenuItems('''
+    Git > Open > log > git-log
+''')

{vgit → visidata/apps/vgit}/main.py

@@ -4,9 +4,10 @@
 The syntax for vgit is the same as the syntax for git.
 By default, will pass the command to git verbatim, as quickly as possible.
 If vgit can provide an interactive interface for a particular subcommand,
-it will open the sheet returned by vd.git_<subcommand>().
+it will open the sheet returned by vd.git_<subcommand>(path, args).
 '''
 
+import os
 import sys
 
 
@@ -20,23 +21,35 @@ def vgit_cli():
         args.remove('--debug')
 
     if not args:
-#        return vd.run(vd.git_help())
-        return
+        args = ['help']
 
     func = getattr(vd, 'git_'+args[0], None)
     if func:
         vd.loadConfigAndPlugins()
         vd.status(visidata.__version_info__)
         vd.domotd()
+        if flDebug:
+            vd.options.debug = True
 
+        rc = 0
         try:
-            vs = func(args[1:])
+            p = Path('.')
+            vs = func(p, args[1:])
             if vs:
-                return vd.run(vs)
+                vd.run(vs)
+        except BrokenPipeError:
+            os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno()) # handle broken pipe gracefully
+        except visidata.ExpectedException as e:
+            print(str(e))
         except Exception as e:
+            rc = 1
             vd.exceptionCaught(e)
             if flDebug:
                 raise
 
+        sys.stderr.flush()
+        sys.stdout.flush()
+        os._exit(rc)  # cleanup can be expensive
+
     import subprocess
     return subprocess.run(['git', *args]).returncode

{vgit → visidata/apps/vgit}/remote.py

@@ -3,13 +3,13 @@ from visidata import vd, VisiData, ItemColumn, AttrDict, RowColorizer, Path
 from .gitsheet import GitSheet
 
 @VisiData.api
-def git_remote(vd, args=None):
+def git_remote(vd, p, args):
     if not args or 'show' in args:
-        return GitRemotes('remotes', source=Path('.'))
+        return GitRemotes('remotes', source=p)
 
 
 class GitRemotes(GitSheet):
-    help = '''
+    guide = '''
         # git remote
         Manage the set of repositories ("remotes") whose branches you track.
 
@@ -50,4 +50,8 @@ class GitRemotes(GitSheet):
         return AttrDict()
 
 
-vd.addCommand('', 'git-open-remotes', 'vd.push(git_remote())', 'open git remotes sheet')
+GitSheet.addCommand('', 'git-open-remotes', 'vd.push(git_remote(Path("."), ""))', 'open git remotes sheet')
+
+vd.addMenuItems('''
+    Git > Open > remotes > git-open-remotes
+''')

visidata/apps/vgit/repos.py

@@ -0,0 +1,71 @@
+from visidata import vd, VisiData, Sheet, Column, AttrColumn, date, vlen, asyncthread, Path, namedlist, PyobjSheet, modtime, AttrDict
+
+from .gitsheet import GitSheet
+
+@VisiData.api
+def guess_git(vd, p):
+    if (p/'.git').is_dir():
+        return dict(filetype='git', _likelihood=10)
+
+
+@VisiData.api
+def open_git(vd, p):
+    return vd.git_status(p, [])
+
+
+@VisiData.api
+def git_repos(vd, p, args):
+    return GitRepos(p.base_stem, source=p)
+
+
+class GitLinesColumn(Column):
+    def __init__(self, name, cmd, *args, **kwargs):
+        super().__init__(name, cache='async', **kwargs)
+        cmdparts = cmd.split()
+        if cmdparts[0] == 'git':
+            cmdparts = cmdparts[1:]
+        self.gitargs = cmdparts + list(args)
+
+    def calcValue(self, r):
+        lines = list(GitSheet(source=r).git_lines(*self.gitargs))
+        if lines:
+            return lines
+
+
+class GitAllColumn(GitLinesColumn):
+    def calcValue(self, r):
+        return GitSheet(source=r).git_all(*self.gitargs).strip()
+
+
+
+class GitRepos(GitSheet):
+    guide = '''
+        # git repos
+        A list of git repositories under `{sheet.source}`
+
+        - `Enter` to open the status sheet for the current repo
+    '''
+    rowtype = 'git repos'  # rowdef: Path
+    columns = [
+        Column('repo', type=str, width=30),
+        GitAllColumn('branch', 'git rev-parse --abbrev-ref HEAD', width=8),
+        GitLinesColumn('diffs', 'git diff --no-color', type=vlen, width=8),
+        GitLinesColumn('staged_diffs', 'git diff --cached', type=vlen, width=8),
+        GitLinesColumn('branches', 'git branch --no-color', type=vlen, width=10),
+        GitLinesColumn('stashes', 'git stash list', type=vlen, width=8),
+        Column('modtime', type=date, getter=lambda c,r: modtime(r)),
+    ]
+    nKeys = 1
+
+    def iterload(self):
+        import glob
+        for fn in glob.glob('**/.git', root_dir=self.source, recursive=True):
+            yield Path(fn).parent
+
+
+    def openRow(self, row):
+        return vd.git_status(row, [])
+
+    def openCell(self, col, row):
+        val = col.getValue(row)
+        return PyobjSheet(getattr(val, '__name__', ''), source=val)

{vgit → visidata/apps/vgit}/setup.py

@@ -2,19 +2,21 @@
 
 from setuptools import setup, find_packages
 
+# Note: use `python3 visidata/apps/setup.py install` from the root directory
+
 __version__ = '0.2-dev'
 
 setup(name='vgit',
       version=__version__,
       description='a sleek terminal user interface for git',
       # long_description=open('README.md').read(),
-      install_requires=['sh'], # visidata
-      package_dir={'':'visidata/apps'},
-      packages=['vgit'],
+      install_requires=['sh<2'], # visidata
+      packages=find_packages(exclude=["tests"]),
+      scripts=['vgit'],
+      entry_points={'visidata.plugins': 'vgit=visidata.apps.vgit'},
       author='Saul Pwanson',
       author_email='vgit@saul.pw',
       url='https://github.com/saulpw/visidata/vgit',
-      scripts=['bin/vgit'],
       license='GPLv3',
       python_requires='>=3.7',
       classifiers=[

visidata/apps/vgit/stash.py

@@ -0,0 +1,69 @@
+from visidata import vd, VisiData, ItemColumn, AttrDict
+
+
+from .gitsheet import GitSheet
+from .diff import GitDiffSheet
+
+
+@VisiData.api
+def git_stash(vd, p, args):
+    if 'list' in args:
+        return GitStashes('git-stash-list', source=p, gitargs=args)
+
+
+class GitStashes(GitSheet):
+    guide = '''
+        # git stash
+        This is the list of changes that have been stashed previously.
+
+        `a` to apply this stashed change (without removing it)
+        `d` to drop this stashed change
+        `b` to create a branch from this stashed change'),
+    '''
+    rowtype = 'stashed change'  # rowdef: AttrDict(stashid=, branched_from=, sha1=, msg=)
+    columns = [
+        ItemColumn('stashid'),
+        ItemColumn('branched_from'),
+        ItemColumn('sha1'),
+        ItemColumn('msg'),
+        ItemColumn('line', width=0),
+    ]
+
+    def iterload(self):
+        for line in self.git_lines('stash', *self.gitargs):
+            stashid, ctx, rest = line.split(': ', 2)
+            if ctx.startswith('WIP on '):
+                branched_from = ctx[len('WIP on '):]
+                sha1, msg = rest.split(' ', 1)
+            elif ctx.startswith('On '):
+                branched_from = ctx[len('On '):]
+                sha1 = ''
+                msg = rest
+            yield AttrDict(
+                line=line,
+                stashid=stashid,
+                branched_from=branched_from,
+                sha1=sha1,
+                msg=msg.strip(),
+            )
+
+    def openRow(self, row):
+        'open this stashed change'
+        return GitDiffSheet(row.stashid, "diffs", gitargs=['stash show --no-color --patch', row.stashid], source=self.source)
+
+
+GitSheet.addCommand('', 'git-open-stashes', 'vd.push(git_stash(source, ["list"]))', 'push stashes sheet')
+
+GitStashes.addCommand('a', 'git-stash-apply', 'loggit("stash", "apply", cursorRow[0])', 'apply this stashed change without removing')
+GitStashes.addCommand('', 'git-stash-pop', 'loggit("stash", "pop", cursorRow[0])', 'apply this stashed change and drop it')
+GitStashes.addCommand('d', 'git-stash-drop', 'loggit("stash", "drop", cursorRow[0])', 'drop this stashed change')
+GitStashes.addCommand('b', 'git-stash-branch', 'loggit("stash", "branch", input("create branch from stash named: "), cursorRow[0])', 'create branch from stash')
+
+
+vd.addMenuItems('''
+    Git > Open > stashes > git-open-stashes
+    Git > Stash > apply > git-stash-apply
+    Git > Stash > drop > git-stash-drop
+    Git > Stash > apply then drop  > git-stash-pop
+    Git > Stash > create branch > git-stash-branch
+''')