def compare(self, first, second, scope_bracket=False): """ Compare brackets. This function allows bracket plugins to add aditional logic. """ if scope_bracket: match = first is not None and second is not None else: match = first.type == second.type if not self.rules.check_compare: return match if match: bracket = self.rules.scopes[first.scope]["brackets"][ first.type] if scope_bracket else self.rules.brackets[ first.type] try: if bracket.compare is not None and match: match = bracket.compare( bracket.name, bh_plugin.BracketRegion(first.begin, first.end), bh_plugin.BracketRegion(second.begin, second.end), self.search.get_buffer()) except: log("Plugin Compare Error:\n%s" % str(traceback.format_exc())) return match
def parse_scope_definition(self, language, loaded_modules): """ Parse the scope defintion """ scopes = {} scope_count = 0 for params in self.scope_rules: if is_valid_definition(params, language): try: bh_plugin.load_modules(params, loaded_modules) entry = ScopeDefinition(params) if not self.check_compare and entry.compare is not None: self.check_compare = True if not self.check_validate and entry.validate is not None: self.check_validate = True if not self.check_post_match and entry.post_match is not None: self.check_post_match = True for x in entry.scopes: if x not in scopes: scopes[x] = scope_count scope_count += 1 self.scopes.append({"name": x, "brackets": [entry]}) else: self.scopes[scopes[x]]["brackets"].append(entry) debug("Scope Regex (%s)\n Opening: %s\n Closing: %s\n" % (entry.name, entry.open.pattern, entry.close.pattern)) except Exception as e: log(e)
def compare(self, first, second, scope_bracket=False): """ Compare brackets. This function allows bracket plugins to add aditional logic. """ if scope_bracket: match = first is not None and second is not None else: match = first.type == second.type if not self.rules.check_compare: return match if match: bracket = self.rules.scopes[first.scope]["brackets"][first.type] if scope_bracket else self.rules.brackets[first.type] try: if bracket.compare is not None and match: match = bracket.compare( bracket.name, bh_plugin.BracketRegion(first.begin, first.end), bh_plugin.BracketRegion(second.begin, second.end), self.search.get_buffer() ) except: log("Plugin Compare Error:\n%s" % str(traceback.format_exc())) return match
def post_match(self, left, right, center, scope_bracket=False): """ Peform special logic after a match has been made. This function allows bracket plugins to add aditional logic. """ if left is not None: if scope_bracket: bracket = self.rules.scopes[left.scope]["brackets"][left.type] bracket_scope = left.scope else: bracket = self.rules.brackets[left.type] bracket_type = left.type elif right is not None: if scope_bracket: bracket = self.rules.scopes[right.scope]["brackets"][ right.type] bracket_scope = right.scope else: bracket = self.rules.brackets[right.type] bracket_type = right.type else: return left, right self.bracket_style = bracket.style if not self.rules.check_post_match: return left, right if bracket.post_match is not None: try: lbracket, rbracket, self.bracket_style = bracket.post_match( self.view, bracket.name, bracket.style, bh_plugin.BracketRegion(left.begin, left.end) if left is not None else None, bh_plugin.BracketRegion(right.begin, right.end) if right is not None else None, center, self.search.get_buffer(), self.search.search_window) if scope_bracket: left = bh_search.ScopeEntry( lbracket.begin, lbracket.end, bracket_scope, bracket_type) if lbracket is not None else None right = bh_search.ScopeEntry( rbracket.begin, rbracket.end, bracket_scope, bracket_type) if rbracket is not None else None else: left = bh_search.BracketEntry( lbracket.begin, lbracket.end, bracket_type) if lbracket is not None else None right = bh_search.BracketEntry( rbracket.begin, rbracket.end, bracket_type) if rbracket is not None else None except: log("Plugin Post Match Error:\n%s" % str(traceback.format_exc())) return left, right
def parse_bracket_definition(self, language, loaded_modules): """ Parse the bracket defintion """ names = [] subnames = [] find_regex = [] sub_find_regex = [] for params in self.bracket_rules: if is_valid_definition(params, language): try: bh_plugin.load_modules(params, loaded_modules) entry = BracketDefinition(params) if not self.check_compare and entry.compare is not None: self.check_compare = True if not self.check_validate and entry.validate is not None: self.check_validate = True if not self.check_post_match and entry.post_match is not None: self.check_post_match = True self.brackets.append(entry) if not entry.find_in_sub_search_only: find_regex.append(params["open"]) find_regex.append(params["close"]) names.append(params["name"]) else: find_regex.append(r"([^\s\S])") find_regex.append(r"([^\s\S])") if entry.find_in_sub_search: sub_find_regex.append(params["open"]) sub_find_regex.append(params["close"]) subnames.append(params["name"]) else: sub_find_regex.append(r"([^\s\S])") sub_find_regex.append(r"([^\s\S])") except Exception as e: log(e) if len(self.brackets): self.brackets = tuple(self.brackets) debug( "Bracket Pattern: (%s)\n" % ','.join(names) + " (Opening|Closing): (?:%s)\n" % '|'.join(find_regex) ) debug( "SubBracket Pattern: (%s)\n" % ','.join(subnames) + " (Opening|Closing): (?:%s)\n" % '|'.join(sub_find_regex) ) self.sub_pattern = ure.compile("(?:%s)" % '|'.join(sub_find_regex), ure.MULTILINE | ure.IGNORECASE) self.pattern = ure.compile("(?:%s)" % '|'.join(find_regex), ure.MULTILINE | ure.IGNORECASE)
def post_match(self, left, right, center, scope_bracket=False): """ Peform special logic after a match has been made. This function allows bracket plugins to add aditional logic. """ if left is not None: if scope_bracket: bracket = self.rules.scopes[left.scope]["brackets"][left.type] bracket_scope = left.scope else: bracket = self.rules.brackets[left.type] bracket_type = left.type elif right is not None: if scope_bracket: bracket = self.rules.scopes[right.scope]["brackets"][right.type] bracket_scope = right.scope else: bracket = self.rules.brackets[right.type] bracket_type = right.type else: return left, right self.bracket_style = bracket.style if not self.rules.check_post_match: return left, right if bracket.post_match is not None: try: lbracket, rbracket, self.bracket_style = bracket.post_match( self.view, bracket.name, bracket.style, bh_plugin.BracketRegion(left.begin, left.end) if left is not None else None, bh_plugin.BracketRegion(right.begin, right.end) if right is not None else None, center, self.search.get_buffer(), self.search.search_window ) if scope_bracket: left = bh_search.ScopeEntry(lbracket.begin, lbracket.end, bracket_scope, bracket_type) if lbracket is not None else None right = bh_search.ScopeEntry(rbracket.begin, rbracket.end, bracket_scope, bracket_type) if rbracket is not None else None else: left = bh_search.BracketEntry(lbracket.begin, lbracket.end, bracket_type) if lbracket is not None else None right = bh_search.BracketEntry(rbracket.begin, rbracket.end, bracket_type) if rbracket is not None else None except: log("Plugin Post Match Error:\n%s" % str(traceback.format_exc())) return left, right
def __init__(self, plugin, loaded): """ Load plugin module """ self.enabled = False self.args = plugin['args'] if ("args" in plugin) else {} self.plugin = None if 'command' in plugin: plib = plugin['command'] try: module = ImportModule.import_module(plib, loaded) self.plugin = getattr(module, 'plugin')() loaded.add(plib) self.enabled = True except Exception: log('BracketHighlighter: Load Plugin Error: %s\n%s' % (plugin['command'], traceback.format_exc()))
def load_modules(obj, loaded): """ Load bracket plugin modules """ plib = obj.get("plugin_library") if plib is None: return try: module = ImportModule.import_module(plib, loaded) obj["compare"] = getattr(module, "compare", None) obj["post_match"] = getattr(module, "post_match", None) obj["validate"] = getattr(module, "validate", None) loaded.add(plib) except: log("Could not load module %s\n%s" % (plib, str(traceback.format_exc()))) raise
def validate(self, b, bracket_type, scope_bracket=False): """ Validate bracket. """ match = True if not self.rules.check_validate: return match bracket = self.rules.scopes[b.scope]["brackets"][ b.type] if scope_bracket else self.rules.brackets[b.type] if bracket.validate is not None: try: match = bracket.validate( bracket.name, bh_plugin.BracketRegion(b.begin, b.end), bracket_type, self.search.get_buffer()) except: log("Plugin Bracket Find Error:\n%s" % str(traceback.format_exc())) return match
def run_command(self, view, name, left, right, selection): """ Load arguments into plugin and run """ plugin = self.plugin() setattr(plugin, "left", left) setattr(plugin, "right", right) setattr(plugin, "view", view) setattr(plugin, "selection", selection) setattr(plugin, "nobracket", False) edit = view.begin_edit() self.args["edit"] = edit self.args["name"] = name try: nobracket = False plugin.run(**self.args) left, right, selection, nobracket = plugin.left, plugin.right, plugin.selection, plugin.nobracket except Exception: log("BracketHighlighter: Plugin Run Error:\n%s" % str(traceback.format_exc())) view.end_edit(edit) return left, right, selection, nobracket
def validate(self, b, bracket_type, scope_bracket=False): """ Validate bracket. """ match = True if not self.rules.check_validate: return match bracket = self.rules.scopes[b.scope]["brackets"][b.type] if scope_bracket else self.rules.brackets[b.type] if bracket.validate is not None: try: match = bracket.validate( bracket.name, bh_plugin.BracketRegion(b.begin, b.end), bracket_type, self.search.get_buffer() ) except: log("Plugin Bracket Find Error:\n%s" % str(traceback.format_exc())) return match