def neovim_python_devel():
playground = 'playground-neovim-python'
venv = HOME + '/' + playground
msg = 'Put a dev version of neovim-python in %s?' % playground
if not yesno('install_neovim_python', msg, False):
return
# my fork of the neovim project
origin = 'ssh://[email protected]/phodge/python-client.git'
# the main neovim repo - for pulling
neovim = 'https://github.com/neovim/python-client.git'
# where to put the local clone
checkout = venv + '/python-client.git'
# create the symlink for the neovim project
mkdir(venv)
if not os.path.exists(checkout):
# NOTE: using execute() directly means the checkout directory isn't tracked by homely ...
# this is exactly what I want
execute(['git', 'clone', origin, checkout])
execute(['git', 'remote', 'add', 'neovim', neovim], cwd=checkout)
execute(['git', 'fetch', 'neovim', '--prune'], cwd=checkout)
if not os.path.exists(os.path.join(venv, 'bin')):
execute(['virtualenv', '--python=python3', venv], stdout="TTY")
if not os.path.exists(os.path.join(venv, 'bin')):
execute(['virtualenv', '--python=python3', venv], stdout="TTY")
# create a python2 virtualenv as well
py2venv = os.path.join(venv, 'py2venv')
if not os.path.exists(os.path.join(py2venv, 'bin')):
execute(['virtualenv', '--python=python2.7', py2venv], stdout="TTY")
# create a symlink to the git repo
symlink(checkout, os.path.join(py2venv, 'python-client.git'))
for path in [venv, py2venv]:
pip = os.path.join(path, 'bin', 'pip')
execute([pip, 'install', '--editable', 'python-client.git'], cwd=path)
mypips(pip)
# we will definitely need tests
execute([pip, 'install', 'nose'])
if wantjerjerrod():
# register the playground with jerjerrod
jerjerrod_addline('WORKSPACE', venv, ignore=["py2venv"])
def homely_dev():
if not yesno("create_homely_venv",
"Create ~/playground-homely virtualenv?", False):
return
venv = environ['HOME'] + '/playground-homely'
# create container dir
mkdir(venv)
checkout = join(venv, 'homely.git')
# create the virtualenv if it doesn't already exist
if not exists(join(venv, 'bin')):
execute(['virtualenv', '--python=python3', venv], stdout="TTY")
# check out homely.git repo if it isn't there yet
if not exists(checkout):
execute(['git', 'clone', '[email protected]:phodge/homely.git', checkout],
stdout="TTY")
# need to install editable version of homely.git in both virtualenvs
venv_pip = venv + '/bin/pip'
execute([venv_pip, 'install', '--editable', checkout])
mypips(venv_pip)
# install all dev requirements
execute(
[venv_pip, 'install', '-r',
join(checkout, 'requirements_dev.txt')])
if wantjerjerrod():
# register the playground with jerjerrod
jerjerrod_addline('WORKSPACE', venv, ignore=["py2venv"])
# we may want to install pandoc to make the slides, but
if yesno('homley_want_pandoc',
'Install pandoc to create slides?',
recommended=True):
from homely.install import installpkg
installpkg('pandoc')
def vim_config():
# install vim-plug into ~/.vim
mkdir('~/.vim')
mkdir('~/.nvim')
mkdir('~/.config')
mkdir('~/.config/nvim')
symlink('~/.vimrc', '~/.config/nvim/init.vim')
mkdir('~/.vim/autoload')
download(
'https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim',
'~/.vim/autoload/plug.vim')
def mkdir_r(path):
assert len(path)
if os.path.islink(path):
raise Exception(
"Cannot mkdir_r(%r): path already exists but is a symlink" %
path)
# if the thing already exists but isn't a dir, then we can't create it
if os.path.exists(path) and not os.path.isdir(path):
raise Exception(
"Cannot mkdir_r(%r): path already exists but is not a dir" %
path)
# create the parent then our target path
parent = os.path.dirname(path)
if len(parent) > 5:
mkdir_r(parent)
mkdir(path)
def _static(url, dest):
dest = HOME + '/.vimstatic/' + dest
mkdir_r(os.path.dirname(dest))
download(url, dest)
vprefs = HOME + '/.vim/prefs.vim'
nprefs = HOME + '/.nvim/prefs.vim'
# chuck in a reference to our shiny new vimrc.vim (this will end up below the rtp magic block)
lineinfile('~/.vimrc', 'source %s/vimrc.vim' % HERE, where=WHERE_TOP)
# do we want a debugger plugin in vim?
for varname, varval in get_vim_options().items():
lineinfile(
'~/.vim/prefs.vim',
f'let {varname} = {"1" if varval else "0"} " set by phodge\'s dotfiles'
.format(varname, '1' if varval else '0'),
where=WHERE_END,
)
# put our magic &rtp block at the top of our vimrc
blockinfile('~/.vimrc', [
' " reset rtp',
' set runtimepath&',
' " let other scripts know they\'re allowed to modify &rtp',
' let g:allow_rtp_modify = 1',
' " grab local preferences',
' if filereadable(%r)' % vprefs,
' source %s' % vprefs,
' endif',
' if has(\'nvim\') && filereadable(%r)' % nprefs,
' source %s' % nprefs,
' endif',
],
'" {{{ START OF dotfiles runtimepath magic',
'" }}} END OF dotfiles runtimepath magic',
where=WHERE_TOP)
# if the .vimrc.preferences file doesn't exist, create it now
if not os.path.exists(vprefs):
with open(vprefs, 'w') as f:
f.write('let g:vim_peter = 1\n')
# make sure we've made a choice about clipboard option in vprefs file
@whenmissing(vprefs, 'clipboard')
def addclipboard():
if allowinteractive():
if yesno(None, 'Use system clipboard in vim? (clipboard=unnamed)',
None):
rem = "Use system clipboard"
val = 'unnamed'
else:
rem = "Don't try and use system clipboard"
val = ''
with open(vprefs, 'a') as f:
f.write('" %s\n' % rem)
f.write("set clipboard=%s\n" % val)
# put a default value about whether we want the hacky mappings for when the
# terminal type isn't set correctly
@whenmissing(vprefs, 'g:hackymappings')
def sethackymappings():
with open(vprefs, 'a') as f:
f.write('" Use hacky mappings for F-keys and keypad?\n')
f.write('let g:hackymappings = 0\n')
# in most cases we don't want insight_php_tests
@whenmissing(vprefs, 'g:insight_php_tests')
def setinsightphptests():
with open(vprefs, 'a') as f:
f.write('" Do we want to use insight to check PHP code?\n')
f.write('let g:insight_php_tests = []\n')
# lock down &runtimepath
lineinfile('~/.vimrc', 'let g:allow_rtp_modify = 0', where=WHERE_END)
# if we have jerjerrod installed, add an ALWAYSFLAG entry for git repos in ~/src/plugedit
if False and wantjerjerrod():
mkdir('~/.config')
mkdir('~/.config/jerjerrod')
lineinfile('~/.config/jerjerrod/jerjerrod.conf',
'PROJECT ~/src/plugedit/*.git ALWAYSFLAG')
# icinga syntax/filetype
if yesno('want_vim_icinga_stuff',
'Install vim icinga2 syntax/ftplugin?',
default=False):
files = ['syntax/icinga2.vim', 'ftdetect/icinga2.vim']
for name in files:
url = 'https://raw.githubusercontent.com/Icinga/icinga2/master/tools/syntax/vim/{}'
_static(url.format(name), name)
# <est> utility
hasphp = haveexecutable('php')
if yesno('install_est_utility', 'Install <vim-est>?', hasphp):
est = InstallFromSource('https://github.com/phodge/vim-est.git',
'~/src/vim-est.git')
est.select_branch('master')
est.symlink('bin/est', '~/bin/est')
run(est)
def powerline_theme():
right = [
{
"function": "todonext.powerline.firstitem"
},
]
if haveexecutable('jerjerrod') and wantjerjerrod():
wsnames = "jerjerrod.powerline.wsnames"
right += [
{
"function": "jerjerrod.powerline.wsscancount"
},
{
"function": wsnames,
"args": {
"category": "JERJERROD:CHANGED"
}
},
{
"function": wsnames,
"args": {
"category": "JERJERROD:UNTRACKED"
}
},
{
"function": wsnames,
"args": {
"category": "JERJERROD:UNPUSHED"
}
},
{
"function": wsnames,
"args": {
"category": "JERJERROD:UNKNOWN"
}
},
]
right.append({
"function": "homely.powerline.shortstatus",
"args": {
"autoupdate":
True,
"reattach_to_user_namespace":
haveexecutable('reattach-to-user-namespace'),
"colors": {
"paused": "HOMELY:PAUSED",
"running": "HOMELY:RUNNING",
"failed": "HOMELY:FAILED",
"noconn": "HOMELY:NOCONN",
"dirty": "HOMELY:DIRTY",
"never": "HOMELY:NEVER",
"ok": "HOMELY:OK",
}
},
})
right.append({
"function": "powerline.segments.common.time.date",
"name": "time",
"args": {
"format": "%H:%M",
"istime": True,
},
})
right.append({"function": "powerline.segments.common.net.hostname"})
config = {"segments": {"right": right}}
if want_unicode_fix():
config["segment_data"] = {"time": {"before": ""}}
import simplejson
dumped = simplejson.dumps(config)
mkdir('~/.config')
mkdir('~/.config/powerline')
mkdir('~/.config/powerline/themes')
mkdir('~/.config/powerline/themes/tmux')
with writefile('~/.config/powerline/themes/tmux/default.json') as f:
f.write(dumped)
def install_completions(rcfile):
lineinfile(rcfile, 'want_click_completion homely')
if wantjerjerrod():
lineinfile(rcfile, 'want_click_completion jerjerrod')
from homely.general import run, section, haveexecutable, WHERE_TOP
from homely.files import lineinfile
from homely.install import InstallFromSource
from homely.ui import yesno
from HOMELY import HERE, jerjerrod_addline, wantjerjerrod, IS_OSX
jerjerrod_clear_cache_in_shell = wantjerjerrod() and yesno(
'jerjerrod_clear_cache_in_shell',
'Jerjerrod: automatic cache clearing in zsh shells?',
recommended=True,
)
@section(quick=True)
def jerjerrod_system_flags():
"""Control how zsh/vim will manage jerjerrod's cache."""
lineinfile(
'~/.shellrc',
'export JERJERROD_CLEAR_CACHE_IN_SHELL={}'.format(
'1' if jerjerrod_clear_cache_in_shell else ''
),
)
@section(enabled=wantjerjerrod())
def jerjerrod_install():
# NOTE: only install jerjerrod where we've installed powerline
install_commands = [
['pip3', 'install', '--user', '-e', '.'],