示例#1
0
    def on_bufenter(self, bufnum):
        """
        There are four cases on bufenter:
        1. The buffer is not a netranger buffer: do nothing
        2. The buffer is a existing netranger buffer: refresh buffer content (e.g. directory content changed else where) and call any pending onuiquit functions
        3. The buffer is a [No Name] temporary buffer and the buffer name is a directory. Then we either create a new netranger buffer or bring up an existing netranger buffer
        """
        if bufnum in self.bufs:
            self.refresh_curbuf()
            if self.onuiquit is not None:
                # If not enough arguments are passed, ignore the pending onuituit, e.g. quit the bookmark go ui without pressing key to specify where to go.
                if len(VimVar('NETRRegister')) == self.onuiquitNumArgs:
                    self.onuiquit(*VimVar('NETRRegister'))
                self.onuiquit = None
                self.vim.vars['NETRRegister'] = []
                self.onuiquitNumArgs = 0
        else:
            bufname = self.vim.current.buffer.name
            if len(bufname) > 0 and bufname[-1] == '~':
                bufname = os.path.expanduser('~')
            if not os.path.isdir(bufname):
                return

            bufname = os.path.abspath(bufname)
            if self.buf_existed(bufname):
                self.show_existing_buf(bufname)
            else:
                self.gen_new_buf(bufname)
示例#2
0
    def __init__(self, vim):
        self.vim = vim
        self.inited = False
        self.bufs = {}
        self.wd2bufnum = {}
        self.pinnedRoots = set()
        self.picked_nodes = defaultdict(set)
        self.cut_nodes, self.copied_nodes = defaultdict(set), defaultdict(set)
        self.bookmarkUI = None
        self.helpUI = None
        self.sortUI = None
        self.askUI = None
        self.onuiquit = None
        self.onuiquitNumArgs = 0
        self.fs = FS()
        self.rclone = None

        self.initVimVariables()
        self.initKeymaps()
        Shell.mkdir(default.variables['NETRRootDir'])
        self.rifle = Rifle(self.vim, VimVar('NETRRifleFile'))
        ignore_pat = list(VimVar('NETRIgnore'))
        self.vim.vars['NETRemoteCacheDir'] = os.path.expanduser(
            VimVar('NETRemoteCacheDir'))
        if '.*' not in ignore_pat:
            ignore_pat.append('.*')
            self.vim.vars['NETRIgnore'] = ignore_pat
示例#3
0
 def load_bookmarks(self):
     self.mark_dict = {}
     if os.path.isfile(VimVar('NETRBookmarkFile')):
         with open(VimVar('NETRBookmarkFile'), 'r') as f:
             for line in f:
                 kp = line.split(':')
                 if (len(kp) == 2):
                     self.mark_dict[kp[0].strip()] = kp[1].strip()
示例#4
0
    def NETRemoteList(self):
        if self.rclone is None:
            Rclone.valid_or_install(self.vim)
            self.rclone = Rclone(VimVar('NETRemoteCacheDir'),
                                 VimVar('NETRemoteRoots'))

        if self.rclone.has_remote:
            self.vim.command('tabe ' + VimVar('NETRemoteCacheDir'))
        else:
            VimErrorMsg(
                "There's no remote now. Run 'rclone config' in a terminal to setup remotes"
            )
示例#5
0
    def NETRBufPanelOpen(self):
        if self.curNode.isDir:
            return

        if len(self.vim.current.tabpage.windows) == 1:
            self.NETROpen(VimVar('NETRSplitOrientation') + ' vsplit',
                          use_rifle=False)
            newsize = VimCurWinWidth() * VimVar('NETRPanelSize')
            self.vim.command('vertical resize {}'.format(newsize))
        else:
            fpath = self.curNode.fullpath
            self.vim.command('wincmd l')
            self.vim.command('edit {}'.format(fpath))
示例#6
0
 def initKeymaps(self):
     """
     Add key mappings to NETR* functions for netranger buffers. Override or skip some default mappings on user demand.
     """
     self.keymaps = {}
     self.keymap_doc = {}
     skip = []
     for k in VimVar('NETRDefaultMapSkip'):
         skip.append(k.lower())
     for fn, (keys, desc) in default.keymap.items():
         user_keys = VimVar(fn, [])
         user_keys += [k for k in keys if k not in skip]
         self.keymaps[fn] = user_keys
         self.keymap_doc[fn] = (user_keys, desc)
示例#7
0
 def edit(self):
     self.vim.command('belowright split {}'.format(
         VimVar('NETRBookmarkFile')))
     self.vim.command('setlocal bufhidden=wipe')
     self.del_buf('set')
     self.del_buf('go')
     self.netranger.pend_onuiquit(self.load_bookmarks)
