def should_handle_tab_key(syntax=None): view = active_view() scopes = settings.get('disabled_single_snippet_for_scopes', None) cur_scope = get_scope(view) if sublime.score_selector(cur_scope, 'source.css'): return True if not scopes or not sublime.score_selector(cur_scope, scopes): return True abbr = ctx.js().locals.pyExtractAbbreviation() if not re.match(r'^[\w\:%]+$', abbr): # it's a complex expression return True if re.match(r'^(lorem|lipsum)\d*$', abbr): # hardcoded Lorem Ipsum generator return True # detect inline CSS if syntax is None: syntax = ctx.js().locals.pyGetSyntax() if syntax == 'css': return True known_tags = settings.get('known_html_tags', '').split() if abbr in known_tags or ctx.js().locals.pyHasSnippet(abbr): return True return False
def should_handle_tab_key(): view = active_view() scopes = settings.get('disabled_single_snippet_for_scopes', None) cur_scope = view.syntax_name(view.sel()[0].begin()) if sublime.score_selector(cur_scope, 'source.css'): return True if not scopes or not sublime.score_selector(cur_scope, scopes): return True abbr = ctx.js().locals.pyExtractAbbreviation() if not re.match(r'^\w+$', abbr): # it's a complex expression return True if re.match(r'^(lorem|lipsum)\d*$', abbr): # hardcoded Lorem Ipsum generator return True known_tags = settings.get('known_html_tags', '').split() if abbr in known_tags or ctx.js().locals.pyHasSnippet(abbr): return True return False
def get_hayaku_options(self): settings = self.view.settings() options = {} match = {} # Autoguessing the options if settings.get("hayaku_CSS_syntax_autoguess"): autoguess = settings.get("hayaku_CSS_syntax_autoguess") offset = len(autoguess[0]) - len(autoguess[0].lstrip()) autoguess = [s[offset:].rstrip() for s in autoguess] match = GUESS_REGEX.search('\n'.join(autoguess)) # Helper to set an option got from multiple sources def get_setting(setting, fallback, match_group=False): if match_group and match: fallback = match.group(match_group) single_setting = False if settings.has("hayaku_" + setting): single_setting = settings.get("hayaku_" + setting, fallback) options[setting] = single_setting or fallback # Some hardcode for different scopes # (could this be defined better?) scope_name = self.view.scope_name(self.view.sel()[0].a) is_sass = sublime.score_selector(scope_name, 'source.sass') > 0 is_stylus = sublime.score_selector(scope_name, 'source.stylus') > 0 disable_braces = is_stylus or is_sass if is_stylus and match and match.group(2) and match.group(8): disable_braces = False disable_colons = is_stylus if match and match.group(4): disable_colons = False disable_semicolons = is_stylus or is_sass if is_stylus and match and match.group(6): disable_semicolons = False # Calling helper, getting all the needed options get_setting("CSS_whitespace_block_start_before", " ", 1) get_setting("CSS_whitespace_block_start_after", "\n\t", 3) get_setting("CSS_whitespace_block_end_before", "\n", 7) get_setting("CSS_whitespace_block_end_after", "", 9) get_setting("CSS_whitespace_after_colon", " ", 5) get_setting("CSS_newline_after_expand", False) get_setting("CSS_syntax_no_curly_braces", disable_braces) get_setting("CSS_syntax_no_colons", disable_colons) get_setting("CSS_syntax_no_semicolons", disable_semicolons) get_setting("CSS_prefixes_disable", False) get_setting("CSS_prefixes_align", not (is_stylus or is_sass)) get_setting("CSS_prefixes_only", []) get_setting("CSS_prefixes_no_unprefixed", False) get_setting("CSS_disable_postexpand", False) get_setting("CSS_colors_case", "uppercase") # or "lowercase" or "initial" get_setting("CSS_colors_length", "short") # or "long" or "initial" get_setting("CSS_clipboard_defaults", ["colors", "images"]) return options
def toggle_breakpoint(view): try: # Get selected point in view point = view.sel()[0] # Check if selected point uses breakpoint line scope if point.size() == 3 and sublime.score_selector( view.scope_name(point.a), 'xdebug.output.breakpoint.line'): # Find line number of breakpoint line = view.substr(view.line(point)) pattern = re.compile( '^\\s*(?:(\\|\\+\\|)|(\\|-\\|))\\s*(?P<line_number>\\d+)\\s*(?:(--)(.*)|.*)' ) match = pattern.match(line) # Check if it has found line number if match and match.group('line_number'): # Get all breakpoint filenames breakpoint_file = view.find_by_selector( 'xdebug.output.breakpoint.file') # Locate line with filename related to selected breakpoint file_line = None for entry in breakpoint_file: # Stop searching if we have passed selected breakpoint if entry > point: break file_line = view.substr(view.line(entry)) # Do not continue without line containing filename if file_line is None: return # Remove unnecessary text from line to get filename file_pattern = re.compile('^\\s*(=>)\\s*(?P<filename>.*)') file_match = file_pattern.match(file_line) # Check if it is a valid filename if file_match and file_match.group('filename'): filename = file_match.group('filename') line_number = match.group('line_number') enabled = None # Disable breakpoint if sublime.score_selector( view.scope_name(point.a), 'entity' ) and S.BREAKPOINT[filename][line_number]['enabled']: enabled = False # Enable breakpoint if sublime.score_selector( view.scope_name(point.a), 'keyword' ) and not S.BREAKPOINT[filename][line_number]['enabled']: enabled = True # Toggle breakpoint only if it has valid value if enabled is None: return sublime.active_window().run_command( 'xdebug_breakpoint', { "enabled": enabled, "rows": [line_number], "filename": filename }) except: pass
def extract_inline_latex_scope(view, point): """Like extract_scope(), but extracts the extent of meta.inline_latex.fortran.""" ltxscope = "meta.inline_latex.fortran" istart = point iend = point while istart > 0 and sublime.score_selector( view.scope_name(istart - 1), ltxscope) > 0: istart = istart - 1 while iend < view.size() and sublime.score_selector( view.scope_name(iend), ltxscope) > 0: iend = iend + 1 r = sublime.Region(istart, iend) if r.size() > 1000: r = sublime.Region(point, point) return r
def toggle_watch(view): # Do not try to toggle when no watch expressions defined if not S.WATCH: return try: # Get selected point in view point = view.sel()[0] # Check if selected point uses watch entry scope if point.size() == 3 and sublime.score_selector( view.scope_name(point.a), 'meta.xdebug.watch.line'): # Determine if watch entry is enabled or disabled line = view.substr(view.line(point)) pattern = re.compile( '^(?:(?P<enabled>\\|\\+\\|)|(?P<disabled>\\|-\\|))\\.*') match = pattern.match(line) if match and (match.group('enabled') or match.group('disabled')): # Get all entries and determine index by line/point match watch = view.find_by_selector('meta.xdebug.watch.line') watch_entries = [ watch_entry for watch_region in watch for watch_entry in view.split_by_newlines(watch_region) ] watch_index = 0 for entry in watch_entries: # Stop searching if we have passed selected expression if entry > point: break # Only increment watch index when it contains expression watch_line = view.substr(view.line(entry)) watch_match = pattern.match(watch_line) if watch_match and (watch_match.group('enabled') or watch_match.group('disabled')): watch_index += 1 # Disable watch expression if sublime.score_selector( view.scope_name(point.a), 'entity') and S.WATCH[watch_index]['enabled']: S.WATCH[watch_index]['enabled'] = False # Enable watch expression if sublime.score_selector( view.scope_name(point.a), 'keyword') and not S.WATCH[watch_index]['enabled']: S.WATCH[watch_index]['enabled'] = True # Update watch view and save watch data to file sublime.active_window().run_command('xdebug_watch', {'update': True}) except: pass
def on_hover(self, view, point, hover_zone): if "Fortran" not in view.settings().get('syntax'): return if view.settings().get('fortran_disable_latex', False): return if hover_zone != sublime.HOVER_TEXT: return scope = view.scope_name(point) score = sublime.score_selector(scope, "meta.inline_latex.fortran") if score > 0: # We are hovering over some embedded latex region = InlineLatexHover.extract_inline_latex_scope(view, point) latex = view.substr(region) # bg, fg = 'ffffff', '222222' bg, fg = InlineLatexHover.get_colors(view) params = urllib.parse.urlencode({ 'cht': "tx", 'chl': latex, 'chf': 'bg,s,' + bg, 'chco': fg }) imgurl = "http://chart.googleapis.com/chart?" + params try: response = urllib.request.urlopen(imgurl) rawdata = response.read() imgdata = b64encode(rawdata).decode() html_str = '<img src="data:image/png;base64,%s" />' % imgdata except (urllib.error.HTTPError) as e: html_str = '<span class="error">%s<span/>' % str(e) view.show_popup(html_str, sublime.HIDE_ON_MOUSE_MOVE, point)
def check_scope(self): scope = self.view.scope_name(self.view.sel()[0].a) allowed_scopes = ['source.js', 'source.coffee'] score = 0 for a in allowed_scopes: score = score + sublime.score_selector(scope, a) return score > 0
def get_color(self, scope_key): """ Simplified version of the guess_color function from MdPopups which simply return the foreground color or a scope """ color = self.special_colors['foreground']['color'] if scope_key in self.matched: color = self.matched[scope_key]["color"] else: best_match_bg = 0 best_match_fg = 0 best_match_style = 0 best_match_sfg = 0 best_match_fg_gradient = 0 for key in self.colors: match = sublime.score_selector(scope_key, key) if ( not self.colors[key]['color_gradient'] and self.colors[key]["color"] is not None and match > best_match_fg ): best_match_fg = match color = self.colors[key]["color"] self.matched[scope_key] = {"color": color} return color
def on_modified(self, view): if sublime.score_selector(view.scope_name(view.sel()[0].b), 'source.php') == 0: return editor = PhpCoder().editor(view) doComplete = False line = editor.before() if len(line) == 0: return if re.match(r'.*[,\(]\s*$', line) or line[-1] == '$' or re.match( r'.*new [a-zA-Z0-9_]*$', line) or re.match( r'(^|\s+)[a-zA-Z]+$', line): doComplete = True else: expr = editor.expr() if expr and expr['prefix'][:2] in ['::', '->']: doComplete = True if doComplete: view.run_command( 'auto_complete', { 'disable_auto_insert': True, 'api_completions_only': False, 'next_completion_if_showing': False, 'auto_complete_commit_on_tab': True, })
def show_context_output(view): """ Show selected variable in an output panel when clicked in context window. Keyword arguments: view -- View reference which holds the context window. """ # Check if there is a debug session and context data if S.SESSION and S.SESSION.connected and S.CONTEXT_DATA: try: # Get selected point in view point = view.sel()[0] # Check if selected point uses variable scope if point.size() == 0 and sublime.score_selector(view.scope_name(point.a), 'variable'): # Find variable in line which contains the point line = view.substr(view.line(point)) pattern = re.compile('^\\s*(\\$.*?)\\s+\\=') match = pattern.match(line) if match: # Get variable details from context data variable_name = match.group(1) variable = get_context_variable(S.CONTEXT_DATA, variable_name) if variable: # Convert details to text output variables = H.new_dictionary() variables[variable_name] = variable data = generate_context_output(variables) # Show context variables and children in output panel window = sublime.active_window() panel = window.get_output_panel('xdebug') panel.run_command("xdebug_view_update", {'data' : data} ) panel.run_command('set_setting', {"setting": 'word_wrap', "value": True}) window.run_command('show_panel', {"panel": 'output.xdebug'}) except: pass
def erlang_goto_definition(window, symbol=None): if symbol is not None: return None view = window.active_view() point = view.sel()[0].begin() scope = view.scope_name(point) symbol = view.substr(view.word(point)) scores = map(lambda s: sublime.score_selector(scope, s[1]), PREFIX_MAP) (maxscore, match) = max(zip(scores, PREFIX_MAP), key=lambda z: z[0]) kind = match[0] if maxscore == 0: gotosym = symbol elif kind == 'Macro': gotosym = kind + ': ' + strip_before('?', symbol) elif kind == 'Record': gotosym = kind + ': ' + strip_before('#', symbol) elif kind == 'Function': return GotoExactDefinition(view).at_position(kind, point) elif kind == 'Type': return GotoExactDefinition(view).at_position(kind, point) else: gotosym = kind + ': ' + symbol return ('goto_definition', {'symbol': gotosym})
def find_matches(scope, founds): global _schemeEditor ret = [] maxscore = 0 # find the scope in the xml that matches the most for found in founds: foundstr = _schemeEditor.substr(found) pos = foundstr.find('<string>') + 8 foundstr = foundstr[pos:-9] foundstrs = foundstr.split(',') fstrlen = 0 for fstr in foundstrs: fstrlen = len(fstr) fstr = fstr.lstrip(' ') padleft = fstrlen - len(fstr) fstr = fstr.rstrip(' ') score = sublime.score_selector(scope, fstr) if score > 0: a = found.a + pos + padleft ret.append([score, sublime.Region(a, a + len(fstr))]) pos += fstrlen + 1 if len(ret) == 0: return None else: return ret
def run(self, edit, **kw): view = active_view() if settings.get('clear_fields_on_enter_key', False): view.run_command('clear_fields') snippet = '\n${0}' if len(view.sel()) > 1: return view.run_command('insert_snippet', {'contents': snippet}) # let's see if we have to insert formatted linebreak caret_pos = view.sel()[0].begin() scope = view.syntax_name(caret_pos) if sublime.score_selector( scope, settings.get('formatted_linebreak_scopes', '')): snippet = '\n\t${0}\n' # Looks like ST2 has buggy scope matcher: sometimes it will call # this action even if context selector forbids that. # Thus, we have to manually filter it. elif 'source.' not in scope: # checking a special case: caret right after opening tag, # but not exactly between pairs if view.substr(sublime.Region(caret_pos - 1, caret_pos)) == '>': line_range = view.line(caret_pos) line = view.substr( sublime.Region(line_range.begin(), caret_pos)) or '' m = re.search( r'<(\w+\:?[\w\-]*)(?:\s+[\w\:\-]+\s*=\s*([\'"]).*?\1)*\s*>$', line) if m and m.group(1).lower() not in settings.get( 'empty_elements', '').split(): snippet = '\n\t${0}' view.run_command('insert_snippet', {'contents': snippet})
def run(self, edit, **kw): view = active_view() if settings.get('clear_fields_on_enter_key', False): view.run_command('clear_fields') snippet = '\n${0}' if len(view.sel()) > 1: return view.run_command('insert_snippet', {'contents': snippet}) # let's see if we have to insert formatted linebreak caret_pos = view.sel()[0].begin() scope = view.syntax_name(caret_pos) if sublime.score_selector( scope, settings.get('formatted_linebreak_scopes', '')) > 0: snippet = '\n\t${0}\n' else: # checking a special case: caret right after opening tag, # but not exactly between pairs if view.substr(sublime.Region(caret_pos - 1, caret_pos)) == '>': line_range = view.line(caret_pos) line = view.substr( sublime.Region(line_range.begin(), caret_pos)) or '' if re.search( r'<\w+\:?[\w\-]*(?:\s+[\w\:\-]+\s*=\s*([\'"]).*?\1)*\s*>$', line) is not None: snippet = '\n\t${0}' view.run_command('insert_snippet', {'contents': snippet})
def on_selection_modified(self): ''' Show selected variable in an output panel when clicked ''' if protocol and protocol.connected and self.context_data: data = '' point = self.view.sel()[0].a var_name = self.view.substr(self.view.word(point)) if not var_name.startswith('$'): var_name = '$' + var_name is_variable = sublime.score_selector(self.view.scope_name(point), 'variable') if is_variable and var_name in self.context_data: kind = self.context_data[var_name]['type'] if kind == 'array' or kind == 'object': for key in sorted(self.context_data.keys()): if key.startswith(var_name): data += '{k} ({t}) = {d}\n'.format(k=key, t=self.context_data[key]['type'], d=self.context_data[key]['data']) else: data += '{k} ({t}) = {d}\n'.format(k=var_name, t=kind, d=self.context_data[var_name]['data']) window = self.view.window() if window: output = window.get_output_panel('xdebug_inspect') edit = output.begin_edit() output.erase(edit, sublime.Region(0, output.size())) output.insert(edit, 0, data) output.end_edit(edit) window.run_command('show_panel', {"panel": 'output.xdebug_inspect'})
def is_applicable(cls, settings): this_syntax = settings.get("syntax") for syntax in sublime.list_syntaxes(): for scope in uri_setting("active_scopes"): if syntax.path == this_syntax: if sublime.score_selector(syntax.scope, scope): return True return False
def run(self, edit): if sublime.score_selector(self.view.scope_name(self.view.sel()[0].b), 'source.php') == 0: return if self.fromMouseEvent: old_sel = [r for r in self.view.sel()] self.view.run_command("drag_select", {'event': self.fromMouseEvent}) new_sel = self.view.sel()[0] editor = PhpCoder().editor(self.view) offset = 0 pos = editor.getPosition() while re.match(r'[a-zA-Z_][a-zA-Z0-9_]*', editor.substr(pos + offset, pos + offset + 1)): offset += 1 expr = editor.expr() if expr: expr['prefix'] += editor.substr(pos, pos + offset) if editor.substr(pos + offset, pos + offset + 1) == '(': expr['prefix'] += '()' else: wordRegion = self.view.word(self.view.sel()[0]) expr = {'prefix': '', 'expr': self.view.substr(wordRegion)} if editor.substr(wordRegion.begin() - 1, wordRegion.begin()) == '$': expr['expr'] = '$' + expr['expr'] if expr['expr']: resolver = phpcoder.resolver.Resolver(editor) self.prefix = None if expr['prefix']: parsedPrefix = resolver.parseExpression('Dummy' + expr['prefix']) if parsedPrefix and len(parsedPrefix) > 1: self.prefix = parsedPrefix[1]['name'] self.matches = [] for r in resolver.resolve(expr['expr']): if self.prefix == None or \ ('properties' in r and self.prefix in r['properties']) or \ ('methods' in r and self.prefix in r['methods']): self.matches.append(r) results = [] for r in self.matches: results.append([ r['name'] + expr['prefix'], r['path'], ]) if len(results) == 1: self.panel_on_select(0) elif len(results) > 0: self.view.window().show_quick_panel( results, self.panel_on_select, on_highlight=self.panel_on_highlight)
def match_view(self, view: sublime.View, scheme: str) -> bool: syntax = view.syntax() if not syntax: return False # Every part of a x.y.z scope seems to contribute 8. # An empty selector result in a score of 1. # A non-matching non-empty selector results in a score of 0. # We want to match at least one part of an x.y.z, and we don't want to match on empty selectors. return scheme in self.schemes and sublime.score_selector( syntax.scope, self.selector) >= 8
def get_CSS_declarations(self): if not sublime.score_selector( self.view.scope_name(self.region.a), 'source.css, source.less, source.sass, source.scss, source.stylus, source.postcss' ): return False return self.get_closest_value( self.view.substr(self.view.line(self.region)), self.view.line(self.region).begin(), r'([^;]+;?)', r'^\s*\/\*|^\W+$')
def find_css_selector(view, start_pt): conds = [track_scope(CSS_SELECTOR)] if not sublime.score_selector(view.scope_name(start_pt), CSS_SELECTOR): # if not view.score_selector((start_pt), CSS_SELECTOR): conds.insert(0, track_scope(CSS_SELECTOR, False)) selector = back_track(view, start_pt, *conds)[-1] if selector is not None: return view.substr(selector).strip()
def run(self, edit, **kw): view = active_view() if settings.get('clear_fields_on_enter_key', False): view.run_command('clear_fields') # let's see if we have to insert formatted linebreak scope = view.syntax_name(view.sel()[0].begin()) if sublime.score_selector(scope, 'meta.scope.between-tag-pair.html, meta.scope.between-tag-pair.xml') > 0: view.run_command('insert_snippet', {'contents': '\n\t${0}\n'}) else: view.run_command('insert_snippet', {'contents': '\n${0}'})
def find_common_scopes(scopes, skip_syntax_suffix): """Find the (partial) scopes that are common for a list of scopes. Example of unique scopes for the following Python code (and test positions): def function(): ^^^^^^^^^^^^^^ [ 'source.python meta.function.python storage.type.function.python', 'source.python meta.function.python', 'source.python meta.function.python entity.name.function.python', 'source.python meta.function.parameters.python punctuation.section.parameters.begin.python' ] The common scope for these, ignoring the base scope, will be 'meta.function' """ # we will use the scopes from index 0 and test against the scopes from the further indexes # as any scopes that doesn't appear in this index aren't worth checking, they can't be common # skip the base scope i.e. `source.python` check_scopes = next(iter(scopes)).split()[1:] shared_scopes = '' # stop as soon as at least one shared scope was found # or when there are no partial scopes left to check while not shared_scopes and check_scopes: if not skip_syntax_suffix: for check_scope in check_scopes: # check that the scope matches when combined with the shared scopes that have # already been discovered, because order matters (a space in a scope selector # is an operator, meaning the next scope must appear somewhere to the right # of the one before), and some scopes may appear more than once compare_with = shared_scopes + check_scope if all( sublime.score_selector(scope, compare_with) > 0 for scope in scopes): shared_scopes += check_scope + ' ' # if no matches were found if not shared_scopes: # split off the last partial scope from each scope to check # i.e. `meta.function.parameters` becomes `meta.function` # if the scope to check doesn't contain any sub-scopes i.e. `meta`, # then drop it from the list of scopes to check check_scopes = [ '.'.join(check_scope.split('.')[0:-1]) for check_scope in check_scopes if '.' in check_scope ] skip_syntax_suffix = False return shared_scopes.strip()
def run(self, edit): scope_name = self.view.scope_name(self.view.sel()[0].a) selectors = self.parse_theme(self.load_theme()) best, bestScore = '', 0 for selector in selectors: score = sublime.score_selector(scope_name, selector) if score > bestScore: bestScore = score best = selector str = "Selector: |%s| Scope: |%s| Score %d " % (best, scope_name, bestScore) print str sublime.status_message(str)
def on_query_completions(self, view, prefix, locations): if sublime.score_selector(view.scope_name(view.sel()[0].b), 'source.php') == 0: return editor = PhpCoder().editor(view) resolver = phpcoder.resolver.Resolver(editor) line = editor.before() if re.match(r'.*[,\(]\s*$', line): return self._completeParams(editor, resolver) if re.match(r'.*new [a-zA-Z0-9_]*$', line): return self._completeNew(view) if line[-1] == '$': return editor.findLocals() expr = editor.expr() if expr: return self._completeExpr(expr, editor, resolver) return []
def run(self, edit, point=None): # TODO: take a list of positions instead? if point is None: point = self.view.sel()[0].begin() # if the mouse cursor is hovering at |SOL#, take the sharp token as well check_tokens = self.view.extract_tokens_with_scopes(sublime.Region(point, point + 4)) if len(check_tokens) > 1: token_to_show = check_tokens[0] if sublime.score_selector(check_tokens[1][1], 'constant.language.sharp') > 0: token_to_show = check_tokens[1] point = token_to_show[0].end() # we could get all the tokens, but we don't need anything after the mouse cursor to show the state, so this saves time # and makes it easier to get the parse_state for the token under the mouse cursor - it's the last token we parsed instructions = piano_tunes.parse_piano_tune(piano_tunes.get_tokens_from_regions(self.view, [sublime.Region(0, point)])) # get the last instruction from an iterator # https://stackoverflow.com/a/3169701/4473405 # (seems less wasteful than making it a list to get the -1 index) parse_state = deque(piano_tunes.resolve_piano_tune_instructions(instructions), maxlen=1).pop() note_index = parse_state.instruction.value self.view.show_popup( f''' <body> <span>Note:</span> <span>{PianoMidi.notes_letters[note_index]}</span> <br /> <span>Solfege:</span> <span>{PianoMidi.notes_solfege[note_index]}</span> <br /> <span>Note Length:</span> <span>{parse_state.current_length}</span> <br /> <span>Note Octave:</span> <span>{parse_state.current_octave}</span> <br /> <a href="play"><span>Midi Note:</span> <span>{PianoMidi.note_to_midi_note(parse_state.current_octave, note_index)}</span></a> <br /> <span>Time Elapsed:</span> <span>{parse_state.time_elapsed:.3f} ms</span> </body> ''', sublime.HIDE_ON_MOUSE_MOVE_AWAY, point, on_navigate=lambda _: self.play_note(parse_state) )
def get_selector_style_map(view, selectors): styles = {} if int(sublime.version()) > 3153: for s in selectors: styles[s] = view.style_for_scope(s) else: color_scheme = get_color_scheme() top_scores = {} for s in selectors: for scope in color_scheme["scopes"]: score = sublime.score_selector(s, scope["scope"]) top_score = top_scores.get(s, 0) if score > 0 and score >= top_score: top_scores[s] = score styles[s] = scope["style"] return styles
def toggle_stack(view): try: # Get selected point in view point = view.sel()[0] # Check if selected point uses stack entry scope if point.size() > 3 and sublime.score_selector(view.scope_name(point.a), 'xdebug.output.stack.entry'): # Get fileuri and line number from selected line in view line = view.substr(view.line(point)) pattern = re.compile('^(\[\d+\])\s*(?P<fileuri>.*)(\..*)(\s*:.*?(?P<lineno>\d+))\s*(\((.*?):.*\)|$)') match = pattern.match(line) # Show file when it's a valid fileuri if match and match.group('fileuri'): filename = get_real_path(match.group('fileuri')) lineno = 0 if match.group('lineno'): lineno = match.group('lineno') show_file(filename, lineno) except: pass
def at_point(self, point): scope = self.view.scope_name(point).strip() if scope in self.scope_style_cache: return self.scope_style_cache[scope] style = self.default_styles.copy() scored_styles = [] for rule in self.json['rules']: if 'scope' in rule: score = score_selector(scope, rule['scope']) if 'foreground' in rule: fg = rule['foreground'] color = fg if fg in self.json_variables_dict: color = self.json_variables_dict[fg] rule.update({'foreground': color.lower()}) if 'background' in rule: bg = rule['background'] color = bg if bg in self.json_variables_dict: color = self.json_variables_dict[bg] rule.update({'background': color.lower()}) if 'font_style' in rule: rule.update({'fontStyle': rule['font_style']}) if score: rule.update({'score': score}) scored_styles.append(rule) for s in sorted(scored_styles, key=lambda k: k['score']): style.update(s) self.scope_style_cache[scope] = style return style
def at_point(self, point): scope = self.view.scope_name(point).strip() if scope in self.scope_style_cache: return self.scope_style_cache[scope] style = self.default_styles.copy() scored_styles = [] for color_scheme_definition in self.plist['settings']: if 'scope' in color_scheme_definition: score = score_selector(scope, color_scheme_definition['scope']) if score: color_scheme_definition.update({'score': score}) scored_styles.append(color_scheme_definition) for s in sorted(scored_styles, key=lambda k: k['score']): style.update(s['settings']) self.scope_style_cache[scope] = style return style