source: ralphm-patches/pubsub-forms.patch @ 26:59ace4d1df68

wokkel/data_form.py

@@ -76 +76 @@
             option['label'] = self.label
         return option
 
+
     @staticmethod
     def fromElement(element):
         valueElements = list(domish.generateElementsQNamed(element.children,
@@ -212 +213 @@
 
         if self.values:
             if (self.fieldType not in ('hidden', 'jid-multi', 'list-multi',
-                                 'text-multi') and
+                                       'text-multi') and
                 len(self.values) > 1):
                 raise TooManyValuesError()
 
@@ -233 +234 @@
 
             self.values = newValues
 
+
     def toElement(self, asForm=False):
         """
         Return the DOM representation of this Field.
@@ -322 +324 @@
 
 
     @staticmethod
-    def fromDict(dictionary):
-        kwargs = dictionary.copy()
+    def fromDict(fieldDict):
+        """
+        Create a field from a dictionary.
 
-        if 'type' in dictionary:
-            kwargs['fieldType'] = dictionary['type']
+        This is a short hand for passing arguments directly on Field object
+        creation. The field type is represented by the C{'type'} key. For
+        C{'options'} the value is not a list of L{Option}s, but a dictionary
+        keyed by value, with an optional label as value.
+        """
+        kwargs = fieldDict.copy()
+
+        if 'type' in fieldDict:
+            kwargs['fieldType'] = fieldDict['type']
             del kwargs['type']
 
-        if 'options' in dictionary:
+        if 'options' in fieldDict:
             options = []
-            for value, label in dictionary['options'].iteritems():
+            for value, label in fieldDict['options'].iteritems():
                 options.append(Option(value, label))
             kwargs['options'] = options
 
@@ -415 +425 @@
         """
         Add a field to this form.
 
-        Fields are added in order, and L{fields} is a dictionary of the
+        Fields are added in order, and C{fields} is a dictionary of the
         named fields, that is kept in sync only if this method is used for
         adding new fields. Multiple fields with the same name are disallowed.
         """
@@ -428 +438 @@
         self.fieldList.append(field)
 
 
+    def removeField(self, field):
+        """
+        Remove a field from this form.
+        """
+        self.fieldList.remove(field)
+
+        if field.var is not None:
+            del self.fields[field.var]
+
+
+    def makeFields(self, values, fieldDefs=None, filterUnknown=True):
+        """
+        Create fields from values and add them to this form.
+
+        This creates fields from a mapping of name to value(s) and adds them to
+        this form. It is typically used for generating outgoing forms.
+
+        If C{fieldDefs} is not C{None}, this is used to fill in
+        additional properties of fields, like the field types, labels and
+        possible options.
+
+        If C{filterUnknown} is C{True} and C{fieldDefs} is not C{None}, fields
+        will only be created from C{values} with a corresponding entry in
+        C{fieldDefs}.
+
+        If the field type is unknown, the field type is derived from the field
+        value. For single values, if the value is a C{bool}, C{'boolean'} s
+        used, for L{JID} C{'jid-single'}, and C{'text-single'} otherwise. For
+        multiple values, if the first item is a L{JID} C{'jid-multi'} is used.
+        Otherwise C{'list-multi'}.
+
+        Note that the values are used as given, no type coersion or checking
+        is performed. Use L{typeCheck} to check types and coerce values of
+        fields added to a form.
+
+        @param values: Values to create fields from.
+        @type values: C{dict}
+
+        @param fieldDefs: Field definitions as a dictionary. See
+            L{wokkel.iwokkel.IPubSubService.getConfigurationOptions}
+        @type fieldDefs: C{dict}
+
+        @param filterUnknown: If C{True}, ignore fields that are not in
+            C{fieldDefs}.
+        @type filterUnknown: C{bool}
+        """
+        for name, value in values.iteritems():
+            fieldDict = {'var': name}
+
+            if fieldDefs is not None:
+                if name in fieldDefs:
+                    fieldDict.update(fieldDefs[name])
+                elif filterUnknown:
+                    continue
+
+            if isinstance(value, list):
+                fieldDict['values'] = value
+                if 'type' not in fieldDict:
+                    if value and hasattr(value[0], 'full'):
+                        fieldDict['type'] = 'jid-multi'
+                    else:
+                        fieldDict['type'] = 'list-multi'
+            else:
+                fieldDict['value'] = value
+                if 'type' not in fieldDict:
+                    if hasattr(value, 'full'):
+                        fieldDict['type'] = 'jid-single'
+                    elif isinstance(value, bool):
+                        fieldDict['type'] = 'boolean'
+
+            self.addField(Field.fromDict(fieldDict))
+
+
     def toElement(self):
+        """
+        Return the DOM representation of this Form.
+
+        @rtype: L{domish.Element}
+        """
         form = domish.Element((NS_X_DATA, 'x'))
         form['type'] = self.formType
 
@@ -516 +604 @@
             values[name] = value
 
         return values
+
+
+    def typeCheck(self, fieldDefs, filterUnknown=False):
+        """
+        Check values of fields according to the field definition.
+
+        This method walks all named fields to check their values against their
+        type, and is typically used for forms received from other entities.The
+        field definition in C{fieldDefs} is used to check the field type.
+
+        If C{filterUnknown} is C{True}, fields that are not present in
+        C{fieldDefs} are removed from the form.
+
+        If the field type is C{None} (when not set by the sending entity),
+        the type from the field definitition is used, or C{'text-single'} if
+        that is not set.
+
+        @param fieldDefs: Field definitions as a dictionary. See
+            L{wokkel.iwokkel.IPubSubService.getConfigurationOptions}
+        @type fieldDefs: C{dict}
+
+        @param filterUnknown: If C{True}, remove fields that are not in
+            C{fieldDefs}.
+        @type filterUnknown: C{bool}
+        """
+
+        filtered = []
+
+        for name, field in self.fields.iteritems():
+            if name in fieldDefs:
+                fieldDef = fieldDefs[name]
+                if 'type' not in fieldDef:
+                    fieldDef['type'] = 'text-single'
+
+                if field.fieldType is None:
+                    field.fieldType = fieldDef['type']
+                elif field.fieldType != fieldDef['type']:
+                    raise TypeError("Field type for %r is %r, expected %r" %
+                                    (name,
+                                     field.fieldType,
+                                     fieldDef['type']))
+                else:
+                    # Field type is correct
+                    pass
+                field.typeCheck()
+            elif filterUnknown:
+                filtered.append(field)
+            else:
+                # Unknown field, not filtering
+                pass
+
+        for field in filtered:
+            self.removeField(field)

wokkel/pubsub.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_pubsub -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) 2003-2010 Ralph Meijer
 # See LICENSE for details.
 
 """
@@ -1012 +1012 @@
             return None
 
 
-    def _makeFields(self, options, values):
-        fields = []
-        for name, value in values.iteritems():
-            if name not in options:
-                continue
-
-            option = {'var': name}
-            option.update(options[name])
-            if isinstance(value, list):
-                option['values'] = value
-            else:
-                option['value'] = value
-            fields.append(data_form.Field.fromDict(option))
-        return fields
-
-
     def _formFromConfiguration(self, resource, values):
-        options = resource.getConfigurationOptions()
-        fields = self._makeFields(options, values)
+        fieldDefs = resource.getConfigurationOptions()
         form = data_form.Form(formType="form",
-                              formNamespace=NS_PUBSUB_NODE_CONFIG,
-                              fields=fields)
-
+                              formNamespace=NS_PUBSUB_NODE_CONFIG)
+        form.makeFields(values, fieldDefs)
         return form
 
 

