diff options
Diffstat (limited to 'app/lib/taggit')
21 files changed, 1596 insertions, 0 deletions
diff --git a/app/lib/taggit/__init__.py b/app/lib/taggit/__init__.py new file mode 100644 index 0000000..3a055a1 --- /dev/null +++ b/app/lib/taggit/__init__.py @@ -0,0 +1 @@ +VERSION = (0, 9, 2) diff --git a/app/lib/taggit/admin.py b/app/lib/taggit/admin.py new file mode 100644 index 0000000..5155b6f --- /dev/null +++ b/app/lib/taggit/admin.py @@ -0,0 +1,16 @@ +from django.contrib import admin + +from taggit.models import Tag, TaggedItem + + +class TaggedItemInline(admin.StackedInline): + model = TaggedItem + +class TagAdmin(admin.ModelAdmin): + list_display = ["name"] + inlines = [ + TaggedItemInline + ] + + +admin.site.register(Tag, TagAdmin) diff --git a/app/lib/taggit/forms.py b/app/lib/taggit/forms.py new file mode 100644 index 0000000..e0198bd --- /dev/null +++ b/app/lib/taggit/forms.py @@ -0,0 +1,21 @@ +from django import forms +from django.utils.translation import ugettext as _ + +from taggit.utils import parse_tags, edit_string_for_tags + + +class TagWidget(forms.TextInput): + 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")]) + return super(TagWidget, self).render(name, value, attrs) + +class TagField(forms.CharField): + widget = TagWidget + + def clean(self, value): + value = super(TagField, self).clean(value) + try: + return parse_tags(value) + except ValueError: + raise forms.ValidationError(_("Please provide a comma-separated list of tags.")) diff --git a/app/lib/taggit/locale/de/LC_MESSAGES/django.mo b/app/lib/taggit/locale/de/LC_MESSAGES/django.mo Binary files differnew file mode 100644 index 0000000..3d9eaaf --- /dev/null +++ b/app/lib/taggit/locale/de/LC_MESSAGES/django.mo diff --git a/app/lib/taggit/locale/de/LC_MESSAGES/django.po b/app/lib/taggit/locale/de/LC_MESSAGES/django.po new file mode 100644 index 0000000..98ecdac --- /dev/null +++ b/app/lib/taggit/locale/de/LC_MESSAGES/django.po @@ -0,0 +1,67 @@ +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: django-taggit\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-09-07 09:26-0700\n" +"PO-Revision-Date: 2010-09-07 09:26-0700\n" +"Last-Translator: Jannis Leidel <jannis@leidel.info>\n" +"Language-Team: German <de@li.org>\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1)\n" + +#: forms.py:20 +msgid "Please provide a comma-separated list of tags." +msgstr "Bitte eine durch Komma getrennte Schlagwortliste eingeben." + +#: managers.py:39 managers.py:83 models.py:50 +msgid "Tags" +msgstr "Schlagwörter" + +#: managers.py:84 +msgid "A comma-separated list of tags." +msgstr "Eine durch Komma getrennte Schlagwortliste." + +#: models.py:10 +msgid "Name" +msgstr "Name" + +#: models.py:11 +msgid "Slug" +msgstr "Kürzel" + +#: models.py:49 +msgid "Tag" +msgstr "Schlagwort" + +#: models.py:56 +#, python-format +msgid "%(object)s tagged with %(tag)s" +msgstr "%(object)s verschlagwortet mit %(tag)s" + +#: models.py:100 +msgid "Object id" +msgstr "Objekt-ID" + +#: models.py:104 models.py:110 +msgid "Content type" +msgstr "Inhaltstyp" + +#: models.py:138 +msgid "Tagged Item" +msgstr "Verschlagwortetes Objekt" + +#: models.py:139 +msgid "Tagged Items" +msgstr "Verschlagwortete Objekte" + +#: contrib/suggest/models.py:57 +msgid "" +"Enter a valid Regular Expression. To make it case-insensitive include \"(?i)" +"\" in your expression." +msgstr "" +"Bitte einen regulären Ausdruck eingeben. Fügen Sie \"(?i) \" dem " +"Ausdruck hinzu, um nicht zwischen Groß- und Kleinschreibung zu " +"unterscheiden." diff --git a/app/lib/taggit/locale/en/LC_MESSAGES/django.po b/app/lib/taggit/locale/en/LC_MESSAGES/django.po new file mode 100644 index 0000000..c5642c7 --- /dev/null +++ b/app/lib/taggit/locale/en/LC_MESSAGES/django.po @@ -0,0 +1,68 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-09-07 09:45-0700\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" +"Language-Team: LANGUAGE <LL@li.org>\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" + +#: forms.py:20 +msgid "Please provide a comma-separated list of tags." +msgstr "" + +#: managers.py:39 managers.py:83 models.py:50 +msgid "Tags" +msgstr "" + +#: managers.py:84 +msgid "A comma-separated list of tags." +msgstr "" + +#: models.py:10 +msgid "Name" +msgstr "" + +#: models.py:11 +msgid "Slug" +msgstr "" + +#: models.py:49 +msgid "Tag" +msgstr "" + +#: models.py:56 +#, python-format +msgid "%(object)s tagged with %(tag)s" +msgstr "" + +#: models.py:100 +msgid "Object id" +msgstr "" + +#: models.py:104 models.py:110 +msgid "Content type" +msgstr "" + +#: models.py:138 +msgid "Tagged Item" +msgstr "" + +#: models.py:139 +msgid "Tagged Items" +msgstr "" + +#: contrib/suggest/models.py:57 +msgid "" +"Enter a valid Regular Expression. To make it case-insensitive include \"(?i)" +"\" in your expression." +msgstr "" diff --git a/app/lib/taggit/locale/he/LC_MESSAGES/django.mo b/app/lib/taggit/locale/he/LC_MESSAGES/django.mo Binary files differnew file mode 100644 index 0000000..562db71 --- /dev/null +++ b/app/lib/taggit/locale/he/LC_MESSAGES/django.mo diff --git a/app/lib/taggit/locale/he/LC_MESSAGES/django.po b/app/lib/taggit/locale/he/LC_MESSAGES/django.po new file mode 100644 index 0000000..e27a878 --- /dev/null +++ b/app/lib/taggit/locale/he/LC_MESSAGES/django.po @@ -0,0 +1,69 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. +# +msgid "" +msgstr "" +"Project-Id-Version: Django Taggit\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-06-26 12:47-0500\n" +"PO-Revision-Date: 2010-06-26 12:54-0600\n" +"Last-Translator: Alex <alex.gaynor@gmail.com>\n" +"Language-Team: LANGUAGE <LL@li.org>\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: forms.py:20 +msgid "Please provide a comma-separated list of tags." +msgstr "נא לספק רשימה של תגים מופרדת עם פסיקים." + +#: managers.py:41 +#: managers.py:113 +#: models.py:18 +msgid "Tags" +msgstr "תגיות" + +#: managers.py:114 +msgid "A comma-separated list of tags." +msgstr "רשימה של תגים מופרדת עם פסיקים." + +#: models.py:10 +msgid "Name" +msgstr "שם" + +#: models.py:11 +msgid "Slug" +msgstr "" + +#: models.py:17 +msgid "Tag" +msgstr "תג" + +#: models.py:56 +#, python-format +msgid "%(object)s tagged with %(tag)s" +msgstr "%(object)s מתויג עם %(tag)s" + +#: models.py:86 +msgid "Object id" +msgstr "" + +#: models.py:87 +msgid "Content type" +msgstr "" + +#: models.py:92 +msgid "Tagged Item" +msgstr "" + +#: models.py:93 +msgid "Tagged Items" +msgstr "" + +#: contrib/suggest/models.py:57 +msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression." +msgstr "" + diff --git a/app/lib/taggit/locale/nl/LC_MESSAGES/django.mo b/app/lib/taggit/locale/nl/LC_MESSAGES/django.mo Binary files differnew file mode 100644 index 0000000..28e7b7e --- /dev/null +++ b/app/lib/taggit/locale/nl/LC_MESSAGES/django.mo diff --git a/app/lib/taggit/locale/nl/LC_MESSAGES/django.po b/app/lib/taggit/locale/nl/LC_MESSAGES/django.po new file mode 100644 index 0000000..7871b0b --- /dev/null +++ b/app/lib/taggit/locale/nl/LC_MESSAGES/django.po @@ -0,0 +1,64 @@ +msgid "" +msgstr "" +"Project-Id-Version: django-taggit\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-09-07 09:45-0700\n" +"PO-Revision-Date: 2010-09-07 23:04+0100\n" +"Last-Translator: Jeffrey Gelens <jeffrey@gelens.org>\n" +"Language-Team: Dutch\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" + +#: forms.py:20 +msgid "Please provide a comma-separated list of tags." +msgstr "Geef een door komma gescheiden lijst van tags." + +#: managers.py:39 +#: managers.py:83 +#: models.py:50 +msgid "Tags" +msgstr "Tags" + +#: managers.py:84 +msgid "A comma-separated list of tags." +msgstr "Een door komma gescheiden lijst van tags." + +#: models.py:10 +msgid "Name" +msgstr "Naam" + +#: models.py:11 +msgid "Slug" +msgstr "Slug" + +#: models.py:49 +msgid "Tag" +msgstr "Tag" + +#: models.py:56 +#, python-format +msgid "%(object)s tagged with %(tag)s" +msgstr "%(object)s getagged met %(tag)s" + +#: models.py:100 +msgid "Object id" +msgstr "Object-id" + +#: models.py:104 +#: models.py:110 +msgid "Content type" +msgstr "Inhoudstype" + +#: models.py:138 +msgid "Tagged Item" +msgstr "Object getagged" + +#: models.py:139 +msgid "Tagged Items" +msgstr "Objecten getagged" + +#: contrib/suggest/models.py:57 +msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression." +msgstr "Voer een valide reguliere expressie in. Voeg \"(?i)\" aan de expressie toe om deze hoofdletter ongevoelig te maken." + diff --git a/app/lib/taggit/locale/ru/LC_MESSAGES/django.mo b/app/lib/taggit/locale/ru/LC_MESSAGES/django.mo Binary files differnew file mode 100644 index 0000000..61a7e39 --- /dev/null +++ b/app/lib/taggit/locale/ru/LC_MESSAGES/django.mo diff --git a/app/lib/taggit/locale/ru/LC_MESSAGES/django.po b/app/lib/taggit/locale/ru/LC_MESSAGES/django.po new file mode 100644 index 0000000..42e3ebe --- /dev/null +++ b/app/lib/taggit/locale/ru/LC_MESSAGES/django.po @@ -0,0 +1,70 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER +# This file is distributed under the same license as the PACKAGE package. +# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. +# +msgid "" +msgstr "" +"Project-Id-Version: Django Taggit\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-06-11 11:28+0700\n" +"PO-Revision-Date: 2010-06-11 11:30+0700\n" +"Last-Translator: Igor 'idle sign' Starikov <idlesign@yandex.ru>\n" +"Language-Team: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n" +"X-Poedit-Language: Russian\n" + +#: forms.py:20 +msgid "Please provide a comma-separated list of tags." +msgstr "Укажите метки через запятую." + +#: managers.py:41 +#: managers.py:101 +#: models.py:17 +msgid "Tags" +msgstr "Метки" + +#: managers.py:102 +msgid "A comma-separated list of tags." +msgstr "Список меток через запятую." + +#: models.py:9 +msgid "Name" +msgstr "Название" + +#: models.py:10 +msgid "Slug" +msgstr "Слаг" + +#: models.py:16 +msgid "Tag" +msgstr "Метка" + +#: models.py:55 +#, python-format +msgid "%(object)s tagged with %(tag)s" +msgstr "элемент «%(object)s» с меткой «%(tag)s»" + +#: models.py:82 +msgid "Object id" +msgstr "ID объекта" + +#: models.py:83 +msgid "Content type" +msgstr "Тип содержимого" + +#: models.py:87 +msgid "Tagged Item" +msgstr "Элемент с меткой" + +#: models.py:88 +msgid "Tagged Items" +msgstr "Элементы с меткой" + +#: contrib/suggest/models.py:57 +msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression." +msgstr "Введите регулярное выражение. Чтобы сделать его чувствительным к регистру укажите \"(?i)\"." + diff --git a/app/lib/taggit/managers.py b/app/lib/taggit/managers.py new file mode 100644 index 0000000..55201b4 --- /dev/null +++ b/app/lib/taggit/managers.py @@ -0,0 +1,244 @@ +from django.contrib.contenttypes.generic import GenericRelation +from django.contrib.contenttypes.models import ContentType +from django.db import models +from django.db.models.fields.related import ManyToManyRel, RelatedField, add_lazy_relation +from django.db.models.related import RelatedObject +from django.utils.text import capfirst +from django.utils.translation import ugettext_lazy as _ + +from taggit.forms import TagField +from taggit.models import TaggedItem, GenericTaggedItemBase +from taggit.utils import require_instance_manager + + +try: + all +except NameError: + # 2.4 compat + try: + from django.utils.itercompat import all + except ImportError: + # 1.1.X compat + def all(iterable): + for item in iterable: + if not item: + return False + return True + + +class TaggableRel(ManyToManyRel): + def __init__(self): + self.related_name = None + self.limit_choices_to = {} + self.symmetrical = True + self.multiple = True + self.through = None + + +class TaggableManager(RelatedField): + def __init__(self, verbose_name=_("Tags"), + help_text=_("A comma-separated list of tags."), through=None, blank=False): + self.through = through or TaggedItem + self.rel = TaggableRel() + self.verbose_name = verbose_name + self.help_text = help_text + self.blank = blank + self.editable = True + self.unique = False + self.creates_table = False + self.db_column = None + self.choices = None + self.serialize = False + self.null = True + self.creation_counter = models.Field.creation_counter + models.Field.creation_counter += 1 + + def __get__(self, instance, model): + if instance is not None and instance.pk is None: + raise ValueError("%s objects need to have a primary key value " + "before you can access their tags." % model.__name__) + manager = _TaggableManager( + through=self.through, model=model, instance=instance + ) + return manager + + def contribute_to_class(self, cls, name): + self.name = self.column = name + self.model = cls + cls._meta.add_field(self) + setattr(cls, name, self) + if not cls._meta.abstract: + if isinstance(self.through, basestring): + def resolve_related_class(field, model, cls): + self.through = model + self.post_through_setup(cls) + add_lazy_relation( + cls, self, self.through, resolve_related_class + ) + else: + self.post_through_setup(cls) + + def post_through_setup(self, cls): + self.use_gfk = ( + self.through is None or issubclass(self.through, GenericTaggedItemBase) + ) + self.rel.to = self.through._meta.get_field("tag").rel.to + if self.use_gfk: + tagged_items = GenericRelation(self.through) + tagged_items.contribute_to_class(cls, "tagged_items") + + def save_form_data(self, instance, value): + getattr(instance, self.name).set(*value) + + def formfield(self, form_class=TagField, **kwargs): + defaults = { + "label": capfirst(self.verbose_name), + "help_text": self.help_text, + "required": not self.blank + } + defaults.update(kwargs) + return form_class(**defaults) + + def value_from_object(self, instance): + if instance.pk: + return self.through.objects.filter(**self.through.lookup_kwargs(instance)) + return self.through.objects.none() + + def related_query_name(self): + return self.model._meta.module_name + + def m2m_reverse_name(self): + return self.through._meta.get_field_by_name("tag")[0].column + + def m2m_target_field_name(self): + return self.model._meta.pk.name + + def m2m_reverse_target_field_name(self): + return self.rel.to._meta.pk.name + + def m2m_column_name(self): + if self.use_gfk: + return self.through._meta.virtual_fields[0].fk_field + return self.through._meta.get_field('content_object').column + + def db_type(self, connection=None): + return None + + def m2m_db_table(self): + return self.through._meta.db_table + + def extra_filters(self, pieces, pos, negate): + if negate or not self.use_gfk: + return [] + prefix = "__".join(["tagged_items"] + pieces[:pos-2]) + cts = map(ContentType.objects.get_for_model, _get_subclasses(self.model)) + if len(cts) == 1: + return [("%s__content_type" % prefix, cts[0])] + return [("%s__content_type__in" % prefix, cts)] + + def bulk_related_objects(self, new_objs, using): + return [] + + +class _TaggableManager(models.Manager): + def __init__(self, through, model, instance): + self.through = through + self.model = model + self.instance = instance + + def get_query_set(self): + return self.through.tags_for(self.model, self.instance) + + def _lookup_kwargs(self): + return self.through.lookup_kwargs(self.instance) + + @require_instance_manager + def add(self, *tags): + str_tags = set([ + t + for t in tags + if not isinstance(t, self.through.tag_model()) + ]) + tag_objs = set(tags) - str_tags + # If str_tags has 0 elements Django actually optimizes that to not do a + # query. Malcolm is very smart. + existing = self.through.tag_model().objects.filter( + name__in=str_tags + ) + tag_objs.update(existing) + + for new_tag in str_tags - set(t.name for t in existing): + tag_objs.add(self.through.tag_model().objects.create(name=new_tag)) + + for tag in tag_objs: + self.through.objects.get_or_create(tag=tag, **self._lookup_kwargs()) + + @require_instance_manager + def set(self, *tags): + self.clear() + self.add(*tags) + + @require_instance_manager + def remove(self, *tags): + self.through.objects.filter(**self._lookup_kwargs()).filter( + tag__name__in=tags).delete() + + @require_instance_manager + def clear(self): + self.through.objects.filter(**self._lookup_kwargs()).delete() + + def most_common(self): + return self.get_query_set().annotate( + num_times=models.Count(self.through.tag_relname()) + ).order_by('-num_times') + + @require_instance_manager + def similar_objects(self): + lookup_kwargs = self._lookup_kwargs() + lookup_keys = sorted(lookup_kwargs) + qs = self.through.objects.values(*lookup_kwargs.keys()) + qs = qs.annotate(n=models.Count('pk')) + qs = qs.exclude(**lookup_kwargs) + qs = qs.filter(tag__in=self.all()) + qs = qs.order_by('-n') + + # TODO: This all feels like a bit of a hack. + items = {} + if len(lookup_keys) == 1: + # Can we do this without a second query by using a select_related() + # somehow? + f = self.through._meta.get_field_by_name(lookup_keys[0])[0] + objs = f.rel.to._default_manager.filter(**{ + "%s__in" % f.rel.field_name: [r["content_object"] for r in qs] + }) + for obj in objs: + items[(getattr(obj, f.rel.field_name),)] = obj + else: + preload = {} + for result in qs: + preload.setdefault(result['content_type'], set()) + preload[result["content_type"]].add(result["object_id"]) + + for ct, obj_ids in preload.iteritems(): + ct = ContentType.objects.get_for_id(ct) + for obj in ct.model_class()._default_manager.filter(pk__in=obj_ids): + items[(ct.pk, obj.pk)] = obj + + results = [] + for result in qs: + obj = items[ + tuple(result[k] for k in lookup_keys) + ] + obj.similar_tags = result["n"] + results.append(obj) + return results + + +def _get_subclasses(model): + subclasses = [model] + for f in model._meta.get_all_field_names(): + field = model._meta.get_field_by_name(f)[0] + if (isinstance(field, RelatedObject) and + getattr(field.field.rel, "parent_link", None)): + subclasses.extend(_get_subclasses(field.model)) + return subclasses diff --git a/app/lib/taggit/models.py b/app/lib/taggit/models.py new file mode 100644 index 0000000..d8a0a41 --- /dev/null +++ b/app/lib/taggit/models.py @@ -0,0 +1,160 @@ +import django +from django.contrib.contenttypes.models import ContentType +from django.contrib.contenttypes.generic import GenericForeignKey +from django.db import models, IntegrityError, transaction +from django.template.defaultfilters import slugify as default_slugify +from django.utils.translation import ugettext_lazy as _, ugettext + + +class TagBase(models.Model): + name = models.CharField(verbose_name=_('Name'), max_length=100) + slug = models.SlugField(verbose_name=_('Slug'), unique=True, max_length=100) + + def __unicode__(self): + return self.name + + class Meta: + abstract = True + + def save(self, *args, **kwargs): + if not self.pk and not self.slug: + self.slug = self.slugify(self.name) + if django.VERSION >= (1, 2): + from django.db import router + using = kwargs.get("using") or router.db_for_write( + type(self), instance=self) + # Make sure we write to the same db for all attempted writes, + # with a multi-master setup, theoretically we could try to + # write and rollback on different DBs + kwargs["using"] = using + trans_kwargs = {"using": using} + else: + trans_kwargs = {} + i = 0 + while True: + i += 1 + try: + sid = transaction.savepoint(**trans_kwargs) + res = super(TagBase, self).save(*args, **kwargs) + transaction.savepoint_commit(sid, **trans_kwargs) + return res + except IntegrityError: + transaction.savepoint_rollback(sid, **trans_kwargs) + self.slug = self.slugify(self.name, i) + else: + return super(TagBase, self).save(*args, **kwargs) + + def slugify(self, tag, i=None): + slug = default_slugify(tag) + if i is not None: + slug += "_%d" % i + return slug + + +class Tag(TagBase): + class Meta: + verbose_name = _("Tag") + verbose_name_plural = _("Tags") + + + +class ItemBase(models.Model): + def __unicode__(self): + return ugettext("%(object)s tagged with %(tag)s") % { + "object": self.content_object, + "tag": self.tag + } + + class Meta: + abstract = True + + @classmethod + def tag_model(cls): + return cls._meta.get_field_by_name("tag")[0].rel.to + + @classmethod + def tag_relname(cls): + return cls._meta.get_field_by_name('tag')[0].rel.related_name + + @classmethod + def lookup_kwargs(cls, instance): + return { + 'content_object': instance + } + + @classmethod + def bulk_lookup_kwargs(cls, instances): + return { + "content_object__in": instances, + } + + +class TaggedItemBase(ItemBase): + if django.VERSION < (1, 2): + tag = models.ForeignKey(Tag, related_name="%(class)s_items") + else: + tag = models.ForeignKey(Tag, related_name="%(app_label)s_%(class)s_items") + + class Meta: + abstract = True + + @classmethod + def tags_for(cls, model, instance=None): + if instance is not None: + return cls.tag_model().objects.filter(**{ + '%s__content_object' % cls.tag_relname(): instance + }) + return cls.tag_model().objects.filter(**{ + '%s__content_object__isnull' % cls.tag_relname(): False + }).distinct() + + +class GenericTaggedItemBase(ItemBase): + object_id = models.IntegerField(verbose_name=_('Object id'), db_index=True) + if django.VERSION < (1, 2): + content_type = models.ForeignKey( + ContentType, + verbose_name=_('Content type'), + related_name="%(class)s_tagged_items" + ) + else: + content_type = models.ForeignKey( + ContentType, + verbose_name=_('Content type'), + related_name="%(app_label)s_%(class)s_tagged_items" + ) + content_object = GenericForeignKey() + + class Meta: + abstract=True + + @classmethod + def lookup_kwargs(cls, instance): + return { + 'object_id': instance.pk, + 'content_type': ContentType.objects.get_for_model(instance) + } + + @classmethod + def bulk_lookup_kwargs(cls, instances): + # TODO: instances[0], can we assume there are instances. + return { + "object_id__in": [instance.pk for instance in instances], + "content_type": ContentType.objects.get_for_model(instances[0]), + } + + @classmethod + def tags_for(cls, model, instance=None): + ct = ContentType.objects.get_for_model(model) + kwargs = { + "%s__content_type" % cls.tag_relname(): ct + } + if instance is not None: + kwargs["%s__object_id" % cls.tag_relname()] = instance.pk + return cls.tag_model().objects.filter(**kwargs).distinct() + + +class TaggedItem(GenericTaggedItemBase, TaggedItemBase): + class Meta: + verbose_name = _("Tagged Item") + verbose_name_plural = _("Tagged Items") diff --git a/app/lib/taggit/tests/__init__.py b/app/lib/taggit/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/app/lib/taggit/tests/__init__.py diff --git a/app/lib/taggit/tests/forms.py b/app/lib/taggit/tests/forms.py new file mode 100644 index 0000000..2cdc6a8 --- /dev/null +++ b/app/lib/taggit/tests/forms.py @@ -0,0 +1,20 @@ +from django import forms + +from taggit.tests.models import Food, DirectFood, CustomPKFood, OfficialFood + + +class FoodForm(forms.ModelForm): + class Meta: + model = Food + +class DirectFoodForm(forms.ModelForm): + class Meta: + model = DirectFood + +class CustomPKFoodForm(forms.ModelForm): + class Meta: + model = CustomPKFood + +class OfficialFoodForm(forms.ModelForm): + class Meta: + model = OfficialFood diff --git a/app/lib/taggit/tests/models.py b/app/lib/taggit/tests/models.py new file mode 100644 index 0000000..a0e21e0 --- /dev/null +++ b/app/lib/taggit/tests/models.py @@ -0,0 +1,143 @@ +from django.db import models + +from taggit.managers import TaggableManager +from taggit.models import (TaggedItemBase, GenericTaggedItemBase, TaggedItem, + TagBase, Tag) + + +class Food(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager() + + def __unicode__(self): + return self.name + +class Pet(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager() + + def __unicode__(self): + return self.name + +class HousePet(Pet): + trained = models.BooleanField() + + +# Test direct-tagging with custom through model + +class TaggedFood(TaggedItemBase): + content_object = models.ForeignKey('DirectFood') + +class TaggedPet(TaggedItemBase): + content_object = models.ForeignKey('DirectPet') + +class DirectFood(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager(through="TaggedFood") + +class DirectPet(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager(through=TaggedPet) + + def __unicode__(self): + return self.name + +class DirectHousePet(DirectPet): + trained = models.BooleanField() + + +# Test custom through model to model with custom PK + +class TaggedCustomPKFood(TaggedItemBase): + content_object = models.ForeignKey('CustomPKFood') + +class TaggedCustomPKPet(TaggedItemBase): + content_object = models.ForeignKey('CustomPKPet') + +class CustomPKFood(models.Model): + name = models.CharField(max_length=50, primary_key=True) + + tags = TaggableManager(through=TaggedCustomPKFood) + + def __unicode__(self): + return self.name + +class CustomPKPet(models.Model): + name = models.CharField(max_length=50, primary_key=True) + + tags = TaggableManager(through=TaggedCustomPKPet) + + def __unicode__(self): + return self.name + +class CustomPKHousePet(CustomPKPet): + trained = models.BooleanField() + +# Test custom through model to a custom tag model + +class OfficialTag(TagBase): + official = models.BooleanField() + +class OfficialThroughModel(GenericTaggedItemBase): + tag = models.ForeignKey(OfficialTag, related_name="tagged_items") + +class OfficialFood(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager(through=OfficialThroughModel) + + def __unicode__(self): + return self.name + +class OfficialPet(models.Model): + name = models.CharField(max_length=50) + + tags = TaggableManager(through=OfficialThroughModel) + + def __unicode__(self): + return self.name + +class OfficialHousePet(OfficialPet): + trained = models.BooleanField() + + +class Media(models.Model): + tags = TaggableManager() + + class Meta: + abstract = True + +class Photo(Media): + pass + +class Movie(Media): + pass + + +class ArticleTag(Tag): + class Meta: + proxy = True + + def slugify(self, tag, i=None): + slug = "category-%s" % tag.lower() + + if i is not None: + slug += "-%d" % i + return slug + +class ArticleTaggedItem(TaggedItem): + class Meta: + proxy = True + + @classmethod + def tag_model(self): + return ArticleTag + +class Article(models.Model): + title = models.CharField(max_length=100) + + tags = TaggableManager(through=ArticleTaggedItem) diff --git a/app/lib/taggit/tests/runtests.py b/app/lib/taggit/tests/runtests.py new file mode 100755 index 0000000..23bfb91 --- /dev/null +++ b/app/lib/taggit/tests/runtests.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python +import os +import sys + +from django.conf import settings + +if not settings.configured: + settings.configure( + DATABASE_ENGINE='sqlite3', + INSTALLED_APPS=[ + 'django.contrib.contenttypes', + 'taggit', + 'taggit.tests', + ] + ) + +from django.test.simple import run_tests + + +def runtests(*test_args): + if not test_args: + test_args = ['tests'] + parent = os.path.join( + os.path.dirname(os.path.abspath(__file__)), + "..", + "..", + ) + sys.path.insert(0, parent) + failures = run_tests(test_args, verbosity=1, interactive=True) + sys.exit(failures) + + +if __name__ == '__main__': + runtests(*sys.argv[1:]) diff --git a/app/lib/taggit/tests/tests.py b/app/lib/taggit/tests/tests.py new file mode 100644 index 0000000..e627701 --- /dev/null +++ b/app/lib/taggit/tests/tests.py @@ -0,0 +1,475 @@ +from unittest import TestCase as UnitTestCase + +import django +from django.conf import settings +from django.core.exceptions import ValidationError +from django.db import connection +from django.test import TestCase, TransactionTestCase + +from taggit.managers import TaggableManager +from taggit.models import Tag, TaggedItem +from taggit.tests.forms import (FoodForm, DirectFoodForm, CustomPKFoodForm, + OfficialFoodForm) +from taggit.tests.models import (Food, Pet, HousePet, DirectFood, DirectPet, + DirectHousePet, TaggedPet, CustomPKFood, CustomPKPet, CustomPKHousePet, + TaggedCustomPKPet, OfficialFood, OfficialPet, OfficialHousePet, + OfficialThroughModel, OfficialTag, Photo, Movie, Article) +from taggit.utils import parse_tags, edit_string_for_tags + + +class BaseTaggingTest(object): + def assert_tags_equal(self, qs, tags, sort=True, attr="name"): + got = map(lambda tag: getattr(tag, attr), qs) + if sort: + got.sort() + tags.sort() + self.assertEqual(got, tags) + + def assert_num_queries(self, n, f, *args, **kwargs): + original_DEBUG = settings.DEBUG + settings.DEBUG = True + current = len(connection.queries) + try: + f(*args, **kwargs) + self.assertEqual( + len(connection.queries) - current, + n, + ) + finally: + settings.DEBUG = original_DEBUG + + def _get_form_str(self, form_str): + if django.VERSION >= (1, 3): + form_str %= { + "help_start": '<span class="helptext">', + "help_stop": "</span>" + } + else: + form_str %= { + "help_start": "", + "help_stop": "" + } + return form_str + + def assert_form_renders(self, form, html): + self.assertEqual(str(form), self._get_form_str(html)) + +class BaseTaggingTestCase(TestCase, BaseTaggingTest): + pass + +class BaseTaggingTransactionTestCase(TransactionTestCase, BaseTaggingTest): + pass + + +class TagModelTestCase(BaseTaggingTransactionTestCase): + food_model = Food + tag_model = Tag + + def test_unique_slug(self): + apple = self.food_model.objects.create(name="apple") + apple.tags.add("Red", "red") + + def test_update(self): + special = self.tag_model.objects.create(name="special") + special.save() + + def test_add(self): + apple = self.food_model.objects.create(name="apple") + yummy = self.tag_model.objects.create(name="yummy") + apple.tags.add(yummy) + + def test_slugify(self): + a = Article.objects.create(title="django-taggit 1.0 Released") + a.tags.add("awesome", "release", "AWESOME") + self.assert_tags_equal(a.tags.all(), [ + "category-awesome", + "category-release", + "category-awesome-1" + ], attr="slug") + +class TagModelDirectTestCase(TagModelTestCase): + food_model = DirectFood + tag_model = Tag + +class TagModelCustomPKTestCase(TagModelTestCase): + food_model = CustomPKFood + tag_model = Tag + +class TagModelOfficialTestCase(TagModelTestCase): + food_model = OfficialFood + tag_model = OfficialTag + +class TaggableManagerTestCase(BaseTaggingTestCase): + food_model = Food + pet_model = Pet + housepet_model = HousePet + taggeditem_model = TaggedItem + tag_model = Tag + + def test_add_tag(self): + apple = self.food_model.objects.create(name="apple") + self.assertEqual(list(apple.tags.all()), []) + self.assertEqual(list(self.food_model.tags.all()), []) + + apple.tags.add('green') + self.assert_tags_equal(apple.tags.all(), ['green']) + self.assert_tags_equal(self.food_model.tags.all(), ['green']) + + pear = self.food_model.objects.create(name="pear") + pear.tags.add('green') + self.assert_tags_equal(pear.tags.all(), ['green']) + self.assert_tags_equal(self.food_model.tags.all(), ['green']) + + apple.tags.add('red') + self.assert_tags_equal(apple.tags.all(), ['green', 'red']) + self.assert_tags_equal(self.food_model.tags.all(), ['green', 'red']) + + self.assert_tags_equal( + self.food_model.tags.most_common(), + ['green', 'red'], + sort=False + ) + + apple.tags.remove('green') + self.assert_tags_equal(apple.tags.all(), ['red']) + self.assert_tags_equal(self.food_model.tags.all(), ['green', 'red']) + tag = self.tag_model.objects.create(name="delicious") + apple.tags.add(tag) + self.assert_tags_equal(apple.tags.all(), ["red", "delicious"]) + + apple.delete() + self.assert_tags_equal(self.food_model.tags.all(), ["green"]) + + def test_add_queries(self): + apple = self.food_model.objects.create(name="apple") + # 1 query to see which tags exist + # + 3 queries to create the tags. + # + 6 queries to create the intermediary things (including SELECTs, to + # make sure we don't double create. + self.assert_num_queries(10, apple.tags.add, "red", "delicious", "green") + + pear = self.food_model.objects.create(name="pear") + # 1 query to see which tags exist + # + 4 queries to create the intermeidary things (including SELECTs, to + # make sure we dont't double create. + self.assert_num_queries(5, pear.tags.add, "green", "delicious") + + self.assert_num_queries(0, pear.tags.add) + + def test_require_pk(self): + food_instance = self.food_model() + self.assertRaises(ValueError, lambda: food_instance.tags.all()) + + def test_delete_obj(self): + apple = self.food_model.objects.create(name="apple") + apple.tags.add("red") + self.assert_tags_equal(apple.tags.all(), ["red"]) + strawberry = self.food_model.objects.create(name="strawberry") + strawberry.tags.add("red") + apple.delete() + self.assert_tags_equal(strawberry.tags.all(), ["red"]) + + def test_delete_bulk(self): + apple = self.food_model.objects.create(name="apple") + kitty = self.pet_model.objects.create(pk=apple.pk, name="kitty") + + apple.tags.add("red", "delicious", "fruit") + kitty.tags.add("feline") + + self.food_model.objects.all().delete() + + self.assert_tags_equal(kitty.tags.all(), ["feline"]) + + def test_lookup_by_tag(self): + apple = self.food_model.objects.create(name="apple") + apple.tags.add("red", "green") + pear = self.food_model.objects.create(name="pear") + pear.tags.add("green") + + self.assertEqual( + list(self.food_model.objects.filter(tags__name__in=["red"])), + [apple] + ) + self.assertEqual( + list(self.food_model.objects.filter(tags__name__in=["green"])), + [apple, pear] + ) + + kitty = self.pet_model.objects.create(name="kitty") + kitty.tags.add("fuzzy", "red") + dog = self.pet_model.objects.create(name="dog") + dog.tags.add("woof", "red") + self.assertEqual( + list(self.food_model.objects.filter(tags__name__in=["red"]).distinct()), + [apple] + ) + + tag = self.tag_model.objects.get(name="woof") + self.assertEqual(list(self.pet_model.objects.filter(tags__in=[tag])), [dog]) + + cat = self.housepet_model.objects.create(name="cat", trained=True) + cat.tags.add("fuzzy") + + self.assertEqual( + map(lambda o: o.pk, self.pet_model.objects.filter(tags__name__in=["fuzzy"])), + [kitty.pk, cat.pk] + ) + + def test_exclude(self): + apple = self.food_model.objects.create(name="apple") + apple.tags.add("red", "green", "delicious") + + pear = self.food_model.objects.create(name="pear") + pear.tags.add("green", "delicious") + + guava = self.food_model.objects.create(name="guava") + + self.assertEqual( + map(lambda o: o.pk, self.food_model.objects.exclude(tags__name__in=["red"])), + [pear.pk, guava.pk], + ) + + def test_similarity_by_tag(self): + """Test that pears are more similar to apples than watermelons""" + apple = self.food_model.objects.create(name="apple") + apple.tags.add("green", "juicy", "small", "sour") + + pear = self.food_model.objects.create(name="pear") + pear.tags.add("green", "juicy", "small", "sweet") + + watermelon = self.food_model.objects.create(name="watermelon") + watermelon.tags.add("green", "juicy", "large", "sweet") + + similar_objs = apple.tags.similar_objects() + self.assertEqual(similar_objs, [pear, watermelon]) + self.assertEqual(map(lambda x: x.similar_tags, similar_objs), [3, 2]) + + def test_tag_reuse(self): + apple = self.food_model.objects.create(name="apple") + apple.tags.add("juicy", "juicy") + self.assert_tags_equal(apple.tags.all(), ['juicy']) + + def test_query_traverse(self): + spot = self.pet_model.objects.create(name='Spot') + spike = self.pet_model.objects.create(name='Spike') + spot.tags.add('scary') + spike.tags.add('fluffy') + lookup_kwargs = { + '%s__name' % self.pet_model._meta.module_name: 'Spot' + } + self.assert_tags_equal( + self.tag_model.objects.filter(**lookup_kwargs), + ['scary'] + ) + + def test_taggeditem_unicode(self): + ross = self.pet_model.objects.create(name="ross") + # I keep Ross Perot for a pet, what's it to you? + ross.tags.add("president") + + self.assertEqual( + unicode(self.taggeditem_model.objects.all()[0]), + "ross tagged with president" + ) + + def test_abstract_subclasses(self): + p = Photo.objects.create() + p.tags.add("outdoors", "pretty") + self.assert_tags_equal( + p.tags.all(), + ["outdoors", "pretty"] + ) + + m = Movie.objects.create() + m.tags.add("hd") + self.assert_tags_equal( + m.tags.all(), + ["hd"], + ) + + +class TaggableManagerDirectTestCase(TaggableManagerTestCase): + food_model = DirectFood + pet_model = DirectPet + housepet_model = DirectHousePet + taggeditem_model = TaggedPet + +class TaggableManagerCustomPKTestCase(TaggableManagerTestCase): + food_model = CustomPKFood + pet_model = CustomPKPet + housepet_model = CustomPKHousePet + taggeditem_model = TaggedCustomPKPet + + def test_require_pk(self): + # TODO with a charfield pk, pk is never None, so taggit has no way to + # tell if the instance is saved or not + pass + +class TaggableManagerOfficialTestCase(TaggableManagerTestCase): + food_model = OfficialFood + pet_model = OfficialPet + housepet_model = OfficialHousePet + taggeditem_model = OfficialThroughModel + tag_model = OfficialTag + + def test_extra_fields(self): + self.tag_model.objects.create(name="red") + self.tag_model.objects.create(name="delicious", official=True) + apple = self.food_model.objects.create(name="apple") + apple.tags.add("delicious", "red") + + pear = self.food_model.objects.create(name="Pear") + pear.tags.add("delicious") + + self.assertEqual( + map(lambda o: o.pk, self.food_model.objects.filter(tags__official=False)), + [apple.pk], + ) + + +class TaggableFormTestCase(BaseTaggingTestCase): + form_class = FoodForm + food_model = Food + + def test_form(self): + self.assertEqual(self.form_class.base_fields.keys(), ['name', 'tags']) + + f = self.form_class({'name': 'apple', 'tags': 'green, red, yummy'}) + self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr> +<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""") + f.save() + apple = self.food_model.objects.get(name='apple') + self.assert_tags_equal(apple.tags.all(), ['green', 'red', 'yummy']) + + f = self.form_class({'name': 'apple', 'tags': 'green, red, yummy, delicious'}, instance=apple) + f.save() + apple = self.food_model.objects.get(name='apple') + self.assert_tags_equal(apple.tags.all(), ['green', 'red', 'yummy', 'delicious']) + self.assertEqual(self.food_model.objects.count(), 1) + + f = self.form_class({"name": "raspberry"}) + self.assertFalse(f.is_valid()) + + f = self.form_class(instance=apple) + self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr> +<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""") + + apple.tags.add('has,comma') + f = self.form_class(instance=apple) + self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr> +<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value=""has,comma", delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""") + + apple.tags.add('has space') + f = self.form_class(instance=apple) + self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr> +<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value=""has space", "has,comma", delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""") + + def test_formfield(self): + tm = TaggableManager(verbose_name='categories', help_text='Add some categories', blank=True) + ff = tm.formfield() + self.assertEqual(ff.label, 'Categories') + self.assertEqual(ff.help_text, u'Add some categories') + self.assertEqual(ff.required, False) + + self.assertEqual(ff.clean(""), []) + + tm = TaggableManager() + ff = tm.formfield() + self.assertRaises(ValidationError, ff.clean, "") + +class TaggableFormDirectTestCase(TaggableFormTestCase): + form_class = DirectFoodForm + food_model = DirectFood + +class TaggableFormCustomPKTestCase(TaggableFormTestCase): + form_class = CustomPKFoodForm + food_model = CustomPKFood + +class TaggableFormOfficialTestCase(TaggableFormTestCase): + form_class = OfficialFoodForm + food_model = OfficialFood + + +class TagStringParseTestCase(UnitTestCase): + """ + Ported from Jonathan Buchanan's `django-tagging + <http://django-tagging.googlecode.com/>`_ + """ + + 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_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. + """ + 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 two"'), [u'one two']) + self.assertEqual(parse_tags('a-one "a-two and a-three"'), + [u'a-one', u'a-two and a-three']) + + def test_with_no_loose_commas(self): + """ + Test with no loose commas -- split on spaces. + """ + self.assertEqual(parse_tags('one two "thr,ee"'), [u'one', u'thr,ee', u'two']) + + def test_with_loose_commas(self): + """ + Loose commas - split on commas + """ + self.assertEqual(parse_tags('"one", two three'), [u'one', u'two 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_naughty_input(self): + """ + Test with naughty input. + """ + # Bad users! Naughty users! + self.assertEqual(parse_tags(None), []) + self.assertEqual(parse_tags(''), []) + self.assertEqual(parse_tags('"'), []) + self.assertEqual(parse_tags('""'), []) + self.assertEqual(parse_tags('"' * 7), []) + self.assertEqual(parse_tags(',,,,,,'), []) + self.assertEqual(parse_tags('",",",",",",","'), [u',']) + self.assertEqual(parse_tags('a-one "a-two" and "a-three'), + [u'a-one', u'a-three', u'a-two', u'and']) + + 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"') diff --git a/app/lib/taggit/utils.py b/app/lib/taggit/utils.py new file mode 100644 index 0000000..1b5e5a7 --- /dev/null +++ b/app/lib/taggit/utils.py @@ -0,0 +1,126 @@ +from django.utils.encoding import force_unicode +from django.utils.functional import wraps + + +def parse_tags(tagstring): + """ + Parses tag input, with multiple word input being activated and + delineated by commas and double quotes. Quotes take precedence, so + they may contain commas. + + Returns a sorted list of unique tag names. + + Ported from Jonathan Buchanan's `django-tagging + <http://django-tagging.googlecode.com/>`_ + """ + if not tagstring: + return [] + + tagstring = force_unicode(tagstring) + + # Special case - if there are no commas or double quotes in the + # input, we don't *do* a recall... I mean, we know we only need to + # split on spaces. + if u',' not in tagstring and u'"' not in tagstring: + words = list(set(split_strip(tagstring, u' '))) + words.sort() + return words + + words = [] + buffer = [] + # Defer splitting of non-quoted sections until we know if there are + # any unquoted commas. + to_be_split = [] + saw_loose_comma = False + open_quote = False + i = iter(tagstring) + try: + while True: + c = i.next() + if c == u'"': + if buffer: + to_be_split.append(u''.join(buffer)) + buffer = [] + # Find the matching quote + open_quote = True + c = i.next() + while c != u'"': + buffer.append(c) + c = i.next() + if buffer: + word = u''.join(buffer).strip() + if word: + words.append(word) + buffer = [] + open_quote = False + else: + if not saw_loose_comma and c == u',': + saw_loose_comma = True + buffer.append(c) + except StopIteration: + # If we were parsing an open quote which was never closed treat + # the buffer as unquoted. + if buffer: + if open_quote and u',' in buffer: + saw_loose_comma = True + to_be_split.append(u''.join(buffer)) + if to_be_split: + if saw_loose_comma: + delimiter = u',' + else: + delimiter = u' ' + for chunk in to_be_split: + words.extend(split_strip(chunk, delimiter)) + words = list(set(words)) + words.sort() + return words + + +def split_strip(string, delimiter=u','): + """ + Splits ``string`` on ``delimiter``, stripping each resulting string + and returning a list of non-empty strings. + + Ported from Jonathan Buchanan's `django-tagging + <http://django-tagging.googlecode.com/>`_ + """ + if not string: + return [] + + words = [w.strip() for w in string.split(delimiter)] + return [w for w in words if w] + + +def edit_string_for_tags(tags): + """ + Given list of ``Tag`` instances, creates a string representation of + the list suitable for editing by the user, such that submitting the + given string representation back without changing it will give the + same list of tags. + + Tag names which contain commas will be double quoted. + + If any tag name which isn't being quoted contains whitespace, the + resulting string of tag names will be comma-delimited, otherwise + it will be space-delimited. + + Ported from Jonathan Buchanan's `django-tagging + <http://django-tagging.googlecode.com/>`_ + """ + names = [] + for tag in tags: + name = tag.name + if u',' in name or u' ' in name: + names.append('"%s"' % name) + else: + names.append(name) + return u', '.join(sorted(names)) + + +def require_instance_manager(func): + @wraps(func) + def inner(self, *args, **kwargs): + if self.instance is None: + raise TypeError("Can't call %s with a non-instance manager" % func.__name__) + return func(self, *args, **kwargs) + return inner diff --git a/app/lib/taggit/views.py b/app/lib/taggit/views.py new file mode 100644 index 0000000..68e955b --- /dev/null +++ b/app/lib/taggit/views.py @@ -0,0 +1,18 @@ +from django.contrib.contenttypes.models import ContentType +from django.shortcuts import get_object_or_404 +from django.views.generic.list_detail import object_list + +from taggit.models import TaggedItem, Tag + + +def tagged_object_list(request, slug, queryset, **kwargs): + if callable(queryset): + queryset = queryset() + tag = get_object_or_404(Tag, slug=slug) + qs = queryset.filter(pk__in=TaggedItem.objects.filter( + tag=tag, content_type=ContentType.objects.get_for_model(queryset.model) + ).values_list("object_id", flat=True)) + if "extra_context" not in kwargs: + kwargs["extra_context"] = {} + kwargs["extra_context"]["tag"] = tag + return object_list(request, qs, **kwargs) |