Merge branch 'mike'

Conflicts:
	source/external/source/sugar-toolkit/src/sugar/tutorius/actions.py
	source/external/source/sugar-toolkit/src/sugar/tutorius/tests/actiontests.py
	source/external/source/sugar-toolkit/src/sugar/tutorius/tests/run-tests.py

1 files changed, 567 insertions, 23 deletions

diff --git a/src/sugar/tutorius/bundler.py b/src/sugar/tutorius/bundler.py
index 585ba88..f9a3911 100644
--- a/src/sugar/tutorius/bundler.py
+++ b/src/sugar/tutorius/bundler.py
@@ -21,33 +21,88 @@ This module contains all the data handling class of Tutorius
 """
 
 import logging
-import linecache
 import os
+import uuid
+import xml.dom.minidom
 
 from sugar.tutorius import gtkutils, overlayer
 from sugar.tutorius.core import Tutorial, State, FiniteStateMachine
-from sugar.tutorius.actions import DialogMessage, OnceWrapper, BubbleMessage
-from sugar.tutorius.filters import GtkWidgetEventFilter, TimerEvent
+from sugar.tutorius.filters import *
+from sugar.tutorius.actions import *
+from ConfigParser import SafeConfigParser
+
+def _get_store_root():
+    return os.path.join(os.getenv("SUGAR_PREFIX"),"share","tutorius","data")
+def _get_bundle_root():
+    return os.path.join(os.getenv("SUGAR_BUNDLE_PATH"),"data","tutorius","data")
+
+INI_ACTIVITY_SECTION = "RELATED_ACTIVITIES"
+INI_METADATA_SECTION = "GENERAL_METADATA"
+INI_GUID_PROPERTY = "GUID"
+INI_NAME_PROPERTY = "NAME"
+INI_XML_FSM_PROPERTY = "FSM_FILENAME"
 
 class TutorialStore:
         
-    def list_avaible_tutorials(self, activity_name):
+    def list_avaible_tutorials(self, activity_name, activity_vers):
         """
         Recuperate the list of all tutorials present on disk for a
         given activity.
         """
-        NotImplementedError
+        
+        store_root = _get_store_root()
+        bundle_root = _get_bundle_root()
+        
+        logging.debug("***********   Path of store_root : " + store_root)
+        
+        # Create /data/tutorius if no exists
+        if not os.path.exists(store_root):
+            os.mkdir(store_root)
+            logging.debug("*************   Creating %s folder" % store_root)
+            
+        tutoGuidName = {}
+        
+        # iterate in each GUID subfolder
+        for dir in os.listdir(store_root):
+            # iterate for each ".ini" file in the activity store_root folder        
+            for file_name in os.listdir(store_root + "/" + dir):
+                
+                if file_name.endswith(".ini"):
+                    logging.debug("**************  .ini file found : " + file_name)
+                    # Filter for just .ini files who metadata ACTIVITY_NAME
+                    # match 'activity_name' given in argument.
+                    config = SafeConfigParser()
+                    config.read(file_name)
+                    # Get all activity tuples (Activity_Name: Activity_Version)
+                    file_activity_tuples = config.items(INI_ACTIVITY_SECTION)
+                    
+                    for i in range(0, len(file_activity_tuples) - 1):
+                        
+                        if file_activity_tuples[i][0] == activity_name and  \
+                        int(file_activity_tuples[i][1]) == activity_vers:
+                            # Add this tutorial guid and name in the dictionary
+                            file_activity_guid = config.get(INI_METADATA_SECTION,
+                                INI_GUID_PROPERTY)
+                            file_activity_name = config.get(INI_METADATA_SECTION,
+                                INI_NAME_PROPERTY)
+                            tutoGuidName[file_activity_name] = file_activity_guid
+
+        return tutoGuidName
     
 
 class Serializer:
     """
-    Class that provide serializing and deserializing of the FSM
-    used in the tutorials to/from disk.
+    Interface that provide serializing and deserializing of the FSM
+    used in the tutorials to/from disk. Must be inherited.
     """
     
-    def save_fsm(self,fsm):
+    def save_fsm(self,fsm, guid = None):
         """
