# HG changeset patch
# User Sylvain Thénault <sylvain.thenault@logilab.fr>
# Date 1244638308 -7200
# Node ID a7ea618e5478ad0cdebc8b94d95c9bf08719eb7c
# Parent  089d1705c89cfe121dbc6d0c355261cc853ce6f5
don't set select widget when a vocabulary widget is already specified on the field class

diff -r 089d1705c89c -r a7ea618e5478 web/formfields.py
--- a/web/formfields.py	Wed Jun 10 12:50:05 2009 +0200
+++ b/web/formfields.py	Wed Jun 10 14:51:48 2009 +0200
@@ -101,10 +101,10 @@
         return self.__unicode__().encode('utf-8')
 
     def init_widget(self, widget):
-        if widget is None and self.choices:
-            widget = Select()
         if widget is not None:
             self.widget = widget
+        elif self.choices and not self.widget.vocabulary_widget:
+            self.widget = Select()
         if isinstance(self.widget, type):
             self.widget = self.widget()
 
diff -r 089d1705c89c -r a7ea618e5478 web/formwidgets.py
--- a/web/formwidgets.py	Wed Jun 10 12:50:05 2009 +0200
+++ b/web/formwidgets.py	Wed Jun 10 14:51:48 2009 +0200
@@ -22,6 +22,8 @@
     # automatically set id and tabindex attributes ?
     setdomid = True
     settabindex = True
+    # does this widget expect a vocabulary
+    vocabulary_widget = False
 
     def __init__(self, attrs=None, setdomid=None, settabindex=None):
         if attrs is None:
@@ -171,6 +173,8 @@
 
 class Select(FieldWidget):
     """<select>, for field having a specific vocabulary"""
+    vocabulary_widget = True
+
     def __init__(self, attrs=None, multiple=False):
         super(Select, self).__init__(attrs)
         self._multiple = multiple
@@ -203,6 +207,7 @@
     input will be generated for each possible value.
     """
     type = 'checkbox'
+    vocabulary_widget = True
 
     def render(self, form, field):
         name, curvalues, attrs = self._render_attrs(form, field)
diff -r 089d1705c89c -r a7ea618e5478 web/test/unittest_formfields.py
--- a/web/test/unittest_formfields.py	Wed Jun 10 12:50:05 2009 +0200
+++ b/web/test/unittest_formfields.py	Wed Jun 10 14:51:48 2009 +0200
@@ -6,13 +6,13 @@
 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
 """
 
-from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.testlib import TestCase, unittest_main, mock_object as mock
 
 from yams.constraints import StaticVocabularyConstraint, SizeConstraint
 
 from cubicweb.devtools import TestServerConfiguration
 from cubicweb.devtools.testlib import EnvBasedTC
-from cubicweb.web.formwidgets import PasswordInput, TextArea, Select
+from cubicweb.web.formwidgets import PasswordInput, TextArea, Select, Radio
 from cubicweb.web.formfields import *
 from cubicweb.web.views.forms import EntityFieldsForm
 
@@ -21,91 +21,104 @@
 config = TestServerConfiguration('data')
 config.bootstrap_cubes()
 schema = config.load_schema()
-state_schema = schema['State']
-cwuser_schema = schema['CWUser']
-file_schema = schema['File']
-salesterm_schema = schema['Salesterm']
 
 class GuessFieldTC(TestCase):
 
     def test_state_fields(self):
-        title_field = guess_field(state_schema, schema['name'])
+        title_field = guess_field(schema['State'], schema['name'])
         self.assertIsInstance(title_field, StringField)
         self.assertEquals(title_field.required, True)
 
-#         synopsis_field = guess_field(state_schema, schema['synopsis'])
+#         synopsis_field = guess_field(schema['State'], schema['synopsis'])
 #         self.assertIsInstance(synopsis_field, StringField)
 #         self.assertIsInstance(synopsis_field.widget, TextArea)
 #         self.assertEquals(synopsis_field.required, False)
 #         self.assertEquals(synopsis_field.help, 'an abstract for this state')
 
-        description_field = guess_field(state_schema, schema['description'])
+        description_field = guess_field(schema['State'], schema['description'])
         self.assertIsInstance(description_field, RichTextField)
         self.assertEquals(description_field.required, False)
         self.assertEquals(description_field.format_field, None)
 
-        description_format_field = guess_field(state_schema, schema['description_format'])
+        description_format_field = guess_field(schema['State'], schema['description_format'])
         self.assertEquals(description_format_field, None)
 
