def run(self, paths=[]): win = self.window for p in paths: if os.path.isfile(p): for b in HaxeComplete_inst().read_hxml(p): HaxeComplete_inst().add_build(b) if (int(sublime.version()) > 3000): proj = win.project_file_name() if proj is not None: proj_path = os.path.dirname(proj) rel_path = os.path.relpath(p, proj_path) else: rel_path = p data = win.project_data() if 'settings' not in data: data['settings'] = {} if 'haxe_builds' not in data['settings']: data['settings']['haxe_builds'] = [] build_files = data['settings']['haxe_builds'] build_files.append(rel_path) win.set_project_data(data)
def init_build_class_map(view): if HaxeOrganizeImports.std_type_map is None: HaxeOrganizeImports.std_type_map = \ init_type_map(HaxeComplete_inst().__class__.stdClasses) if HaxeOrganizeImports.build_classes is None: build = HaxeComplete_inst().get_build(view) HaxeOrganizeImports.build_classes, _ = build.get_types() HaxeOrganizeImports.build_type_map = init_type_map( HaxeOrganizeImports.build_classes, HaxeOrganizeImports.std_type_map)
def find_classpaths(self): view = self.window.active_view() self.classpaths = [] build = HaxeComplete_inst().get_build(view) self.classpaths.extend(HaxeComplete_inst().__class__.stdPaths) for cp in build.classpaths: self.classpaths.append(os.path.join(build.cwd, cp)) for lib in build.libs: if lib is not None: self.classpaths.append(lib.path)
def run(self, paths=[], t="class"): builds = HaxeComplete_inst().builds HaxeCreateType.currentType = t view = sublime.active_window().active_view() scopes = view.scope_name(view.sel()[0].end()).split() fn = view.file_name() pack = [] if fn is None: return if len(builds) == 0: HaxeComplete_inst().extract_build_args(view) if len(paths) == 0: paths.append(fn) for path in paths: if os.path.isfile(path): path = os.path.dirname(path) if HaxeCreateType.classpath is None: HaxeCreateType.classpath = path for b in builds: for cp in b.classpaths: if path.startswith(cp): HaxeCreateType.classpath = path[0:len(cp)] for p in path[len(cp):].split(os.sep): if "." in p: break elif p: pack.append(p) if HaxeCreateType.classpath is None: if len(builds) > 0: HaxeCreateType.classpath = builds[0].classpaths[0] # so default text ends with . if len(pack) > 0: pack.append("") win = sublime.active_window() sublime.status_message("Current classpath : " + HaxeCreateType.classpath) win.show_input_panel("Enter " + t + " name : ", ".".join(pack), self.on_done, self.on_change, self.on_cancel)
def run(self, mode=None): view = self.window.active_view() if view is None or view.is_loading() or not is_haxe_scope(view): return self.classpath = \ HaxeComplete_inst().get_build(view).get_classpath(view) if self.classpath is None: return self.classes, self.packages = self.extract_modules(self.classpath) self.mode = mode idx = 0 self.options = None if mode == 'module': self.options = self.classes cl = to_haxe_form(self.classpath, view.file_name(), True) if cl in self.options: idx = self.options.index(cl) elif mode == 'package': self.options = self.packages pk = to_haxe_form( self.classpath, os.path.dirname(view.file_name())) if pk in self.options: idx = self.options.index(pk) else: return self.window.show_quick_panel(self.options, self.on_select, 0, idx)
def poll(ctx): view = ctx.view cmds = [] if HaxeRefactor.is_installed == -1: HaxeRefactor.check_refactor_lib(ctx.view) if HaxeRefactor.is_installed == 0: return cmds classpath = HaxeComplete_inst().get_build(view).get_classpath(view) if classpath is None or classpath not in view.file_name(): return cmds for w in sublime.windows(): for v in w.views(): if v.is_dirty(): return cmds # if ctx.word: if True: cmds.append(( 'Rename/Move module ...', 'haxe_refactor', {'mode': 'module'})) if True: cmds.append(( 'Rename package ...', 'haxe_refactor', {'mode': 'package'})) return cmds
def find_param_usages(self, filepath): # print('HU param usage') src = self.context.src src = src[:self.context.method.block.begin()] + \ '%s' % self.context.word.name offset = len(codecs.encode(src, 'utf-8')) + 1 src += ';' + self.context.src[self.context.method.block.begin():] complete = HaxeComplete_inst() with open(filepath, 'w') as f: f.write(src) usage = complete.run_haxe( self.view, dict(mode='usage', filename=filepath, offset=offset, commas=None)) if usage: tree = self.parse_xml(usage[0]) if tree is not None: usages = [i.text for i in tree.getiterator('pos')] if usages: usages.pop(0) for u in usages: self.parse_and_append_usage(u) self.finish()
def get_param_type(self): view = self.window.active_view() complete = HaxeComplete_inst() comps, hints = complete.get_haxe_completions( view, view.sel()[0].end(), ignoreTopLevel=True) return hints
def get_param_type(self): view = self.window.active_view() complete = HaxeComplete_inst() for r in view.sel(): comps, hints = complete.get_haxe_completions(view, r.end()) return hints
def init_build_class_map(view): HaxeOrganizeImports.std_type_map = init_type_map( HaxeComplete_inst().__class__.stdClasses) # print('OI: Std') # lst = HaxeComplete_inst().__class__.stdClasses # print("\n".join([k for k in sorted(lst)])) build = HaxeComplete_inst().get_build(view) HaxeOrganizeImports.build_classes, _ = build.get_types() # print('OI: Build') # lst = HaxeOrganizeImports.build_classes # print("\n".join([k for k in sorted(lst)])) HaxeOrganizeImports.build_type_map = init_type_map( HaxeOrganizeImports.build_classes, HaxeOrganizeImports.std_type_map)
def find_usages(self, offset=0, type_paths=None, field=None, is_static=False): static = 'true' if is_static else 'false' if self.hx_files is None: self.scan_hx_files() complete = HaxeComplete_inst() args = None if type_paths: field = 'null' if field is None else '"%s"' % field args = [] for tp in type_paths: args.append( ('--macro', 'addMetadata("@:usage", "%s", %s, %s)' % (tp, field, static))) num_files = len(self.hx_files) def find(idx, t): if idx >= num_files: self.finish() return t0 = time.time() f = self.hx_files[idx] sublime.status_message('Find usages in \'%s\'' % f) usage = complete.run_haxe( self.view, dict(mode='usage', filename=f, offset=offset, commas=None, serverMode=False), args) tree = self.parse_xml(usage[0]) if tree is not None: for i in tree.getiterator('pos'): self.parse_and_append_usage(i.text) t += time.time() - t0 idx += 1 if t > 0.5: t = 0 sublime.set_timeout(lambda: find(idx, t), 10) else: find(idx, t) sublime.set_timeout(lambda: find(0, 0), 10)
def poll(ctx): if HaxeComplete_inst().compilerVersion < 3.2: return [] for w in sublime.windows(): for v in w.views(): if v.is_dirty() and v.score_selector(0, 'source.haxe.2') > 0: return [] if ctx.word: return [('Find Usages: %s ...' % ctx.word.name, 'haxe_usage', {})] return []
def run(self, edit, input=''): complete = HaxeComplete_inst() view = self.view if not input: pos = view.sel()[0].end() if view.substr(pos) == '(' and view.score_selector( pos - 1, 'source.haxe.2 meta.parameters.haxe.2') == 0: view.run_command('haxe_show_type') return if input == '(': sel = view.sel() emptySel = True for r in sel: if not r.empty(): emptySel = False break autoMatch = view.settings().get('auto_match_enabled', False) if autoMatch: if emptySel: view.run_command('insert_snippet', {'contents': '($0)'}) else: view.run_command('insert_snippet', {'contents': '(${0:$SELECTION})'}) else: view.run_command('insert', {'characters': '('}) else: view.run_command('insert', {'characters': input}) if input and not view.settings().get('haxe_auto_complete', True): return haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False) haxe_use_popup = view.settings().get('haxe_use_popup', True) and \ int(sublime.version()) >= 3070 if not haxe_smart_snippets and not haxe_use_popup: return for r in view.sel(): comps, hints = complete.get_haxe_completions(view, r.end(), ignoreTopLevel=True) if haxe_use_popup: self.show_popup(hints) elif haxe_smart_snippets and input: self.insert_snippet(hints)
def find_method_positions(self, type_paths, word): # print('HU positions:', word) filepath = os.path.join(self.root_dir, 'SublimeHaxeUsage.hx') complete = HaxeComplete_inst() def find(idx, t): if idx >= len(type_paths): try: os.remove(filepath) except OSError: pass self.find_usages(0, type_paths, self.context.word.name) return t0 = time.time() type_path = type_paths[idx] s = ('class SublimeHaxeUsage {' 'static var temp:%s;' 'static function main() {temp.%s.|;}' '}') % (type_path, word) sublime.status_message('Find method in \'%s\'' % type_path) with open(filepath, 'w') as f: f.write(s) position = complete.run_haxe( self.view, dict(mode='position', filename=filepath, offset=0, commas=None)) if position: self.parse_and_append_usage(position) else: self.has_pos_errors = True t += time.time() - t0 idx += 1 if t > 0.5: t = 0 sublime.set_timeout(lambda: find(idx, t), 10) else: find(idx, t) sublime.set_timeout(lambda: find(0, 0), 10)
def finish(self): if self.usages: self.output_view.find_all_results() self.has_errors = self.has_errors or self.has_pos_errors if self.has_pos_errors: usage = HaxeComplete_inst().run_haxe( self.view, dict(mode='usage', filename=self.view.file_name(), offset=0, commas=None)) if usage: self.parse_xml(usage[0]) self.log('[Finished]') HaxeUsage.is_active = False
def run( self , edit ) : view = self.view # get word under cursor word = view.word(view.sel()[0]) # get utf-8 byte offset to the end of the word src = view.substr(sublime.Region(0, word.b)) offset = len(codecs.encode(src, "utf-8")) + 1 # add 1 because offset is 1-based complete = HaxeComplete_inst() # save file and run completion temp = complete.save_temp_file( view ) pos = complete.run_haxe(view, dict( mode="position", filename=view.file_name(), offset=offset, commas=None )) complete.clear_temp_file( view , temp ) if pos is None: status = "Definition of '" + view.substr(sublime.Region(word.a, word.b)) + "' not found." self.view.set_status( "haxe-status", status ) return else : pos = pos.strip() # parse position m = posRe.match(pos) filename = m.group(1) line = int(m.group(2)) - 1 mode = m.group(3) start = int(m.group(4)) if mode == "lines": start = 0 if os.name == "nt": filename = self.get_windows_path(filename) # open definition file in the active window and go to given position window = sublime.active_window() view = window.open_file(filename) self.goto_pos(view, line, start)
def run(self): win = self.window view = win.active_view() if view is None or view.is_loading() or not is_haxe_scope(view): return self.context = get_context(view) if not self.context.type: return method_names = {'new': True} for methodCtx in self.context.type.methods: method_names[methodCtx.name] = True tmp_name = '__sublime_tmp_method__' method_names[tmp_name] = True win.run_command('haxe_override_method_edit', { 'pos': self.context.type.block.begin(), 'name': tmp_name }) complete = HaxeComplete_inst() temp = complete.save_temp_file(view) _, _, _, _, fields = complete.run_haxe( view, dict(mode=None, filename=view.file_name(), offset=0, commas=None)) complete.clear_temp_file(view, temp) win.run_command('undo') self.methods = [] for field in fields: name = field[0] args = field[1] if args is None or name in method_names: continue self.methods.append(field) options = [] for method in self.methods: options.append('%s()' % method[0]) show_quick_panel(win, options, self.on_select, sublime.MONOSPACE_FONT, 0)
def find_local_usages(self, filepath, usage_line): self.append_usage(self.view.file_name(), usage_line) rgn = self.word.region pos_cols = (self.view.rowcol(rgn.begin())[1], self.view.rowcol(rgn.end())[1]) src = self.view.substr( sublime.Region(self.context.word.region.end(), self.context.method.region.end())) idx = 0 idx = src.find(self.context.word.name, idx) complete = HaxeComplete_inst() while idx != -1: offset = self.context.word.region.end() + idx + \ len(self.context.word.name) src_o = self.view.substr(sublime.Region(0, offset)) offset = len(codecs.encode(src_o, 'utf-8')) + 1 position = complete.run_haxe( self.view, dict(mode='position', filename=filepath, offset=offset, commas=None)) if position: mo = re_haxe_position.search(position) if mo: line = int(mo.group(2)) cols = (int(mo.group(3)), int(mo.group(4))) if line == usage_line and \ cols[0] <= pos_cols[0] and pos_cols[1] <= cols[1]: self.find_usages(offset) return else: self.has_pos_errors = True idx = src.find(self.context.word.name, idx + 1) self.finish()
def run(self, edit): view = self.view if view.score_selector(0, 'source.haxe.2') == 0 or \ int(sublime.version()) < 3000: return # get word under cursor word = view.word(view.sel()[0]) # get utf-8 byte offset to the end of the word src = view.substr(sublime.Region(0, word.b)) offset = len(codecs.encode(src, "utf-8")) + 1 # add 1 because offset is 1-based complete = HaxeComplete_inst() # save file and run completion temp = complete.save_temp_file(view) hint = complete.run_haxe( view, dict(mode="type", filename=view.file_name(), offset=offset, commas=None)) complete.clear_temp_file(view, temp) if hint is None: status = "No type information for '%s'." % \ view.substr(sublime.Region(word.a, word.b)) view.set_status("haxe-status", status) else: hint = format_statement(view, hint) view.set_status("haxe-status", hint) hint = hint.replace('<', '<') hint = hint.replace('>', '>') hint = re_params.sub(r'<b>\1</b>\2:', hint) if int(sublime.version()) >= 3070 and \ view.settings().get("haxe_use_popup", True): view.run_command('haxe_show_popup', {'text': hint}) else: view.show_popup_menu([hint], lambda i: None)
def run(self, edit, input=''): complete = HaxeComplete_inst() view = self.view if input == '(': sel = view.sel() emptySel = True for r in sel: if not r.empty(): emptySel = False break autoMatch = view.settings().get('auto_match_enabled', False) if autoMatch: if emptySel: view.run_command('insert_snippet', {'contents': '($0)'}) else: view.run_command('insert_snippet', {'contents': '(${0:$SELECTION})'}) else: view.run_command('insert', {'characters': '('}) else: view.run_command('insert', {'characters': input}) autocomplete = view.settings().get('auto_complete', True) if not autocomplete: return haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False) haxe_use_popup = view.settings().get('haxe_use_popup', True) and \ int(sublime.version()) >= 3070 if not haxe_smart_snippets and not haxe_use_popup: return for r in view.sel(): comps, hints = complete.get_haxe_completions(view, r.end()) if haxe_use_popup: self.show_popup(hints) elif haxe_smart_snippets and input: self.insert_snippet(hints)
def get_type(view, pos, name): win = view.window() win.run_command('haxe_promote_var_edit', { 'pos0': pos, 'pos1': pos, 'text': '%s.|' % name }) complete = HaxeComplete_inst() temp = complete.save_temp_file(view) tp = complete.run_haxe( view, dict(mode="type", filename=view.file_name(), offset=0, commas=None)) complete.clear_temp_file(view, temp) win.run_command('undo') return tp
def poll(ctx): view = ctx.view cmds = [] classpath = HaxeComplete_inst().get_build(view).get_classpath(view) if classpath is None: return cmds filename = os.path.splitext(os.path.basename(view.file_name()))[0] filedir = os.path.dirname(view.file_name()) src = ctx.src mos = [mo for mo in re_type.finditer(src)] if len(mos) == 1: mo = mos[0] if filename != mo.group(2): cmds.append( ('Rename %s %s to %s' % (mo.group(1), mo.group(2), filename), 'haxe_fix_module', { 'cname': filename })) mo = re_package.search(src) cur_package = mo.group(1) if mo else '' if classpath in filedir: package = os.path.relpath(filedir, classpath) if package == '.': package = '' package = package.replace(os.sep, '.') if package != cur_package: cmds.append(('Rename package \'%s\' to \'%s\'' % (cur_package, package), 'haxe_fix_module', { 'package': package })) return cmds
def on_build_change(self, view): build = HaxeComplete_inst().get_build(view) if build is not None: HaxeOrganizeImports.build_classes, _ = build.get_types() HaxeOrganizeImports.build_type_map = None
def find_local_or_field_usages(self): self.show_panel() self.log('Find usages: %s' % self.word.name) # print('HU local_or_field') ctx = self.context is_param = ctx.method and \ ctx.method.region.begin() < ctx.word.region.begin() and \ self.word.region.end() <= ctx.method.block.begin() and \ '(' in ctx.src[ctx.method.region.begin():ctx.word.region.begin()] complete = HaxeComplete_inst() temp = complete.save_temp_file(self.view, is_param) filepath = None usage_line = 0 src = self.view.substr(sublime.Region(0, ctx.word.region.end())) offset = len(codecs.encode(src, 'utf-8')) + 1 mos = [ mo for mo in re.finditer( r'\b(for\s*\(\s*|var\s+|function\s+)%s\b' % ctx.word.name, src, re.M) ] mo = mos[-1] if mos else None is_declaration = mo and mo.end(0) == ctx.word.region.end() is_field = False view_filepath = os.path.realpath(self.view.file_name()) if is_declaration or is_param: filepath = os.path.realpath(self.view.file_name()) usage_line, _ = self.view.rowcol(ctx.word.region.end()) usage_line += 1 self.append_usage(filepath, usage_line) if is_declaration: is_field = not ctx.method or \ ctx.word.region.end() <= ctx.method.block.begin() else: position = complete.run_haxe( self.view, dict(mode='position', filename=self.view.file_name(), offset=offset, commas=None)) if position: filepath, usage_line, begin, end = \ self.parse_and_append_usage(position) begin = self.view.text_point(usage_line, begin) end = self.view.text_point(usage_line, end) is_field = view_filepath != filepath or \ not ctx.method or \ end <= ctx.method.block.begin() or \ begin >= ctx.method.block.end() else: self.has_pos_errors = True if filepath: if filepath != view_filepath: self.find_field_usages(filepath, usage_line) else: if is_param: self.find_param_usages(filepath) elif not is_field: # print('HU local usages') self.hx_files = [filepath] if is_declaration: self.find_local_usages(filepath, usage_line) else: self.find_usages(offset) else: self.find_field_usages(filepath, usage_line) else: self.finish() complete.clear_temp_file(self.view, temp)
def run( self ) : view = sublime.active_window().active_view() HaxeComplete_inst().stop_server() HaxeComplete_inst().start_server( view )