Bug fixes and removing some print() calls

Author: mpourmpoulis

CHANGELOG.md

@@ -19,6 +19,8 @@
 
 * Fixed old name of my output panel:)
 
+* Fixed a bug in the argument module where not forwarding selections cause errors went down in lines for the above below keywords.
+
 ### Changed
 
 * The customer bundles have been modified to be usable with aenea !

library/repair.py

@@ -166,7 +166,8 @@ def before_double_dot(t):
 	return t[-1] is None   or not( 
 		finish_atom(t[-1]) or 
 		t[-1].string.isspace() or
-		t[-1].string=="["
+		t[-1].string=="[" or 
+		t[-1].string  in KEYWORDS
 		)
 
 def before_dot(t):
@@ -185,7 +186,14 @@ def after_dot(t):
 		)
 	)
 	return False
-
+'''
+def after_else(t):
+	if 60<t[0].start[0]<80:
+		print(t,"\n",start_atom(t[1]),t[1].string in [":"],start_atom(t[1]) or t[1].string in [":"])
+	return t[1] is None or not(
+		start_atom(t[1]) or t[1].string in [":"]
+	)
+'''
 def handle_empty_compound(atok ,t,l,b,dummy):
 	n = neighbors(atok, t)
 	left,right = expand_to_line_or_statement(atok,t, l, b)

queries/argument.py

@@ -29,7 +29,7 @@ class SelectArgument(SelectionQuery):
 
 	def process_line(self,q, root ,atok, origin  = None, select_node = None,tiebreaker = lambda x: x, 
 					line = None, transformation = None,inverse_transformation = None, priority = {}, 
-					constrained_space = (),
+					constrained_space = (), second_tiebreaker = None
 		):
 		result = None
 		alternatives = None
@@ -110,6 +110,9 @@ def process_line(self,q, root ,atok, origin  = None, select_node = None,tiebreak
 			temporary = [x[1]  for x in temporary]
 			result,alternatives = obtain_result(None,temporary)
 
+		if second_tiebreaker:
+			alternatives = second_tiebreaker(origin,result,alternatives)
+		
 
 
 

queries/big_roi.py

@@ -142,16 +142,13 @@ def case_three(self,view_information,query_description, extra = {}):
 		# bug fixing
 		test_result = decode_abstract_vertical(root,atok,targets,row+1, 1,direction,True,
 					temporary_information,want_alternatives = False)
-		print(test_result,ast.dump(test_result))
-		print(search_upwards_log(origin,ast.stmt))
 		l = search_upwards_log(origin,ast.stmt)
 		if test_result in [l[0]] + l[1]:
 			ndir  = ndir + 1
 
 
 		result,alternatives = decode_abstract_vertical(root,atok,targets,row+1, ndir,direction,True,
 					temporary_information,want_alternatives = True)
-		print("\n\n promoter is old\n",result,alternatives,"\n")
 
 		if result:
 			new_definition_node = search_upwards(result,ast.FunctionDef)

queries/strategies/abstract_vertical.py

@@ -11,16 +11,13 @@ def decode_abstract_vertical(root,atok, target,current_line, index,direction,
 	for n in nodes:	
 		line_information.add(n.first_token.start[0])
 	line_information = sorted(list(line_information))
-	print(" inside to go to abstract vertical",line_information)
 	ll=len(line_information)
 	if direction=="below":	
 		i = bisect_right(line_information,current_line)
 		i = min(ll-1,i+index-1)
-		print(i)
 	elif direction=="above":
 		i = bisect_left(line_information,current_line)
 		i  = max(0,i-index)
-		print(i)
 	else:
 		return None
 	if want_node:

queries/strategies/adjective_strategy.py

@@ -50,7 +50,6 @@ def adjective_strategy(
 	small_special = sorted_by_source_region(atok, small_special)
 	level_nodes = sorted_by_source_region(atok, level_nodes)
 	information_nodes = sorted_by_source_region(atok,information_nodes)
-	print("information_note",information_nodes,"level_nones",level_nodes)
     ################################################################
 	# small root level and lexical order strategy
 	################################################################
@@ -70,19 +69,19 @@ def adjective_strategy(
 			lca = lca,
 			constrained_space = constrained_space
 		)
-	print("small_root",small_root)
+	# print("small_root",small_root)
 
     ################################################################
 	# root level and lexical order strategy
 	################################################################
-	print("\nDEBUGGING after wrote stuf 0f\n", accumulator.history)
+	# print("\nDEBUGGING after wrote stuf 0f\n", accumulator.history)
 	root_level_order(accumulator,root,
 		level,index,
 		only_information = only_information,
 		priority = priority["root_level"],
 		penalty = 2
 	)
-	print("\nDEBUGGING after wrote stuff 1\n", accumulator.history)
+	# print("\nDEBUGGING after wrote stuff 1\n", accumulator.history)
 	root_lexical_order(accumulator,root,
 		level_nodes,information_nodes,index,
 		only_information=only_information,
@@ -91,7 +90,7 @@ def adjective_strategy(
 		lca = None,
 		constrained_space = constrained_space
 	)
-	print("\nDEBUGGING after wroteup 20\n", accumulator.history)
+	# print("\nDEBUGGING after wroteup 20\n", accumulator.history)
 	################################################################
 	#  strategies for spacial and very special
 	################################################################

queries/strategies/primitives.py

@@ -5,7 +5,6 @@ def _get(l,n,d):
 def root_level_order(accumulator,root,level,index,only_information,priority,penalty):
 	first_option   = level(root,1, index,False)
 	second_option  = level(root,1, index,True)
-	print(first_option,second_option,"from root level order ")
 	if first_option in level.special and only_information==False: 	
 		accumulator.push(first_option,priority)
 	else: