Massive Commit with many bugs For sure

Author: mpourmpoulis

application/application.py

@@ -2,7 +2,7 @@
 
 from PythonVoiceCodingPlugin.queries import *
 from PythonVoiceCodingPlugin.application.build_cache import BuildCache
-from PythonVoiceCodingPlugin.application.state_update import retrieve_state
+from PythonVoiceCodingPlugin.application.state_update import clear_state,retrieve_state,retrieve_text,get_location_text,update_changes
 from PythonVoiceCodingPlugin.interface.common.actions import *
 
 
@@ -14,7 +14,7 @@ class Application():
 
 	def __init__(self,vid):
 		self.history = []
-		self.state = {"result": None,"origin": None,"alternatives": [],"change_count":-1}
+		self.state = {"result": None,"origin": None,"initial_origin":None,"alternatives": [],"change_count":-1}
 		self.ui_controller = None
 		self.vid = vid
 
@@ -26,7 +26,11 @@ def get_application(vid):
 		Application.create_application_for_view(vid)
 		return Application.active_applications[vid]
 
-	
+	def update_text(self,code):
+		retrieve_text(self.state,code)
+
+	def update_locations(self,locations_text):
+		update_changes(self.state,locations_text)
 
 
 	def respond_to_query(self,interface,query_description,secondary=False):
@@ -38,25 +42,31 @@ def respond_to_query(self,interface,query_description,secondary=False):
 		code = view_information["code"]
 		change_count = view_information["change_count"]
 		latest_build = Application.build_cache.get_build(self.vid,change_count)
-		retrieve_state(self.state,view_information,code)
+		print("state\n\n",self.state,"\n\n")
+		try:
+			if not secondary:
+				print("and during inside here ",query_description)
+				need_update = retrieve_state(self.state,view_information,code)
+				print("\n needed update: ",need_update,"\n")
+				print(" after update this state ",self.state)
+		except:
+			clear_state(self.state)
+			if False:
+				raise
 
 		# get the corresponding query and execute it
 		s = get_query(query_description)(code,latest_build)
 		secondary_query_description = get_secondary_query(query_description)
 		if secondary_query_description:
-			backup=[deepcopy(self.state),deepcopy(self.global_state)]
+			self.backup=[deepcopy(self.state),deepcopy(self.global_state)]
 
 		try:
 			s(view_information,query_description,extra)
 		except Exception as e:
-			print("\n\n finally\n\n")
-			if not s.exceptions_raised  :
-				print(e)
-				
-			print("\n\n finally\n\n")
-			interface.clear_actions()
-			interface.push_action(PopUpErrorAction(str(e)))
-			return False
+			if not s.exceptions_raised:
+				print("inside exceptions raised",e)
+				raise
+				return False
 
 
 		# check if there are exceptions
@@ -65,35 +75,36 @@ def respond_to_query(self,interface,query_description,secondary=False):
 			interface.push_action(PopUpErrorAction(str(s.exceptions_raised)))
 			return False
 
+
 		# register build for later use
 		b = s.get_the_latest_build()
 		if b:
 			Application.build_cache.register_build(self.vid,change_count,b)
 
+		if 	secondary:
+			self.state,self.global_state = self.backup
+
+
 		if isinstance(s,SelectionQuery):
 			result = s.result 
 			alternatives  = s.alternatives
-			# self.state["result"]  = None
-			# self.state["alternatives"] = []
+			self.state["origin"] = view_information["selection"]
+			self.state["initial_origin"] = view_information["selection"]
+			names = ["result","origin", "alternatives","initial_origin"]
+			for name in names:
+				interface.push_action(ClearHighlightAction(name))
 			if result:
 				self.state["result"] = result
-				self.state["alternatives"] = []
-				self.state["alternatives_text"] = []
-				if not isinstance(result,list):
-					self.state["result_text"] = code[result[0]:result[1]]	
-				else:
-					self.state["result_text"] = [code[x[0]:x[1]] for x in result if x]
+				self.state["alternatives"] = alternatives
+				# self.state["alternatives_text"] = get_location_text(alternatives,code)
+				self.update_text(code)
 				interface.push_action(SelectionAction(result))
 				self.history.append(("selection",view_information["change_count"],view_information["selection"],result))
-			interface.push_action(ClearHighlightAction("alternatives"))
-			if alternatives:
-				self.state["alternatives"] = alternatives
-				if not isinstance(alternatives[0],list):
-					self.state["alternatives_text"] = [code[x[0]:x[1]] for x in alternatives]
-				else:
-					self.state["alternatives_text"] = [[code[x[0]:x[1]] for x in y] for y in alternatives if y]
-				interface.push_action(DisplayRegionsAction("alternatives",alternatives,"Alternatives:\n"))
-				interface.push_action(HighlightCleverAction(alternatives,"alternatives",result))
+
+			
+			# if alternatives:
+				# interface.push_action(DisplayRegionsAction("alternatives",alternatives,"Alternatives:\n"))
+
 
 		elif isinstance(s,InsertionQuery):
 			output = s.writing_locations_text
