From 6fa568daae3291c7a876cd903f04079a12945dcb Mon Sep 17 00:00:00 2001 From: mike Date: Tue, 05 May 2009 05:44:27 +0000 Subject: 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 --- (limited to 'src/sugar/tutorius/bundler.py') 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 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") -- cgit v0.9.1