Merge lp:~milo/linaro-ci-dashboard/xml-to-dict into lp:linaro-ci-dashboard

[Milo Casagrande]

Here there is all the logic for XML to dictionary and dictionary to XML conversions. Some tests and their values are provided.

[lp:~milo/linaro-ci-dashboard/xml-to-dict]

42. By Milo Casagrande on 2012-09-06

Removed print statements.

43. By Milo Casagrande on 2012-09-06

Fixed tests regressions, modified function.

44. By Milo Casagrande on 2012-09-06

Removed redundant errors div.

45. By Milo Casagrande on 2012-09-06

Merged from trunk.

46. By Milo Casagrande on 2012-09-07

Fixes for review.

47. By Milo Casagrande on 2012-09-07

Fixed assertion.

48. By Milo Casagrande on 2012-09-07

PEP8 fixes.

49. By Milo Casagrande on 2012-09-07

Added some tests.

50. By Milo Casagrande on 2012-09-07

Added note, fixed some tests.

51. By Milo Casagrande on 2012-09-07

Fixed reference.

52. By Milo Casagrande on 2012-09-07

Removed comment.

Unmerged revisions

=== modified file 'dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html'
--- dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-08-31 15:21:11 +0000
+++ dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-09-06 08:33:21 +0000
@@ -6,14 +6,6 @@
     <form name="{{ form_name }}" action="{% url AndroidTextFieldLoopCreate %}" method="post">
     {% csrf_token %}
 {% endblock create_form %}
-
-{% if form.non_field_errors %}
-    <div class="form_error">
-        {% for err in form.non_field_errors %}
-            <div class="error_message">{{ err }}</div>
-        {% endfor %}
-    </div>
-{% endif %}
 {{ form.as_p }}
         <div><input type="submit" value="Submit" /></div>
     </form>
 
=== modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
--- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-05 13:59:57 +0000
+++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-06 08:33:21 +0000
@@ -24,9 +24,9 @@
 
     A_NAME = 'a-build'
     B_NAME = 'b-build'
-    VALID_VALUES = 'a=2\nb=3'
+    VALID_VALUES = u'a=2\nb=3'
     VALID_LINES = ['a=2', 'b=3']
-    NON_VALID_VALUES = 'a:2\nb=3'
+    NON_VALID_VALUES = u'a:2\nb=3'
     NON_VALID_LINES = ['a:2', 'b=3']
     VALID_DICT = {'a': '2', 'b': '3'}
 
@@ -52,6 +52,7 @@
     def test_valid_values_wrong(self):
         self.assertEqual((False, self.NON_VALID_LINES),
                          AndroidTextFieldLoop.valid_values(
+<<<<<<< TREE
                              self.NON_VALID_VALUES))
 
     def test_schedule_build(self):
@@ -62,3 +63,27 @@
     def test_schedule_build_invalid(self):
         build = self.non_valid_android_loop.schedule_build()
         self.assertEqual(build.result_xml, {})
