def test_custom_comma_splitter(self):
     self.assertEqual(parse_tags("   Cued Speech "), ["Cued Speech"])
     self.assertEqual(parse_tags(" ,Cued Speech, "), ["Cued Speech"])
     self.assertEqual(parse_tags("Cued Speech"), ["Cued Speech"])
     self.assertEqual(
         parse_tags("Cued Speech, dictionary"), ["Cued Speech", "dictionary"]
     )

 def test_with_comma_delimited_multiple_words_disabled_space_split(self, mocked_settings):
     mocked_settings.TAGGIT_ENABLE_SPACE_SPLIT_IF_NOT_QUOTES = False
     tools.assert_equals(parse_tags(',one'), [u'one'])
     tools.assert_equals(parse_tags(',one two'), [u'one two'])
     tools.assert_equals(parse_tags(',one two three'), [u'one two three'])
     tools.assert_equals(parse_tags('a one, a-two and a-three'),
         [u'a one', u'a-two and a-three'])

 def test_tags_with_double_quotes_can_contain_commas(self):
     """
     Double quotes can contain commas
     """
     self.assertEqual(parse_tags('a-one "a-two, and a-three"'),
         [u'a-one', u'a-two, and a-three'])
     self.assertEqual(parse_tags('"two", one, one, two, "one"'),
         [u'one', u'two'])

 def test_with_simple_space_delimited_tags(self):
     """
     Test with simple space-delimited tags.
     """
     self.assertEqual(parse_tags('one'), [u'one'])
     self.assertEqual(parse_tags('one two'), [u'one', u'two'])
     self.assertEqual(parse_tags('one two three'), [u'one', u'three', u'two'])
     self.assertEqual(parse_tags('one one two two'), [u'one', u'two'])

 def test_with_simple_space_delimited_tags(self):
     """
     Test with simple space-delimited tags.
     """
     self.assertEqual(parse_tags("one"), ["one"])
     self.assertEqual(parse_tags("one two"), ["one", "two"])
     self.assertEqual(parse_tags("one two three"), ["one", "three", "two"])
     self.assertEqual(parse_tags("one one two two"), ["one", "two"])

 def test_with_comma_delimited_multiple_words(self):
     """
     Test with comma-delimited multiple words.
     An unquoted comma in the input will trigger this.
     """
     self.assertEqual(parse_tags(",one"), ["one"])
     self.assertEqual(parse_tags(",one two"), ["one two"])
     self.assertEqual(parse_tags(",one two three"), ["one two three"])
     self.assertEqual(parse_tags("a-one, a-two and a-three"), ["a-one", "a-two and a-three"])

 def test_with_double_quoted_multiple_words(self):
     """
     Test with double-quoted multiple words.
     A completed quote will trigger this.  Unclosed quotes are ignored.
     """
     self.assertEqual(parse_tags('"one'), ["one"])
     self.assertEqual(parse_tags('"one two'), ["one", "two"])
     self.assertEqual(parse_tags('"one two three'), ["one", "three", "two"])
     self.assertEqual(parse_tags('"one two"'), ["one two"])
     self.assertEqual(parse_tags('a-one "a-two and a-three"'), ["a-one", "a-two and a-three"])

    def clean_expertise(self):
        """Enforce expertise as a subset of interests"""
        # bug 709938 - don't assume interests passed validation
        interests = set(parse_tags(self.cleaned_data.get("interests", "")))
        expertise = set(parse_tags(self.cleaned_data["expertise"]))

        if len(expertise) > 0 and not expertise.issubset(interests):
            raise forms.ValidationError(_("Areas of expertise must be a " "subset of interests"))

        return self.cleaned_data["expertise"]

 def test_with_comma_delimited_multiple_words(self):
     """
     Test with comma-delimited multiple words.
     An unquoted comma in the input will trigger this.
     """
     self.assertEqual(parse_tags(',one'), [u'one'])
     self.assertEqual(parse_tags(',one two'), [u'one two'])
     self.assertEqual(parse_tags(',one two three'), [u'one two three'])
     self.assertEqual(parse_tags('a-one, a-two and a-three'),
         [u'a-one', u'a-two and a-three'])

 def test_with_double_quoted_multiple_words(self):
     """
     Test with double-quoted multiple words.
     A completed quote will trigger this.  Unclosed quotes are ignored.
     """
     tools.assert_equals(parse_tags('"one'), [u'one'])
     tools.assert_equals(parse_tags('"one two'), [u'one', u'two'])
     tools.assert_equals(parse_tags('"one two three'), [u'one', u'three', u'two'])
     tools.assert_equals(parse_tags('"one two"'), [u'one two'])
     tools.assert_equals(parse_tags('a-one "a-two and a-three"'),
         [u'a-one', u'a-two and a-three'])

    def clean_expertise(self):
        """Enforce expertise as a subset of interests"""
        cleaned_data = self.cleaned_data

        interests = set(parse_tags(cleaned_data['interests']))
        expertise = set(parse_tags(cleaned_data['expertise']))

        if len(expertise) > 0 and not expertise.issubset(interests):
            raise forms.ValidationError(_("Areas of expertise must be a " 
                "subset of interests"))

        return cleaned_data['expertise']

 def render(self, name, value, attrs=None):
     if value is not None:
         if isinstance(value, basestring):
             value = parse_tags(value)
         else:
             value = edit_string_for_tags([o.tag for o in value.select_related("tag")])
     return super(TagWidget, self).render(name, value, attrs)

    def search(self):
        # First, store the SearchQuerySet received from other processing.
        if self.cleaned_data['q']:
            sqs = super(objectSearchForm, self).search()
        else:
            sqs= SearchQuerySet().exclude(draft=True)
  
        if not self.is_valid():
            return self.no_query_found()
        # Check to see if a start_date was chosen.
        if self.cleaned_data['tags']:
            sqs = sqs.filter(tags=parse_tags(self.cleaned_data['tags']))


