def case_three(self, view_information, query_description, extra={}): ################################################################ # <vertical_abstract_only_direction> [<ndir>] <big_roi> [<big_roi_sub_index>] ############################################################### build, selection, origin, definition_node = self.preliminary( view_information, query_description, extra) targets, exclusions, information = self.decode(query_description, build) root, atok, m, r = build temporary_information = lambda x: information(x) if match_node( x, targets, exclusions) and generic_fix(x, atok) else None direction = query_description["vertical_direction"] ndir = query_description["ndir"] row, column = view_information["rowcol"](m.backward(selection)[0]) # bug fixing test_result = decode_abstract_vertical(root, atok, targets, row + 1, 1, direction, True, temporary_information, want_alternatives=False) l = search_upwards_log(origin, ast.stmt) if (test_result in [l[0]] + l[1] and row + 1 >= test_result.first_token.start[0] and row + 1 <= test_result.last_token.end[0]): ndir = ndir + 1 result, alternatives = decode_abstract_vertical(root, atok, targets, row + 1, ndir, direction, True, temporary_information, want_alternatives=True) if result: new_definition_node = search_upwards(result, ast.FunctionDef) if definition_node is not new_definition_node and new_definition_node is not None: alternatives = tiebreak_on_lca( new_definition_node, result, find_all_nodes(new_definition_node, targets, exclusions)) result, alternatives = obtain_result(result, alternatives) information = getattr(information, "secondary", information) result = information(result) if result else None alternatives = [information(x) for x in alternatives] if alternatives else [] return self._backward_result(result, alternatives, build)
def handle_single(self,view_information,query_description,extra = {}): build, selection, origin = self._preliminary(view_information = view_information,query_description = query_description,extra = extra) if not build: return None,None root,atok,m,r = build definition_nodes = [search_upwards(origin,ast.FunctionDef)] if query_description["format"]>=2 else find_all_nodes(root,ast.FunctionDef) if query_description["format"]>=2: if "vertical_direction" in query_description: definition_node = definition_nodes[0] temporary_information = lambda x: match_node(x,ast.FunctionDef) direction = query_description["vertical_direction"] ndir = query_description["ndir"] row = view_information["rowcol"](m.backward(selection)[0])[0] + 1 if definition_node is None else definition_node.first_token.start[0] bonus = 1 if definition_node.first_token.startpos > selection[1] else 0 t = decode_abstract_vertical(root,atok,(),row, ndir + bonus,direction,True,temporary_information) definition_nodes = [t] name_nodes = make_flat([get_argument_from_definition(x) for x in definition_nodes]) names = list(OrderedDict([(x,0) for x in name_nodes]).keys()) if "experimental" in query_description: names = [x + "=" + x for x in names] if query_description["format"]==1: result = None else: mode = { 2:"individual", 3:"range", }[query_description["format"]] result = ",".join(decode_item_selection(names,query_description,mode,"item_index")) return result, names
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_four(self, view_information, query_description, extra={}): ################################################################ # [smart] <vertical_abstract_only_direction> [<ndir>] <block> [<adjective>] <big_roi> [<big_roi_sub_index>] ############################################################### build, selection, origin, definition_node = self.preliminary( view_information, query_description, extra) targets, exclusions, information = self.decode(query_description, build) temporary_information = lambda x: match_node(x, ast.FunctionDef) root, atok, m, r = build direction = query_description["vertical_direction"] ndir = query_description["ndir"] row = view_information["rowcol"]( m.backward(selection)[0] )[0] + 1 if definition_node is root else definition_node.first_token.start[ 0] bonus = 1 if definition_node.first_token.startpos > selection[1] else 0 t = decode_abstract_vertical(root, atok, targets, row, ndir + bonus, direction, True, temporary_information) if "nth" not in query_description: information = getattr(information, "secondary", information) selector = lambda x: match_node(x, targets, exclusions ) and generic_fix(x, build[1]) candidates = tiebreak_on_lca(root, definition_node, find_all_nodes(t, selector=selector)) candidates = [information(x) for x in candidates if information(x)] result, alternatives = obtain_result(None, candidates) return self._backward_result(result, alternatives, build) else: additional_parameters = {} result, alternatives = adjective_strategy( atok=atok, root=t, adjective_word=query_description["nth"], level_nodes=find_all_nodes( t, (ast.If, ast.While, ast.For, ast.Try, ast.With, ast.FunctionDef)), information_nodes=find_matching( t, lambda x: information(x) if match_node(x, targets, exclusions) else None), **additional_parameters) information = getattr(information, "secondary", information) result = information(result) if result else None alternatives = [information(x) for x in alternatives] if alternatives else [] return self._backward_result(result, alternatives, build)