-        description_format_field = guess_field(state_schema, schema['description_format'], skip_meta_attr=False)
+        description_format_field = guess_field(schema['State'], schema['description_format'], skip_meta_attr=False)
         self.assertEquals(description_format_field.internationalizable, True)
         self.assertEquals(description_format_field.sort, True)
         self.assertEquals(description_format_field.initial(None), 'text/rest')
 
-
-#         wikiid_field = guess_field(state_schema, schema['wikiid'])
+#         wikiid_field = guess_field(schema['State'], schema['wikiid'])
 #         self.assertIsInstance(wikiid_field, StringField)
 #         self.assertEquals(wikiid_field.required, False)
 
 
     def test_cwuser_fields(self):
-        upassword_field = guess_field(cwuser_schema, schema['upassword'])
+        upassword_field = guess_field(schema['CWUser'], schema['upassword'])
         self.assertIsInstance(upassword_field, StringField)
         self.assertIsInstance(upassword_field.widget, PasswordInput)
         self.assertEquals(upassword_field.required, True)
 
-        last_login_time_field = guess_field(cwuser_schema, schema['last_login_time'])
+        last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time'])
         self.assertIsInstance(last_login_time_field, DateTimeField)
         self.assertEquals(last_login_time_field.required, False)
 
-        in_group_field = guess_field(cwuser_schema, schema['in_group'])
+        in_group_field = guess_field(schema['CWUser'], schema['in_group'])
         self.assertIsInstance(in_group_field, RelationField)
         self.assertEquals(in_group_field.required, True)
         self.assertEquals(in_group_field.role, 'subject')
         self.assertEquals(in_group_field.help, 'groups grant permissions to the user')
 
-        owned_by_field = guess_field(cwuser_schema, schema['owned_by'], 'object')
+        owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object')
         self.assertIsInstance(owned_by_field, RelationField)
         self.assertEquals(owned_by_field.required, False)
         self.assertEquals(owned_by_field.role, 'object')
 
 
     def test_file_fields(self):
-        data_format_field = guess_field(file_schema, schema['data_format'])
+        data_format_field = guess_field(schema['File'], schema['data_format'])
         self.assertEquals(data_format_field, None)
-        data_encoding_field = guess_field(file_schema, schema['data_encoding'])
+        data_encoding_field = guess_field(schema['File'], schema['data_encoding'])
         self.assertEquals(data_encoding_field, None)
 
-        data_field = guess_field(file_schema, schema['data'])
+        data_field = guess_field(schema['File'], schema['data'])
         self.assertIsInstance(data_field, FileField)
         self.assertEquals(data_field.required, True)
         self.assertIsInstance(data_field.format_field, StringField)
         self.assertIsInstance(data_field.encoding_field, StringField)
 
     def test_constraints_priority(self):
-        salesterm_field = guess_field(salesterm_schema, schema['reason'])
+        salesterm_field = guess_field(schema['Salesterm'], schema['reason'])
         constraints = schema['reason'].rproperty('Salesterm', 'String', 'constraints')
         self.assertEquals([c.__class__ for c in constraints],
                           [SizeConstraint, StaticVocabularyConstraint])
         self.assertIsInstance(salesterm_field.widget, Select)
 
+
+    def test_bool_field_base(self):
+        field = guess_field(schema['CWAttribute'], schema['indexed'])
+        self.assertIsInstance(field, BooleanField)
+        self.assertEquals(field.required, False)
+        self.assertEquals(field.initial(None), None)
+        self.assertIsInstance(field.widget, Radio)
+        self.assertEquals(field.vocabulary(mock(req=mock(_=unicode))),
+                          [(u'yes', '1'), (u'no', '')])
+
+    def test_bool_field_explicit_choices(self):
+        field = guess_field(schema['CWAttribute'], schema['indexed'],
+                            choices=[(u'maybe', '1'), (u'no', '')])
+        self.assertIsInstance(field.widget, Radio)
+        self.assertEquals(field.vocabulary(mock(req=mock(_=unicode))),
+                          [(u'maybe', '1'), (u'no', '')])
+
+
 class MoreFieldsTC(EnvBasedTC):
     def test_rtf_format_field(self):
         req = self.request()
         req.use_fckeditor = lambda: False
         e = self.etype_instance('State')
         form = EntityFieldsForm(req, entity=e)
-        description_field = guess_field(state_schema, schema['description'])
+        description_field = guess_field(schema['State'], schema['description'])
         description_format_field = description_field.get_format_field(form)
         self.assertEquals(description_format_field.internationalizable, True)
         self.assertEquals(description_format_field.sort, True)