def test_recreation_of_tag_list_string_representations(self):
     plain = Tag.objects.create(name='plain')
     spaces = Tag.objects.create(name='spa ces')
     comma = Tag.objects.create(name='com,ma')
     self.assertEqual(edit_string_for_tags([plain]), u'plain')
     self.assertEqual(edit_string_for_tags([plain, spaces]), u'"spa ces", plain')
     self.assertEqual(edit_string_for_tags([plain, spaces, comma]), u'"com,ma", "spa ces", plain')
     self.assertEqual(edit_string_for_tags([plain, comma]), u'"com,ma", plain')
     self.assertEqual(edit_string_for_tags([comma, spaces]), u'"com,ma", "spa ces"')

 def test_recreation_of_tag_list_string_representations(self):
     plain = Tag(name="plain")
     spaces = Tag(name="spa ces")
     comma = Tag(name="com,ma")
     self.assertEqual(edit_string_for_tags([plain]), "plain")
     self.assertEqual(edit_string_for_tags([plain, spaces]), '"spa ces", plain')
     self.assertEqual(
         edit_string_for_tags([plain, spaces, comma]), '"com,ma", "spa ces", plain'
     )
     self.assertEqual(edit_string_for_tags([plain, comma]), '"com,ma", plain')
     self.assertEqual(edit_string_for_tags([comma, spaces]), '"com,ma", "spa ces"')

    def __init__(self, *args, **kwargs):

        super(EntryForm, self).__init__(*args, **kwargs)

        if 'instance' in kwargs:
            #Update mode
            obj = kwargs['instance']
        else: #Creation mode
            obj = None

        if obj:
            if obj.status == Entry.PUBLISHED_STATUS:
                initial_tags = edit_string_for_tags(obj.tags_list)
            else:
                initial_tags = ','.join(obj.drafted_tags)

            initial_other_authors = [user.username for user in obj.authors]
            self.fields['other_authors'].label = "Author(s)"
            if obj.front_image:
                initial_image = type('ImgTemp', (object,),
                                     { "url": force_text(obj.front_image),
                                       '__unicode__': lambda self : unicode(self.url)})()
                self.fields['front_image_upload'].initial = initial_image
        else:
            initial_tags = None
            initial_other_authors = []


        self.fields['tags'].initial=initial_tags
        #Get all available tags and set it inside the form field. These will be used by tag-it plugin to perform
        #the autocomplet on the widget
        self.fields['tags'].available_tags = json.dumps([ tag.name for tag in Tag.objects.all()])

        self.fields['other_authors'].initial = ", ".join(initial_other_authors)

    def get_initial(self):
        """
        We want to populate the form with data from the two associated models,
        and so we have to use initial, not instance, as this is not a
        ModelForm.

        So we basically slurp and serialize two models.
        """
        review = self.get_object()
        # Dumbest possible serialization that could work
        # @todo: this isn't very DRY.
        artwork = review.artwork
        initial = dict(
            review_id=review.pk,
            artwork_name=artwork.name,
            artwork_kind=artwork.kind,
            artwork_creator=artwork.creator,
            artwork_year=artwork.year,
            artwork_season=review.season,
            artwork_episode=review.episode,
            spider_quantity=review.spider_quantity,
            spider_quality=edit_string_for_tags(review.spider_quality.all()),
            summary=review.summary
        )
        return initial

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

        return mark_safe(html)

 def render(self, name, value, attrs=None):
     if attrs is not None:
         attrs = dict(self.attrs.items() + attrs.items())
     list_view = reverse("taggit-list")
     if value is not None and not isinstance(value, basestring):
         value = simplejson.dumps(
             [{"value": u"%s" % edit_string_for_tags([o.tag])} for o in value.select_related("tag")]
         )
     else:
         value = []
     html = super(TagAutocomplete, self).render(name + "_dummy", u"", attrs)
     allow_add = "false"
     if "allow_add" in attrs and attrs["allow_add"]:
         allow_add = "true"
     js_config = (
         u'{startText: "%s", \
         preFill: %s, \
         allowAdd: %s, \
         allowAddMessage: "%s"}'
         % (escapejs(_("Enter Tag Here")), value, allow_add, escapejs(_("Please choose an existing tag")))
     )
     js = (
         u'<script type="text/javascript">jQuery = django.jQuery; \
         jQuery().ready(function() { jQuery("#%s").autoSuggest("%s", \
         %s); });</script>'
         % (attrs["id"], list_view, js_config)
     )
     return mark_safe("\n".join([html, js]))

