bh_search.py

"""
BracketHighlighter.

Copyright (c) 2013 - 2016 Isaac Muse <isaacmuse@gmail.com>
License: MIT
"""
import sublime
from collections import namedtuple

BH_SEARCH_LEFT = 0
BH_SEARCH_RIGHT = 1
BH_SEARCH_OPEN = 0
BH_SEARCH_CLOSE = 1
BH_ADJACENT_LEFT = 0
BH_ADJACENT_RIGHT = 1


class BhEntry(object):
    """Generic object for bracket regions."""

    def move(self, begin, end):
        """Create a new object with the points moved to the specified locations."""

        return self._replace(begin=begin, end=end)

    def size(self):
        """Size of bracket selection."""

        return abs(self.begin - self.end)

    def toregion(self):
        """Convert to sublime Region."""

        return sublime.Region(self.begin, self.end)


class BracketEntry(namedtuple('BracketEntry', ['begin', 'end', 'type'], verbose=False), BhEntry):
    """Bracket object."""

    pass


class ScopeEntry(namedtuple('ScopeEntry', ['begin', 'end', 'scope', 'type'], verbose=False), BhEntry):
    """Scope bracket object."""

    pass


class Search(object):
    """Search buffer object."""

    def __init__(self, view, rules, sel, selection_threshold=None):
        """Read in the view's buffer for scanning for brackets etc."""

        self.rules = rules

        self.view = view
        # Determine how much of the buffer to search
        view_min = 0
        view_max = view.size()
        if selection_threshold is not None:
            left_delta = sel.a - view_min
            right_delta = view_max - sel.a
            limit = selection_threshold / 2
            rpad = limit - left_delta if left_delta < limit else 0
            lpad = limit - right_delta if right_delta < limit else 0
            llimit = limit + lpad
            rlimit = limit + rpad
            search_window = (
                sel.a - llimit if left_delta >= llimit else view_min,
                sel.a + rlimit if right_delta >= rlimit else view_max
            )
        else:
            search_window = (0, view_max)

        # Search Buffer
        self.bfr = view.substr(sublime.Region(0, view_max))
        self.set_search_window(search_window)

    def get_buffer(self):
        """Get view buffer."""

        return self.bfr

    def set_search_window(self, search_window):
        """Set the window of search in the buffer."""

        self.search_window = search_window

    def new_scope_search(self, center, before_center, scope, adj_dir):
        """Retrieve a new search object."""

        return ScopeSearch(
            self, center, before_center, scope, adj_dir
        )

    def new_bracket_search(self, center, subsearch, scope):
        """Retrieve a new search object."""

        return BracketSearch(self, center, subsearch, scope)


class ScopeSearch(object):
    """Object that extracts brackets from scope."""

    def __init__(self, search, center, before_center, scope, adj_dir):
        """Set scope buffer by getting the extent of the scope."""

        self.adjusted_center = center
        self.view = search.view
        self.search = search
        extent = None

        if self.is_scope(center, before_center, scope, adj_dir):
            if int(sublime.version()) >= 3067:
                max_size = self.view.size()
            else:
                max_size = self.view.size() - 1
            extent = self.view.extract_scope(self.adjusted_center)
            while extent is not None and extent.begin() != 0:
                if search.view.match_selector(extent.begin() - 1, scope):
                    extent = extent.cover(self.view.extract_scope(extent.begin() - 1))
                    if extent.begin() < search.search_window[0] or extent.end() > search.search_window[1]:
                        extent = None
                else:
                    break
            while extent is not None and extent.end() != max_size:
                if self.view.match_selector(extent.end(), scope):
                    extent = extent.cover(self.view.extract_scope(extent.end()))
                    if extent.begin() < search.search_window[0] or extent.end() > search.search_window[1]:
                        extent = None
                else:
                    break
        assert extent is not None, "Failed to acquire scope buffer!"

        self.extent = extent
        self.scope_bfr = search.get_buffer()[extent.begin():extent.end()]

    def is_scope(self, center, before_center, scope, adj_dir=None):
        """Check if cursor is in scope or touching scope."""

        match = False
        if int(sublime.version()) >= 3067:
            match_test = before_center >= 0 and center != self.view.size()
        else:
            match_test = before_center >= 0
        if match_test:
            match = (
                self.view.match_selector(center, scope) and
                self.view.match_selector(before_center, scope)
            )
        if not match and (self.search.rules.outside_adj or self.search.rules.block_cursor):
            if adj_dir == BH_ADJACENT_LEFT:
                if self.search.rules.block_cursor:
                    match = self.view.match_selector(center, scope)
                    if match:
                        self.adjusted_center += 1
                elif before_center > 0 and not self.search.rules.block_cursor:
                    match = self.view.match_selector(before_center, scope)
                    if match:
                        self.adjusted_center = before_center
            else:
                match = self.view.match_selector(center, scope)
                if match:
                    self.adjusted_center += 1
        elif match and (self.search.rules.outside_adj or self.search.rules.block_cursor):
            if adj_dir == BH_ADJACENT_RIGHT:
                self.adjusted_center += 1
            else:
                self.adjusted_center -= 1
        return match

    def get_brackets(self, open_pattern, close_pattern, scope_id, bracket_id):
        """
        Get the brackets.

        Get the brackets from the scopes endpoints using
        the given open and closing patterns.
        """

        o = None
        c = None
        m = open_pattern.search(self.scope_bfr)
        if m and m.group(1):
            o = ScopeEntry(self.extent.begin() + m.start(1), self.extent.begin() + m.end(1), scope_id, bracket_id)
        m = close_pattern.search(self.scope_bfr)
        if m and m.group(1):
            c = ScopeEntry(self.extent.begin() + m.start(1), self.extent.begin() + m.end(1), scope_id, bracket_id)
        return o, c


