我们从Python开源项目中，提取了以下16个代码示例，用于说明如何使用sublime.INHIBIT_EXPLICIT_COMPLETIONS。
def on_query_completions(self, view, prefix, locations): """ ST API method: gets called when autocompletion triggers """ completions = [] scope_name = view.scope_name(view.sel()[0].b) filename = view.file_name() if not filename or not INFOS.addon: return [] folder = filename.split(os.sep)[-2] if folder not in INFOS.addon.includes: return [] if "text.xml" in scope_name: for dir_, _, files in os.walk(INFOS.addon.media_path): for filename in files: rel_dir = os.path.relpath(dir_, INFOS.addon.media_path) rel_file = os.path.join(rel_dir, filename).lstrip("./").lstrip("\\") rel_file = rel_file.replace("\\", "/") completions.append([rel_file, rel_file]) colors = [] for node in INFOS.get_colors(): if node["name"] not in colors: colors.append(node["name"]) completions.append(["%s (%s)" % (node["name"], node["content"]), node["name"]]) for node in chain(INFOS.addon.includes[folder], INFOS.addon.fonts[folder]): completions.append([node["name"], node["name"]]) for node in chain(INFOS.builtins, INFOS.conditions): completions.append([node[0], node[0]]) for item in INFOS.WINDOW_NAMES: completions.append([item, item]) for item in completions: for i, match in enumerate(re.findall(r"\([a-z,\]\[]+\)", item[1])): item[1] = item[1].replace(match, "($%i)" % (i + 1)) return completions # return (completions, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def on_query_completions(self, view, prefix, locations): active_file_extension = util.file_extension(view) if active_file_extension != '.cls' and active_file_extension != '.trigger': return None if not self.refreshing: client = lsClient if not client: return completionProvider = client.get_capability('completionProvider') if not completionProvider: return autocomplete_triggers = completionProvider.get('triggerCharacters') if locations[0] > 0: self.completions = [] purge_did_change(view.buffer_id()) client.send_request( Request.complete( util.get_document_position(view, locations[0])), self.handle_response) self.refreshing = False return self.completions, (sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def on_query_completions(self, view, prefix, locations): """Runs on all views, but is NOOP unless view is response view or history view. Inside gql query string, only completions returned by this method are shown. """ response_view = view.settings().get('requester.response_view', False) history_view = view.settings().get('requester.history_view', False) if not response_view and not history_view: return None content = view.substr(sublime.Region(0, view.size())) m = re.search(r'\bgql\s*=\s*("|\')+', content) if m is None: return None offset, idx = m.end(), view.sel()[0].begin() try: request = parse_requests(content, n=1)[0] if getattr(view, '_env', None) is None: view._env = RequestCommandMixin.get_env_dict_from_string( view.settings().get('requester.env_string', None) ) req = prepare_request(request, view._env, 1) schema = view.settings().get('requester.gql_schema', None) if not schema: # let user know schema is being retrieved set_graphql_schema_on_view(view, req) raise Exception('Loading GraphQL schema info') gql = req.skwargs['gql'] completions = get_completions(gql, idx-offset, schema) return completions except Exception as e: print('GraphQL Error:') traceback.print_exc(file=sys.stdout) return ( [[str(e), ' '], ['...', ' ']], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS )
def on_query_completions(self, view, prefix, points): selected_completions = set() for point in points: if "source.rbxlua" not in view.scope_name(point): return None row_col = view.rowcol(point) line_region = view.line(point) line_text = view.substr(line_region) function_match = FUNCTION_CALL_REGEX.search(line_text, 0, row_col[1]) enum_match = ENUM_REGEX.search(line_text, 0, row_col[1]) if function_match is not None and function_match.end(0) >= row_col[1]: function_name = function_match.group(1) value = None if function_name in service_detections: value = services elif function_name in creatable_detections: value = creatables elif function_name in class_detections: value = classes if value is not None: selected_completions.update([x for x in value if x.startswith(prefix)]) elif enum_match is not None and enum_match.end(0) >= row_col[1]: if enum_match.group(2) is None or enum_match.group(2) == "": selected_completions.update(enum_names) else: if enum_match.group(2)[0] == ".": selected_completions.update(set([ e["entry_completion"] for e in completion_items if e["entry_type"] == "EnumItem" and e["enum_parent"] == enum_match.group(1) ])) else: selected_completions.add("GetEnumItems()") if len(selected_completions) > 0: return ([ [e] for e in selected_completions ], sublime.INHIBIT_EXPLICIT_COMPLETIONS | sublime.INHIBIT_WORD_COMPLETIONS)
def on_query_completions(self, view, prefix, locations): if settings.get('no_dialogs_autocomplete_mode') != 'default': return if currently_open_prompt is None or currently_open_prompt != view: return comps = autocomplete_file_name(read_view(view)) flags = 0 flags |= sublime.INHIBIT_WORD_COMPLETIONS if settings.get('no_dialogs_inhibit_word_completions') else 0 flags |= sublime.INHIBIT_EXPLICIT_COMPLETIONS if settings.get('no_dialogs_inhibit_explicit_completions') else 0 return ([[comp, comp] for comp in comps], flags)
def on_query_completions(self, prefix, locations): if self.view.match_selector(locations[0], NO_COMPLETION_SCOPES): return ( [], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS ) if not self.initialized: self.initialize() if self.enabled: reuse_completion = self.is_same_completion(prefix, locations) if self.state == CompletionState.IDLE: if not reuse_completion: self.last_prefix = prefix self.last_location = locations[0] self.do_request(prefix, locations) self.completions = [] elif self.state in (CompletionState.REQUESTING, CompletionState.CANCELLING): self.next_request = (prefix, locations) self.state = CompletionState.CANCELLING elif self.state == CompletionState.APPLYING: self.state = CompletionState.IDLE return ( self.completions, 0 if not settings.only_show_lsp_completions else sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS )
def test_enabled(self): self.view.run_command('insert', {"characters": '.'}) self.client.send_request = MagicMock() handler = CompletionHandler(self.view) self.assertEquals(handler.state, CompletionState.IDLE) items, mask = handler.on_query_completions("", [1]) self.assertEquals(len(items), 0) self.assertEquals(mask, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) self.assertTrue(handler.initialized) self.assertTrue(handler.enabled) self.assertEquals(handler.state, CompletionState.REQUESTING) self.client.send_request.assert_called_once() # time.sleep(1000) # self.assertEquals(len(handler.completions), 2) # self.assertEquals(handler.state, CompletionState.APPLYING) # running auto_complete command does not work # sublime does not know about the instance we registered here. # we do it directly here # items, mask = handler.on_query_completions("", [1]) # self.assertEquals(len(items), 2) # self.assertEquals(mask, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def on_query_completions(self, view: sublime.View, prefix: str, locations: List[Tuple[int]]) -> Tuple[List[Tuple[str]], int]: # noqa """Sublime Text autocompletion event handler """ if not is_python(view, autocomplete_ignore_repl=True): return if completion_is_disabled(view): return global JUST_COMPLETED if self.ready_from_defer is True: completion_flags = 0 if get_settings(view, 'suppress_word_completions', False): completion_flags = sublime.INHIBIT_WORD_COMPLETIONS if get_settings(view, 'suppress_explicit_completions', False): completion_flags |= sublime.INHIBIT_EXPLICIT_COMPLETIONS cpl = self.completions self.completions = [] self.ready_from_defer = False JUST_COMPLETED = True return (cpl, completion_flags) location = view.rowcol(locations[0]) data = prepare_send_data(location, 'autocomplete', 'jedi') Worker().execute(self._complete, **data)
def on_query_completions(self, view, prefix, locations): project = get_or_create_project_and_add_view(view) if project and project.is_initialized(): pos = view.sel()[0].begin() (line, col) = view.rowcol(pos) Debug('autocomplete', "on_query_completions(), sublime wants to see the results, cursor currently at %i , %i (enabled: %s, items: %i)" % (line+1, col+1, project.completion.enabled_for['viewid'], len(project.completion.get_list()) ) ) if project.completion.enabled_for['viewid'] == view.id(): project.completion.enabled_for['viewid'] = -1 # receive only once return (project.completion.get_list(), sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) # ON QUERY CONTEXT (execute commandy only on opened .ts files)
def on_query_completions(self, view, prefix, locations): self.view = view file = view.file_name() if not _is_swift(file): return None offset = locations[0] project_directory = _project_directory(view) text = _view_text(view) suggestions = subl_source_kitten.complete_with_haste(offset, file, project_directory, text) return (suggestions, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def add_completions_flags(self, a_completions): return (a_completions, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS,) #@timed
def on_query_completions(self, view, prefix, locations): # parts of the code inspired by: https://github.com/agibsonsw/AndyPython/blob/master/PythonCompletions.py global builtin_compl_vars, builtin_compl_funcs, magic_control_pars if not view.match_selector(locations[0], 'source.ksp -string -comment -constant'): return [] pt = locations[0] # - len(prefix) - 1 #ch = view.substr(sublime.Region(pt, pt + 1)) # the character before the trigger line_start_pos = view.line(sublime.Region(pt, pt)).begin() line = view.substr(sublime.Region(line_start_pos, pt)) # the character before the trigger if re.match(r' *declare .*', line) and ':=' not in line: compl = [] elif re.match(r'.*-> ?[a-zA-Z_]*$', line): # if the line ends with something like '->' or '->valu' compl = magic_control_pars else: compl = self._extract_completions(view, prefix, pt) compl = [(item + "\tdefault", item) for item in compl if len(item) > 3 and item not in all_builtins] if '.' not in prefix: bc = [] bc.extend(builtin_compl_vars) bc.extend(builtin_compl_funcs) compl.extend(bc) compl = self.unique(compl) return (compl, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
def on_query_completions_async(self, view, prefix, locations): self.completions = None flow_settings = find_flow_settings(view.window().project_data()) autocomplete_flags = sublime.INHIBIT_WORD_COMPLETIONS | \ sublime.INHIBIT_EXPLICIT_COMPLETIONS if flow_settings.get('show_sublime_autocomplete_suggestions'): autocomplete_flags = 0 result = None try: result = CLI(view).autocomplete() except InvalidContext: pass except Exception as e: display_unknown_error(self.view, e) if not result: return self.completions = ( [ ( # matching text match['name'] + '\t' + match['type'], # inserted text build_snippet( match['name'], match.get('func_details')['params'] ) if ( match.get('func_details') and not flow_settings.get('omit_function_parameters') ) else match['name'] ) for match in result['result'] ], autocomplete_flags ) self.completions_ready = True sublime.active_window().active_view().run_command( 'hide_auto_complete' ) self.run_auto_complete()
def get_completions(gql, idx, schema): """Creates AST from `gql` query string, finds out exactly where cursor is in string, and uses `schema` to get appropriate completions. Doesn't protect against exceptions. They should be handled by calling code. """ try: # at module import time this package is not available from graphql.parser import GraphQLParser from graphql.lexer import GraphQLLexer except ImportError: raise Exception('Install graphql-py with pip for GraphQL autocomplete') try: # monkey-patch this class, the `t_NULL` method breaks parsing delattr(GraphQLLexer, 't_NULL') except AttributeError: pass start, end = slurp_word(gql, idx) gql_parser = GraphQLParser() ast = gql_parser.parse(gql[:start] + placeholder + gql[end:], lexer=GraphQLLexer()) for query in ast.definitions: # get path if it exists path = placeholder_path(query, placeholder) if path is not None: break query_type, types = schema t = resolve_type(path, types, query_type) fields = types[t]['fields'] completions = [] for f in fields.values(): name = f['name'] args = [a['name'] + ':' for a in f['args']] args_string = '({})'.format(', '.join(args)) if args else '' type_name = resolve_field_type(f) completions.append([ '{}{}\t{}'.format(name, args_string, type_name), '{}{}'.format(name, args_string), ]) return ( completions, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS )
def on_query_completions(self, view, prefix, locations): # Check if this is a Crystal source file. This check # relies on the Crystal syntax formatting extension # being installed - https://github.com/crystal-lang/sublime-crystal if view.match_selector(locations[0], "source.crystal"): try: raw_results = run_cracker(view, locations[0]) except FileNotFoundError: print("Unable to find cracker executable (check settings)") return results = [] regexp = '[\.#](.+)\(' for r in raw_results: if r.type == "Function": if r.name.find("#") != -1: trigger = r.name.split("#")[1] else: trigger = r.name.split(".")[1] contents = trigger.split("(")[0] if r.name.find("()") == -1: contents = contents + '(' else: trigger = r.name contents = r.name results.append([trigger, contents]) if len(results) > 0: # return results return (results, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) #class CrystalGotoDefinitionCommand(sublime_plugin.TextCommand): # def run(self, edit): # # Get the buffer location in correct format for cracker # row, col = self.view.rowcol(self.view.sel()[0].begin()) # row += 1 # # results = run_cracker(self.view, ["find-definition", str(row), str(col)]) # # if len(results) == 1: # result = results[0] # path = result.path # # On Windows the cracker will return the paths without the drive # # letter and we need the letter for the open_file to work. # if sublime.platform() == 'windows' and not re.compile('^\w\:').match(path): # path = 'c:' + path # encoded_path = "{0}:{1}:{2}".format(path, result.row, result.column) # self.view.window().open_file(encoded_path, sublime.ENCODED_POSITION)
def on_query_completions(self, view, prefix, locations): """Sublime Text autocompletion event handler """ if not is_code(view, lang='rust'): return if self.ready_from_defer is True: completion_flags = 0 if ags(view, 'suppress_word_completions', False): completion_flags = sublime.INHIBIT_WORD_COMPLETIONS if ags(view, 'suppress_explicit_completions', False): completion_flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS cpl = self.completions self.completions = [] self.ready_from_defer = False return (cpl, completion_flags) code = view.substr(sublime.Region(0, view.size())) row, col = view.rowcol(locations[0]) racer = get_settings(view, 'racer_binary_path', 'racer') if racer == '': racer = 'racer' data = { 'vid': view.id(), 'filename': view.file_name(), 'settings': { 'racer_binary_path': racer, 'rust_src_path': get_settings(view, 'rust_src_path'), 'row': row, 'col': col, 'source': code, }, 'method': 'autocomplete', 'handler': 'racer' } Worker().execute( Callback( on_success=self._complete, on_failure=self._on_failure, on_timeout=self._on_timeout ), **data )