wokkel/test/test_data_form.py

@@ -787 +787 @@
         self.assertRaises(data_form.Error, form.addField, field2)
 
 
+    def test_removeField(self):
+        """
+        A removed field should not occur in fieldList.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field('fixed', value='Section 1')
+        form.addField(field)
+        form.removeField(field)
+        self.assertNotIn(field, form.fieldList)
+
+
+    def test_removeFieldNamed(self):
+        """
+        A removed named field should not occur in fields.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field(var='test', value='test1')
+        form.addField(field)
+        form.removeField(field)
+        self.assertNotIn('test', form.fields)
+
+
+    def test_makeField(self):
+        """
+        Fields can be created from a dict of values and a dict of field defs.
+        """
+        fieldDefs = {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"},
+                "pubsub#creator":
+                    {"type": "jid-single",
+                     "label": "The JID of the node creator"},
+                "pubsub#description":
+                    {"type": "text-single",
+                     "label": "A description of the node"},
+                "pubsub#owner":
+                    {"type": "jid-single",
+                     "label": "Owner of the node"},
+                }
+        values = {'pubsub#deliver_payloads': '0',
+                  'pubsub#persist_items': True,
+                  'pubsub#description': 'a great node',
+                  'pubsub#owner': jid.JID('user@example.org'),
+                  'x-myfield': ['a', 'b']}
+
+        form = data_form.Form('submit')
+        form.makeFields(values, fieldDefs)
+
+        # Check that the expected fields have been created
+        self.assertIn('pubsub#deliver_payloads', form.fields)
+        self.assertIn('pubsub#persist_items', form.fields)
+        self.assertIn('pubsub#description', form.fields)
+        self.assertIn('pubsub#owner', form.fields)
+
+        # This field is not created because there is no value for it.
+        self.assertNotIn('pubsub#creator', form.fields)
+
+        # This field is not created because it does not appear in fieldDefs
+        self.assertNotIn('x-myfield', form.fields)
+
+        # Check properties the created fields
+        self.assertEqual('boolean',
+                         form.fields['pubsub#deliver_payloads'].fieldType)
+        self.assertEqual('0',
+                         form.fields['pubsub#deliver_payloads'].value)
+        self.assertEqual('Deliver payloads with event notifications',
+                         form.fields['pubsub#deliver_payloads'].label)
+        self.assertEqual(True,
+                         form.fields['pubsub#persist_items'].value)
+
+
+
+
+    def test_makeFieldsUnknownTypeJID(self):
+        """
+        Without type, a single JID value sets field type jid-single.
+        """
+        values = {'pubsub#creator': jid.JID('user@example.org')}
+        form = data_form.Form('result')
+        form.makeFields(values)
+        field = form.fields['pubsub#creator']
+        self.assertEqual('jid-single', field.fieldType)
+
+
+    def test_makeFieldsUnknownTypeJIDMulti(self):
+        """
+        Without type, multiple JID values sets field type jid-multi.
+        """
+        values = {'pubsub#contact': [jid.JID('user@example.org'),
+                                     jid.JID('other@example.org')]}
+        form = data_form.Form('result')
+        form.makeFields(values)
+        field = form.fields['pubsub#contact']
+        self.assertEqual('jid-multi', field.fieldType)
+
+
+    def test_makeFieldsUnknownTypeBoolean(self):
+        """
+        Without type, a boolean value sets field type boolean.
+        """
+        values = {'pubsub#persist_items': True}
+        form = data_form.Form('result')
+        form.makeFields(values)
+        field = form.fields['pubsub#persist_items']
+        self.assertEqual('boolean', field.fieldType)
+
+
+    def test_makeFieldsUnknownTypeListMulti(self):
+        """
+        Without type, multiple values sets field type list-multi.
+        """
+        values = {'pubsub#show-values': ['chat', 'online', 'away']}
+        form = data_form.Form('result')
+        form.makeFields(values)
+        field = form.fields['pubsub#show-values']
+        self.assertEqual('list-multi', field.fieldType)
+
+
     def test_getValues(self):
         """
         Each named field is represented in the values, keyed by name.
@@ -834 +956 @@
         form = data_form.Form('submit', fields=fields)
         values = form.getValues()
         self.assertEqual({'features': 'news'}, values)
+
+
+    def test_typeCheckKnownFieldChecked(self):
+        """
+        Known fields are type checked.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field(var='pubsub#description',
+                                      value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckKnownFieldNoType(self):
+        """
+        Known fields without a type get the type of the field definition.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field(None, var='pubsub#description',
+                                            value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual('text-single', field.fieldType)
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckWrongFieldType(self):
+        """
+        A field should have the same type as the field definition.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+
+        self.assertRaises(TypeError, form.typeCheck, fieldDefs)
+        self.assertEqual([], checked)
+
+
+    def test_typeCheckDefaultTextSingle(self):
+        """
+        If a field definition has no type, use text-single.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('text-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckUnknown(self):
+        """
+        Unkown fields are not checked, but not removed if filterUnknown False.
+        """
+        checked = []
+        fieldDefs = {}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs, filterUnknown=False)
+
+        self.assertIn('pubsub#description', form.fields)
+        self.assertEqual([], checked)
+
+
+    def test_typeCheckUnknownRemoved(self):
+        """
+        Unkown fields are not checked, and removed if filterUnknown True.
+        """
+        checked = []
+        fieldDefs = {}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs, filterUnknown=True)
+
+        self.assertNotIn('pubsub#description', form.fields)
+        self.assertEqual([], checked)
+
+