def run(self, edit):
    if len(self.view.sel()) == 0:
      return

    sel = self.view.sel()[0]
    if not sel.empty():
      variable = [sel.a, sel.b]
    else:
      line_region = self.view.line(sel.b)
      line_start, line_end = line_region.begin(), line_region.end()

      start = expression.find_match(self.view, sel.b, '[^\w$@]|^', {'backward': True,
        'range': [line_start, sel.b], 'string': True, 'nesting': True,
        'comment': True})

      end = expression.find_match(self.view, sel.b, '[^\w?!]|$',
        {'range': [sel.b, line_end], 'string': True, 'nesting': True,
        'comment': True})

      if start == None or end == None or start == end:
        return

      variable = [start.end(0) + line_start, end.start(0) + sel.b]

    entries = find_entries(self.view, variable)
    if len(entries) == 0:
      return

    self.view.sel().clear()
    for entry in entries:
      self.view.sel().add(sublime.Region(*entry))
def _set_method_starts(view, edit, current_method):
  header = [current_method['start'], current_method['body_start']]

  match = expression.find_match(view, current_method['body_start'], r'(\s*)$',
    {'range': header, 'backward': True})

  if match == None:
    return match

  shift = match.start(1) + current_method['start']
  header[1] = shift

  match = expression.find_match(view, shift, r'^(\s+)\n[ \t]*\S', {'nesting': True,
    'range': [shift, current_method['end']]})

  if match == None:
    return

  replacement = ''
  if "\n" in view.substr(sublime.Region(*header)):
    replacement = "\n"

  region = sublime.Region(match.start(1) + shift, match.end(1) + shift)
  if match.group(1) == replacement:
    return

  view.replace(edit, region, replacement)
Example #3
0
  def _get_args(self, method, snippet_index):
    match_options = {
      'range': [method['start'], method['end']],
      'nesting': True,
    }

    args_point = expression.find_match(self.view, method['start'], r'(?:\()',
      match_options)

    args = []
    if args_point != None:
      tokens_point = method['start'] + args_point.end(0)
      tokens = statement.get_tokens(self.view, tokens_point)
      for token in tokens:
        args.append(self.view.substr(sublime.Region(*token)))

    # f*****g self
    if 'python' in self.view.scope_name(method['start']) and 'self' in args:
      args.remove('self')

    args_prepared = []
    for arg in args:
      snippet_index += 1
      args_prepared.append('${' + str(snippet_index) + ':' +
        re.search(r'^\S*', arg).group(0) + '}')

    return args_prepared
    def is_lesser_indentation_required(self, entries):
        if len(entries) == 1:
            return False

        start_line, _ = self.view.rowcol(entries[0][0])
        lines = self.view.substr(
            self.view.line(
                sublime.Region(entries[0][0], entries[len(entries) - 1][1])))

        indentation = None
        for index, line in enumerate(lines.split("\n")):
            if line.strip() == '':
                continue

            point = self.view.text_point(start_line + index, 0)
            in_nesting = expression.find_match(self.view, point, r'[\])]',
                                               {'range': [point, point + 512]})

            if in_nesting:
                continue

            if statement.is_arguments(self.view, point):
                continue

            current = len(self.get_indentation(line))

            if indentation == None:  # first overlap
                indentation = current
            if current < indentation:
                return True

        return False
Example #5
0
def get(view, sel, values):
    scope = None
    method = method_parser.extract_method(view, sel.b)
    if method != None:
        scope = [method['start'], method['end']]
    else:
        scope = [0, view.size()]

    match = expression.find_match(view, sel.b, r'[^=][\*\/+\-]?=(?!=)\s*', {
        'backward': True,
        'range': [scope[0], sel.b]
    })

    if match == None:
        return None

    container = statement.get_statement(view, scope[0] + match.start(0))
    if container == None:
        return None

    variables = local_variable.find_variables(view, container[0], False,
                                              container)

    if variables == None or len(variables) == 0:
        return

    return view.substr(sublime.Region(*variables[0]))
Example #6
0
  def _get_definition_info(self):
    selection = self.view.sel()[0]
    if selection.empty():
      token_info = statement.get_token(self.view, selection.b)
      token = None
      if token_info != None:
        _, token = token_info

      if token == None or '(' not in self.view.substr(sublime.Region(*token)):
        token = statement.get_parent_token(self.view, selection.b, r'\(')

      if token == None:
        return 'name', None

      return 'name', token
    else:
      statement_1 = statement.get_statement(self.view, selection.begin())
      statement_2 = statement.get_statement(self.view, selection.end())

      if statement_1 == None or statement_2 == None:
        return None
      if statement_1 != statement_2 or expression.find_match(self.view,
        statement_1[0], r'\{', {'range': statement_1, 'string': False}) != None:
        return 'body', [statement_1[0], statement_2[1]]
      else:
        return 'name', statement_1
