rename to select url field

Author: fruitschen

select_url_field/__init__.py

@@ -0,0 +1,67 @@
+from django import forms
+from django.conf import settings
+from django.utils.encoding import force_unicode
+
+OTHER_CHOICE = '__other__'
+OTHER_CHOICE_DISPLAY = '' # 'Other:'
+
+class ChoiceWithOtherWidget(forms.MultiWidget):
+    """MultiWidget for use with ChoiceWithOtherField."""
+    def __init__(self, choices, attrs=None):
+        widgets = [
+            forms.Select(choices=choices),
+            forms.TextInput(attrs={'size':'80'})
+        ]
+        self.choices = choices
+        super(ChoiceWithOtherWidget, self).__init__(widgets, attrs=attrs)
+
+    def decompress(self, value):
+        if value:
+            choices = [c[0] for c in self.choices]
+            provided_choices, other_choice = choices[:-1], choices[-1:]
+            if value in provided_choices:
+                return [value, '']
+            else:
+                return [OTHER_CHOICE, value]
+        return ['', '']
+
+    def format_output(self, rendered_widgets):
+        """Format the output by substituting the "other" choice into the first widget."""
+        return '<div class="choice_with_other_wrapper">%s %s</div>' % \
+            (rendered_widgets[0], rendered_widgets[1])
+
+    def _media(self):
+        js_list = ['%sadmin/choice_with_other.js' % settings.STATIC_URL, ]
+        return forms.Media(js=js_list)
+    media = property(_media)
+
+
+class ChoiceWithOtherField(forms.MultiValueField):
+
+    def __init__(self, *args, **kwargs):
+        choices = list(kwargs.pop('choices'))
+        has_empty_choice = False
+        for c in choices:
+            if not c[0]:
+                has_empty_choice = True
+                break
+        if not has_empty_choice:
+            choices.insert(0, ('', '---------'))
+        choices.append((OTHER_CHOICE, OTHER_CHOICE_DISPLAY))
+        fields = [
+            forms.ChoiceField(choices=choices),
+            forms.CharField(required=False)
+        ]
+        widget = ChoiceWithOtherWidget(choices=choices)
+        self._was_required = kwargs.pop('required', True)
+        kwargs['required'] = False
+        super(ChoiceWithOtherField, self).__init__(widget=widget, fields=fields, *args, **kwargs)
+
+    def compress(self, value):
+        if self._was_required and (not value or value[0] in (None, '')):
+            raise forms.ValidationError(self.error_messages['required'])
+        if not value:
+            return ''
+
+        return value[1] #value[0] is ignored. Only ever take the value from the text field. The select menu is now just a way to correctly fill in the text field.
+

select_url_field/choice_with_other.py

@@ -0,0 +1,97 @@
+import re
+import os.path
+
+from django import forms
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
+from django.db import models
+from django.db import IntegrityError
+from django.template.defaultfilters import filesizeformat
+from django.utils.translation import ugettext_lazy as _
+from django.utils.encoding import smart_unicode
+from django.utils import importlib
+
+from select_url_field.choice_with_other import ChoiceWithOtherField
+
+class SelectURLField(models.CharField):
+    description = _("URL")
+
+    def __init__(self, verbose_name=None, name=None, **kwargs):
+        kwargs['max_length'] = kwargs.get('max_length', 200)
+        # handle choices option:
+        # from custom_site.url_choices import get_url_choices
+        # link = SelectURLField(blank=True, choices=get_url_choices)
+        self._has_choices = False
+        if 'choices' in kwargs:
+            self._has_choices = True
+            self._url_choices = kwargs.pop('choices')
+        
+        models.CharField.__init__(self, verbose_name, name, **kwargs)
+        self.validators.append(SelectURLValidator())
+
+    def formfield(self, **kwargs):
+        # As with CharField, this will cause URL validation to be performed twice
+        defaults = {
+            'form_class': SelectURLFormField,
+        }
+        defaults.update(kwargs)
+        ## when choices given, use them. 
+        ## when not, use global settings. 
+        if self._has_choices:
+            if callable(self._url_choices):
+                choices = self._url_choices()
+            else:
+                choices = self._url_choices
+        else:
+            from django.conf import settings 
+            mod_path, func_name = settings.URL_CHOICES_FUNC.rsplit('.', 1)
+            mod = importlib.import_module(mod_path)
+            choices_func = getattr(mod, func_name)        
+            choices = choices_func()
+        required = not self.blank
+        return ChoiceWithOtherField(choices=choices, required=required)
+
+
+    def to_python(self, value):
+        from django.conf import settings
+        if value:
+            domain = getattr(settings, 'SITE_DOMAIN', '')
+            if domain:
+                domain_pattern = r'^(?:http|ftp)s?://' + domain
+                domain_regex = re.compile(domain_pattern, re.IGNORECASE)
+                #match = domain_regex.search(value)
+                value = domain_regex.sub('', value)
+        return super(SelectURLField, self).to_python(value)
+
+#We need IxxyURLField so this is backwards compatible
+IxxyURLField = SelectURLField
+
+class SelectURLValidator(object):
+    code = 'invalid'
+    regex = re.compile(r'(?:[/?]\S+)$', re.IGNORECASE)
+
+    def __init__(self):
+        self.url_validator = URLValidator()
+        
+    def __call__(self, value):
+        try:
+            #OK if it's a valid url 
+            self.url_validator(value)
+        except ValidationError, e:
+            #Not a valid url, see it's a path 
+            if not self.regex.search(smart_unicode(value)):
+                raise e
+
+class SelectURLFormField(forms.CharField):
+    default_error_messages = {
+        'invalid': _(u'Enter a valid URL.'),
+    }
+
+    def __init__(self, max_length=None, min_length=None, *args, **kwargs):
+        super(SelectURLFormField, self).__init__(max_length, min_length, *args, **kwargs)
+        self.validators.append(SelectURLValidator())
+
+
+from south.modelsinspector import add_introspection_rules
+add_introspection_rules([], ["^select_url_field\.fields\.IxxyURLField"])
+add_introspection_rules([], ["^select_url_field\.fields\.SelectURLField"])

select_url_field/fields.py

@@ -0,0 +1,31 @@
+(function($) {
+    var OTHER_CHOICE = '__other__'; //See
+    $(function(){
+        var wrappers = $('.choice_with_other_wrapper');
+        wrappers.each(function(){
+            var select = $('select', this);
+            var text_input = $('input', this);
+            select.change(function(){
+                if(select.val() == OTHER_CHOICE){
+                    ;
+                }else{
+                    text_input.val(select.val());
+                }
+            });
+            text_input.keyup(function(){
+                var match = false;
+                $(select).find('option').each(function(){
+                    if($(this).attr('value') == text_input.val()){
+                        match = true;
+                    }
+                })
+                if(!match){
+                    select.val(OTHER_CHOICE);
+                }else{
+                    select.val(text_input.val());
+                }
+            });
+            select.change();
+        })
+    })
+})(django.jQuery);