@@ -102,6 +113,8 @@ def respond_to_query(self,interface,query_description,secondary=False):
 				for location, text in output:
 					interface.push_action(ReplaceAction(location,text))
 				self.history.append(("insert"))
+				self.update_locations(output)
+
 			if selections:
 				interface.push_action(SelectionAction(selections))
 
@@ -113,6 +126,7 @@ def respond_to_query(self,interface,query_description,secondary=False):
 			if result:
 				for location in writing_positions:
 					interface.push_action(ReplaceAction(location,result))
+				self.update_locations([(x,result)  for x in writing_positions])
 			if items:
 				print(s.label,"labeling\n")
 				interface.push_action(DisplayNiceAction(s.label,items,True))  
@@ -122,20 +136,29 @@ def respond_to_query(self,interface,query_description,secondary=False):
 			if selections:
 				interface.push_action(SelectionAction(selections))
 
+		interface.push_action(HighlightCleverAction(self.state["alternatives"],"alternatives",self.state["result"],colorize = True))
+		for name in ["result","origin", "initial_origin"]:
+			interface.push_action(HighlightCleverAction(self.state[name],name))				
+
+
 		if secondary_query_description:
 			interface.push_action(ClearHighlightAction("alternatives"))
 			secondary_success = self.respond_to_query(interface,secondary_query_description,secondary=True)
 			if not secondary_success:
-				self.state,self.global_state = backup
+				self.state,self.global_state = self.backup
 				return False
 		return True
 
 
 
 	def respond_to_event(self,interface,event_description):
 		event = event_description["event"]
+		view_information  = interface.get_view_information()
 		if event=="update_change_count":
+			if self.state["change_count"] != event_description["change_count"]:
+				retrieve_text(self.state,view_information["code"])
 			self.state["change_count"] = event_description["change_count"]
+	
 
 
 

application/state_update.py

@@ -59,7 +59,7 @@ def get_location_text(location,code):
 	return code[location[0]:location[1]]
 
 def convert_single_to_multiple(state):
-	for k in ["result","origin","alternatives"]:
+	for k in ["result","origin","initial_origin","alternatives"]:
 		data = state[k]
 		if data is None:
 			data = []
@@ -73,17 +73,20 @@ def convert_single_to_multiple(state):
 		state[k] = data
 
 def convert_multiple_to_single(state):
-	for k in ["result","origin","alternatives"]:
+	print(" inside multiple single ",state)
+	for k in ["result","origin","initial_origin","alternatives"]:
 		data = state[k]
 		if k not in ["alternatives"]:
 			if data == []:
 				data = None
 			elif isinstance(data,list) and len(data)==1 and isinstance(data[0],list) and len(data[0])==1:
+				print(" inside this case",k,data)
 				data = data[0][0]
+				print(" outside this case",k,data)
 			else:
 				raise Exception("when converting from multiple mode In single_mode "+k+" cannot be a nested list!")
 		else:
-			if isinstance(data,list) and all(isinstance(x,list)  and len(x)==1 for x in data):
+			if isinstance(data,list) and len(data)==1:
 				data = make_flat(data)
 			else:
 				raise Exception(" when converting into single mode, each of the items in the alternatives must have length of one")
@@ -93,59 +96,78 @@ def convert_multiple_to_single(state):
 def clear_state(state):
 	state["result"] = None
 	state["origin"] = None
+	state["initial_origin"] = None
 	state["alternatives"] = []
 	state["change_count"] = -1
 
 def retrieve_primitive(state,sublime_data):
 	output = deepcopy(state)
 	output["alternatives"] = invert_guided(sublime_data["alternatives"],state["alternatives"])
-	for k in ["result","origin"]:
+	for k in ["result","origin","initial_origin"]:
 		if not match_length(state[k],sublime_data[k]):
 			raise Exception("state "+k+" does not match the sublime data")
 		else:
 			output[k] = sublime_data[k]
-	return output
+	for k in ["result","origin","initial_origin","alternatives"]:
+		state[k] = output[k]
+	return state
+
+def retrieve_text(state,code):
+	for k in ["result","origin","initial_origin","alternatives"]:
+		state[k+"_text"] = get_location_text(state[k],code)
 
 
 def retrieve_state(state,view_information,code):
+	'''		
+		normally I would like these to be implemented by means of modification handlers
+		And an event listener transmitting every chains in the code. However it seems
+		but the provided event listener does not provide me with the location that was changed.
+		So in order to keep track over the location of important regions when the code changes,
+		The current solution is to outsource everything to the sublime add_regions/get_regions 
+		functionality
+	'''
+
 	if state["change_count"]>=view_information["change_count"]:
-		return 
+		return False
 	if state["change_count"]==-1:
 		state["change_count"]=view_information["change_count"]
-		return 
-	# retrieve data from their region tracker
+		return False
 
 	try :
 		convert_single_to_multiple(state)
-		sublime_data = {x:get_regions_while_you_still_can(view_information,x) for x in ["result","origin","alternatives"]}
+		sublime_data = {x:get_regions_while_you_still_can(view_information,x) 
+			for x in ["result","origin","alternatives","initial_origin"]}
+		print("\nsublime date at ease ",sublime_data,"\n")
+
 		state = retrieve_primitive(state,sublime_data)
 		convert_multiple_to_single(state)