def get(view, sel, values):
  scope = None
  method = method_parser.extract_method(view, sel.b)
  if method != None:
    _, method = method
    scope = [method['start'], method['end']]
  else:
    scope = [0, view.size()]

  match = expression.find_match(view, sel.b, r'[^=][\*\/+\-]?=(?!=)\s*',
    {'backward': True, 'range': [scope[0], sel.b]})

  if match == None:
    return None

  container = statement.get_statement(view, scope[0] + match.start(0))
  if container == None:
    return None

  variables = local_variable.find_variables(view, container[0], False,
    container)

  if variables == None or len(variables) == 0:
    return

  return view.substr(sublime.Region(*variables[0]))
  def is_lesser_indentation_required(self, entries):
    if len(entries) == 1:
      return False

    start_line, _ = self.view.rowcol(entries[0][0])
    lines = self.view.substr(self.view.line(sublime.Region(entries[0][0],
      entries[len(entries) - 1][1])))

    indentation = None
    for index, line in enumerate(lines.split("\n")):
      if line.strip() == '':
        continue

      point = self.view.text_point(start_line + index, 0)
      in_nesting = expression.find_match(self.view, point, r'[\])]',
        {'range': [point, point + 512]})

      if in_nesting:
        continue

      if statement.is_arguments(self.view, point):
        continue

      current = len(self.get_indentation(line))

      if indentation == None : # first overlap
        indentation = current
      if current < indentation:
        return True

    return False
def get_partial_statement(view, point):
    nesting = expression.get_nesting(view, point)

    as_argument = (nesting != None and statement.get_statement(
        view, nesting[0]) == statement.get_statement(view, nesting[1]))

    if as_argument:
        argument = statement.get_argument(view, point)
        if argument != None:
            _, argument = argument

        argument = prepare_argument(view, argument, point)
        if argument == None or is_variable(view, argument):
            token = statement.get_parent_token(view, point)
            return prepare_argument(view, token, point)

        return argument
    else:
        tokens = statement.get_tokens(view, point)
        if tokens == None:
            return None

        _, token = statement.get_token(view, point, tokens)
        if token == None or not is_variable(view, token):
            return token

        tokens_range = [tokens[0][0], tokens[len(tokens) - 1][1]]
        assignment_match = expression.find_match(view, tokens_range[0],
                                                 r'=[^=]\s*',
                                                 {'range': tokens_range})
        if assignment_match != None:
            tokens_range[0] += assignment_match.end(0)
        return tokens_range
Example #10
0
def _skip_parenthesis(view, point):
  if '(' not in view.substr(sublime.Region(point, view.line(point).b)):
    return point

  match = expression.find_match(view, point, r'\)',
    {'range': [point, point + 512], 'nesting': 'end'})

  if match == None:
    return point

  return match.end(0) + point
def _set_method_endings(view, edit, current_method):
  if current_method['end'] == current_method['body_end']:
    return

  shift = current_method['body_start']
  options = {'nesting': True, 'range': [shift, current_method['end']]}
  match = expression.find_match(view, shift, r'(\s+)\n\s*\S+$', options)
  if match == None:
    return

  region = sublime.Region(match.start(1) + shift, match.end(1) + shift)
  view.replace(edit, region, "")
Example #12
0
def extract_query(view, sel):
  if not sel.empty():
    query_start, query_end = sel.begin(), sel.end()
  else:
    point = sel.a
    if view.substr(sublime.Region(point - 1, point)) == ';':
      point -= 1

    if view.substr(sublime.Region(point - 2, point)) == '\G':
      point -= 2

    query_start = (expression.find_match(view, point, r'(\\g|\\G|;|^)',
        {'backward': True}).end(1))

    query_end = (expression.find_match(view, point, r'(\\g|\\G|;|$)').
      end(1))

  query = view.substr(sublime.Region(query_start, query_end))
  query_start += len(re.search('^(\s*)', query).group(1))

  return query, query_start, query_end
def _get_new_line(view, container, ruler, bad_case = False):
  position = _get_new_line_for_string(view, ruler)
  if position != None:
    return position

  if bad_case:
    match = expression.find_match(view, ruler, r'[{(]',
      {'backward': True, 'range': container, 'nesting': True})

    if match != None:
      if match.group(1) != '' and match.group(1) != None:
        return container[0] + match.end(1)
      else:
        return container[0] + match.end(0)
  else:
    match = expression.find_match(view, ruler, DELIMETER, {
      'backward': True, 'range': container, 'nesting': True})

    if match != None:
      return container[0] + match.end(0)

  return None