class BracketSearch(object):
    """Object that performs regex search on the view's buffer and finds brackets."""

    def __init__(self, search, center, sub_search, scope):
        """Prepare for search."""

        self.search = search
        self.center = center
        self.scope = scope
        self.sub_search = sub_search
        if sub_search:
            self.pattern = search.rules.sub_pattern
        else:
            self.pattern = search.rules.pattern
        if search.rules.outside_adj:
            self.bracket_sort = self.sort_brackets_adj
        elif search.rules.block_cursor:
            self.bracket_sort = self.sort_block_cursor
        else:
            self.bracket_sort = self.sort_brackets
        self.prev_match = [None, None]
        self.return_prev = [False, False]
        self.done = [False, False]
        self.start = [None, None]
        self.left = [[], []]
        self.right = [[], []]
        self.touch_left = False
        self.touch_right = False
        if self.pattern:
            self.findall()

    def escaped(self, pt, ignore_string_escape, scope):
        """Check if sub bracket in string scope is escaped."""

        if not ignore_string_escape:
            return False
        if scope and scope.startswith("string"):
            return self.string_escaped(pt)
        return False

    def string_escaped(self, pt):
        """
        Check if bracket follows escape characters.

        Account for if in string or regex string scope.
        """

        escaped = False
        start = pt - 1
        first = False
        if (
            self.search.view.settings().get(
                "bracket_highlighter.bracket_string_escape_mode", self.search.rules.string_escape_mode
            ) == "string"
        ):
            first = True
        while self.search.view.substr(start) == "\\":
            if first:
                first = False
            else:
                escaped = False if escaped else True
            start -= 1
        return escaped

    def is_illegal_scope(self, pt, bracket_id, scope=None):
        """Check if scope at pt X should be ignored."""

        bracket = self.search.rules.brackets[bracket_id]
        if self.sub_search and not bracket.find_in_sub_search:
            return True
        illegal_scope = False
        # Scope sent in, so we must be scanning whatever this scope is
        if scope is not None:
            if self.escaped(pt, bracket.ignore_string_escape, scope):
                illegal_scope = True
            return illegal_scope
        # for exception in bracket.scope_exclude_exceptions:
        elif (
            len(bracket.scope_exclude_exceptions) and
            self.search.view.match_selector(pt, ", ".join(bracket.scope_exclude_exceptions))
        ):
            pass
        elif len(bracket.scope_exclude) and self.search.view.match_selector(pt, ", ".join(bracket.scope_exclude)):
            illegal_scope = True
        return illegal_scope

    def reset_end_state(self):
        """
        Reset the the current search flags etc.

        This is usually done before searching the other direction.
        """

        self.start = [None, None]
        self.done = [False, False]
        self.prev_match = [None, None]
        self.return_prev = [False, False]

    def remember(self, match_type):
        """
        Remember the current match.

        Don't get the next bracket on the next
        request, but return the current one again.
        """

        self.return_prev[match_type] = True
        self.done[match_type] = False

    def sort_brackets(self, start, end, match_type, bracket_id):
        """
        Sort brackets.

        Sort by type (opening or closing) and whether they
        are left of cursor or right.
        """

        if (end <= self.center if match_type else start < self.center):
            # Sort bracket to left
            self.left[match_type].append(BracketEntry(start, end, bracket_id))
        elif (end > self.center if match_type else start >= self.center):
            # Sort bracket to right
            self.right[match_type].append(BracketEntry(start, end, bracket_id))

    def sort_block_cursor(self, start, end, match_type, bracket_id):
        """
        Special sort for block cursor mode.

        Sorting to favor the visual representation of block cursors.
        """

        if (
            self.touch_right is False and
            self.touch_left is False and
            match_type == BH_SEARCH_OPEN and
            start == self.center
        ):
            # Check for adjacent opening bracket on right
            entry = BracketEntry(start, end, bracket_id)
            self.touch_left = entry
            self.left[match_type].append(entry)
        elif (end <= self.center if match_type else start < self.center):
            # Sort bracket to left
            self.left[match_type].append(BracketEntry(start, end, bracket_id))
        elif (end > self.center if match_type else start >= self.center):
            # Sort bracket to right
            self.right[match_type].append(BracketEntry(start, end, bracket_id))

    def sort_brackets_adj(self, start, end, match_type, bracket_id):
        """
        Sort adjacent brackets.

        Sort brackets, but with slightly altered logic for telling when
        there are brackets adjacent to the cursor.
        """

        if (
            self.touch_right is False and
            end == (self.center)
        ):
            # Check for adjacent opening or closing bracket on left side
            entry = BracketEntry(start, end, bracket_id)
            self.touch_right = True
            if match_type == BH_SEARCH_OPEN:
                self.left[match_type].append(entry)
            else:
                self.right[match_type].append(entry)
        elif (end <= self.center if match_type else start < self.center):
            # Sort bracket to left
            self.left[match_type].append(BracketEntry(start, end, bracket_id))
        elif (
            self.touch_right is False and
            self.touch_left is False and
            match_type == BH_SEARCH_OPEN and
            start == self.center
        ):
            # Check for adjacent opening bracket of right
            entry = BracketEntry(start, end, bracket_id)
            self.touch_left = entry
            self.left[match_type].append(entry)
        elif (end > self.center if match_type else start >= self.center):
            # Sort bracket to right
            self.right[match_type].append(BracketEntry(start, end, bracket_id))

    def findall(self):
        """Find all of the brackets."""

        window_start = int(self.search.search_window[0])
        window_end = int(self.search.search_window[1])

        for m in self.pattern.finditer(self.search.get_buffer(), window_start, window_end):
            g = m.lastindex
            try:
                start = m.start(g)
                end = m.end(g)
            except Exception:
                continue

            match_type = int(not bool(g % 2))
            bracket_id = int((g / 2) - match_type)

            if not self.is_illegal_scope(start, bracket_id, self.scope):
                self.bracket_sort(start, end, match_type, bracket_id)

    def get_open(self, bracket_code):
        """
        Get opening bracket.

        Accepts a bracket code that determines which side of the cursor
        the next match is returned from.
        """

        for b in self._get_bracket(bracket_code, BH_SEARCH_OPEN):
            yield b

    def get_close(self, bracket_code):
        """
        Get closing bracket.

        Accepts a bracket code that determines which side of the cursor
        the next match is returned from.
        """

        for b in self._get_bracket(bracket_code, BH_SEARCH_CLOSE):
            yield b

    def is_done(self, match_type):
        """Retrieve done flag."""

        return self.done[match_type]

    def _get_bracket(self, bracket_code, match_type):
        """
        Get the next bracket.

        Accepts bracket code that determines which side of the cursor
        the next match is returned from and the match type which
        determines whether a opening or closing bracket is desired.
        """

        if self.done[match_type]:
            return
        if self.return_prev[match_type]:
            self.return_prev[match_type] = False
            yield self.prev_match[match_type]
        if bracket_code == BH_SEARCH_LEFT:
            if self.start[match_type] is None:
                self.start[match_type] = len(self.left[match_type])
            for x in reversed(range(0, self.start[match_type])):
                b = self.left[match_type][x]
                self.prev_match[match_type] = b
                self.start[match_type] -= 1
                yield b
        else:
            if self.start[match_type] is None:
                self.start[match_type] = 0
            for x in range(self.start[match_type], len(self.right[match_type])):
                b = self.right[match_type][x]
                self.prev_match[match_type] = b
                self.start[match_type] += 1
                yield b

        self.done[match_type] = True