+		print(" after conversion ",state,"\n")
 	except:
 		clear_state(state)
 		raise
+	retrieve_text(state,code)
+	return True
 
 
-	for k in ["result","origin","alternatives"]:
-		state[k+"_text"] = get_location_text(state[k],code)
-
 
 
 
 
+def update_changes(state,locations_text):
+	def forward(x,m):
+		if x is None:
+			return x
+		if isinstance(x,list):
+			return [forward(y,m)  for y in x]
+		return m.forward(x)
+
+	m = ModificationHandler()
+	for location,t in locations_text:
+		m.modify_from(0, location, t)
+
+	for k in ["result","origin","initial_origin","alternatives"]:
+		state[k] = forward(state[k],m)
 
 
 
 
-	def update_state(state,view_information,code):
-		'''		
-		normally I would like these to be implemented by means of modification handlers
-		And an event listener transmitting every chains in the code. However it seems
-		but the provided event listener does not provide me with the location that was changed.
-		So in order to keep track over the location of important regions when the code changes,
-		The current solution is to outsource everything to the sublime add_regions/get_regions 
-		functionality
-		'''
-		state["result"] = view_information["get_regions"]("result")
-		state["alternatives"] = view_information["get_regions"]("alternatives")
-		state["origin"] = view_information["get_regions"]("origin")
-		state["initial_origin"] = view_information["get_regions"]("initial_origin")

interface/common/actions.py

@@ -1,5 +1,7 @@
 import html
 
+from PythonVoiceCodingPlugin.interface.common.utility import make_region,make_sequence,all_or_nothing
+
 class InterfaceAction():
 	"""docstring for InterfaceAction"""
 	def __init__(self):
@@ -54,6 +56,7 @@ def __init__(self,name):
 	def execute(self,view,**kwargs):
 		index = 0
 		while True:
+			print(self.data["name"],index," attempted deletion ")
 			index+=1
 			r = view.get_regions(self.data["name"]+str(index)) 
 			if r:
@@ -92,8 +95,8 @@ def execute(self,view,sublime,**kwargs):
 
 class HighlightCleverAction(InterfaceAction):
 	"""docstring for HighlightAction(InterfaceAction"""
-	def __init__(self, region,name, result):  
-		self.data = {"region":region, "name":name , "result":result}
+	def __init__(self, region,name, avoid = [],colorize = False):  
+		self.data = {"region":region, "name":name , "avoid":avoid,"colorize":colorize}
 
 	def execute(self,view,sublime,**kwargs):
 		# these are the standard color maps for highlighting using the region-ish api
@@ -115,33 +118,35 @@ def execute(self,view,sublime,**kwargs):
 		color_order = ["red","blue","green","yellow","orange"]
 
 		# transform the region variable into at list of sublime regions
+		single_mode = False
 		region =  self.data["region"]
 		if not isinstance(region ,list):
-			region = [region]
-		region  = [ sublime.Region(x[0],x[1])  for x in region if x]
+			region = [[region]] if region else [[]]
+		elif isinstance(region,list):
+			assert all_or_nothing(region,isinstance,list)," singular regions and sequences of regions are mixed"
+			if all(not isinstance(x,list) for x in region):
+				region = [[x]  for x in region]
+				single_mode = True
+		region = make_region(region)
 
 		# transform the result into a sublime region
-		result = self.data["result"]
-		result = sublime.Region(result[0],result[1])
-
-		for i,(r,c) in enumerate(zip(region,color_order)):
+		avoid = self.data["avoid"]
+		avoid = make_region(avoid)
+		avoid_sequence = make_sequence(avoid)
+		overlapping = make_sequence(region) + make_sequence(avoid)
+		for i,(br,c) in enumerate(zip(region,color_order)):
 			use_reinforced = False
-			# we use reinforced color if the region is contained within another 
-			for x,y in zip(region,color_order):
-				if x.contains(r) and x is not r:
-					use_reinforced = True
-
-			# to avoid foreground background problems if the region contains the selection it will not be reinforced
-			if r.contains(result):
-				use_reinforced = False
-			# however if the region is contained within the selection it must be reinforced
-			elif result.contains(r):
-				use_reinforced = True
-			if r.b-r.a==1:
-				use_reinforced = True
-			# we add the region alongside with an index
-			view.add_regions(self.data["name"]+str(i+1), [r], reinforced_color[c] if use_reinforced else standard_color[c],
-				"circle")
+			for r in br:
+				use_reinforced = any(
+					(x.contains(r) and x is not r) or (r.contains(x) and x in avoid_sequence)  
+					for x in overlapping
+				) or r.b-r.a==1 or use_reinforced
+			if self.data["colorize"] and i<5:
+				view.add_regions(self.data["name"]+str(i+1), br,
+					  reinforced_color[c] if use_reinforced  and  single_mode else standard_color[c],"circle")
+			else:
+				view.add_regions(self.data["name"]+str(i+1),br)
+