def list_tags(request):
    try:
        tags = Tag.objects.filter(name__icontains=request.GET['q'])
        data = [{'value': edit_string_for_tags([t]), 'name': t.name} for t in tags]
    except MultiValueDictKeyError:
        data = ""
    return HttpResponse(simplejson.dumps(data), content_type='application/json')

	def render(self, name, value, attrs=None):
		if value is not None and not isinstance(value, basestring):
			value = edit_string_for_tags([o.tag for o in value.select_related("tag")])
		if attrs is None:
			attrs = {}
		attrs.update({'class': 'taggit-tags'})
		return super(TagWidget, self).render(name, value, attrs)

 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 render(self, name, value, attrs=None):
        tags = []
        if value is not None and not isinstance(value, str):
            # value contains a list a TaggedItem instances
            # Here we retrieve a comma-delimited list of tags
            # suitable for editing by the user
            tags = [o.tag for o in value.select_related('tag')]
            value = edit_string_for_tags(tags)
        elif value is not None:
            tags = split_strip(value)

        json_view = reverse('taggit_autocomplete_jqueryui_tag_list')

        html = '<div class="selector"><ul class="tags">'
        for tag in tags:
            html += ('''
                <li data-tag="%(name)s">
                    <span class="name">%(name)s</span>
                    <a class="remove" href="#">X</a>
                </li>''' % {'name': tag})
        html += '</ul>'
        html += super(TagAutocomplete, self).render(name, value, attrs)
        html += '<input type="text" id="%s_autocomplete"/></div>' % attrs['id']

        js = '''
            <script type="text/javascript">
                (function (root) {
                    root.taggit_init = root.taggit_init || [];
                    root.taggit_init.push(['#%s_autocomplete', '%s']);
                })(window);
            </script>''' % (attrs['id'], json_view)
        return mark_safe("\n".join([html, js]))

    def render(self, name, value, attrs=None):
        list_view = reverse('taggit_autocomplete-list')
        if value is not None and not isinstance(value, basestring):
            value = edit_string_for_tags(
                    [o.tag for o in value.select_related("tag")])
        html = super(TagAutocomplete, self).render(name, value, attrs)

        # Activate tag-it in this field
        js = u"""
            <script type="text/javascript">
              document.addEventListener('DOMContentLoaded', function() {
                (function($) {
                    $(document).ready(function() {
                        $("#%(id)s").tagit({
                            caseSensitive: false,
                            allowSpaces: true,
                            tagSource: function(search, showChoices) {
                                options = this;
                                $.getJSON("%(source)s", {
                                    q: search.term.toLowerCase()
                                }, function(data) {
                                    showChoices(options._subtractArray(data, options.assignedTags()));
                                });
                            }
                        });
                    });
                })(jQuery);
              }, false);
            </script>
            """ % ({
                'id': attrs['id'],
                'source': list_view
            })
        return mark_safe("\n".join([html, js]))

    def dehydrate(self, bundle):
        bundle.data["embed_url"] = bundle.obj.get_embed_url()
        bundle.data["raw_url"] = bundle.obj.get_raw_url()
        bundle.data["tags_list"] = edit_string_for_tags(bundle.obj.tags.all())
        bundle.data["full_absolute_url"] = bundle.obj.get_full_absolute_url()
        bundle.data["description_rendered"] = linebreaksbr(
            urlize(bundle.obj.description)
        )
        bundle.data["views"] = bundle.obj.views
        bundle.data["favs"] = bundle.obj.favs()

        if bundle.data["publish_date"]:
            bundle.data["publish_date"] = date(
                bundle.data["publish_date"], "M d, Y \\a\\t h:i A"
            )

        log_entries = bundle.obj.sniptlogentry_set.all()
        bundle_log_entries = []

        for entry in log_entries:
            bundle_log_entries.append(
                {
                    "created": entry.created,
                    "user": entry.user,
                    "code": entry.code,
                    "diff": entry.diff,
                }
            )

        bundle.data["log_entries"] = bundle_log_entries

        return bundle

 def render(self, name, value, attrs=None):
     if value is not None and not isinstance(value, basestring):
         value = edit_string_for_tags(
                 [o.tag for o in value.select_related("tag")])
     attrs['class'] = (attrs.get('class', '') + ' django-taggit-ac').strip()
     attrs['data-src'] = reverse('taggit_autocomplete-list')
     return super(TagAutocomplete, self).render(name, value, attrs)

 def render(self, name, value, attrs=None):
     if attrs is not None:
         attrs = dict(self.attrs.items() + attrs.items())
     if value is not None and not isinstance(value, basestring):
         value = [edit_string_for_tags([o.tag]) for o in value.select_related("tag")]
     else:
         if value is not None:
             value = value.split(",")
         else:
             value = []
     html = super(TagAutocomplete, self).render("%s_dummy" % name, ",".join(value), attrs)
     allow_add = "false"
     if "allow_add" in attrs and attrs["allow_add"]:
         allow_add = "true"
     js_config = u"""{startText: "%s", \
         preFill: prefill, \
         allowAdd: %s, \
         allowAddMessage: "%s"}""" % (
         escapejs(_("Enter Tag Here")),
         allow_add,
         escapejs(_("Please choose an existing tag")),
     )
     js = u"""<script type="text/javascript">jQuery = django.jQuery; \
         jQuery().ready(function() { \
         var prefill = [];
         jQuery.each(jQuery('input[name="%s_dummy"]').val().split(','),function(i,v){prefill.push({'value': v})});
         jQuery("#%s").autoSuggest("%s", \
         %s); });</script>""" % (
         name,
         attrs["id"],
         reverse("taggit-list"),
         js_config,
     )
     return mark_safe("\n".join([html, js]))

    def dehydrate(self, bundle):
        bundle.data['embed_url'] = bundle.obj.get_embed_url()
        bundle.data['raw_url'] = bundle.obj.get_raw_url()
        bundle.data['tags_list'] = edit_string_for_tags(bundle.obj.tags.all())
        bundle.data['full_absolute_url'] = bundle.obj.get_full_absolute_url()
        bundle.data['description_rendered'] = \
            linebreaksbr(urlize(bundle.obj.description))
        bundle.data['views'] = bundle.obj.views
        bundle.data['favs'] = bundle.obj.favs()

        if bundle.data['publish_date']:
            bundle.data['publish_date'] = \
                date(bundle.data['publish_date'], 'M d, Y \\a\\t h:i A')

        log_entries = bundle.obj.sniptlogentry_set.all()
        bundle_log_entries = []

        for entry in log_entries:
            bundle_log_entries.append({
                'created': entry.created,
                'user': entry.user,
                'code': entry.code,
                'diff': entry.diff
            })

        bundle.data['log_entries'] = bundle_log_entries

        return bundle

 def render(self, name, value, attrs=None):
     if value is not None and not isinstance(value, basestring):
         value = edit_string_for_tags([o.tag for o in value.select_related("tag")])
     rendered = super(TaggitLiveWidget, self).render(name, value, attrs)
     url = reverse("taggit_autocomplete_list")
     js = '<script type="text/javascript">(function($) { $("#%s").taggit_live({callback: "%s"}); })(jQuery || django.jQuery);</script>' % (attrs['id'], url)
     return rendered + mark_safe(js)

 def __init__(self, *args, **kwargs):
     self.page = kwargs.pop('page')
     super(PageEditForm, self).__init__(*args, **kwargs)
     if self.page.pk:
         self.fields['tags'].initial = edit_string_for_tags(
                 self.page.tags.all())
         self.fields['prev_revision'].queryset = self.page.revisions.all()
         self.fields['prev_revision'].initial = self.page.last_revision()

