visidata 2.11.dev0__py3-none-any.whl → 3.0__py3-none-any.whl

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
+''')

visidata/apps/vgit/status.py

@@ -0,0 +1,204 @@
+from visidata import vd, Column, VisiData, ItemColumn, Path, AttrDict, BaseSheet, IndexSheet
+from visidata import RowColorizer, CellColorizer
+from visidata import filesize, modtime, date
+
+from .gitsheet import GitSheet
+#from .diff import DifferSheet
+
+vd.option('vgit_show_ignored', False, 'show ignored files on git status')
+vd.theme_option('color_git_staged_mod', 'green', 'color of files staged with modifications')
+vd.theme_option('color_git_staged_add', 'green', 'color of files staged for addition')
+vd.theme_option('color_git_staged_del', 'red', 'color of files staged for deletion')
+vd.theme_option('color_git_unstaged_del', 'on 88', 'color of files deleted but unstaged')
+vd.theme_option('color_git_untracked', '243 blue', 'color of ignored/untracked files')
+
+
+@VisiData.api
+def git_status(vd, p, args, **kwargs):
+    vs = GitStatus('/'.join(p.parts[-2:]), source=p)
+    if not vs.gitRootPath:
+        return vd.git_repos(p, [])
+    return vs
+
+class GitFile:
+    def __init__(self, path, gitsrc):
+        self.path = path
+        self.filename = path.relative_to(gitsrc)
+        self.is_dir = self.path.is_dir()
+
+    def __str__(self):
+        return str(self.filename) + (self.is_dir and '/' or '')
+
+class GitStatus(GitSheet):
+    rowtype = 'files'  # rowdef: GitFile
+    guide = '''
+        # git status
+        An overview of the local git checkout.
+
+        - `Enter` to open diff of file (`git diff`)
+        - `a` to stage changes in file (`git add`)
+        - `r` to unstage changes in file (`git reset`)
+        - `c` to revert all unstaged changes in file (`git checkout`)
+        - `d` to stage the entire file for deletion (`git rm`)
+        - `z Ctrl+S` to commit staged changes (`git commit`)
+    '''
+
+    columns = [
+        Column('path', width=40, getter=lambda c,r: str(r)),
+        Column('status', getter=lambda c,r: c.sheet.statusText(c.sheet.git_status(r)), width=8),
+        Column('status_raw', getter=lambda c,r: c.sheet.git_status(r), width=0),
+        Column('staged', getter=lambda c,r: c.sheet.git_status(r).dels),
+        Column('unstaged', getter=lambda c,r: c.sheet.git_status(r).adds),
+        Column('type', getter=lambda c,r: r.is_dir() and '/' or r.suffix, width=0),
+        Column('size', type=int, getter=lambda c,r: filesize(r)),
+        Column('modtime', type=date, getter=lambda c,r: modtime(r)),
+    ]
+    nKeys = 1
+
+    colorizers = [
+        CellColorizer(3, 'color_git_staged_mod',   lambda s,c,r,v: r and c and c.name == 'staged' and s.git_status(r).status[0] == 'M'), # staged mod
+        CellColorizer(1, 'color_git_staged_del',     lambda s,c,r,v: r and c and c.name == 'staged' and s.git_status(r).status == 'D '), # staged delete
+        RowColorizer(1, 'color_git_staged_add',  lambda s,c,r,v: r and s.git_status(r).status in ['A ', 'M ']), # staged add/mod
+        RowColorizer(1, 'color_git_unstaged_del',       lambda s,c,r,v: r and s.git_status(r).status[1] == 'D'), # unstaged delete
+        RowColorizer(3, 'color_git_untracked', lambda s,c,r,v: r and s.git_status(r).status == '!!'),  # ignored
+        RowColorizer(1, 'color_git_untracked', lambda s,c,r,v: r and s.git_status(r).status == '??'),  # untracked
+    ]
+
+    def statusText(self, st):
+        vmod = {'A': 'add', 'D': 'rm', 'M': 'mod', 'T': 'chmod', '?': '', '!': 'ignored', 'U': 'unmerged'}
+        x, y = st.status
+        if st == '??': # untracked
+            return 'new'
+        elif st == '!!':  # ignored
+            return 'ignored'
+        elif x != ' ' and y == ' ': # staged
+            return vmod.get(x, x)
+        elif y != ' ': # unstaged
+            return vmod.get(y, y)
+        else:
+            return ''
+
+    @property
+    def workdir(self):
+        return str(self.source)
+
+    def git_status(self, r):
+        '''return tuple of (status, adds, dels).
+        status like !! ??
+        adds and dels are lists of additions and deletions.
+        '''
+        if not r:
+            return None
+
+        fn = str(r)
+        ret = self._cachedStatus.get(fn, None)
+        if not ret:
+            ret = AttrDict(status='??')
+            self._cachedStatus[fn] = ret
+
+        return ret
+
+    def ignored(self, fn):
+        if self.options.vgit_show_ignored:
+            return False
+
+        if fn in self._cachedStatus:
+            return self._cachedStatus[fn].status == '!!'
+
+        return False
+
+    @property
+    def remotediff(self):
+        return self.gitBranchStatuses.get(self.branch, 'no branch')
+
+    def iterload(self):
+        files = [GitFile(p, self.source) for p in self.source.iterdir() if p.base_stem not in ('.git')]  # files in working dir
+
+        filenames = dict((gf.filename, gf) for gf in files)
+
+        self._cachedStatus.clear()
+        for fn in self.git_iter('ls-files', '-z'):
+            self._cachedStatus[fn] = AttrDict(status='  ')
+
+        for line in self.git_iter('status', '-z', '-unormal', '--ignored'):
+            if not line: continue
+
+            if line[2:3] == ' ':
+                st, fn = line[:2], line[3:]
+            else:
+                fn = line
+                st = '??'  # untracked file
+
+            self._cachedStatus[fn] = AttrDict(status=st)
+            if not self.ignored(fn):
+                yield Path(fn)
+
+        for line in self.git_iter('diff-files', '--numstat', '-z'):
+            if not line: continue
+            adds, dels, fn = line.split('\t')
+            if fn not in self._cachedStatus:
+                self._cachedStatus[fn] = AttrDict(status='##')
+            cs = self._cachedStatus[fn]
+            cs.adds = '+%s/-%s' % (adds, dels)
+
+        for line in self.git_iter('diff-index', '--cached', '--numstat', '-z', 'HEAD'):
+            if not line: continue
+            adds, dels, fn = line.split('\t')
+            if fn not in self._cachedStatus:
+                self._cachedStatus[fn] = AttrDict(status='$$')
+            cs = self._cachedStatus[fn]
+            cs.dels = '+%s/-%s' % (adds, dels)
+
+        self.orderBy(None, self.columns[-1], reverse=True)
+
+        self.recalc()  # erase column caches
+
+    def openRow(self, row):
+        'Open unstaged diffs for this file, or dive into directory'
+        if row.is_dir:
+            return GitStatus(row.path)
+        else:
+            return DifferSheet(row, "HEAD", "index", "working", source=sheet)
+
+    def openRows(self, rows):
+        'Open unstaged hunks for selected rows'
+        return getHunksSheet(sheet, *rows)
+
+
+@GitStatus.lazy_property
+def _cachedStatus(self):
+    return {}  # [filename] -> AttrDict(status='xx', adds=, dels=)
+
+
+GitStatus.addCommand('a', 'git-add', 'loggit("add", cursorRow.filename)', 'add this new file or modified file to staging')
+#GitStatus.addCommand('m', 'git-mv', 'loggit("mv", cursorRow.filename, input("rename file to: ", value=cursorRow.filename))', 'rename this file')
+GitStatus.addCommand('d', 'git-rm', 'loggit("rm", cursorRow.filename)', 'stage this file for deletion')
+GitStatus.addCommand('r', 'git-reset', 'loggit("reset", "HEAD", cursorRow.filename)', 'reset/unstage this file')
+GitStatus.addCommand('c', 'git-checkout', 'loggit("checkout", cursorRow.filename)', 'checkout this file')
+GitStatus.addCommand('ga', 'git-add-selected', 'loggit("add", *[r for r in selectedRows])', 'add all selected files to staging')
+GitStatus.addCommand('gd', 'git-rm-selected', 'loggit("rm", *[r for r in selectedRows])', 'delete all selected files')
+GitStatus.addCommand(None, 'git-commit', 'loggit("commit", "-m", input("commit message: "))', 'commit changes')
+GitStatus.addCommand(None, 'git-ignore-file', 'open(rootPath/".gitignore", "a").write(cursorRow.filename+"\\n"); reload()', 'add file to toplevel .gitignore')
+GitStatus.addCommand(None, 'git-ignore-wildcard', 'open(rootPath/.gitignore, "a").write(input("add wildcard to .gitignore: "))', 'add input line to toplevel .gitignore')
+
+
+#GitStatus.addCommand('z^J', 'diff-file-staged', 'vd.push(getStagedHunksSheet(sheet, cursorRow))', 'push staged diffs for this file')
+#GitStatus.addCommand('gz^J', 'diff-selected-staged', 'vd.push(getStagedHunksSheet(sheet, *(selectedRows or rows)))', 'push staged diffs for selected files or all files')
+#GitStatus.addCommand('^O', 'sysopen-row', 'launchExternalEditorPath(Path(cursorRow.path))', 'open this file in $EDITOR')
+
+
+vd.addMenuItems('''
+    Git > View staged changes > current file > diff-file-staged
+    Git > View staged changes > selected files > staged changes > diff-selected-staged
+    Git > Stage > current file > git-add
+    Git > Stage > selected files > git-add-selected
+    Git > Unstage > current file > git-reset
+    Git > Unstage > selected files > git-reset-selected
+    Git > Rename file > git-mv
+    Git > Delete > file > git-rm
+    Git > Delete > selected files > git-rm-selected
+    Git > Ignore > file > ignore-file
+    Git > Ignore > wildcard > ignore-wildcard
+    Git > Commit staged changes > git-commit
+    Git > Revert unstaged changes > current file > git-checkout
+''')

visidata/apps/vgit/statusbar.py

@@ -0,0 +1,34 @@
+from .gitsheet import vd, GitSheet
+
+
+GitSheet.options.disp_status_fmt = '{sheet.progressStatus}‹{sheet.branchStatus}› {sheet.name}| '
+
+@GitSheet.property
+def progressStatus(sheet):
+    inp = sheet.gitInProgress()
+    return ('[%s] ' % inp) if inp else ''
+
+
+@GitSheet.property
+def branchStatus(sheet):
+    if hasattr(sheet.gitRootSheet, 'branch'):
+        return '%s%s' % (sheet.rootSheet.branch, sheet.rootSheet.remotediff)
+    return ''
+
+
+@GitSheet.api
+def gitInProgress(sheet):
+    p = sheet.gitPath
+    if not p:
+        return 'no repo'
+    if (p/'rebase-merge').exists() or (p/'rebase-apply/rebasing').exists():
+        return 'rebasing'
+    elif p/'rebase-apply'.exists():
+        return 'applying'
+    elif p/'CHERRY_PICK_HEAD'.exists():
+        return 'cherry-picking'
+    elif p/'MERGE_HEAD'.exists():
+        return 'merging'
+    elif p/'BISECT_LOG'.exists():
+        return 'bisecting'
+    return ''

visidata/basesheet.py

@@ -1,8 +1,7 @@
 import os
 
 import visidata
-from visidata import Extensible, VisiData, vd, EscapeException, cleanName
-from unittest import mock
+from visidata import Extensible, VisiData, vd, EscapeException, MissingAttrFormatter, AttrDict
 
 
 UNLOADED = tuple()  # sentinel for a sheet not yet loaded for the first time
@@ -98,6 +97,7 @@ class BaseSheet(DrawablePane):
     rowtype = 'objects'  # one word, plural, describing the items
     precious = True      # False for a few discardable metasheets
     defer = False        # False for not deferring changes until save
+    guide = ''           # default to show in sidebar
 
     def _obj_options(self):
         return vd.OptionsObject(vd._options, obj=self)
@@ -107,15 +107,14 @@ class BaseSheet(DrawablePane):
 
     class_options = options = _dualproperty(_obj_options, _class_options)
 
-    def __init__(self, *names, **kwargs):
+    def __init__(self, *names, rows=UNLOADED, **kwargs):
         self._name = None   # initial cache value necessary for self.options
-        self.names = names
+        self.loading = False
+        self.names = list(names)
         self.name = self.options.name_joiner.join(str(x) for x in self.names if x)
         self.source = None
-        self.rows = UNLOADED      # list of opaque objects
-        self._scr = mock.MagicMock(__bool__=mock.Mock(return_value=False))  # disable curses in batch mode
-        self.mouseX = 0
-        self.mouseY = 0
+        self.rows = rows      # list of opaque objects
+        self._scr = None
         self.hasBeenModified = False
 
         super().__init__(**kwargs)
@@ -153,6 +152,14 @@ class BaseSheet(DrawablePane):
     def __str__(self):
         return self.name
 
+    @property
+    def rows(self):
+        return self._rows
+
+    @rows.setter
+    def rows(self, rows):
+        self._rows = rows
+
     @property
     def nRows(self):
         'Number of rows on this sheet.  Override in subclass.'
@@ -165,11 +172,26 @@ class BaseSheet(DrawablePane):
             return vs in self.source
         return False
 
-    def execCommand(self, cmd, vdglobals=None, keystrokes=None):
-        cmd = self.getCommand(cmd or keystrokes)
+    @property
+    def displaySource(self):
+        if isinstance(self.source, BaseSheet):
+            return f'the *{self.source[0]}* sheet'
+
+        if isinstance(self.source, (list, tuple)):
+            if len(self.source) == 1:
+                return f'the **{self.source[0]}** sheet'
+            return f'{len(self.source)} sheets'
+
+        return f'**{self.source}**'
+
+    def execCommand(self, longname, vdglobals=None, keystrokes=None):
+        if ' ' in longname:
+            cmd, arg = longname.split(' ', maxsplit=1)
+            vd.injectInput(arg)
+
+        cmd = self.getCommand(longname or keystrokes)
         if not cmd:
-            if keystrokes:
-                vd.status('no command for %s' % keystrokes)
+            vd.warning('no command for %s' % (longname or keystrokes))
             return False
 
         escaped = False
@@ -183,25 +205,30 @@ class BaseSheet(DrawablePane):
         try:
             for hookfunc in vd.beforeExecHooks:
                 hookfunc(self, cmd, '', keystrokes)
-            vd.debug(cmd.longname)
             escaped = super().execCommand2(cmd, vdglobals=vdglobals)
         except Exception as e:
             vd.debug(cmd.execstr)
             err = vd.exceptionCaught(e)
             escaped = True
 
-        try:
-            if vd.cmdlog:
-                # sheet may have changed
-                vd.cmdlog.afterExecSheet(vd.activeSheet, escaped, err)
-        except Exception as e:
-            vd.exceptionCaught(e)
+        if vd.cmdlog:
+            # sheet may have changed
+            vd.callNoExceptions(vd.cmdlog.afterExecSheet, vd.activeSheet, escaped, err)
 
-        self.checkCursorNoExceptions()
+        vd.callNoExceptions(self.checkCursor)
 
         vd.clearCaches()
+
+        for t in self.currentThreads:
+            if not hasattr(t, 'lastCommand'):
+                t.lastCommand = True
+
         return escaped
 
+    @property
+    def lastCommandThreads(self):
+        return [t for t in self.currentThreads if getattr(t, 'lastCommand', None)]
+
     @property
     def names(self):
         return self._names
@@ -224,8 +251,7 @@ class BaseSheet(DrawablePane):
         self._name = self.maybeClean(str(name))
 
     def maybeClean(self, s):
-        if self.options.clean_names:
-            s = cleanName(s)
+        'stub'
         return s
 
     def recalc(self):
@@ -233,10 +259,8 @@ class BaseSheet(DrawablePane):
         pass
 
     def refresh(self):
-        'Clear the terminal screen and let the next draw cycle redraw everything.'
-        if self._scr:
-            self._scr.clear()
-            self._scr.refresh()
+        'Recalculate any internal state needed for `draw()`.  Overridable.'
+        pass
 
     def ensureLoaded(self):
         'Call ``reload()`` if not already loaded.'
@@ -257,30 +281,14 @@ class BaseSheet(DrawablePane):
         'Check cursor and fix if out-of-bounds.  Overridable.'
         pass
 
-    def checkCursorNoExceptions(self):
-        try:
-            return self.checkCursor()
-        except Exception as e:
-            vd.exceptionCaught(e)
-
     def evalExpr(self, expr, **kwargs):
         'Evaluate Python expression *expr* in the context of *kwargs* (may vary by sheet type).'
         return eval(expr, vd.getGlobals(), None)
 
-    @property
-    def sidebar(self):
-        'Default implementation just returns set value.  Overridable.'
-        return self._sidebar
+    def formatString(self, fmt, **kwargs):
+        'Return formatted string with *sheet* and *vd* accessible to expressions.  Missing expressions return empty strings instead of error.'
+        return MissingAttrFormatter().format(fmt, sheet=self, vd=vd, **kwargs)
 
-    @sidebar.setter
-    def sidebar(self, v):
-        'Default implementation just sets value.  Overridable.'
-        self._sidebar = v
-
-    @property
-    def sidebar_title(self):
-        'Default implementation returns fixed value.  Overridable.'
-        return 'sidebar'
 
 
 @VisiData.api
@@ -288,10 +296,11 @@ def redraw(vd):
     'Clear the terminal screen and let the next draw cycle recreate the windows and redraw everything.'
     for vs in vd.sheets:
         vs._scr = None
-    vd.scrFull.clear()
-    vd.win1.clear()
-    vd.win2.clear()
-    vd.setWindows(vd.scrFull)
+    if vd.win1: vd.win1.clear()
+    if vd.win2: vd.win2.clear()
+    if vd.scrFull:
+        vd.scrFull.clear()
+        vd.setWindows(vd.scrFull)
 
 
 @VisiData.property
@@ -299,7 +308,7 @@ def sheet(self):
     return self.activeSheet
 
 @VisiData.api
-def isLongname(self, ks):
+def isLongname(self, ks:str):
     'Return True if *ks* is a longname.'
     return ('-' in ks) and (ks[-1] != '-') or (len(ks) > 3 and ks.islower())