def preliminary(self, view_information, query_description, extra={}):
selection = self._get_selection(view_information, extra)
build = self.general_build
if not build or not build[0]:
return None, None, None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
definition_node = search_upwards(
origin, ast.FunctionDef) # ,aybe need to change that in the future
# in order to find the outermost function.
if definition_node and definition_node.first_token.startpos > selection[
1]:
token = atok.get_token_from_offset(selection[0])
while token.string.isspace():
token = atok.prev_token(token)
s = token.startpos
origin = nearest_node_from_offset(root, atok, s)
definition_node = search_upwards(origin, ast.FunctionDef)
definition_node = (
definition_node
if definition_node and query_description["big_roi"] not in [
"import statement", "import module", "import value",
"class name", "base class", "decorator"
] else root)
return build, selection, origin, definition_node
def case_three(self, view_information, query_description, extra={}):
################################################################
# <adjective> inside <level_index> argument <argument_index>
###############################################################
selection = self._get_selection(view_information, extra)
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
statement_node = self.get_statement(origin, atok)
###############################################################
# transformations
################################################################
temporary = {}
lca = LCA(statement_node)
def transformation(node):
calling_parent = search_upwards_for_parent(node, ast.Call)
calling_parent = calling_parent.parent if calling_parent else None
if not calling_parent:
return None
field, field_index = lca.get_field_with_respect_to(
node, calling_parent)
if query_description[
"level_index"] == 0 or correspond_to_index_in_call(
calling_parent, query_description["level_index"] - 1,
field, field_index):
if calling_parent not in temporary:
temporary[calling_parent] = []
temporary[calling_parent].append(node)
return calling_parent
else:
return None
def inverse_transformation(node):
if node in temporary:
return temporary[node]
else:
return None
result, alternatives = self.process_line(
q=query_description,
root=statement_node,
atok=atok,
origin=origin,
select_node=origin if selection[0] != selection[1] else None,
tiebreaker=lambda x: tiebreak_on_lca(statement_node, origin, x, lca
),
transformation=transformation,
inverse_transformation=inverse_transformation,
)
return self._backward_result(result, alternatives, build)
def case_five(self, view_information, query_description, extra={}):
################################################################
# <level> [<level_index>] <adjective> (argument <argument_index>|caller [<sub_index>])
###############################################################
selection = self._get_selection(view_information, extra)
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
statement_node = self.get_statement(origin, atok)
priority = {}
if query_description["level_index"] == 0:
query_description["level_index"] = -1
_, calling_parents = search_upwards_log(origin,
targets=ast.stmt,
log_targets=(ast.Call))
index = query_description["level_index"]
if index < len(calling_parents):
priority["child_level"] = 1
origin = calling_parents[index]
result, alternatives = self.process_line(
q=query_description,
root=statement_node,
atok=atok,
origin=origin,
select_node=origin if selection[0] != selection[1] else None,
tiebreaker=lambda x: tiebreak_on_lca(statement_node, origin, x),
priority=priority)
return self._backward_result(result, alternatives, build)
def case_one(self, view_information, query_description, extra={}):
################################################################
# <adjective> argument <argument_index>
###############################################################
selection = self._get_selection(view_information, extra)
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
statement_node = self.get_statement(origin, atok)
result, alternatives = self.process_line(
q=query_description,
root=statement_node,
atok=atok,
origin=origin,
select_node=origin if selection[0] != selection[1] else None,
tiebreaker=lambda x: tiebreak_on_lca(statement_node, origin, x))
return self._backward_result(result, alternatives, build)
def case_four(self, view_information, query_description, extra={}):
################################################################
# <level> [<level_index>] <adjective> (argument <argument_index>|caller [<sub_index>])
###############################################################
selection = self._get_selection(view_information, extra)
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
statement_node = self.get_statement(origin, atok)
###############################################################
# transformationszooming
################################################################
every_caller = find_all_nodes(root, (ast.Call))
level = LevelVisitor(root, every_caller, atok)
lca = LCA(statement_node)
def transformation(node):
calling_parent, field, field_index = level[node]
if not calling_parent or calling_parent is level.root:
return None
if query_description[
"level_index"] == 0 or correspond_to_index_in_call(
calling_parent, query_description["level_index"] - 1,
field, field_index):
adj = translate_adjective[query_description["nth"]] - 1
n = level(node, 3, adj)
return node if n is node else None
else:
return None
def inverse_transformation(node):
return [node]
q = deepcopy(query_description)
del q["nth"]
result, alternatives = self.process_line(
q=q,
root=statement_node,
atok=atok,
origin=origin,
select_node=origin if selection[0] != selection[1] else None,
tiebreaker=lambda x: tiebreak_on_lca(statement_node, origin, x, lca
),
transformation=transformation,
inverse_transformation=inverse_transformation,
invert_then_tiebreak=False)
return self._backward_result(result, alternatives, build)
def case_two(self, view_information, query_description, extra={}):
################################################################
# <vertical_direction> <ndir> <adjective> argument <argument_index>
###############################################################
selection = self._get_selection(view_information, extra)
if "vertical_direction" in query_description:
vertical_direction = query_description["vertical_direction"]
ndir = query_description["ndir"]
else:
vertical_direction = "upwards"
ndir = 0
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
# this is the wrong but for some reason it is working:)
if vertical_direction in ["upwards", "downwards"]:
row, column = view_information["rowcol"](m.backward(selection)[0])
nr = decode_abstract_vertical(root, atok, ast.Call, row + 1, ndir,
vertical_direction) - 1
t = view_information["text_point"](nr, 0)
selection = (t, t)
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok,
selection[0]) if selection[0] == selection[1] else node_from_range(
root, atok, selection)
statement_node = self.get_statement(origin, atok)
#
alternative_logical_lines = find_all_nodes(
statement_node.parent,
selector=lambda x: match_node(x, ast.stmt) and x.first_token.start[
0] == origin.first_token.start[0],
visit_all_levels=False)
sharing_physical = alternative_logical_lines not in [[],
[statement_node]]
priority = {
"root_lexical_order": 1
} if (
statement_node.first_token.start[0] != origin.first_token.start[0]
or sharing_physical or ndir) else {}
result, alternatives = self.process_line(
q=query_description,
root=statement_node
if not sharing_physical else statement_node.parent,
atok=atok,
origin=None,
select_node=None,
tiebreaker=lambda x: tiebreak_on_lca(
statement_node
if not sharing_physical else statement_node.parent, origin, x),
line=nr + 1,
priority=priority,
constrained_space=m.forward((view_information["text_point"](nr, 0),
view_information["text_point"](nr + 1,
0))),
second_tiebreaker=lambda x, y: tiebreak_on_visual(row + 1, x, y))
if sharing_physical:
if alternatives:
alternatives = [
x for x in alternatives
if x.first_token.start[0] == origin.first_token.start[0]
]
if result and result.first_token.start[
0] != origin.first_token.start[0]:
result, alternatives = obtain_result(result, alternatives)
return self._backward_result(result, alternatives, build)
def _preliminary(self,view_information,query_description, extra = {}):
selection = self._get_selection(view_information,extra)
build = self.general_build
if not build or not build[0] :
return None,None,None
root,atok,m,r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(root,atok, selection[0]) if selection[0]==selection[1] else node_from_range(root,atok, selection)
return build, selection, origin
def handle_single(self, view_information, query_description, extra={}):
# print(" inside here selection where he parked ")
selection = self._get_selection(view_information, extra)
build = self.general_build if self.general_build else line_partial(
self.code, selection[0])
if not build or not build[0]:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
origin = nearest_node_from_offset(
root, atok, selection[0],
special=True) if selection[0] == selection[1] else node_from_range(
root, atok, selection, special=True)
if selection[0] == selection[1]:
# return None,None
pass
second_origin = origin
if "nth" in query_description:
# print(" hello world ")
# print(translate_adjective[query_description["nth"]])
second_origin = get_sub_index(
origin, translate_adjective[query_description["nth"]] - 1)
if query_description["format"] == 1:
if "nth2" in query_description:
second_origin = get_sub_index(
second_origin,
translate_adjective[query_description["nth2"]] - 1)
result = get_sub_index(second_origin,
query_description["sub_index"] - 1)
alternatives = []
elif query_description["format"] == 2:
if "nth2" in query_description:
second_origin = get_sub_index(
second_origin,
translate_adjective[query_description["nth2"]] - 1)
result = [
get_sub_index(second_origin,
query_description["sub_index"] - 1),
get_sub_index(second_origin,
query_description.get("sub_index2", 0) - 1)
]
alternatives = []
elif query_description["format"] == 3 or query_description[
"format"] == 4:
intermediate = get_sub_index(second_origin, None)
if "nth2" in query_description:
intermediate = [
get_sub_index(
x, translate_adjective[query_description["nth2"]] - 1)
for x in intermediate
]
intermediate = [x for x in intermediate if x]
if "sub_index" in query_description:
candidates = [
get_sub_index(x, query_description["sub_index"] - 1)
for x in intermediate
]
candidates = [x for x in candidates if x]
else:
candidates = intermediate
if query_description["format"] == 3:
result, alternatives = obtain_result(None, candidates)
elif query_description["format"] == 4:
result = candidates if candidates else None
alternatives = []
return self._backward_result(
result,
alternatives,
build,
individually=query_description["format"] == 4)