-        Save fsm to disk.
+        Save fsm to disk. If a GUID parameter is provided, the existing GUID is
+        located in the .ini files in the store root and bundle root and
+        the corresponding FSM is/are overwritten. If the GUId is not found, an 
+        exception occur. If no GUID is provided, FSM is written in a new file 
+        in the store root.
         """
         NotImplementedError
         
@@ -60,43 +115,532 @@ class Serializer:
 class XMLSerializer(Serializer):
     """
     Class that provide serializing and deserializing of the FSM
-    used in the tutorials to/from a xml file.
+    used in the tutorials to/from a .xml file. Inherit from Serializer
     """
     
-    def save_fsm(self,fsm):
+    def _create_state_dict_node(self, state_dict, doc):
         """
-        Save fsm to .xml file
+        Create and return a xml Node from a State dictionnary.
         """
-        NotImplementedError
+        statesList = doc.createElement("States")
+        for state_name, state in state_dict.items():
+            stateNode = doc.createElement("State")
+            statesList.appendChild(stateNode)
+            stateNode.setAttribute("Name", state_name)
+            actionsList = stateNode.appendChild(self._create_action_list_node(state.get_action_list(), doc))
+            eventfiltersList = stateNode.appendChild(self._create_event_filters_node(state.get_event_filter_list(), doc))
+        return statesList
+    
+    def _create_action_node(self, action, doc):
+        """
+        Takes a single action and transforms it into a xml node.
+        
+        @param action A single action
+        @param doc The XML document root (used to create nodes only
+        @return A XML Node object with the Action tag name
+        """
+        actionNode = doc.createElement("Action")
+        
+        # Write down just the name of the Action class as the Class
+        # property --
+        # Using .__class__ since type() doesn't have the same behavior 
+        # with class derivating from object and class that don't
+        actionNode.setAttribute("Class", str(action.__class__))
+        
+        if type(action) is DialogMessage:
+            actionNode.setAttribute("Message", action.message.value)
+            actionNode.setAttribute("PositionX", str(action.position.value[0]))
+            actionNode.setAttribute("PositionY", str(action.position.value[1]))
+        elif type(action) is BubbleMessage:
+            actionNode.setAttribute("Message", action.message.value)
+            actionNode.setAttribute("PositionX", str(action.position.value[0]))
+            actionNode.setAttribute("PositionY", str(action.position.value[1]))
+            actionNode.setAttribute("Tail_posX", str(action.tail_pos.value[0]))
+            actionNode.setAttribute("Tail_posY", str(action.tail_pos.value[1]))
+        # TO ADD : elif for each type of action
+        elif type(action) is WidgetIdentifyAction:
+            # Nothing else to save
+            pass
+        elif type(action) is ChainAction:
+            # Recusively write the contained actions - in the correct order
+            subActionsNode = self._create_action_list_node(action._actions, doc)
+            actionNode.appendChild(subActionsNode)
+        elif type(action) is DisableWidgetAction:
+            # Remember the target
+            actionNode.setAttribute("Target", action._target)
+        elif type(action) is TypeTextAction:
+            # Save the text and the widget
+            actionNode.setAttribute("Widget", action._widget)
+            actionNode.setAttribute("Text", action._text)
+        elif type(action) is ClickAction:
+            # Save the widget to click
+            actionNode.setAttribute("Widget", action._widget)
+        elif type(action) is OnceWrapper:
+            # Encapsulate the action in a OnceWrapper
+            subActionNode = self._create_action_node(action._action, doc)
+            actionNode.appendChild(subActionNode)
+            
+        return actionNode
+        
+    def _create_action_list_node(self, action_list, doc):
+        """
+        Create and return a xml Node from a Action list.
+        
+        @param action_list A list of actions
+        @param doc The XML document root (used to create new nodes only)
+        @return A XML Node object with the Actions tag name and a serie of 
+        Action children
+        """
+        actionsList = doc.createElement("Actions")
+        for action in action_list:
+            # Create the action node
+            actionNode = self._create_action_node(action, doc)
+            # Append it to the list
+            actionsList.appendChild(actionNode)
+            
+        return actionsList
+    
+    def _create_event_filters_node(self, event_filters, doc):
+        """
+        Create and return a xml Node from a event filters.
+        """
+        eventFiltersList = doc.createElement("EventFiltersList")
+        for event_f in event_filters:
+            eventFilterNode = doc.createElement("EventFilter")
+            eventFiltersList.appendChild(eventFilterNode)
+            
+            # Write down just the name of the Action class as the Class
+            # property --
+            # using .__class__ since type() doesn't have the same behavior 
+            # with class derivating from object and class that don't
+            eventFilterNode.setAttribute("Class", str(event_f.__class__))
+            
+            # Write the name of the next state
+            eventFilterNode.setAttribute("NextState", event_f.next_state)
+            
+            if type(event_f) is TimerEvent:
+                eventFilterNode.setAttribute("Timeout_s", str(event_f._timeout))
+                
+            elif type(event_f) is GtkWidgetEventFilter:
+                eventFilterNode.setAttribute("EventName", event_f._event_name)
+                eventFilterNode.setAttribute("ObjectId", event_f._object_id)
+                
+            elif type(event_f) is GtkWidgetTypeFilter:
+                eventFilterNode.setAttribute("ObjectId", event_f._object_id)
+                if event_f._strokes is not None:
+                    eventFilterNode.setAttribute("Strokes", event_f._strokes)
+                if event_f._text is not None:
+                    eventFilterNode.setAttribute("Text", event_f._text)
+                
+        return eventFiltersList       
 
+    def save_fsm(self, fsm, xml_filename, path):
+        """
+        Save fsm to disk, in the xml file specified by "xml_filename", in the 
+        "path" folder. If the specified file doesn't exist, it will be created.
+        """ 
+        doc = xml.dom.minidom.Document()
+        fsm_element = doc.createElement("FSM")
+        doc.appendChild(fsm_element)
+        fsm_element.setAttribute("Name", fsm.name)
+        fsm_element.setAttribute("StartStateName", fsm.start_state_name)
+        statesDict = fsm_element.appendChild(self._create_state_dict_node(fsm._states, doc))
+        
+        fsm_actions_node = self._create_action_list_node(fsm.actions, doc)
+        fsm_actions_node.tagName = "FSMActions"
+        actionsList = fsm_element.appendChild(fsm_actions_node)
+        
+        file_object = open(os.path.join(path, xml_filename), "w")
+        file_object.write(doc.toprettyxml())
+        file_object.close()
+        
+    
+    def _find_tutorial_dir_with_guid(self, guid):
+        """
+        Finds the tutorial with the associated GUID. If it is found, return
+        the path to the tutorial's directory. If it doesn't exist, raise an
+        IOError.
+        
+        A note : if there are two tutorials with this GUID in the folders,
+        they will both be inspected and the one with the highest version
+        number will be returned. If they have the same version number, the one
+        from the global store will be returned.
+        
+        @param guid The GUID of the tutorial that is to be loaded.
+        """
+        # Attempt to find the tutorial's directory in the global directory
+        global_dir = os.path.join(_get_store_root(), guid)
+        # Then in the activty's bundle path
+        activity_dir = os.path.join(_get_bundle_root(), guid)
+        
+        # If they both exist
+        if os.path.isdir(global_dir) and os.path.isdir(activity_dir):
+            # Inspect both metadata files
+            global_meta = os.path.join(global_dir, "meta.ini")
+            activity_meta = os.path.join(activity_dir, "meta.ini")
+            
+            # Open both config files
+            global_parser = SafeConfigParser()
+            global_parser.read(global_meta)
+            
+            activity_parser = SafeConfigParser()
+            activity_parser.read(activity_meta)
+            
+            # Get the version number for each tutorial
+            global_version = global_parser.get(INI_METADATA_SECTION, "version")
+            activity_version = activity_parser.get(INI_METADATA_SECTION, "version")
+            
+            # If the global version is higher or equal, we'll take it
+            if global_version >= activity_version:
+                return global_dir
+            else:
+                return activity_dir
+        
+        # Do we just have the global directory?
+        if os.path.isdir(global_dir):
+            return global_dir
+        
+        # Or just the activity's bundle directory?
+        if os.path.isdir(activity_dir):
+            return activity_dir
+        
+        # Error : none of these directories contain the tutorial
+        raise IOError(2, "Neither the global nor the bundle directory contained the tutorial with GUID %s"%guid)
+    
+    def _load_xml_properties(self, properties_elem):
+        """
+        Changes a list of properties into fully instanciated properties.
+        
+        @param properties_elem An XML element reprensenting a list of 
+        properties
+        """
+        return []
+    
+    def _load_xml_event_filters(self, filters_elem):
+        """
+        Loads up a list of Event Filters.
+        
+        @param filters_elem An XML Element representing a list of event filters
+        """
+        reformed_event_filters_list = []
+        event_filter_element_list = filters_elem.getElementsByTagName("EventFilter")
+        new_event_filter = None
+        
+        for event_filter in event_filter_element_list:
+            # Load the name of the next state for this filter
+            next_state = event_filter.getAttribute("NextState")
+            
+            if event_filter.getAttribute("Class") == str(TimerEvent):
+                timeout = int(event_filter.getAttribute("Timeout_s"))
+                new_event_filter = TimerEvent(next_state, timeout)
+                
+            elif event_filter.getAttribute("Class") == str(GtkWidgetEventFilter):
+                # Get the event name and the object's ID
+                event_name = event_filter.getAttribute("EventName")
+                object_id = event_filter.getAttribute("ObjectId")
+                
+                new_event_filter = GtkWidgetEventFilter(next_state, object_id, event_name)
+            elif event_filter.getAttribute("Class") == str(GtkWidgetTypeFilter):
+                # Get the widget to write in and the text
+                object_id = event_filter.getAttribute("ObjectId")
+                if event_filter.hasAttribute("Text"):
+                    text = event_filter.getAttribute("Text")
+                    new_event_filter = GtkWidgetTypeFilter(next_state, object_id, text=text)
+                elif event_filter.hasAttribute("Strokes"):
+                    strokes = event_filter.getAttribute("Strokes")
+                    new_event_filter = GtkWidgetTypeFilter(next_state, object_id, strokes=strokes)
+            
+            if new_event_filter is not None:
+                reformed_event_filters_list.append(new_event_filter)
+            
+        return reformed_event_filters_list
+    
+    def _load_xml_action(self, action):
+        """
+        Loads a single action from an Xml Action node.
+        
+        @param action The Action XML Node to transform
+        object
+        @return The Action object of the correct type according to the XML
+        description
+        """
+        # TO ADD: an elif for each type of action
+        if action.getAttribute("Class") == str(DialogMessage):
+            message = action.getAttribute("Message")
+            positionX = int(action.getAttribute("PositionX"))
+            positionY = int(action.getAttribute("PositionY"))
+            position = [positionX, positionY]
+            return DialogMessage(message,position)
+        elif action.getAttribute("Class") == str(BubbleMessage):
+            message = action.getAttribute("Message")
+            positionX = int(action.getAttribute("PositionX"))
+            positionY = int(action.getAttribute("PositionY"))
+            position = [positionX, positionY]
+            tail_posX = action.getAttribute("Tail_posX")
+            tail_posY = action.getAttribute("Tail_posY")
+            tail_pos = [tail_posX, tail_posY]
+            return BubbleMessage(message,position,None,tail_pos)
+        elif action.getAttribute("Class") == str(WidgetIdentifyAction):
+            return WidgetIdentifyAction()
+        elif action.getAttribute("Class") == str(ChainAction):
+            # Load the subactions
+            subActionsList = self._load_xml_actions(action.getElementsByTagName("Actions")[0])
+            return ChainAction(subActionsList)
+        elif action.getAttribute("Class") == str(DisableWidgetAction):
+            # Get the target
+            targetName = action.getAttribute("Target")
+            return DisableWidgetAction(targetName)
+        elif action.getAttribute("Class") == str(TypeTextAction):
+            # Get the widget and the text to type
+            widget = action.getAttribute("Widget")
+            text = action.getAttribute("Text")
+            
+            return TypeTextAction(widget, text)
+        elif action.getAttribute("Class") == str(ClickAction):
+            # Load the widget to click
+            widget = action.getAttribute("Widget")
+            
+            return ClickAction(widget)
+    
+    def _load_xml_actions(self, actions_elem):
+        """
+        Transforms an Actions element into a list of instanciated Action.
+        
+        @param actions_elem An XML Element representing a list of Actions
+        """
+        reformed_actions_list = []
+        actions_element_list = actions_elem.getElementsByTagName("Action")
+        
+        for action in actions_element_list:
+            new_action = self._load_xml_action(action)
+            
+            reformed_actions_list.append(new_action)
+        
+        return reformed_actions_list
+    
+    def _load_xml_states(self, states_elem):
+        """
+        Takes in a States element and fleshes out a complete list of State 
+        objects.
+        
+        @param states_elem An XML Element that represents a list of States
+        """
+        reformed_state_list = []
+        # item(0) because there is always only one <States> tag in the xml file
+        # so states_elem should always contain only one element
+        states_element_list = states_elem.item(0).getElementsByTagName("State")
+        
+        for state in states_element_list:
+            stateName = state.getAttribute("Name")
+            # Using item 0 in the list because there is always only one 
+            # Actions and EventFilterList element per State node.
+            actions_list = self._load_xml_actions(state.getElementsByTagName("Actions")[0])
+            event_filters_list = self._load_xml_event_filters(state.getElementsByTagName("EventFiltersList")[0])
+            reformed_state_list.append(State(stateName, actions_list, event_filters_list))
+        
+        return reformed_state_list
+    
+    def _load_xml_fsm(self, fsm_elem):
+        """
+        Takes in an XML element representing an FSM and returns the fully 
+        crafted FSM.
+        
+        @param fsm_elem The XML element that describes a FSM
+        """
+        # Load the FSM's name and start state's name
+        fsm_name = fsm_elem.getAttribute("Name")
+        
+        fsm_start_state_name = None
+        try:
+            fsm_start_state_name = fsm_elem.getAttribute("StartStateName")
+        except:
+            pass
+        
+        fsm = FiniteStateMachine(fsm_name, start_state_name=fsm_start_state_name)
+        
+        # Load the states
+        states = self._load_xml_states(fsm_elem.getElementsByTagName("States"))
+        for state in states:
+            fsm.add_state(state)
+        
+        # Load the actions on this FSM
+        actions = self._load_xml_actions(fsm_elem.getElementsByTagName("FSMActions")[0])
+        for action in actions:
+            fsm.add_action(action)
+            
+        # Load the event filters
+        events = self._load_xml_event_filters(fsm_elem.getElementsByTagName("EventFiltersList")[0])
+        for event in events:
+            fsm.add_event_filter(event)
+            
+        return fsm
+        
     
     def load_fsm(self, guid):
         """
-        Load fsm from xml file who .ini file guid match argument guid.
+        Load fsm from xml file whose .ini file guid match argument guid.
         """
-        NotImplementedError
+        # Fetch the directory (if any)
+        tutorial_dir = self._find_tutorial_dir_with_guid(guid)
+        
+        # Open the XML file
+        tutorial_file = os.path.join(tutorial_dir, "fsm.xml")
         
+        xml_dom = xml.dom.minidom.parse(tutorial_file)
         
+        fsm_elem = xml_dom.getElementsByTagName("FSM")[0]
+        
+        return self._load_xml_fsm(fsm_elem)
+        
+    
 class TutorialBundler:
     """
     This class provide the various data handling methods useable by the tutorial
     editor.
     """
     
-    def write_metadata_file(data):
+    def __init__(self,generated_guid = None):
         """
-        Write metadata to a .ini file.
+        Tutorial_bundler constructor. If a GUID is given in the parameter, the
+        Tutorial_bundler object will be associated with it. If no GUID is given,
+        a new GUID will be generated,
         """
-        NotImplementedError
-    
-    def write_fsm(fsm):
+            
+        self.Guid = generated_guid or uuid.uuid1()
+
+        #Look for the file in the path if a uid is supplied
+        if generated_guid:
+            #General store
+            store_path = os.path.join(_get_store_root(), generated_guid, INI_FILENAME)
+            if os.path.isfile(store_path):
+                self.Path = os.path.dirname(store_path)
+            else:
+                #Bundle store
+                bundle_path = os.path.join(_get_bundle_root(), generated_guid, INI_FILENAME)
+                if os.path.isfile(bundle_path):
+                    self.Path = os.path.dirname(bundle_path)
+                else:
+                    raise IOError(2,"Unable to locate metadata file for guid '%s'" % generated_guid)
+
+        else:
+                #Create the folder, any failure will go through to the caller for now
+                store_path = os.path.join(_get_store_root(), generated_guid)
+                os.mkdir(store_path)
+                self.Path = store_path
+
+            
+        def __SetGuid(self, value):
+            self.__guid = value
+            
+        def __GetGuid(self):
+            return self.__guid
+            
+        def __DelGuid(self):
+            del self.__guid
+            
+        def __SetPath(self, value):
+            self.__path = value
+            
+        def __GetPath(self):
+            return self.__path
+            
+        def __DelPath(self):
+            del self.__path
+            
+        Guid = property(fget=__SetGuid,
+                            fset=__GetGuid,
+                            fdel=__DelGuid,
+                            doc="The guid associated with the Tutoria_Bundler")
+                            
+        Path = property(fget=__SetPath,
+                            fset=__GetPath,
+                            fdel=__DelPath,
+                            doc="The path associated with the Tutoria_Bundler")
+            
+        
+    def write_metadata_file(self, data):
         """
-        Write fsm to disk.
+        Write metadata to a property file. If a GUID is provided, TutorialBundler
+        will try to find and overwrite the existing property file who contain the 
+        given GUID, and will raise an exception if it cannot find it.
         """
         NotImplementedError
         
-    def add_resources(typename, file):
+    def get_tutorial_path(self):
+        """
+        Return the path of the .ini file associated with the guiven guid set in
+        the Guid property of the Tutorial_Bundler. If the guid is present in 
+        more than one path, the store_root is given priority.
+        """
+        
+        store_root = _get_store_root()
+        bundle_root = _get_bundle_root()
+        
+        config = SafeConfigParser()
+        path = None
+        
+        logging.debug("************ Path of store_root folder of activity : " \
+            + store_root)
+            
+        # iterate in each GUID subfolder
+        for dir in os.listdir(store_root):
+            
+            # iterate for each .ini file in the store_root folder
+                            
+            for file_name in os.listdir(store_root + "/" + dir):
+                if file_name.endswith(".ini"):
+                    logging.debug("******************* Found .ini file : " \
+                        + file_name)
+                    config.read(file_name)
+                    if config.get(INI_METADATA_SECTION, INI_GUID_PROPERTY) == self.Guid:
+                        xml_filename = config.get(INI_METADATA_SECTION,
+                            INI_XML_FSM_PROPERTY)
+                        
+                        path = os.path.join(store_root, self.Guid)
+                        return path
+            
+        logging.debug("************ Path of bundle_root folder of activity : " \
+            + bundle_root)
+            
+                   
+        # iterate in each GUID subfolder
+        for dir in os.listdir(bundle_root):    
+            
+            # iterate for each .ini file in the bundle_root folder
+            for file_name in os.listdir(bundle_root + "/" + dir):
+                if file_name.endswith(".ini"):
+                    logging.debug("******************* Found .ini file : " \
+                        + file_name)
+                    config.read(file_name)
+                    if config.get(INI_METADATA_SECTION, INI_GUID_PROPERTY) == guid:
+                        path = os.path.join(bundle_root, self.Guid)
+                        return path
+                
+        if path is None:
+            logging.debug("**************** Error : GUID not found")
+            raise KeyError
+
+    def write_fsm(self, fsm, guid=None):
+
+        """
+        Save fsm to disk. If a GUID parameter is provided, the existing GUID is
+        located in the .ini files in the store root and bundle root and
+        the corresponding FSM is/are created or overwritten. If the GUID is not 
+        found, an exception occur.
+        """ 
+        
+        config = SafeConfigParser()
+                   
+        if guid is not None:
+            serializer = XMLSerializer()
+            path = get_tutorial_path() + "/meta.ini"
+            config.read(path)
+            xml_filename = config.get(INI_METADATA_SECTION, INI_XML_FSM_PROPERTY)
+            serializer.save_fsm(fsm, xml_filename, store_root)
+            
+        
+    def add_resources(self, typename, file):
         """
         Add ressources to metadata.
         """
-        NotImplementedError
\ No newline at end of file
+        raise NotImplementedError("add_resources not implemented")