def get_QueryRegions ( QUERY, REGEX_ENABLED, IGNORE_CASE ):
if REGEX_ENABLED == True and IGNORE_CASE == True:
queryRegions = V.view.find_all ( QUERY, sublime.IGNORECASE )
elif REGEX_ENABLED == True and IGNORE_CASE == False:
queryRegions = V.view.find_all ( QUERY )
elif REGEX_ENABLED == False and IGNORE_CASE == True:
queryRegions = V.view.find_all ( QUERY, sublime.LITERAL|sublime.IGNORECASE )
elif REGEX_ENABLED == False and IGNORE_CASE == False:
queryRegions = V.view.find_all ( QUERY, sublime.LITERAL )
return ( queryRegions )
#?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????¦?#
#??????? ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????‡#
#???????? { Variables } ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????c3#
#??????? ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????‡#
#?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????¦?#
python类LITERAL的实例源码
def _get_match_info(self, current_region, match_word):
'''
????????
'''
index = 0
all_match_regions = self.view.find_all(match_word, sublime.LITERAL)
for region in all_match_regions:
if region == current_region:
break
index += 1
if index >= len(all_match_regions):
index = len(all_match_regions)
return all_match_regions, index
def run(self, edit, **args):
if not self._is_current_finding:
self.view.erase_regions(self.FINDING_KEY)
self.view.settings().set("is_finding", False)
current_region = current.wordregion(self.view)
current_word = current.word(self.view)
first_region = self.view.find(current_word, 0, sublime.LITERAL)
self._draw_regions([current_region, first_region])
self.view.settings().set("is_finding", True)
self.view.show(first_region)
return
visible_region = self.view.visible_region()
for region in self._match_regions:
if not visible_region.contains(region):
self.view.show(region)
return
def replace(self, edit, s, replace_what):
old, new = (replace_what, '')
open_, close_ = get_surround_pairs(self.view).get(old, (old, old))
if len(open_) == 1 and open_ == 't':
open_, close_ = ('<.*?>', '</.*?>')
next_ = self.view.find(close_, s.b)
prev_ = reverse_search(self.view, open_, end=s.b, start=0)
else:
# brute force
next_ = self.view.find(close_, s.b, sublime.LITERAL)
prev_ = reverse_search(self.view, open_, end=s.b, start=0, flags=sublime.LITERAL)
if not (next_ and prev_):
return
self.view.replace(edit, next_, new)
self.view.replace(edit, prev_, new)
def calculate_flags(self):
# TODO: Implement smartcase?
flags = 0
if self.view.settings().get('vintageous_magic') is False:
flags |= sublime.LITERAL
if self.view.settings().get('vintageous_ignorecase') is True:
flags |= sublime.IGNORECASE
return flags
def find_balanced_closing_bracket(self, start, brackets, unbalanced=0):
new_start = start
for i in range(unbalanced or 1):
next_closing_bracket = find_in_range(self.view, brackets[1],
start=new_start,
end=self.view.size(),
flags=LITERAL)
if next_closing_bracket is None:
# Unbalanced brackets; nothing we can do.
return
new_start = next_closing_bracket.end()
nested = 0
while True:
next_opening_bracket = find_in_range(self.view, brackets[0],
start=start,
end=next_closing_bracket.end(),
flags=LITERAL)
if not next_opening_bracket:
break
nested += 1
start = next_opening_bracket.end()
if nested > 0:
return self.find_balanced_closing_bracket(next_closing_bracket.end(),
brackets, nested)
else:
return next_closing_bracket.begin()
def find_balanced_opening_bracket(self, start, brackets, unbalanced=0):
new_start = start
for i in range(unbalanced or 1):
prev_opening_bracket = reverse_search_by_pt(self.view, brackets[0],
start=0,
end=new_start,
flags=LITERAL)
if prev_opening_bracket is None:
# Unbalanced brackets; nothing we can do.
return
new_start = prev_opening_bracket.begin()
nested = 0
while True:
next_closing_bracket = reverse_search_by_pt(self.view, brackets[1],
start=prev_opening_bracket.a,
end=start,
flags=LITERAL)
if not next_closing_bracket:
break
nested += 1
start = next_closing_bracket.begin()
if nested > 0:
return self.find_balanced_opening_bracket(prev_opening_bracket.begin(),
brackets,
nested)
else:
return prev_opening_bracket.begin()
def run(self):
view = self.window.new_file()
regions = view.sel()
view.set_syntax_file('Packages/Chains'
'/Chains.tmLanguage')
view.run_command("chains")
# view.run_command("highlight_today")
msg_r = view.find(INITIAL_MESSAGE, 0, sublime.LITERAL)
region = region_cursor_start(msg_r)
regions.clear()
regions.add(region)
def display_footer(self, hit_count):
regions = self.whoosh_view.find_all(self.search_string,
sublime.LITERAL | sublime.IGNORECASE)
reg_num = len(regions) - 1
text = "\n%d matches across %d files\n" % (reg_num if reg_num >= 0 else 0, hit_count)
self.whoosh_view.run_command("whoosh_view_append_text",
{"text" : text, "search_string" : None})
def run(self, edit, text, search_string):
start_point = self.view.size()
self.view.insert(edit, start_point, text)
if search_string is not None:
regions = self.view.find_all(search_string,
sublime.LITERAL | sublime.IGNORECASE)
self.view.add_regions('whoosh_regions', regions[1:], "text.find-in-files", "", sublime.DRAW_OUTLINED)
def run(self, edit, start_point, word, replacement):
region = self.view.find(word, start_point, sublime.LITERAL)
if region:
self.view.run_command("erase_snippet", {"start_point": region.a,
"end_point": region.b
})
self.view.run_command("insert_issue_snippet", {"start_point":region.a,
"snippet": replacement})
def finishGoingToLocation(caller, view):
# Highlight the text
position = view.sel()[0].a
line = view.substr(view.line(position))
view.sel().clear()
view.sel().add(view.line(position))
if (caller['text'] in line):
return
# Find where the line might be
regions = view.find_all(caller['text'], sublime.LITERAL)
if not regions:
return
# Find the closest region to our current position
closest_region = None
for region in regions:
if closest_region is None:
closest_region = region
continue
if abs(region.a - closest_region.a) < abs(closest_region.a - position):
closest_region = region
view.show_at_center(closest_region)
view.sel().clear()
view.sel().add(closest_region)
def run(self, view):
path = self.path
window = self.view.window()
names = os.listdir(path)
f = []
for name in names:
if isdir(join(path, name)):
name += os.sep
f.append(name)
def on_done(select):
if not select == -1 :
line_str = f[select]
r_list = self.view.find_all(line_str, sublime.LITERAL)
# Make match whole word.
if len(r_list) > 1 :
for r in r_list :
find_str = self.view.substr(self.view.line(r))
if find_str == line_str :
break
else :
r = r_list[0]
if self.p_key :
window.run_command('dired_preview_refresh', {'path':path + line_str})
self.view.sel().clear()
self.view.sel().add(r.a)
self.view.show(r.a)
if self.p_key :
self.view.settings().set('preview_key', True)
self.p_key = self.view.settings().get('preview_key')
self.view.settings().set('preview_key', False)
window.show_quick_panel(f, on_done)
def run(self, search_string='', mode=None, count=1):
def f(view, s):
if mode == modes.VISUAL:
return sublime.Region(s.a, match.a + 1)
elif mode == modes.INTERNAL_NORMAL:
return sublime.Region(s.a, match.a)
elif mode == modes.NORMAL:
return sublime.Region(match.a, match.a)
elif mode == modes.VISUAL_LINE:
return sublime.Region(s.a, view.full_line(match.b - 1).b)
return s
# This happens when we attempt to repeat the search and there's no search term stored yet.
if not search_string:
return
# We want to start searching right after the current selection.
current_sel = self.view.sel()[0]
start = current_sel.b if not current_sel.empty() else current_sel.b + 1
wrapped_end = self.view.size()
# TODO: What should we do here? Case-sensitive or case-insensitive search? Configurable?
# Search wrapping around the end of the buffer.
# flags = sublime.IGNORECASE | sublime.LITERAL
flags = self.calculate_flags()
match = find_wrapping(self.view, search_string, start, wrapped_end, flags=flags, times=count)
if not match:
return
regions_transformer(self.view, f)
self.hilite(search_string)
def find_balanced_closing_bracket(self, start, brackets, unbalanced=0):
new_start = start
for i in range(unbalanced or 1):
next_closing_bracket = find_in_range(self.view, brackets[1],
start=new_start,
end=self.view.size(),
flags=sublime.LITERAL)
if next_closing_bracket is None:
# Unbalanced brackets; nothing we can do.
return
new_start = next_closing_bracket.end()
nested = 0
while True:
next_opening_bracket = find_in_range(self.view, brackets[0],
start=start,
end=next_closing_bracket.end(),
flags=sublime.LITERAL)
if not next_opening_bracket:
break
nested += 1
start = next_opening_bracket.end()
if nested > 0:
return self.find_balanced_closing_bracket(next_closing_bracket.end(),
brackets, nested)
else:
return next_closing_bracket.begin()
def find_balanced_opening_bracket(self, start, brackets, unbalanced=0):
new_start = start
for i in range(unbalanced or 1):
prev_opening_bracket = reverse_search_by_pt(self.view, brackets[0],
start=0,
end=new_start,
flags=sublime.LITERAL)
if prev_opening_bracket is None:
# Unbalanced brackets; nothing we can do.
return
new_start = prev_opening_bracket.begin()
nested = 0
while True:
next_closing_bracket = reverse_search_by_pt(self.view, brackets[1],
start=prev_opening_bracket.a,
end=start,
flags=sublime.LITERAL)
if not next_closing_bracket:
break
nested += 1
start = next_closing_bracket.begin()
if nested > 0:
return self.find_balanced_opening_bracket(prev_opening_bracket.begin(),
brackets,
nested)
else:
return prev_opening_bracket.begin()
def calculate_flags(self):
# TODO: Implement smartcase?
flags = 0
if self.view.settings().get('vintageous_magic') == False:
flags |= sublime.LITERAL
if self.view.settings().get('vintageous_ignorecase') == True:
flags |= sublime.IGNORECASE
return flags
def set_sels(self, sels):
"""
Enables adding selections to the buffer text using a minilanguage:
S = add empty sel before S and delete S
x = add empty sel before x
v = add sel from before the first 'v' to after the last contiguous 'v'
"""
self.view.sel().clear()
self.view.sel().add_all(sels)
return
if test.args['mode'] in ('mode_normal', 'mode_internal_normal'):
regions = self.view.find_all(r'$', sublime.LITERAL)
if not regions:
# TODO(guillermooo): report this? we should expect some regions
return
self.view.sel().add_all(regions)
self.view.run_command('right_delete')
return
if test.args ['mode'] == 'mode_visual':
visual_mode_regs = self.view.find_all(r'v+')
for vmr in visual_mode_regs:
self.view.sel().add(vmr)
if len(self.view.sel()) > 0:
return
visual_mode_regs = self.view.find_all(r'S')
for vmr in visual_mode_regs:
self.view.sel().add(sublime.Region(vmr.a))
self.view.run_command('right_delete')
def _replace(self, edit, s, replace_what):
if len(replace_what) != 2:
# TODO REVIEW replace single argument with two: *target* and *replacement*
# TODO REVIEW should an exception be raised, and if yes, what type of exception e.g. package, module, plugin, generic? # noqa: E501
return s
target_pairs = {
')': ('(', ')'),
'(': ('(', ')'),
']': ('[', ']'),
'[': ('[', ']'),
'}': ('{', '}'),
'{': ('{', '}'),
'>': ('<', '>'),
}
replacement_pairs = {
')': ('(', ')'),
'(': ('( ', ' )'),
']': ('[', ']'),
'[': ('[ ', ' ]'),
'}': ('{', '}'),
'{': ('{ ', ' }'),
'>': ('<', '>'),
}
old, new = tuple(replace_what)
open_, close_ = target_pairs.get(old, (old, old))
new_open, new_close = replacement_pairs.get(new, (new, new))
if len(open_) == 1 and open_ == 't':
open_, close_ = ('<.*?>', '</.*?>')
next_ = self.view.find(close_, s.b)
prev_ = reverse_search(self.view, open_, end=s.b, start=0)
else:
# brute force
next_ = self.view.find(close_, s.b, flags=LITERAL)
prev_ = reverse_search(self.view, open_, end=s.b, start=0, flags=LITERAL)
if not (next_ and prev_):
return s
self.view.replace(edit, next_, new_close)
self.view.replace(edit, prev_, new_open)
return Region(prev_.begin())
def run(self, char=None, mode=None, count=1, inclusive=True, skipping=False):
# Contrary to *f*, *t* does not look past the caret's position, so if
# @character is under the caret, nothing happens.
def f(view, s):
if mode == modes.VISUAL_LINE:
raise ValueError(
'this operator is not valid in mode {}'.format(mode))
b = s.b
# If we are in any visual mode, get the actual insertion point.
if s.size() > 0:
b = resolve_insertion_point_at_b(s)
# Vim skips a character while performing the search
# if the command is ';' or ',' after a 't' or 'T'
if skipping:
b = b + 1
eol = view.line(b).end()
match = Region(b + 1)
for i in range(count):
# Define search range as 'rest of the line to the right'.
search_range = Region(match.end(), eol)
match = find_in_range(view, char, search_range.a, search_range.b, LITERAL)
# Count too high or simply no match; break.
if match is None:
return s
target_pos = match.a
if not inclusive:
target_pos = target_pos - 1
if mode == modes.NORMAL:
return Region(target_pos)
elif mode == modes.INTERNAL_NORMAL:
return Region(s.a, target_pos + 1)
# For visual modes...
else:
new_a = resolve_insertion_point_at_a(s)
return utils.new_inclusive_region(new_a, target_pos)
if not all([char, mode]):
raise ValueError('bad parameters')
char = utils.translate_char(char)
regions_transformer(self.view, f)
def run(self, char=None, mode=None, count=1, inclusive=True, skipping=False):
# Contrary to *f*, *t* does not look past the caret's position, so if
# @character is under the caret, nothing happens.
def f(view, s):
if mode == modes.VISUAL_LINE:
raise ValueError(
'this operator is not valid in mode {}'.format(mode))
b = s.b
# If we are in any visual mode, get the actual insertion point.
if s.size() > 0:
b = resolve_insertion_point_at_b(s)
# Vim skips a character while performing the search
# if the command is ';' or ',' after a 't' or 'T'
if skipping:
b = b + 1
eol = view.line(b).end()
match = R(b + 1)
for i in range(count):
# Define search range as 'rest of the line to the right'.
search_range = R(match.end(), eol)
match = find_in_range(view, char, search_range.a,
search_range.b, sublime.LITERAL)
# Count too high or simply no match; break.
if match is None:
return s
target_pos = match.a
if not inclusive:
target_pos = target_pos - 1
if mode == modes.NORMAL:
return R(target_pos)
elif mode == modes.INTERNAL_NORMAL:
return R(s.a, target_pos + 1)
# For visual modes...
else:
new_a = resolve_insertion_point_at_a(s)
return utils.new_inclusive_region(new_a, target_pos)
if not all([char, mode]):
raise ValueError('bad parameters')
char = utils.translate_char(char)
state = self.state
regions_transformer(self.view, f)
