def do_init(cls, nvim):
inst = cls(nvim)
inst.on_init()
cmd_list = cls.build_interfaces(nvim)
log.log_info("Defining commands {}", "\n".join(cmd_list))
cls.__instances__[cls.name] = inst
return cmd_list
def acid_alternate_file(self, args):
try:
src = src_paths(self.nvim)
path = get(args, 0, self.nvim.funcs.expand("%:p"))
log_info("Finding alternate file for {}", path)
root_path = self.nvim.funcs.getcwd()
rel_path = os.path.relpath(path, start=root_path).split('/')
if rel_path[0] in src:
paths = alt_paths(
rel_path,
test_paths(self.nvim),
root_path,
lambda f: '{}_test'.format(f),
)
else:
paths = alt_paths(rel_path, src, root_path,
lambda f: "_".join(f.split('_')[:-1]), 'src')
except Exception as e:
log_debug("error: {}", e)
paths = []
log_debug("paths: {}", paths)
return list(paths)
def handler(msg, wc, key):
try:
nvim.async_call(lambda: nvim.exec_lua(
"require('acid').callback(...)", msg, async_=True))
log_info(msg)
finally:
if should_finalize(msg):
finalizer(msg, wc, key)
def prepare_payload(self, *args):
log.log_info('Evaluating {}'.format(str(args)))
code = parser.transform(" ".join(args), parser.remove_comment)
log.log_info('Final code after transform {}'.format(code))
return {"code": code, "ns": get_acid_ns(self.nvim)}
def send(self, url, data, handler_fn):
conn = self.get_or_create(url)
watcher_key = "{}-watcher".format(data['id'])
conn.watch(watcher_key, {"id": data['id']}, handler_fn(finalize_watch))
try:
conn.send(data)
log.log_info('sent -> {}', str(data))
return True, ""
except Exception as e:
log.log_error('failed to send data: {} - {}', e, str(data))
return False, str(e)
def send(self, url, data, handlers):
conn = self.get_or_create(url)
log.log_info('sending data -> {}', str(data))
for handler in handlers:
handler.pre_send(data)
try:
conn.send(data)
except:
conn.close()
del self.sessions[url]
def add_persistent_watch(self, url, handler, matches={}):
"Adds a callback to all messages in a connection."
watcher_key = "{}-persistent".format(handler.name)
conn = self.get_or_create(url)
if not watcher_key in self.persistent[url]:
log.log_info('Adding new persisntent watcher fn: {}', handler.name)
self.persistent[url].add(watcher_key)
patched_handler = handler.gen_handler(finalize_watch)
conn.watch(watcher_key, matches, patched_handler)
def acid_command(self, args):
cmd, *args = args
log_info(r"Received args for command {}: {}", cmd, args)
url = formatted_localhost_address(self.nvim)
if url is None:
path = current_path(self.nvim)
echo(self.nvim, "No REPL open")
log_info("No repl open on path {}".format(path))
return
command = self.extensions['commands'].get(cmd.strip())
command.call(self, self.context(), *args)
def acid_command_meta(self, args):
cmd, meta_key, *args = args
log_info(r"Prompting metadata {} for command {} with args {}",
meta_key, cmd, args)
command = self.extensions['commands'].get(cmd.strip())
if command is None:
log_warning('Command not found. Aborting!')
return None
ret = getattr(command, meta_key)(self.nvim, *args)
log_info(r"Got {} as a return for {}[{}]".format(ret, cmd, meta_key))
return ret
def __init__(self, nvim):
log_handler = new_handler(
nvim,
lambda msg, *_: not "changed-namespaces" in msg and log_info(msg),
lambda *_: False)
self.nvim = nvim
self.session_handler = SessionHandler(log_handler)
def add_atomic_watch(self, url, msg_id, handler, matches={}):
"Adds a callback to a msg_id on a connection."
watcher_key = "{}-{}-watcher".format(msg_id, handler.name)
conn = self.get_or_create(url)
log.log_info(
'handler -> {}, connection -> {}, matchers -> {}, key -> {}',
str(handler), str(url), str(matches), str(watcher_key)
)
patched_handler = handler.gen_handler(finalize_watch)
# Avoid side-effects
matches = matches.copy()
matches.update({"id": msg_id})
conn.watch(watcher_key, matches, patched_handler)
try:
handler.pre_handle(msg_id, url)
except Exception as e:
log.log_error('Err: could not pre-handle -> {}', str(e))
def on_handle(self, msg, *_):
if not 'state' in msg.get('status', []):
log_info(msg)
def prepare_payload(self, *args):
log.log_info('Evaluating {}'.format(str(args)))
return {"code": " ".join(args), "ns": get_acid_ns(self.nvim)}
def find_fpath(self, args):
log_info("Finding path")
return find_file_in_path(nvim, *args)