+=======
+                             self.NON_VALID_VALUES))
+
+    def test_schedule_build(self):
+        build = self.android_loop.schedule_build()
+        expected_out = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE ' \
+                       'loop [\n    <!ELEMENT loop (description?,fields)>\n' \
+                       '    <!ELEMENT description (#PCDATA)>\n    ' \
+                       '<!ELEMENT fields (field+)>\n    <!ELEMENT field ' \
+                       '(#PCDATA)>\n    <!ATTLIST field name CDATA ' \
+                       '#REQUIRED>\n    <!ATTLIST field type (text|int|bool) ' \
+                       '"text">\n]><loop><fields><field name="a">2</field>' \
+                       '<field name="b">3</field><field name="name">a-build' \
+                       '</field><field name="is_restricted">False</field>' \
+                       '<field name="is_official">False</field>' \
+                       '<field name="type">AndroidTextFieldLoop</field>' \
+                       '</fields></loop>'
+        self.assertEqual(expected_out, build.result_xml)
+        self.assertEqual(build.status, "success")
+
+    def test_schedule_build_invalid(self):
+        build = self.non_valid_android_loop.schedule_build()
+        self.assertEqual("", build.result_xml)
+>>>>>>> MERGE-SOURCE
 
=== modified file 'dashboard/frontend/models/loop_build.py'
--- dashboard/frontend/models/loop_build.py	2012-09-05 13:23:05 +0000
+++ dashboard/frontend/models/loop_build.py	2012-09-06 08:33:21 +0000
@@ -18,6 +18,7 @@
 
 from django.db import models
 from frontend.models.loop import Loop
+from dashboard.lib.xml_to_dict import XmlToDict
 
 
 class LoopBuild(models.Model):
@@ -47,3 +48,15 @@
             else:
                 self.build_number = 1
         super(LoopBuild, self).save(*args, **kwargs)
+
+    def get_build_result(self):
+        """
+        Returns a Python dictionary representation of the build XML stored.
+
+        :return A dictionary of the XML result.
+        """
+        dict_result = {}
+        if self.result_xml:
+            xml_to_dict = XmlToDict(self.result_xml)
+            dict_result = xml_to_dict.tree_to_dict()
+        return dict_result
 
=== modified file 'dashboard/frontend/models/textfield_loop.py'
--- dashboard/frontend/models/textfield_loop.py	2012-09-05 13:59:57 +0000
+++ dashboard/frontend/models/textfield_loop.py	2012-09-06 08:33:21 +0000
@@ -17,6 +17,7 @@
 
 from django.db import models
 from frontend.models.loop import Loop
+from dashboard.lib.xml_to_dict import DictToXml
 
 
 # Default delimiter to separate values from keys in the text field.
@@ -40,6 +41,7 @@
     values = models.TextField()
 
     def schedule_build(self, parameters=None):
+<<<<<<< TREE
         from frontend.models.loop_build import LoopBuild
         build = LoopBuild()
         build.loop = self
@@ -55,14 +57,40 @@
         return build
 
     def values_to_dict(self):
+=======
+        from frontend.models.loop_build import LoopBuild
+        build = LoopBuild()
+        build.loop = self
+        build.duration = 0.00
+
+        try:
+            build.result_xml = self.dict_to_xml()
+            build.status = 'success'
+        except:
+            build.status = 'failure'
+
+        build.save()
+        return build
+
+    def values_to_dict(self, valid=None, lines=None):
+>>>>>>> MERGE-SOURCE
         """
         Returns a dictionary representation of the values inserted. The
         key<>value pairs are split on DEFAULT_DELIMITER.
 
-        :return A dictionary of the values inserted.
+        The default parameters are used for a second iteration of this function
+        if we do not want to parse again the lines, but we only want to get the
+        dictionary.
+
+        :param valid: If the lines are valid or not.
+        :type valid bool
+        :param lines: The list of lines in the text field.
+        :type lines list
+        :return A dictionary of the values inserted in the text field.
         """
         text_to_dict = {}
-        valid, lines = self.valid_values(self.values)
+        if valid is None and lines is None:
+            valid, lines = self.valid_values(self.values)
 
         if valid:
             for line in lines:
@@ -71,6 +99,19 @@
 
         return text_to_dict
 
+    def _all_values_to_dict(self):
+        """
+        Returns a dict representation of the necessary fields for the loops.
+
+        :return A Python dictionary with the necessary fields.
+        """
+        # TODO need a better way to serialize the model
+        all_values_dict = {'is_official': self.is_official,
+                           'is_restricted': self.is_restricted,
+                           'name': self.name,
+                           'type': self.type}
+        return all_values_dict
+
     @staticmethod
     def valid_values(values):
         """
@@ -79,7 +120,7 @@
 
         :param values: the string with all the key<>value pairs, separated with
         a newline character.
-        :type str
+        :type values unicode
         :return a boolean for the validity, and the list of lines.
         """
         valid = True
@@ -91,3 +132,18 @@
                 valid = False
                 break
         return valid, lines
+
+    def dict_to_xml(self):
+        """
+        Converts the necessary values into an XML tree.
+
+        :return The XML tree as a string, or an empty string if the inserted
+        values are not valid.
+        """
+        xml_string = ""
+        valid, lines = self.valid_values(self.values)
+        if valid:
+            values = self.values_to_dict(valid, lines)
+            values.update(self._all_values_to_dict())
+            xml_string = DictToXml(values).dict_to_tree()
+        return xml_string
 
=== modified file 'dashboard/frontend/tests/__init__.py'
--- dashboard/frontend/tests/__init__.py	2012-09-03 08:18:10 +0000
+++ dashboard/frontend/tests/__init__.py	2012-09-06 08:33:21 +0000
@@ -2,6 +2,7 @@
 from dashboard.frontend.tests.test_models import *
 from dashboard.frontend.tests.test_clientresponse import *
 from dashboard.frontend.tests.test_custom_commands import *
+from dashboard.frontend.tests.test_xml_to_dict import *
 
 
 #starts the test suite
@@ -14,4 +15,6 @@
            'LoopTests': LoopTest,
            'ClientResponseTests': ClientResponseTests,
            'JenkinsCommandTest': JenkinsCommandTest,
+           'XmlToDictTest': XmlToDictTest,
+           'DictToXmlTest': DictToXmlTest,
            }
 
=== added file 'dashboard/frontend/tests/test_xml_to_dict.py'
--- dashboard/frontend/tests/test_xml_to_dict.py	1970-01-01 00:00:00 +0000
+++ dashboard/frontend/tests/test_xml_to_dict.py	2012-09-06 08:33:21 +0000
@@ -0,0 +1,286 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+
+from django.test import TestCase
+import os
+from dashboard.lib.xml_to_dict import (
+    XmlToDict,
+    DictToXml
+)
+from dashboard.lib.xml_fields import (
+    LOOP_ELEMENT,
+    FIELDS_ELEMENT,
+    TYPE_ATTR,
+    NAME_ATTR,
+    XML_START,
+    INT_TYPE,
+    BOOL_TYPE,
+)
+
+
+# XML tags
+ROOT_TAG_OPEN = '<loop>'
+ROOT_TAG_CLOSE = '</loop>'
+FIELDS_TAG_OPEN = '<fields>'
+FIELDS_TAG_CLOSE = '</fields>'
+VALID_FIELD = '<field name="%(field_name)s">%(field_value)s</field>'
+VALID_FIELD_WITH_TYPE = ('<field name="%(field_name)s" '
+                         'type="%(field_type)s">%(field_value)s</field>')
+
+# Field names, types and values used as defaults for the tests.
+LOOP_TYPE_VAL = 'text-build'
+LOOP_NAME_VAL = 'build-test'
+BUILD_TYPE = 'build_type'
+BUILD_TYPE_VAL = 'build-android'
+REPO_QUIET = 'repo_quiet'
+REPO_QUIET_VAL = True
+BUILD_FS_IMAGE = 'build_fs_image'
+BUILD_FS_IMAGE_VAL = False
+MAKE_JOBS = 'make_jobs'
+MAKE_JOBS_VAL = 2
+
+NEWLINE = os.linesep
+# Used to create the needed dictionary for fields creation.
+# The dictionary has to be:
+# {FIELD_NAME: value, FIELD_VALUE: value [, FIELD_TYPE: value]}
+# FIELD_TYPE is optional.
+FIELD_NAME = 'field_name'
+FIELD_VALUE = 'field_value'
+FIELD_TYPE = 'field_type'
+
+FIELDS = [
+        {FIELD_NAME: BUILD_TYPE, FIELD_VALUE: BUILD_TYPE_VAL},
+        {FIELD_NAME: REPO_QUIET, FIELD_TYPE: BOOL_TYPE,
+         FIELD_VALUE: REPO_QUIET_VAL},
+        {FIELD_NAME: BUILD_FS_IMAGE, FIELD_TYPE: BOOL_TYPE,
+         FIELD_VALUE: BUILD_FS_IMAGE_VAL},
+        {FIELD_NAME: MAKE_JOBS, FIELD_TYPE: INT_TYPE,
+         FIELD_VALUE: MAKE_JOBS_VAL},
+        {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL},
+        {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL}
+]
+
+VALID_START = XML_START + ROOT_TAG_OPEN
+VALID_CLOSE = ROOT_TAG_CLOSE
+
+
+def create_xml_fields(fields_list):
+    """
+    Support functions to create the <fields><field>... hierarchy.
+
+    :param fields_list: the list of fields to create. Each field has to be
+    a dictionary with FIELD_NAME, FIELD_VALUE and optional FIELD_TYPE keys.
+    :type fields_list list
+    """
+    assert isinstance(fields_list, list)
+    fields_xml = FIELDS_TAG_OPEN
+
+    for field in fields_list:
+        if field.get(FIELD_TYPE, None) is not None:
+            fields_xml += VALID_FIELD_WITH_TYPE % field
+        else:
+            fields_xml += VALID_FIELD % field
+    fields_xml += FIELDS_TAG_CLOSE
+    return fields_xml
+
+
+class XmlToDictTest(TestCase):
+    """
+    Test class for the conversion from XML to Python dictionary.
+    The XML specification is taken from the HACKING file.
+    """
+
+    def setUp(self):
+        super(XmlToDictTest, self).setUp()
+        self.xml_string = VALID_START
+        self.xml_string += create_xml_fields(FIELDS)
+        self.xml_string += VALID_CLOSE
+        self.xml_to_dict = XmlToDict(self.xml_string)
+
+    def test_get_element_from_root(self):
+        """
+        Tests retrieval of the elements in the XML tree, but the root.
+        """
+        self.assertEqual(self.xml_to_dict.get_elements_from_root()[0].tag,
+                         FIELDS_ELEMENT)
+
+    def test_get_element_by_name_correct(self):
+        """Tests retrieving of an element with a correct name."""
+        self.assertEqual(FIELDS_ELEMENT,
+                         self.xml_to_dict.get_element_by_name(
+                             FIELDS_ELEMENT).tag)
+
+    def test_get_element_by_name_wrong(self):
+        """ Tests retrieving of an element with a wrong name."""
+        self.assertEqual(None,
+                         self.xml_to_dict.get_element_by_name('wrong'))
+
+    def test_elements_to_dict(self):
+        """
+        Tests creation of a dictionary with multiple elements.
+        """
+        expected_output = {MAKE_JOBS: MAKE_JOBS_VAL,
+                           BUILD_TYPE: BUILD_TYPE_VAL,
+                           BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL,
+                           REPO_QUIET: REPO_QUIET_VAL,
+                           NAME_ATTR: LOOP_NAME_VAL,
+                           TYPE_ATTR: LOOP_TYPE_VAL}
+        element = self.xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+        self.assertEqual(expected_output,
+                         self.xml_to_dict.element_to_dict(element))
+
+    def test_bool_true_conversion(self):
+        """
+        Tests the True bool conversion.
+        """
+        expected_out = {'a-field': True}
+        for value in ['1', 1, 'y', 'Yes', True, 'True']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: BOOL_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_bool_false_conversion(self):
+        """
+        Tests the False bool conversion.
+        """
+        expected_out = {'a-field': False}
+        for value in ['n', 0, 42, 'Yep', 'No', False, 'False', '?']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: BOOL_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_int_conversion(self):
+        """
+        Tests the int conversion.
+        """
+        expected_out = {'a-field': 42}
+        for value in [42, '42', '42           ', '   42']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: INT_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_str_conversion(self):
+        """
+        Tests the str conversion.
+        """
+        expected_out = {'a-field': '42'}
+        for value in [42, '42', '42           ', '   42']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_tree_to_dict(self):
+        """
+        Tests the conversion of a dictionary into a full XML tree.
+        """
+        expected_output = {
+            REPO_QUIET: REPO_QUIET_VAL,
+            NAME_ATTR: LOOP_NAME_VAL,
+            MAKE_JOBS: MAKE_JOBS_VAL,
+            TYPE_ATTR: LOOP_TYPE_VAL,
+            BUILD_TYPE: BUILD_TYPE_VAL,
+            BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL
+        }
+        self.assertEqual(expected_output, self.xml_to_dict.tree_to_dict())
+
+    def test_get_root_name(self):
+        """
+        Tests retrieving of the root element.
+        """
+        self.assertEqual(self.xml_to_dict.get_root(), LOOP_ELEMENT)
+
+    def test_get_root_attributes(self):
+        """
+        Tests retrieving of the root attributes.
+        """
+        self.assertEqual({}, self.xml_to_dict.get_root_attributes())
+
+
+class DictToXmlTest(TestCase):
+    """
+    Test class for the conversion from Python dictionary into XML.
+    The XML specification is taken from the HACKING file.
+    """
+
+    FIELDS_LIST = [
+            {FIELD_NAME: MAKE_JOBS, FIELD_VALUE: MAKE_JOBS_VAL},
+            {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL},
+            {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL},
+    ]
+
+    VALID_DICT = {
+        NAME_ATTR: LOOP_NAME_VAL, TYPE_ATTR: LOOP_TYPE_VAL,
+        MAKE_JOBS: str(MAKE_JOBS_VAL)
+    }
+
+    def setUp(self):
+        super(DictToXmlTest, self).setUp()
+        self.valid_xml = VALID_START
+        self.valid_xml += create_xml_fields(self.FIELDS_LIST)
+        self.valid_xml += VALID_CLOSE
+        self.dict_to_xml = DictToXml(self.VALID_DICT)
+
+    def test_dict_to_tree(self):
+        """
+        Tests dictionary to XML conversion.
+        """
+        self.assertEqual(self.valid_xml, self.dict_to_xml.dict_to_tree())
+
+    def test_dict_to_tree_with_bool(self):
+        """
+        Tests dictionary to XML conversion, with a bool inside, ElementTree
+        does not cope very well with bool type.
+        """
+        fields = [
+                {FIELD_NAME: REPO_QUIET, FIELD_VALUE: REPO_QUIET_VAL},
+                {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL},
+                {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL},
+        ]
+        dictionary = {TYPE_ATTR: LOOP_TYPE_VAL, NAME_ATTR: LOOP_NAME_VAL,
+                      REPO_QUIET: REPO_QUIET_VAL}
+        dict_2_xml = DictToXml(dictionary)
+        xml_string = VALID_START
+        xml_string += create_xml_fields(fields)
+        xml_string += VALID_CLOSE
+        self.assertEqual(xml_string, dict_2_xml.dict_to_tree())
 
=== added file 'dashboard/lib/xml_fields.py'
--- dashboard/lib/xml_fields.py	1970-01-01 00:00:00 +0000
+++ dashboard/lib/xml_fields.py	2012-09-06 08:33:21 +0000
@@ -0,0 +1,51 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+# Django settings for dashboard project.
+
+# The file contains all the necessary elements, tags and everything else
+# related to the XML representation of a chain-build.
+
+# All the XML valid elements.
+FIELD_ELEMENT = 'field'
+FIELDS_ELEMENT = 'fields'
+LOOP_ELEMENT = 'loop'
+DESCRIPTION_ELEMENT = 'description'
+
+# All the XML attributes.
+NAME_ATTR = 'name'
+TYPE_ATTR = 'type'
+
+# The valid types for element values.
+BOOL_TYPE = 'bool'
+INT_TYPE = 'int'
+STR_TYPE = 'text'
+VALID_TYPES = [BOOL_TYPE, INT_TYPE, STR_TYPE]
+
+# List of valid values considered as boolean True.
+VALID_TRUES = ['1', 'y', 'yes', 'Yes', 'True', 'true']
+
+# This is the start of the XML file. The DTD, if updated, needs to be updated
+# also in the HACKING file. This one is taken from the HACKING file.
+XML_START = '''<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE loop [
+    <!ELEMENT loop (description?,fields)>
+    <!ELEMENT description (#PCDATA)>
+    <!ELEMENT fields (field+)>
+    <!ELEMENT field (#PCDATA)>
+    <!ATTLIST field name CDATA #REQUIRED>
+    <!ATTLIST field type (text|int|bool) "text">
+]>'''
 
=== added file 'dashboard/lib/xml_to_dict.py'
--- dashboard/lib/xml_to_dict.py	1970-01-01 00:00:00 +0000
+++ dashboard/lib/xml_to_dict.py	2012-09-06 08:33:21 +0000
@@ -0,0 +1,230 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+# Django settings for dashboard project.
+
+import xml.etree.ElementTree as ET
+from dashboard.lib.xml_fields import *
+
+
+class XmlToDict(object):
+    """
+    Class to convert an XML string into a Python dictionary.
+    This applies to the XML as defined for the loop chaining.
+
+    Simple usage:
+        xml_2_dict = XmlToDict(xml_string).tree_to_dict()
+    """
+
+    def __init__(self, xml):
+        """
+        Initialize the XmlToDict class.
+
+        :param xml: The XML tree as a string.
+        :type xml str
+        """
+        assert isinstance(xml, str)
+
+        super(XmlToDict, self).__init__()
+        self.tree = ET.fromstring(xml)
+
+    def get_root(self):
+        """
+        Returns the name of the root of the XML tree.
+        :return The name of the root element.
+        """
+        return self.tree.tag
+
+    def get_root_attributes(self):
+        """
+        Returns a dictionary containing the attributes of the root element.
+
+        :return A dictionary with the attributes of the root element.
+        """
+        root_attr = {}
+        for item in self.tree.items():
+            root_attr[item[0]] = item[1]
+        return root_attr
+
+    def get_elements_from_root(self):
+        """
+        Returns the list of elements of the XML tree starting from the root.
+        :return A list with Element instances.
+        """
+        return list(self.tree)
+
+    def get_element_by_name(self, name):
+        """
+        Returns an element from the XML tree by its name.
+        :param name: the name of the element to get.
+        :type name str
+        :return An Element instance, None if not found.
+        """
+        return self.tree.find(name)
+
+    def element_to_dict(self, element):
+        """
+        Returns a dictionary representation of the provided XML element.
+
+        :param element: The Element to convert.
+        :type element Element
+        :return The dictionary representation of element.
+        """
+        assert isinstance(element, ET.Element)
+
+        element_dict = {}
+        element_tag = element.tag
+        element_text = element.text
+
+        if element_text:
+            element_text = self._check_element_text(element_text)
+
+        attributes = element.items()
+        children = list(element)
+
+        # Special case for XML 'field' tag.
+        # 'field' tag must have a value and at least 'name' attribute set.
+        if element_tag == FIELD_ELEMENT:
+            if attributes:
+                element_name = element.get(NAME_ATTR)
+                element_type = element.get(TYPE_ATTR)
+                # Convert the value into the specified type.
+                value = self.convert_to_type(element_type, element.text)
+                element_dict[element_name] = value
+        else:
+            if attributes:
+                # Other case, we store all attributes as key<>value, plus also
+                # the tag name and its value if OK.
+                # There might be name collisions if XML is not well done.
+                for attribute in attributes:
+                    element_dict[attribute[0]] = attribute[1]
+                if element_text:
+                    element_dict[element_tag] = element_text
+            elif element_text:
+                element_dict[element_tag] = element_text
+        if children:
+            for child in children:
+                element_dict.update(self.element_to_dict(child))
+        return element_dict
+
+    def _check_element_text(self, text):
+        """
+        Check that the value contained in an XML element is valid, meaning it
+        is not an empty space, a newline. In these cases, we return None since
+        we do not want to have that element in the final dictionary.
+
+        :param text: The value contained between opening and closing XML tag.
+        :type text str
+        :return None if text is empty spaces or newlines, text otherwise.
+        """
+        # We do this since when we get nested elements, there might be 'valid'
+        # characters, like newlines or empty spaces, between the opening and
+        # closing tags, but we do not want to have such fields in the resulting
+        # dictionary.
+        import os
+        text = str(text).strip()
+        if text == os.linesep or len(text) == 0:
+            text = None
+        return text
+
+    def convert_to_type(self, type, value):
+        """
+        Converts a value of an XML element into the provided type. If type is
+        None, tha value is converted into a string.
+
+        :param type: The type of the resulting value.
+        :type type str
+        :param value: The value associated with the XML element.
+        :return The value converted into the specified type.
+        """
+        converted = str(value).strip()
+        if type == BOOL_TYPE:
+            if converted in VALID_TRUES:
+                converted = True
+            else:
+                converted = False
+        elif type == INT_TYPE:
+            converted = int(converted)
+
+        return converted
+
+    def tree_to_dict(self):
+        """
+        Create a dictionary out of the XML tree.
+
+        :return A python dictionary of the XML tree.
+        """
+        tree_dict = {}
+
+        root_dict = self.get_root_attributes()
+        elements_dict = {}
+        for element in self.get_elements_from_root():
+            elements_dict.update(self.element_to_dict(element))
+
+        if root_dict:
+            tree_dict.update(root_dict)
+
+        if elements_dict:
+            if tree_dict:
+                tree_dict.update(elements_dict)
+            else:
+                tree_dict = elements_dict
+
+        return tree_dict
+
+
+class DictToXml(object):
+    """
+    Class to convert a Python dictionary into an XML string .
+
+    Simple usage:
+        dict_2_xml = DictToXml(dictionary).dict_to_tree()
+    """
+
+    def __init__(self, dictionary):
+        """
+        Initialize the DictToXml class.
+
+        :param dictionary: The dictionary to convert.
+        :type dictionary dict
+        """
+        assert isinstance(dictionary, dict)
+        super(DictToXml, self).__init__()
+        self.dictionary = dictionary
+
+    def dict_to_tree(self):
+        """
+        Create an XML tree out of the provided dictionary. The XML structure
+        is defined in the HACKING file.
+
+        :return A string with the XML representation of the dictionary.
+        """
+        dict_to_xml = XML_START
+
+        loop = ET.Element(LOOP_ELEMENT)
+        fields = ET.SubElement(loop, FIELDS_ELEMENT)
+        for key, value in self.dictionary.iteritems():
+            # TODO need to find a way to reflect the type of the data.
+            attrib = {NAME_ATTR: key}
+            field = ET.SubElement(fields, FIELD_ELEMENT, attrib)
+            # ElementTree cannot serialize boolean types.
+            field.text = str(value)
+
+        # Dump the XML and add it to the valid start with its DTD.
+        xml_dump = ET.tostring(loop, encoding="utf-8")
+        dict_to_xml += xml_dump
+
+        return dict_to_xml