source: ralphm-patches/pubsub-forms.patch @ 25:e467ff96b011

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):
+        kwargs = fieldDict.copy()
 
-        if 'type' in dictionary:
-            kwargs['fieldType'] = dictionary['type']
+        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 +417 @@
         """
         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 +430 @@
         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. 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}.
+
+        @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'] = 'text-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 +582 @@
             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. The field definition in C{fieldDefs} is used to check the field
+        type. Unknown fields are ignored.
+
+        If the field type is C{None} (when not set by the receiving entity),
+        C{'text-single'} is assumed, as this is the default value.
+
+        @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:
+                if field.fieldType is None:
+                    field.fieldType = fieldDefs[name]['type']
+                elif field.fieldType != fieldDefs[name]['type']:
+                    raise TypeError("Field type for %r is %r, expected %r" %
+                                    (name,
+                                     field.fieldType,
+                                     fieldDefs[name]['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

@@ -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

@@ -782 +782 @@
         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_makeFieldsJID(self):
+        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_makeFieldsJIDMulti(self):
+        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_getValues(self):
         """
         Each named field is represented in the values, keyed by name.