示例#8
0
    def _set(self, mark):
        if mark == '':
            return
        if mark not in self.valid_mark:
            self.vim.command('echo "Only a-zA-Z are valid mark!!"')
            return
        set_buf = self.bufs['set']
        set_buf.options['modifiable'] = True

        if mark in self.mark_dict:
            for i, line in enumerate(set_buf):
                if len(line) > 0 and line[0] == mark:
                    set_buf[i] = '{}:{}'.format(mark, self.path_to_mark)
                    break
        elif self.path_to_mark in self.mark_dict.values():
            for i, line in enumerate(set_buf):
                if len(line) > 0 and line[2:] == self.path_to_mark:
                    set_buf[i] = '{}:{}'.format(mark, self.path_to_mark)
                    break
        else:
            set_buf.append('{}:{}'.format(mark, self.path_to_mark))
        set_buf.options['modifiable'] = False
        self.mark_dict[mark] = self.path_to_mark
        self.del_buf('go')
        with open(VimVar('NETRBookmarkFile'), 'w') as f:
            for k, p in self.mark_dict.items():
                f.write('{}:{}\n'.format(k, p))
示例#9
0
    def __init__(self, vim, netranger):
        UI.__init__(self, vim)
        self.valid_mark = string.ascii_lowercase + string.ascii_uppercase
        self.netranger = netranger
        self.mark_dict = {}
        self.path_to_mark = None

        # This is to avoid a bug that I can't solve.
        # If bookmark file is initially empty. The first time
        # 'm' (set) mapping is trigger, it won't quit the buffer
        # on user input..
        if not os.path.isfile(VimVar('NETRBookmarkFile')):
            with open(VimVar('NETRBookmarkFile'), 'w') as f:
                f.write('/:/')

        self.load_bookmarks()
示例#10
0
    def reset_default_colors(self):
        for name, color in VimVar('NETRColors').items():
            if name not in default.color:
                VimErrorMsg('netranger: {} is not a valid NETRColors key!')
                continue
            if type(color) is int and (color < 0 or color > 255):
                VimErrorMsg('netranger: Color value should be within 0~255')
                continue
            elif type(color) is str and color not in colortbl:
                VimErrorMsg('netranger: {} is not a valid color name!')
                continue

            default.color[name] = color
示例#11
0
    def gen_new_buf(self, bufname):
        bufnum = self.vim.current.buffer.number
        if (bufname.startswith(VimVar('NETRemoteCacheDir'))):
            self.bufs[bufnum] = NetRangerBuf(self.vim,
                                             os.path.abspath(bufname),
                                             self.rclone, self.rifle)
        else:
            self.bufs[bufnum] = NetRangerBuf(self.vim,
                                             os.path.abspath(bufname), self.fs,
                                             self.rifle)

        self.map_keys()
        self.wd2bufnum[bufname] = bufnum
        self.setBufOption()
示例#12
0
 def NETRToggleShowHidden(self):
     """
     Change ignore pattern and mark all existing netranger buffers to be content_outdated so that their content will be updated when entered again.
     """
     ignore_pat = VimVar('NETRIgnore')
     if '.*' in ignore_pat:
         ignore_pat.remove('.*')
     else:
         ignore_pat.append('.*')
     self.vim.vars['NETRIgnore'] = ignore_pat
     for buf in self.bufs.values():
         buf.content_outdated = True
     self.curBuf.refresh_nodes(force_refreh=True)
示例#13
0
    def NETROpen(self, open_cmd=None, rifle_cmd=None, use_rifle=True):
        """
        The real work for opening directories is handled in on_bufenter. For openning files, we check if there's rifle rule to open the file. Otherwise, open it in vim.
        """
        curNode = self.curNode
        if curNode.isINFO:
            return

        if open_cmd is None:
            if curNode.isDir:
                open_cmd = 'edit'
            else:
                open_cmd = VimVar('NETROpenCmd')

        fullpath = curNode.fullpath
        if curNode.isDir:
            if curNode.size == '?' or curNode.size == '':
                VimErrorMsg('Permission Denied: {}'.format(curNode.name))
                return
            self.vim.command('silent {} {}'.format(open_cmd, fullpath))
            # manually call on_bufenter as vim might not trigger BufEnter with the above command
            self.on_bufenter(self.vim.eval("winnr()"))
        else:
            if self.rclone is not None and self.isRemotePath(fullpath):
                self.rclone.ensure_downloaded(fullpath)

            if rifle_cmd is None:
                rifle_cmd = self.rifle.decide_open_cmd(fullpath)

            if use_rifle and rifle_cmd is not None:
                Shell.run_async(rifle_cmd.format(fullpath))
            else:
                try:
                    self.vim.command('{} {}'.format(open_cmd, fullpath))
                except Exception as e:
                    err_msg = str(e)
                    if 'E325' not in err_msg:
                        VimErrorMsg(err_msg)
示例#14
0
 def shouldIgnore(self, basename):
     for ig in VimVar('NETRIgnore'):
         if fnmatch.fnmatch(basename, ig):
             return True
     return False
示例#15
0
 def NETRBufHSplitOpen(self):
     self.NETROpen(VimVar('NETRSplitOrientation') + ' split',
                   use_rifle=False)
示例#16
0
 def position(self):
     return VimVar('NETRSplitOrientation')
示例#17
0
 def isRemotePath(self, path):
     return path.startswith(VimVar('NETRemoteCacheDir'))
示例#18
0
 def shouldIgnore(self, basename):
     # TODO this is not efficient for neovim
     for ig in VimVar('NETRIgnore'):
         if fnmatch.fnmatch(basename, ig):
             return True
     return False