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"] else root)
return build, selection, origin, definition_node
def case_two(self,view_information,query_description, extra = {}):
################################################################
# <vertical_direction> <ndir> <adjective> argument <argument_index>
###############################################################
selection = self._get_selection(view_information,extra)
vertical_direction = query_description["vertical_direction"]
ndir = query_description["ndir"]
if vertical_direction in ["up","down"]:
row, column = view_information["rowcol"](m.backward(selection)[0])
nr = max(0,row + ndir if vertical_direction=="down" else row - ndir)
t = view_information["text_point"](nr,0)
selection = (t,t)
build = self.general_build if self.general_build else line_partial(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 ["above","below"]:
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 = search_upwards(origin,ast.stmt)
#
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) 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 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(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 = search_upwards(origin,ast.stmt)
###############################################################
# 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 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),
transformation = transformation,
inverse_transformation = inverse_transformation
)
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 case_four(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(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 = search_upwards(origin,ast.stmt)
###############################################################
# 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 correspond_to_index_in_call(calling_parent,query_description["level_index"]-1,field,field_index):
adj = translate_adjective[query_description["adjective"]]-1
n = level(node, 3,adj)
return node if n is node else None
else:
return None
def inverse_transformation(node):
return [node]
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),
transformation = transformation,
inverse_transformation = inverse_transformation
)
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(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 = search_upwards(origin,ast.stmt)
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_one(self, v, q):
"""
<adjective> argument <argument_index>
"""
selection = v["selection"]
build = self.general_build if self.general_build else line_partial(
selection[0])
print(build)
if not build:
return None, None
root, atok, m, r = build
selection = m.forward(selection)
# after build we set up some variables
result = None
alternatives = None
origin = nearest_node_from_offset(root, atok, selection[0])
calling_node = search_upwards(origin, ast.Call)
statement_node, callers = search_upwards_log(origin,
ast.stmt,
log_targets=ast.Call)
information = lambda x: info.get_argument_from_call(
x, q["argument_index"] - 1)
candidates = sorted_by_source_region(
atok, find_matching(statement_node, info.identity(information)))
every_caller = find_all_nodes(statement_node, (ast.Call))
################################################################
# if no adjective is given
################################################################
if q["adjective"] == "None":
if calling_node:
result = information(calling_node)
candidates = [
information(x)
for x in tiebreak_on_lca(statement_node, origin, candidates)
if x != calling_node
]
result, alternatives = obtain_result(result, candidates)
################################################################
# adjective is even
################################################################
if q["adjective"] != "None":
additional_parameters = {}
if selection[0] != selection[1]:
small_root = node_from_range(root, atok, selection)
additional_parameters["small_root"] = small_root
print("dumping the small root\n", ast.dump(small_root))
additional_parameters["special"] = [calling_node]
if calling_node:
print(ast.dump(calling_node))
additional_parameters["penalized"] = [calling_node]
result, alternatives = adjective_strategy(
atok=atok,
root=root,
adjective_word=q["adjective"],
level_nodes=every_caller,
information_nodes=candidates,
**additional_parameters)
result = information(result) if result else m.forward(
v["selection"])
alternatives = [information(x)
for x in alternatives] if alternatives else []
# translate those nodes back to offsets and forward them through the modification under
print("\n\nnow finally printing result and alternatives\n\n")
print(result)
print(
ast.dump(result) if isinstance(result, ast.AST
) else " not known node")
print(alternatives)
result = m.backward(get_source_region(atok, result))
alternatives = [
m.backward(get_source_region(atok, x)) for x in alternatives
]
return result, alternatives