def run(self, edit):
cxt = op.edit_cxt_for[self.view]
reg = op.edit_region_for[self.view]
if cxt.adding_new:
with op.quitting_edit_mode(self.view):
self.view.erase(edit, end_plus_1(reg))
return
body = op.module_body(self.view)
entry = body.entry_under_edit()
if entry.is_def_under_edit():
defn = comm.op('getDefinition', {
'module': op.view_module_name(self.view),
'name': entry.name()
})
with op.quitting_edit_mode(self.view):
self.view.replace(edit, reg, defn)
elif entry.is_name_under_edit():
name = comm.op('getNameAt', {
'module': op.view_module_name(self.view),
'at': entry.myindex
})
with op.quitting_edit_mode(self.view):
self.view.replace(edit, reg, name)
else:
raise RuntimeError
def run(self, edit):
remove = sublime.ok_cancel_dialog(
"Remove module '{}'?".format(op.view_module_name(self.view))
)
if not remove:
return
res = comm.op('removeModule', {
'module': op.view_module_name(self.view),
'force': False
})
if res is not True:
remove = sublime.ok_cancel_dialog(
"Module '{}' is connected with these modules: {}. Force removal?".format(
op.view_module_name(self.view), ', '.join(res)
)
)
if not remove:
return
res = comm.op('removeModule', {
'module': op.view_module_name(self.view),
'force': True
})
if res is not True:
sublime.error_message("Could not delete module, returned: {}".format(res))
return
file_name = self.view.file_name()
self.view.close()
os.unlink(file_name)
def run(self, edit):
if regedit.is_active_in(self.view):
ok = sublime.ok_cancel_dialog("Unsaved changes would be lost. Continue?")
if not ok:
return
op.terminate_edit_mode(self.view)
comm.op('refreshModule', {'module': op.view_module_name(self.view)})
def run(self, edit, module_name):
comm.op('renameModule', {
'module': op.view_module_name(self.view),
'newName': module_name
})
new_file_name = op.module_filename(module_name, op.view_lang(self.view))
os.rename(self.view.file_name(), new_file_name)
self.view.retarget(new_file_name)
def run(self, edit, entry, alias):
module_name, entry_name = entry
comm.op('import', {
'recp': op.view_module_name(self.view),
'donor': module_name,
'name': entry_name,
'alias': alias,
})
def run(self, edit, direction):
body = op.module_body(self.view)
loc = body.cursor_location_or_stop(single_selected_region(self.view),
require_fully_selected=True)
comm.op(
'moveBy1', {
'module': op.view_module_name(self.view),
'name': loc.entry.name(),
'direction': direction
})
def run(self, edit):
edit_region = op.edit_region_for[self.view]
cxt = op.edit_cxt_for[self.view]
body = op.module_body(self.view)
if cxt.adding_new:
index = body.remove_ephemeral_entry()
templ = op.RE_FULL_ENTRY[op.view_lang(self.view)]
mtch = re.search(templ, self.view.substr(edit_region), re.DOTALL)
if mtch is None:
sublime.status_message("Invalid entry definition")
return
if mtch.group('def').isspace():
sublime.status_message("Empty definition not allowed")
return
comm.op(
'addEntry',
{
'module': op.view_module_name(self.view),
'name': mtch.group('name'),
'def': mtch.group('def'),
'index': index
},
committing_module_name=op.view_module_name(self.view)
)
return
entry = body.entry_under_edit()
if entry.is_def_under_edit():
res = comm.op(
'editEntry',
{
'module': op.view_module_name(self.view),
'name': entry.name(),
'newDef': self.view.substr(edit_region)
},
committing_module_name=op.view_module_name(self.view)
)
elif entry.is_name_under_edit():
comm.op(
'renameEntry',
{
'module': op.view_module_name(self.view),
'index': entry.myindex,
'newName': self.view.substr(edit_region)
},
committing_module_name=op.view_module_name(self.view)
)
else:
raise RuntimeError
def run(self, module_name, lang):
try:
with open(op.module_filename(module_name, lang), 'x') as file:
file.write('-----\n')
except FileExistsError:
sublime.error_message("Module file already exists")
comm.op('addModule', {
'module': module_name,
'lang': lang
})
sublime.active_window().open_file(op.module_filename(module_name, lang))
def __init__(self, view, args, chain_tail):
super().__init__(view, chain_tail)
res = comm.op('getImportables', {'recp': op.view_module_name(view)})
self.items = [
("{} ({})".format(entry or '*', module), [module, entry])
for module, entry in res
]
def run(self, edit, imported_as, new_alias):
data = comm.op('renameImport', {
'module': op.view_module_name(self.view),
'importedAs': imported_as,
'newAlias': new_alias
})
op.modify_module(self.view, edit, data)
op.save_module(self.view)
def run(self):
res = comm.op('removeUnusedImportsInAllModules', {})
removed_count = res['removedCount']
if removed_count > 0:
sublime.status_message("Removed {} unused imports".format(removed_count))
else:
sublime.status_message("There are no unused imports in any module")
def run(self, edit, name, new_name):
res = comm.op(
'replaceUsages', {
'module': op.view_module_name(self.view),
'name': name,
'newName': new_name
})
op.modify_module(self.view, edit, res)
op.save_module(self.view)
def __init__(self, view, args, chain_tail):
super().__init__(view, chain_tail)
dest_module = args['dest_module']
self.items = comm.op('getModuleEntries', {'module': dest_module})
src_module, entry = args['src_module_entry']
if src_module == dest_module:
self.items.remove(entry)
if self.items:
self.items[:0] = [(self.BOTTOM, True), (self.TOP, False)]
def run(self, edit):
reg = single_selected_region(self.view)
mtch = op.reference_at(self.view, reg)
if mtch is None:
star = None
name = op.word_at(self.view, reg)
else:
star, name = mtch.group('star', 'name')
res = comm.op('findReferences', {
'module': op.view_module_name(self.view),
'star': star,
'name': name
})
if res is None:
sublime.status_message("Unknown reference at point: \"{}\"".format(
mtch.group()))
return
with active_view_preserved(self.view.window()):
all_views = [
self.view.window().open_file(op.module_filename(module_name))
for module_name, entry_name in res
]
def make_location(view, entry_defn_name, reg):
row, col = view.rowcol(reg.begin())
return (view.file_name(), "{}.{}".format(op.view_module_name(view),
entry_defn_name),
(row + 1, col + 1))
def proceed():
locations = []
for view, (module_name, entry_name) in zip(all_views, res):
# We also track to which definition occurences belong. We do this by
# determining what is the key region with max index which is still fully
# before the occurence region.
regkeys = op.name_regions(view)
k = 0
entry_defn_name = "(unknown)"
regs = view.find_all(r'(?<![\w$])\$\.{}\b'.format(entry_name))
for reg in regs:
while k < len(regkeys) and regkeys[k].end() < reg.begin():
k += 1
entry_defn_name = view.substr(regkeys[k - 1])
locations.append(make_location(view, entry_defn_name, reg))
navigate_to_symbol(sublime.active_window().active_view(), name,
locations)
on_all_views_load(all_views, proceed)
def run(self):
data = comm.op('getEntries', {})
def proceed(idx):
if idx == -1:
return
module, entry = data[idx]
op.goto_module_entry(self.window, module, entry)
self.window.show_quick_panel([[entry, module]
for module, entry in data], proceed)
def run(self, edit, callback):
module_names = comm.op('getModules', {})
self.view.window().show_quick_panel(module_names, callback)
(idx, ) = yield
if idx == -1:
return
module_name = module_names[idx]
poli_cur_module[self.view] = module_name
reg = active_prompt_reg(self.view)
with regedit.region_editing_suppressed(self.view):
self.view.replace(edit, reg, current_prompt(self.view))
def run(self, edit):
res = comm.op('removeUnusedImports', {
'module': op.view_module_name(self.view)
})
new_import_section = res['importSection']
removed_count = res['removedCount']
if removed_count > 0:
op.replace_import_section(self.view, edit, new_import_section)
op.save_module(self.view)
sublime.status_message("Removed {} unused imports".format(removed_count))
else:
sublime.status_message("There are no unused imports in this module")
def on_query_completions(self, prefix, locations):
if len(locations) != 1:
return None
[pt] = locations
dollar_dot = self.view.substr(
sublime.Region(pt - len(prefix) - 2, pt - len(prefix)))
if dollar_dot != "$.":
return None
entries = comm.op('getModuleEntries',
{'module': poli_cur_module[self.view]})
return ([(x, x) for x in entries
if x.startswith(prefix)], sublime.INHIBIT_WORD_COMPLETIONS)
def run(self, edit):
reg = single_selected_region(self.view)
if op.reg_import_section(self.view).contains(reg):
self.view.run_command('poli_remove_this_import', {
'force': False
})
return
loc = op.module_body(self.view).cursor_location_or_stop(
reg, require_fully_selected=True
)
res = comm.op('removeEntry', {
'module': op.view_module_name(self.view),
'entry': loc.entry.name(),
'force': False
})
if not res['removed']:
remove_anyway = sublime.ok_cancel_dialog(
"Entry \"{}\" is being referred to. Remove it anyway?".format(
loc.entry.name()
)
)
if not remove_anyway:
return
res = comm.op('removeEntry', {
'module': op.view_module_name(self.view),
'entry': loc.entry.name(),
'force': True
})
if not res['removed']:
raise RuntimeError
with read_only_set_to(self.view, False):
self.view.erase(edit, loc.entry.reg_entry_nl)
op.save_module(self.view)
def run(self, edit, imported_as, force):
res = comm.op('removeImport', {
'module': op.view_module_name(self.view),
'importedAs': imported_as,
'force': force
})
if not res['removed']:
assert not force # otherwise it would have removed the import
remove_anyway = sublime.ok_cancel_dialog(
"The import \"{}\" is being used. Remove it anyway?".format(imported_as),
"Remove"
)
if not remove_anyway:
return
res = comm.op('removeImport', {
'module': op.view_module_name(self.view),
'importedAs': imported_as,
'force': True
})
op.replace_import_section(self.view, edit, res['importSection'])
op.save_module(self.view)
def run(self, edit):
if not regedit.is_active_in(self.view):
return # Protected by keymap binding
reg = regedit.editing_region(self.view)
reg_stripped = end_strip_region(self.view, reg)
if reg_stripped.empty():
sublime.status_message("Empty prompt")
return
if reg.end() > reg_stripped.end():
self.view.erase(edit, sublime.Region(reg_stripped.end(),
reg.end()))
reg = reg_stripped
code = self.view.substr(reg)
try:
text = comm.op('eval', {
'module': poli_cur_module[self.view],
'code': code
})
success = True
except ReplEvalError as e:
text = e.stack
success = False
if success:
self.view.insert(edit, self.view.size(), '\n< ')
else:
self.view.insert(edit, self.view.size(), '\n! ')
self.view.insert(edit, self.view.size(), text)
self.view.insert(edit, self.view.size(), '\n')
insert_prompt_at_end(self.view, edit)
hns_for.pop(self.view, None)
def on_query_completions(self, prefix, locations):
if not config.enabled:
return None
if len(locations) != 1:
return None
[pt] = locations
linereg = self.view.line(pt)
str_prec = self.view.substr(sublime.Region(linereg.begin(), pt))
mtch = re.search(r'^.*?\$(?:\.(?P<star>\w+))?\.(?P<prefix>\w+)$',
str_prec)
if mtch is None:
return None
entries = comm.op(
'getCompletions', {
'module': op.view_module_name(self.view),
'star': mtch.group('star'),
'prefix': mtch.group('prefix')
})
return ([(x, x) for x in entries], sublime.INHIBIT_WORD_COMPLETIONS
| sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def run(self, edit, donor_module):
comm.op('convertImportsToStar', {
'recp': op.view_module_name(self.view),
'donor': donor_module
})
def __init__(self, view, args, chain_tail):
module_name, entry = args['entry']
disallowed_names = comm.op('getModuleNames', {
'module': op.view_module_name(view)
})
super().__init__(view, chain_tail, entry, disallowed_names)
def __init__(self, view, args, chain_tail):
super().__init__(view, chain_tail)
self.existing_module_names = comm.op('getModules', {})
def __init__(self, module):
self.module = module
self.names = comm.op('getModuleNames', {'module': module})
def __init__(self, view, args, chain_tail):
super().__init__(view, chain_tail)
data = comm.op('getEntries', {})
self.items = [("{} ({})".format(entry, module), [module, entry])
for module, entry in data]
def __init__(self, view, args, chain_tail):
super().__init__(view, chain_tail)
self.items = comm.op('getModules', {})
self.items.remove(args['src_module_entry'][0])
def run(self, src_module_entry, dest_module, anchor, before=None):
src_module, entry = src_module_entry
self._check_src_available(src_module, entry)
self._check_anchor_available(dest_module, anchor)
res = comm.op(
'move', {
'srcModule': src_module,
'entry': entry,
'destModule': dest_module,
'anchor': anchor,
'before': before
})
if not res['moved']:
msg = ["Failed to move the entry because:\n"]
if res['offendingRefs']:
msg.append(
"the definition refers to names that could not be imported into "
"the destination module: {}".format(', '.join(
'$.' + r for r in res['offendingRefs'])))
if res['blockingReferrers']:
msg.append(
"these modules cannot star-import the entry from the destination "
"module: {}".format(', '.join(res['blockingReferrers'])))
sublime.error_message('\n'.join(msg))
return
def process_source(view, edit):
with regedit.region_editing_suppressed(view):
entry_obj = op.module_body(view).entry_by_name(entry)
view.erase(edit, entry_obj.reg_entry_nl)
op.save_module(view)
def process_destination(view, edit):
with regedit.region_editing_suppressed(view):
if anchor is None:
insert_at = op.reg_body(view).begin()
else:
mcont = op.module_body(view)
if anchor is False:
insert_at = mcont.entries[0].reg_entry_nl.begin()
elif anchor is True:
insert_at = mcont.entries[-1].reg_entry_nl.end()
else:
entry_obj = op.module_body(view).entry_by_name(anchor)
if before:
insert_at = entry_obj.reg_entry_nl.begin()
else:
insert_at = entry_obj.reg_entry_nl.end()
view.insert(edit, insert_at,
'{} ::= {}\n'.format(entry, res['newCode']))
op.save_module(view)
def process_other(view, module_data, edit):
op.modify_module(view, edit, module_data)
op.save_module(view)
def proceed(src_view, dest_view, other_views):
with exc_recorded() as exc_src:
call_with_edit(src_view, partial(process_source, src_view))
with exc_recorded() as exc_dest:
call_with_edit(dest_view,
partial(process_destination, dest_view))
exc_others = [exc_recorded() for view in other_views]
for exc, view, module_data in zip(exc_others, other_views,
res['modifiedModules']):
with exc:
call_with_edit(view,
partial(process_other, view, module_data))
fmodules = {
op.view_module_name(view)
for exc, view in zip(exc_others, other_views) if exc
}
if exc_src:
fmodules.add(op.view_module_name(src_view))
if exc_dest:
fmodules.add(op.view_module_name(dest_view))
if fmodules:
sublime.error_message(
"The following modules failed to update (you may consider refreshing "
"them from the image): {}".format(', '.join(fmodules)))
if exc_src:
print("Source updating failed:")
traceback.print_exception(type(exc_src.exc), exc_src.exc,
None)
if exc_dest:
print("Dest updating failed:")
traceback.print_exception(type(exc_dest.exc), exc_dest.exc,
None)
for view, exc in zip(other_views, exc_others):
if not exc:
continue
print("Modified module \"{}\" updating failed:".format(
op.view_module_name(view)))
traceback.print_exception(type(exc.exc), exc.exc, None)
elif res['danglingRefs']:
sublime.message_dialog(
"These references appear to be dangling: {}".format(
','.join('$.' + r for r in res['danglingRefs'])))
else:
sublime.status_message("Move succeeded!")
with active_view_preserved(self.window):
src_view = self.window.open_file(op.module_filename(src_module))
dest_view = self.window.open_file(op.module_filename(dest_module))
other_views = [
self.window.open_file(op.module_filename(d['module']))
for d in res['modifiedModules']
]
on_all_views_load([src_view, dest_view] + other_views,
lambda: proceed(src_view, dest_view, other_views))