#        if 'start_date' in self.cleaned_data:
#            sqs = sqs.filter(created__gte=self.cleaned_data['start_date'])

        # Check to see if an end_date was chosen.
#        if 'end_date' in self.cleaned_data:
#            sqs = sqs.filter(created=self.cleaned_data['end_date'])

        if not self.cleaned_data['sort'] or self.cleaned_data['sort'] == "votes":
            sqs = sqs.order_by('-ratingSortBest')
        elif self.cleaned_data['sort'] == "new":
            sqs = sqs.order_by('-created')

        return sqs

	def clean(self, value):
		value = super(TagField, self).clean(value)
		value = ','.join(SIO(value))
		try:
			return parse_tags(value)
		except ValueError:
			raise forms.ValidationError(_("Please provide a comma-separated list of tags."))

    def read_csv(source, csv_stream):
        """
        Reads metadata from a CSV for a specified source name.
        """
        if not isinstance(source, Source):
            source = Source.objects.get(name=source)

        from csvkit import CSVKitReader
        rows = list(CSVKitReader(csv_stream, delimiter='\t'))
        fields = dict(enumerate(rows[0]))

        errors = []
        for row in rows[1:]:
            try:
                data = {fields[idx]: value for idx, value in enumerate(row)}
                tags = data.pop('tags', None)
                dataset = Dataset(**data)
                dataset.source = source
                dataset.save()

                if tags:
                    dataset.tags.add(*parse_tags(tags))
            except Exception, e:
                logger.exception('Cannot import a dataset from CSV')
                errors.append(repr(e))

    def tag_all(self, request, queryset):
        """
        Tag all selected requests with given tags

        """
        opts = self.model._meta
        # Check that the user has change permission for the actual model
        if not self.has_change_permission(request):
            raise PermissionDenied

        # User has already chosen the other req
        if request.POST.get('tags'):
            tags = parse_tags(request.POST.get('tags'))
            for obj in queryset:
                obj.tags.add(*tags)
                obj.save()
            self.message_user(request, _("Successfully added tags to requests"))
            # Return None to display the change list page again.
            return None

        context = {
            'opts': opts,
            'queryset': queryset,
            'media': self.media,
            'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
            'applabel': opts.app_label
        }

        # Display the confirmation page
        return TemplateResponse(request, 'foirequest/admin_tag_all.html',
            context, current_app=self.admin_site.name)

 def save(self, user):
     artwork, created = Artwork.objects.get_or_create(
         name=self.cleaned_data['artwork_name'],
         kind=self.cleaned_data['artwork_kind'],
         creator=self.cleaned_data['artwork_creator'],
         year=self.cleaned_data['artwork_year'],
     )
     if artwork.kind == 'show':
         # Allow unlimited reviews:
         review, created = Review.objects.get_or_create(
             pk=self.cleaned_data['review_id'],
             user=user,
             artwork=artwork,
             season=self.cleaned_data['artwork_season'],
             episode=self.cleaned_data['artwork_episode'],
         )
     else:
         review, created = Review.objects.get_or_create(
             user=user,
             artwork=artwork,
         )
     review.spider_quantity = self.cleaned_data['spider_quantity']
     review.summary = self.cleaned_data['summary']
     review.spider_quality.set(
         *parse_tags(self.cleaned_data['spider_quality'])
     )
     review.save()
     return review

