Code is not ready yet

Code steel contains different path
I'll fix it later
not ready for release yet

Author: mpourmpoulis

application/__init__py.py

@@ -0,0 +1,4 @@
+from noob.application.build_cache import BuildCache
+from noob.application.application import Application
+
+

application/application.py

@@ -0,0 +1,106 @@
+from noob.queries import *
+from noob.application.build_cache import BuildCache
+from noob.interface.common.actions import *
+
+
+class Application():
+	"""docstring for Application"""
+	active_applications = {}
+	build_cache  = BuildCache()
+
+	def __init__(self,vid):
+		self.history = []
+		self.state = {}
+		self.ui_controller = None
+		self.vid = vid
+
+	def create_application_for_view(vid):
+		if vid not in Application.active_applications:
+			Application.active_applications[vid] = Application(vid)
+
+	def get_application(vid):
+		Application.create_application_for_view(vid)
+		return Application.active_applications[vid]
+
+
+	
+
+
+	def respond_to_query(self,interface,query_description):
+		extra = {"state":self.state,"history":self.history}
+		view_information  = interface.get_view_information()
+		ui_information = interface.get_ui_information()
+
+		# extract code and change count and reuse previous build if possible
+		code = view_information["code"]
+		change_count = view_information["change_count"]
+		latest_build = Application.build_cache.get_build(self.vid,change_count)
+
+		# get the corresponding query and execute it
+		s = get_query(query_description)(code,latest_build)
+		s(view_information,query_description,extra)
+
+		# register build for later use
+		b = s.get_the_latest_build()
+		if b:
+			Application.build_cache.register_build(self.vid,change_count,b)
+
+		if isinstance(s,SelectionQuery):
+			result = s.result 
+			alternatives  = s.alternatives
+			# self.state["result"]  = None
+			# self.state["alternatives"] = []
+			if result:
+				self.state["result"] = result
+				self.state["alternatives"] = []
+				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
+				interface.push_action(DisplayRegionsAction("alternatives",alternatives,"Alternatives:\n"))
+				interface.push_action(HighlightCleverAction(alternatives,"alternatives",result))
+		elif isinstance(s,InsertionQuery):
+			output = s.writing_locations_text
+			selections = s.optional_selection
+			if output:
+				for location, text in output:
+					interface.push_action(ReplaceAction(location,text))
+				self.history.append(("insert"))
+			if selections:
+				interface.push_action(SelectionAction(selections))
+		
+		elif isinstance(s,CollectionQuery):
+			result = s.result
+			items = s.items
+			writing_positions = s.writing_positions
+			selections = s.optional_selection
+			if result:
+				for location in writing_positions:
+					interface.push_action(ReplaceAction(location,result))
+			if items:
+				interface.push_action(DisplayNiceAction(items,True))  
+				self.state["collection"] = items
+			if selections:
+				interface.push_action(SelectionAction(selections))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	def respond_to_event(interface,event_description):
+		pass
+
+
+		

application/build_cache.py

@@ -0,0 +1,16 @@
+class BuildCache():
+	"""docstring for BuildCache"""
+	def __init__(self):
+		self.cache_memory = {}
+	def register_build(self,vid,change_count,build):
+		self.cache_memory[vid] = (change_count,build)
+
+	def get_build(self,vid,change_count):
+		if vid not in self.cache_memory:
+			return None
+		data = self.cache_memory[vid]
+		if change_count!= data[0]:
+			return None
+		return  data[1]
+
+		

bundles/Caster/python_voice_coding_plugin_caster.py

@@ -33,12 +33,12 @@ def noob_send(command,format,**kwargs):
     data = create_arguments(command,format,**kwargs)
     send_sublime("noob_voice_coding", data)
 
-def lazy_value(c,f):
-    return  R(Function(noob_send, command = c, format = f))
+def lazy_value(c,f,**kwargs):
+    return  R(Function(noob_send, command = c, format = f,**kwargs))
 
 
 class NoobRule(MergeRule):
-    pronunciation = "noob"
+    pronunciation = "python voice coding plugin"
     mapping = {
         # alternative rule
         "[smart] alternative <alternative_index>":
@@ -75,15 +75,19 @@ class NoobRule(MergeRule):
 
         # insert rule
         "(smart insert|insert item) <item_index>":
-            lazy_value("insert",1),
+            lazy_value("insert_item",1),
 
         # collect rule
-        "[smart] collect <index_collectable>":
+        "[smart] collect <collectable>":
             lazy_value("collect_indexable",1),
         "[smart] variable <collect_index>":
             lazy_value("collect_variable",2),
         "[smart] parameter <collect_index>":
             lazy_value("collect_parameter",2),
+        "[smart] module <collect_index>":
+            lazy_value("collect_module",2),
+        "[smart] imported (value|object) <collect_index>":
+            lazy_value("collect_imported_value",2),
 
 
 
@@ -128,7 +132,7 @@ class NoobRule(MergeRule):
             }
         ),
         Choice("color",{
-                "(red|gray)":1,
+                "red":1,
                 "blue":2, 
                 "green":3,
                 "yellow":4,
@@ -156,8 +160,8 @@ class NoobRule(MergeRule):
                 "(assignment left| left)" : "assignment left",
                 "assignment full" : "assignment full",
                 "import statement":"import statement",
-                "(import|imported) (value|item|object|element)":"import value",
-                "module" : "module", 
+                #"(import|imported) (value|item|object|element)":"import value",
+                #"module" : "module", 
                 "(expression statement|expression)" : "expression statement",
                 "iterator" : "iterator",
                 "iterable" : "iterable",
@@ -168,9 +172,12 @@ class NoobRule(MergeRule):
                 "(function|functions)" :"function",
             }
         ),
-        Choice("index_collectable",{
+        Choice("collectable",{
                 "(variable|variables)":"variable",
                 "( parameter | parameters)":"parameter",
+                "(module|modules)":"module",
+                "(import|imported) (value|item|object|element)":"import value",
+                "function ( name |names)":"function name",
             }
         ),