Example #14
0
  def _get_class_name(self, view, point):
    expr = r'(?:\n|^)\s*((class|module|interface).*)\n'
    text = view.substr(sublime.Region(0, view.size()))
    match = expression.find_match(view, point.begin(), expr, {
        'backward': True,
        'nesting': True,
        'options': re.IGNORECASE,
    })

    if match == None:
      return None

    return match.group(1)
Example #15
0
File: go.py Project: lanffy/myVimrc
def find_this_arg(view, star=None):
    expr = "func\s*\((.*?)\)"
    result = expression.find_match(
        view, view.sel()[0].a, expr, {"backward": True, "scope": "keyword.(control|other).go"}
    )
    result = result or expression.find_match(
        view, view.sel()[0].a, expr, {"backward": False, "scope": "keyword.(control|other).go"}
    )
    result = result or expression.find_match(
        view, 0, "type (\w+)", {"backward": False, "scope": "keyword.(control|other).go"}
    )

    if result != None:
        result = result.group(1)
    else:
        result = ""

    if star == True:
        result = re.sub(r"(\s)(\w+)$", "\\1*\\2", result)
    elif star == False:
        result = re.sub(r"(\s)\*(\w+)$", "\\1\\2", result)

    return result
def toggle(view, edit, selection):
  token = _get_token(view, selection)
  if token == None:
    return

  delimeter = expression.find_match(view, token[0], r'(?:\.|->)\s*',
    {'range': token})

  if delimeter == None:
    return

  if "\n" in delimeter.group(0):
    join(view, edit, selection)
  else:
    unjoin(view, edit, selection)
def _get_parts(view, point):
  container = statement.get_root_statement(view, point)
  if container == None:
    return None

  assignment_match = expression.find_match(view, container[0], r'\s+=\s+',
    {'range': container})

  if assignment_match == None:
    return None

  part_1 = [container[0], container[0] + assignment_match.start(0)]
  part_2 = [container[0] + assignment_match.end(0), container[1]]

  return part_1, part_2
Example #18
0
def _skip_parenthesis_or_return_args(view, point):
  new_point = point
  while True:
    new_point = _skip_parenthesis(view, point)
    if new_point == point:
      break

    point = new_point

  if 'source.go' in view.scope_name(point):
    match = expression.find_match(view, point, r'{',
      {'range': [point, point + 128]})
    if match != None:
      new_point += match.end(0)

  return new_point
Example #19
0
  def _is_definition_exist(self, snippets, places = None):
    for snippet in snippets:
      definition = re.escape(snippet['contents'])

      if places == None:
        places = self.get_places()

      for place in places:
        shift = place['range'][0]
        match = expression.find_match(self.view, place['range'][0],
          definition, {'range': place['range']})

        if match != None:
          return True

    return False
def prepare_argument(view, argument, point):
    if argument == None:
        return None

    hash_match = expression.find_match(view, argument[0],
                                       r'((\S|^)(?<!:):(?!:)|=>|=)\s*',
                                       {'range': argument})

    if hash_match == None:
        return argument

    delimeter_point = argument[0] + hash_match.end(0)
    if point >= delimeter_point:
        return None

    argument[0] = delimeter_point
    return argument
Example #21
0
  def on_query_context(self, view, key, operator, operand, match_all):
    if key != 'in_nesting':
      return None

    result = True
    for sel in view.sel():
      in_nesting = expression.find_match(view, sel.b, r'[\)\}\]]',
        {'range': [sel.b, min(sel.b + 1024 * 5, view.size())]}) != None

      if operator == sublime.OP_EQUAL:
        result = result and in_nesting == operand
      elif operator == sublime.OP_NOT_EQUAL:
        result = result and in_nesting != operand
      else:
        raise Exception('Operator "' + operator + '" is not supported')

      if not match_all:
        return result

    return result
Example #22
0
    def on_query_context(self, view, key, operator, operand, match_all):
        if key != 'in_nesting':
            return None

        result = True
        for sel in view.sel():
            in_nesting = expression.find_match(
                view, sel.b, r'[\)\}\]]',
                {'range': [sel.b, min(sel.b + 1024 * 5, view.size())]}) != None

            if operator == sublime.OP_EQUAL:
                result = result and in_nesting == operand
            elif operator == sublime.OP_NOT_EQUAL:
                result = result and in_nesting != operand
            else:
                raise Exception('Operator "' + operator + '" is not supported')

            if not match_all:
                return result

        return result