def taggit(request):
    if request.current_page:
        tags = get_page_tags(request.current_page)
        return {'taggit':
                    {'tags': tags,
                     'edit_string': edit_string_for_tags(tags)}
                }
    return {}

 def render(self, name, value, attrs=None, renderer=None):
     if value is not None and not isinstance(value, six.string_types):
         value = edit_string_for_tags([o.tag for o in value.select_related("tag")])
     final_attrs = self.build_attrs(attrs, extra_attrs={"name": name})
     return mark_safe(render_to_string('taggit_bootstrap/widget.html', {
         'final_attrs': flatatt(final_attrs),
         'value': value if value else '',
         'id': final_attrs['id']
     }))

    def _has_changed(self, initial, data):
        """
        Called by BaseForm._get_changed_data, which sends this the form's initial value
        for the field and the raw value that was submitted to the form, *before it has
        been through any clean() methods.*

        This means that the initial data will (usually) be a related Tag manager, while
        the raw data will (usually) be a string. So, they're both converted to strings
        before sending them to the regular change comparison.
        """

        if initial is not None and not isinstance(initial, basestring):
            initial = edit_string_for_tags([o.tag for o in initial.select_related("tag")])

        if data is not None and not isinstance(data, basestring):
            data = edit_string_for_tags([o.tag for o in data.select_related("tag")])

        return super(TagWidget, self)._has_changed(initial, data)