def on_text_command(self, view, command_name, args): # check if a completion may be inserted if command_name in settings.get("trigger_action", []) or command_name in settings.get("insert_action", []): self.start_tracking(view, command_name) elif command_name == "hide_auto_complete": self.on_query_abort() self.abort_tracking()
def on_post_text_command(self, view, command_name, args): if len( view.sel() ) < 1: return current_line = Selection.get_line(view) command_trigger = command_name in settings.get("trigger_action", []) and self.track_insert["start_line"] != current_line if command_trigger or command_name in settings.get("insert_action", []): self.finish_tracking(view, command_name) self.on_post_insert_completion(view, command_name)
def run(self, edit, a, b, string, move_cursor=False): if settings.get("DISABLE_KEYMAP_ACTIONS") is True: return False self.view.replace(edit, sublime.Region(a, b), string) if move_cursor and settings.get("POST_INSERT_MOVE_CHARACTERS"): self.move_skip(a + len(string))
def get_file_cache(folder): if not folder in file_caches: valid_file_extensions = get_valid_extensions(settings.get("trigger")) logger.verbose(ID, "Build cache for " + folder + " (", valid_file_extensions, ") excluding", settings.get("exclude_folders")) file_caches[folder] = FileCache(valid_file_extensions, settings.get("exclude_folders"), folder) return file_caches.get(folder)
def find_trigger(current_scope, expression, byCommand=False): """ Returns the first trigger matching the given scope and expression """ triggers = settings.get("TRIGGER") if not byCommand: # get any triggers that match the requirements and may start automatically triggers = get_matching_autotriggers(current_scope, settings.get("TRIGGER")) if not bool(triggers): verbose(ID, "abort query, no valid scope-regex for current context") return False # check if one of the triggers match the current context (expression, scope) return Context.find_trigger(expression, current_scope, triggers)
def read(self, folder, base=None): """return all files in folder""" folder_cache = {} base = base if base is not None else folder if base is not folder: # ensure project_folders are not excluded by another folders exclude patterns # e.g. project/node_modules excludes project/node_modules/module, which is also a project folder relative_folder = os.path.relpath(folder, base) # test ignore expressions on current path for test in self.exclude_folders: if re.search(test, relative_folder) is not None: # verbose(ID, "skip " + folder) return folder_cache # ressources = for ressource in os.listdir(folder): current_path = os.path.join(folder, ressource) if (os.path.isfile(current_path)): relative_path = os.path.relpath(current_path, base) filename, extension = os.path.splitext(relative_path) extension = extension[1:] # posix required for windows, else absolute paths are wrong: /asd\ads\ relative_path = posix(relative_path) # substitute $ which prevents errors in further processing. is replaced again in completion.py post repl relative_path = re.sub("\$", settings.get("escape_dollar"), relative_path) if extension in self.extensions: current_filename = posix(filename) folder_cache[relative_path] = [ # modified filepath. $ hack is reversed in post_commit_completion re.sub("\$", settings.get("escape_dollar"), current_filename), # extension of file extension, # sublime completion text current_filename + "\t" + extension ] elif (not ressource.startswith('.') and os.path.isdir(current_path)): folder_cache.update(self.read(current_path, base)) return folder_cache
def resolve_path_type(needle, trigger): """ ^ | Force | -------- | Needle | -------- | Trigger? """ type_of_path = False # OR RELATIVE BY DEFAULT? # test if forced by command if override.get("filepath_type"): type_of_path = override.get("filepath_type") # test path to trigger auto-completion by needle elif not by_command() and trigger.get("auto") is False and settings.get( "auto_trigger") and Path.is_absolute(needle): type_of_path = "absolute" elif Path.is_absolute(needle): type_of_path = "absolute" elif Path.is_relative(needle): type_of_path = "relative" elif trigger.get("relative") is True: type_of_path = "relative" elif trigger.get("relative") is False: type_of_path = "absolute" return type_of_path
def build(needle, trigger, current_folder): """ updates state object for given trigger. The state object is then used to query the file cache: @see completion ProjectManager.search_completions( query.get_needle(), current_file.get_project_directory(), query.get_extensions(), query.get_base_path() ) """ needle = Path.sanitize(needle) needle_is_absolute = Path.is_absolute(needle) needle_is_path = needle_is_absolute or Path.is_relative(needle) if not trigger or not ( by_command() or (settings.get("auto_trigger") if needle_is_path else trigger.get( "auto", settings.get("auto_trigger")))): return False """ Adjust current folder by specified base folder: BASE-FOLDER -> CURRENT_FOLDER ------------------------------------------------------------ True use settings base_directory String use string as base_directory False use current file's directory (parameter) """ base_path = resolve_value("base_directory", trigger, False) if base_path is True: current_folder = settings.get("base_directory") elif base_path: current_folder = Path.sanitize_base_directory(base_path) state["post_remove_path"] = current_folder if ( base_path and needle_is_absolute) else False state["base_directory"] = current_folder if resolve_path_type( needle, trigger) == "relative" else False state["replace_on_insert"] = resolve_value("replace_on_insert", trigger, []) state["extensions"] = resolve_value("extensions", trigger, ["*"]) state["needle"] = sanitize_needle(needle, current_folder) return True
def apply_post_replacements(path, base_directory, replace_on_insert): # hack reverse path = re.sub(settings.get("ESCAPE_DOLLAR"), "$", path) for replace in replace_on_insert: path = re.sub(replace[0], replace[1], path) if base_directory and path.startswith("/"): path = re.sub("^\/" + base_directory, "", path) path = Path.sanitize(path) return path
def move_skip(self, point): length = 0 word_region = self.view.word(point) line_region = self.view.line(point) post_region = sublime.Region(word_region.b, line_region.b) post = self.view.substr(post_region) to_move = re.search(settings.get("POST_INSERT_MOVE_CHARACTERS"), post) if to_move: length = len(to_move.group(0)) self.move_cursor(point + length)
def check_trigger(trigger, expression): # returns True if the expression statements match the trigger for statement in set( settings.get("trigger_statements")).intersection(trigger): values = trigger.get(statement) # statement values may be None (or any other value...) if type(values) is list and not expression.get(statement) in values: return False # validate other value by comparison # elif not values == expression.get(statement): # return False return True
def on_query_completions(self, view, prefix, locations): if settings.get("disable_autocompletion") and not Query.by_command(): return False if self.track_insert["active"] is False: self.start_tracking(view) completions = controller.get_filepath_completions(view) if completions is not False: return completions self.finish_tracking(view) return False
def run(self, edit, type="default", base_directory=None, replace_on_insert=[], extensions=[]): if settings.get("DISABLE_KEYMAP_ACTIONS") is True: return False Query.override_trigger_setting("filepath_type", type) Query.override_trigger_setting("base_directory", base_directory) if len(replace_on_insert) > 0: Query.override_trigger_setting("replace_on_insert", replace_on_insert) if len(extensions) > 0: Query.override_trigger_setting("extensions", extensions) self.view.run_command('auto_complete', "insert")
def end_block(): if settings.get("log") or settings.get("debug"): print("")
def log(*args): if settings.get("log"): print("FFP\t", *args)
def plugin_loaded(): """ load settings """ update_settings() settings_file = sublime.load_settings(Settings.get("ffp_settings_file")) settings_file.add_on_change("update", update_settings)
def verbose(*args): if settings.get("debug") is True and not args[0] in IGNORE: print("FFP\t", *args)