def profile_edit(request, username):
    """View and edit user profile"""
    profile = get_object_or_404(UserProfile, user__username=username)
    if not profile.allows_editing_by(request.user):
        return HttpResponseForbidden()

    # Map of form field names to tag namespaces
    field_to_tag_ns = (
        ('interests', 'profile:interest:'),
        ('expertise', 'profile:expertise:')
    )

    if request.method != "POST":

        initial = dict(email=profile.user.email)

        # Load up initial websites with either user data or required base URL
        for name, meta in UserProfile.website_choices:
            val = profile.websites.get(name, '') or meta['prefix']
            initial['websites_%s' % name] = val

        # Form fields to receive tags filtered by namespace.
        for field, ns in field_to_tag_ns:
            initial[field] = ', '.join(t.name.replace(ns, '')
                                       for t in profile.tags.all_ns(ns))

        # Finally, set up the form.
        form = UserProfileEditForm(instance=profile, initial=initial)

    else:
        form = UserProfileEditForm(request.POST, request.FILES,
                                   instance=profile)
        if form.is_valid():
            profile_new = form.save(commit=False)

            # Gather up all websites defined by the model, save them.
            sites = dict()
            for name, meta in UserProfile.website_choices:
                field_name = 'websites_%s' % name
                field_value = form.cleaned_data.get(field_name, '')
                if field_value:
                    sites[name] = field_value
            profile_new.websites = sites

            # Save the profile record now, since the rest of this deals with
            # related resources...
            profile_new.save()

            # Update tags from form fields
            for field, tag_ns in field_to_tag_ns:
                tags = [t.lower() for t in parse_tags(
                                            form.cleaned_data.get(field, ''))]
                profile_new.tags.set_ns(tag_ns, *tags)

            return HttpResponseRedirect(reverse(
                    'devmo.views.profile_view', args=(profile.user.username,)))

    return jingo.render(request, 'devmo/profile_edit.html', dict(
        profile=profile, form=form, INTEREST_SUGGESTIONS=INTEREST_SUGGESTIONS
    ))

    def clean_tags(self):
        """
        Validate the tags ensuring we have no case-sensitive duplicates.
        """
        tags = self.cleaned_data['tags']
        cleaned_tags = []

        if tags:
            for tag in parse_tags(tags):
                # Note: The exact match query doesn't work correctly with
                # MySQL with regards to case-sensitivity. If we move to
                # Postgresql in the future this code may need to change.
                doc_tag = (DocumentTag.objects.filter(name__exact=tag)
                                              .values_list('name', flat=True))

                # Write a log we can grep to help find pre-existing duplicate
                # document tags for cleanup.
                if len(doc_tag) > 1:
                    log.warn('Found duplicate document tags: %s' % doc_tag)

                if doc_tag:
                    if doc_tag[0] != tag and doc_tag[0].lower() == tag.lower():
                        # The tag differs only by case. Do not add a new one,
                        # add the existing one.
                        cleaned_tags.append(doc_tag[0])
                        continue

                cleaned_tags.append(tag)

        return ' '.join([u'"%s"' % t for t in cleaned_tags])

 def clean(self, value):
     value = super().clean(value)
     try:
         return parse_tags(value)
     except ValueError:
         raise forms.ValidationError(
             _("Please provide a comma-separated list of tags.")
         )