aboutsummaryrefslogtreecommitdiff
path: root/tagging
diff options
context:
space:
mode:
Diffstat (limited to 'tagging')
-rw-r--r--tagging/._models.pybin187 -> 0 bytes
-rw-r--r--tagging/._settings.pybin184 -> 0 bytes
-rw-r--r--tagging/__init__.py69
-rw-r--r--tagging/admin.py13
-rw-r--r--tagging/apps.py14
-rw-r--r--tagging/fields.py13
-rw-r--r--tagging/forms.py13
-rw-r--r--tagging/generic.py13
-rw-r--r--tagging/managers.py13
-rw-r--r--tagging/migrations/0001_initial.py52
-rw-r--r--tagging/migrations/__init__.py3
-rw-r--r--tagging/models.py131
-rw-r--r--tagging/registry.py51
-rw-r--r--tagging/settings.py4
-rw-r--r--tagging/templatetags/__init__.py3
-rw-r--r--tagging/templatetags/tagging_tags.py131
-rw-r--r--tagging/tests/._settings.pybin184 -> 0 bytes
-rw-r--r--tagging/tests/._tags.txtbin184 -> 0 bytes
-rw-r--r--tagging/tests/__init__.py3
-rw-r--r--tagging/tests/models.py19
-rw-r--r--tagging/tests/settings.py50
-rw-r--r--tagging/tests/tests.py1386
-rw-r--r--tagging/tests/urls.py20
-rw-r--r--tagging/tests/utils.py16
-rw-r--r--tagging/utils.py92
-rw-r--r--tagging/views.py86
26 files changed, 1364 insertions, 831 deletions
diff --git a/tagging/._models.py b/tagging/._models.py
deleted file mode 100644
index bdd7231..0000000
--- a/tagging/._models.py
+++ /dev/null
Binary files differ
diff --git a/tagging/._settings.py b/tagging/._settings.py
deleted file mode 100644
index 3c4ee38..0000000
--- a/tagging/._settings.py
+++ /dev/null
Binary files differ
diff --git a/tagging/__init__.py b/tagging/__init__.py
index 03d6c03..735691d 100644
--- a/tagging/__init__.py
+++ b/tagging/__init__.py
@@ -1,62 +1,15 @@
-VERSION = (0, 3, 1, "final", 0)
+"""
+Django-tagging
+"""
+__version__ = '0.4'
+__license__ = 'BSD License'
+__author__ = 'Jonathan Buchanan'
+__author_email__ = 'jonathan.buchanan@gmail.com'
+__maintainer__ = 'Fantomas42'
+__maintainer_email__ = 'fantomas42@gmail.com'
-def get_version():
- if VERSION[3] == "final":
- return "%s.%s.%s" % (VERSION[0], VERSION[1], VERSION[2])
- elif VERSION[3] == "dev":
- if VERSION[2] == 0:
- return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[3], VERSION[4])
- return "%s.%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3], VERSION[4])
- else:
- return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3])
+__url__ = 'https://github.com/Fantomas42/django-tagging'
-
-__version__ = get_version()
-
-
-class AlreadyRegistered(Exception):
- """
- An attempt was made to register a model more than once.
- """
- pass
-
-
-registry = []
-
-
-def register(model, tag_descriptor_attr='tags',
- tagged_item_manager_attr='tagged'):
- """
- Sets the given model class up for working with tags.
- """
-
- from tagging.managers import ModelTaggedItemManager, TagDescriptor
-
- if model in registry:
- raise AlreadyRegistered("The model '%s' has already been "
- "registered." % model._meta.object_name)
- if hasattr(model, tag_descriptor_attr):
- raise AttributeError("'%s' already has an attribute '%s'. You must "
- "provide a custom tag_descriptor_attr to register." % (
- model._meta.object_name,
- tag_descriptor_attr,
- )
- )
- if hasattr(model, tagged_item_manager_attr):
- raise AttributeError("'%s' already has an attribute '%s'. You must "
- "provide a custom tagged_item_manager_attr to register." % (
- model._meta.object_name,
- tagged_item_manager_attr,
- )
- )
-
- # Add tag descriptor
- setattr(model, tag_descriptor_attr, TagDescriptor())
-
- # Add custom manager
- ModelTaggedItemManager().contribute_to_class(model, tagged_item_manager_attr)
-
- # Finally register in registry
- registry.append(model)
+default_app_config = 'tagging.apps.TaggingConfig'
diff --git a/tagging/admin.py b/tagging/admin.py
index bec3922..8eb9833 100644
--- a/tagging/admin.py
+++ b/tagging/admin.py
@@ -1,13 +1,16 @@
+"""
+Admin components for tagging.
+"""
from django.contrib import admin
-from tagging.models import Tag, TaggedItem
+
+from tagging.models import Tag
+from tagging.models import TaggedItem
from tagging.forms import TagAdminForm
+
class TagAdmin(admin.ModelAdmin):
form = TagAdminForm
+
admin.site.register(TaggedItem)
admin.site.register(Tag, TagAdmin)
-
-
-
-
diff --git a/tagging/apps.py b/tagging/apps.py
new file mode 100644
index 0000000..492318c
--- /dev/null
+++ b/tagging/apps.py
@@ -0,0 +1,14 @@
+"""
+Apps for tagging.
+"""
+from django.apps import AppConfig
+from django.utils.translation import ugettext_lazy as _
+
+
+class TaggingConfig(AppConfig):
+ """
+ Config for Tagging application.
+ """
+ name = 'tagging'
+ label = 'tagging'
+ verbose_name = _('Tagging')
diff --git a/tagging/fields.py b/tagging/fields.py
index f52daff..dd4a936 100644
--- a/tagging/fields.py
+++ b/tagging/fields.py
@@ -8,6 +8,8 @@ from django.utils.translation import ugettext_lazy as _
from tagging import settings
from tagging.models import Tag
from tagging.utils import edit_string_for_tags
+from tagging.forms import TagField as TagFormField
+
class TagField(CharField):
"""
@@ -58,7 +60,8 @@ class TagField(CharField):
self._set_instance_tag_cache(instance, '')
else:
self._set_instance_tag_cache(
- instance, edit_string_for_tags(Tag.objects.get_for_object(instance)))
+ instance, edit_string_for_tags(
+ Tag.objects.get_for_object(instance)))
return self._get_instance_tag_cache(instance)
def __set__(self, instance, value):
@@ -66,12 +69,13 @@ class TagField(CharField):
Set an object's tags.
"""
if instance is None:
- raise AttributeError(_('%s can only be set on instances.') % self.name)
+ raise AttributeError(
+ _('%s can only be set on instances.') % self.name)
if settings.FORCE_LOWERCASE_TAGS and value is not None:
value = value.lower()
self._set_instance_tag_cache(instance, value)
- def _save(self, **kwargs): #signal, sender, instance):
+ def _save(self, **kwargs): # signal, sender, instance):
"""
Save tags back to the database
"""
@@ -101,7 +105,6 @@ class TagField(CharField):
return 'CharField'
def formfield(self, **kwargs):
- from tagging import forms
- defaults = {'form_class': forms.TagField}
+ defaults = {'form_class': TagFormField}
defaults.update(kwargs)
return super(TagField, self).formfield(**defaults)
diff --git a/tagging/forms.py b/tagging/forms.py
index a2d9fd9..e597f2d 100644
--- a/tagging/forms.py
+++ b/tagging/forms.py
@@ -1,5 +1,5 @@
"""
-Tagging components for Django's form library.
+Form components for tagging.
"""
from django import forms
from django.utils.translation import ugettext as _
@@ -8,21 +8,20 @@ from tagging import settings
from tagging.models import Tag
from tagging.utils import parse_tag_input
+
class TagAdminForm(forms.ModelForm):
class Meta:
model = Tag
+ fields = ('name',)
def clean_name(self):
value = self.cleaned_data['name']
tag_names = parse_tag_input(value)
if len(tag_names) > 1:
raise forms.ValidationError(_('Multiple tags were given.'))
- elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
- raise forms.ValidationError(
- _('A tag may be no more than %s characters long.') %
- settings.MAX_TAG_LENGTH)
return value
+
class TagField(forms.CharField):
"""
A ``CharField`` which validates that its input is a valid list of
@@ -30,11 +29,9 @@ class TagField(forms.CharField):
"""
def clean(self, value):
value = super(TagField, self).clean(value)
- if value == u'':
- return value
for tag_name in parse_tag_input(value):
if len(tag_name) > settings.MAX_TAG_LENGTH:
raise forms.ValidationError(
_('Each tag may be no more than %s characters long.') %
- settings.MAX_TAG_LENGTH)
+ settings.MAX_TAG_LENGTH)
return value
diff --git a/tagging/generic.py b/tagging/generic.py
index 75d1b8e..770e928 100644
--- a/tagging/generic.py
+++ b/tagging/generic.py
@@ -1,5 +1,9 @@
+"""
+Generic components for tagging.
+"""
from django.contrib.contenttypes.models import ContentType
+
def fetch_content_objects(tagged_items, select_related_for=None):
"""
Retrieves ``ContentType`` and content objects for the given list of
@@ -15,7 +19,8 @@ def fetch_content_objects(tagged_items, select_related_for=None):
``ContentType``) for which ``select_related`` should be used when
retrieving model instances.
"""
- if select_related_for is None: select_related_for = []
+ if select_related_for is None:
+ select_related_for = []
# Group content object pks by their content type pks
objects = {}
@@ -27,9 +32,11 @@ def fetch_content_objects(tagged_items, select_related_for=None):
for content_type_pk, object_pks in objects.iteritems():
model = content_types[content_type_pk].model_class()
if content_types[content_type_pk].model in select_related_for:
- objects[content_type_pk] = model._default_manager.select_related().in_bulk(object_pks)
+ objects[content_type_pk] = model._default_manager.select_related(
+ ).in_bulk(object_pks)
else:
- objects[content_type_pk] = model._default_manager.in_bulk(object_pks)
+ objects[content_type_pk] = model._default_manager.in_bulk(
+ object_pks)
# Set content types and content objects in the appropriate cache
# attributes, so accessing the 'content_type' and 'object'
diff --git a/tagging/managers.py b/tagging/managers.py
index 02cd1c2..d85c260 100644
--- a/tagging/managers.py
+++ b/tagging/managers.py
@@ -1,17 +1,18 @@
"""
-Custom managers for Django models registered with the tagging
-application.
+Custom managers for tagging.
"""
-from django.contrib.contenttypes.models import ContentType
from django.db import models
+from django.contrib.contenttypes.models import ContentType
+
+from tagging.models import Tag
+from tagging.models import TaggedItem
-from tagging.models import Tag, TaggedItem
class ModelTagManager(models.Manager):
"""
A manager for retrieving tags for a particular model.
"""
- def get_query_set(self):
+ def get_queryset(self):
ctype = ContentType.objects.get_for_model(self.model)
return Tag.objects.filter(
items__content_type__pk=ctype.pk).distinct()
@@ -25,6 +26,7 @@ class ModelTagManager(models.Manager):
def usage(self, *args, **kwargs):
return Tag.objects.usage_for_model(self.model, *args, **kwargs)
+
class ModelTaggedItemManager(models.Manager):
"""
A manager for retrieving model instances based on their tags.
@@ -47,6 +49,7 @@ class ModelTaggedItemManager(models.Manager):
else:
return TaggedItem.objects.get_union_by_model(queryset, tags)
+
class TagDescriptor(object):
"""
A descriptor which provides access to a ``ModelTagManager`` for
diff --git a/tagging/migrations/0001_initial.py b/tagging/migrations/0001_initial.py
new file mode 100644
index 0000000..d784916
--- /dev/null
+++ b/tagging/migrations/0001_initial.py
@@ -0,0 +1,52 @@
+from django.db import models
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+ dependencies = [
+ ('contenttypes', '0001_initial'),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name='Tag',
+ fields=[
+ ('id', models.AutoField(
+ verbose_name='ID', serialize=False,
+ auto_created=True, primary_key=True)),
+ ('name', models.CharField(
+ unique=True, max_length=50,
+ verbose_name='name', db_index=True)),
+ ],
+ options={
+ 'ordering': ('name',),
+ 'verbose_name': 'tag',
+ 'verbose_name_plural': 'tags',
+ },
+ ),
+ migrations.CreateModel(
+ name='TaggedItem',
+ fields=[
+ ('id', models.AutoField(
+ verbose_name='ID', serialize=False,
+ auto_created=True, primary_key=True)),
+ ('object_id', models.PositiveIntegerField(
+ verbose_name='object id', db_index=True)),
+ ('content_type', models.ForeignKey(
+ verbose_name='content type',
+ to='contenttypes.ContentType')),
+ ('tag', models.ForeignKey(
+ related_name='items', verbose_name='tag',
+ to='tagging.Tag')),
+ ],
+ options={
+ 'verbose_name': 'tagged item',
+ 'verbose_name_plural': 'tagged items',
+ },
+ ),
+ migrations.AlterUniqueTogether(
+ name='taggeditem',
+ unique_together=set([('tag', 'content_type', 'object_id')]),
+ ),
+ ]
diff --git a/tagging/migrations/__init__.py b/tagging/migrations/__init__.py
new file mode 100644
index 0000000..805bae9
--- /dev/null
+++ b/tagging/migrations/__init__.py
@@ -0,0 +1,3 @@
+"""
+Migrations for tagging.
+"""
diff --git a/tagging/models.py b/tagging/models.py
index 860cf81..9e89e43 100644
--- a/tagging/models.py
+++ b/tagging/models.py
@@ -1,29 +1,31 @@
"""
-Models and managers for generic tagging.
+Models and managers for tagging.
"""
-# Python 2.3 compatibility
-try:
- set
-except NameError:
- from sets import Set as set
-
-from django.contrib.contenttypes import generic
-from django.contrib.contenttypes.models import ContentType
-from django.db import connection, models
-from django.db.models.query import QuerySet
+from django.db import models
+from django.db import connection
+from django.utils.encoding import smart_text
+from django.utils.encoding import python_2_unicode_compatible
from django.utils.translation import ugettext_lazy as _
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericForeignKey
from tagging import settings
-from tagging.utils import calculate_cloud, get_tag_list, get_queryset_and_model, parse_tag_input
from tagging.utils import LOGARITHMIC
+from tagging.utils import get_tag_list
+from tagging.utils import calculate_cloud
+from tagging.utils import parse_tag_input
+from tagging.utils import get_queryset_and_model
+
qn = connection.ops.quote_name
+
############
# Managers #
############
class TagManager(models.Manager):
+
def update_tags(self, obj, tag_names):
"""
Update tags associated with an object.
@@ -36,12 +38,13 @@ class TagManager(models.Manager):
updated_tag_names = [t.lower() for t in updated_tag_names]
# Remove tags which no longer apply
- tags_for_removal = [tag for tag in current_tags \
+ tags_for_removal = [tag for tag in current_tags
if tag.name not in updated_tag_names]
if len(tags_for_removal):
- TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
- object_id=obj.pk,
- tag__in=tags_for_removal).delete()
+ TaggedItem._default_manager.filter(
+ content_type__pk=ctype.pk,
+ object_id=obj.pk,
+ tag__in=tags_for_removal).delete()
# Add new tags
current_tag_names = [tag.name for tag in current_tags]
for tag_name in updated_tag_names:
@@ -55,9 +58,11 @@ class TagManager(models.Manager):
"""
tag_names = parse_tag_input(tag_name)
if not len(tag_names):
- raise AttributeError(_('No tags were given: "%s".') % tag_name)
+ raise AttributeError(
+ _('No tags were given: "%s".') % tag_name)
if len(tag_names) > 1:
- raise AttributeError(_('Multiple tags were given: "%s".') % tag_name)
+ raise AttributeError(
+ _('Multiple tags were given: "%s".') % tag_name)
tag_name = tag_names[0]
if settings.FORCE_LOWERCASE_TAGS:
tag_name = tag_name.lower()
@@ -75,12 +80,14 @@ class TagManager(models.Manager):
return self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk)
- def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None):
+ def _get_usage(self, model, counts=False, min_count=None,
+ extra_joins=None, extra_criteria=None, params=None):
"""
Perform the custom SQL query for ``usage_for_model`` and
``usage_for_queryset``.
"""
- if min_count is not None: counts = True
+ if min_count is not None:
+ counts = True
model_table = qn(model._meta.db_table)
model_pk = '%s.%s' % (model_table, qn(model._meta.pk.column))
@@ -112,7 +119,8 @@ class TagManager(models.Manager):
params.append(min_count)
cursor = connection.cursor()
- cursor.execute(query % (extra_joins, extra_criteria, min_count_sql), params)
+ cursor.execute(query % (extra_joins, extra_criteria, min_count_sql),
+ params)
tags = []
for row in cursor.fetchall():
t = self.model(*row[:2])
@@ -121,7 +129,8 @@ class TagManager(models.Manager):
tags.append(t)
return tags
- def usage_for_model(self, model, counts=False, min_count=None, filters=None):
+ def usage_for_model(self, model, counts=False, min_count=None,
+ filters=None):
"""
Obtain a list of tags associated with instances of the given
Model class.
@@ -139,7 +148,8 @@ class TagManager(models.Manager):
of field lookups to be applied to the given Model as the
``filters`` argument.
"""
- if filters is None: filters = {}
+ if filters is None:
+ filters = {}
queryset = model._default_manager.filter()
for f in filters.items():
@@ -161,24 +171,16 @@ class TagManager(models.Manager):
greater than or equal to ``min_count`` will be returned.
Passing a value for ``min_count`` implies ``counts=True``.
"""
-
- if getattr(queryset.query, 'get_compiler', None):
- # Django 1.2+
- compiler = queryset.query.get_compiler(using='default')
- extra_joins = ' '.join(compiler.get_from_clause()[0][1:])
- where, params = queryset.query.where.as_sql(
- compiler.quote_name_unless_alias, compiler.connection
- )
- else:
- # Django pre-1.2
- extra_joins = ' '.join(queryset.query.get_from_clause()[0][1:])
- where, params = queryset.query.where.as_sql()
+ compiler = queryset.query.get_compiler(using=queryset.db)
+ where, params = compiler.compile(queryset.query.where)
+ extra_joins = ' '.join(compiler.get_from_clause()[0][1:])
if where:
extra_criteria = 'AND %s' % where
else:
extra_criteria = ''
- return self._get_usage(queryset.model, counts, min_count, extra_joins, extra_criteria, params)
+ return self._get_usage(queryset.model, counts, min_count,
+ extra_joins, extra_criteria, params)
def related_for_model(self, tags, model, counts=False, min_count=None):
"""
@@ -193,13 +195,16 @@ class TagManager(models.Manager):
greater than or equal to ``min_count`` will be returned.
Passing a value for ``min_count`` implies ``counts=True``.
"""
- if min_count is not None: counts = True
+ if min_count is not None:
+ counts = True
+
tags = get_tag_list(tags)
tag_count = len(tags)
tagged_item_table = qn(TaggedItem._meta.db_table)
query = """
SELECT %(tag)s.id, %(tag)s.name%(count_sql)s
- FROM %(tagged_item)s INNER JOIN %(tag)s ON %(tagged_item)s.tag_id = %(tag)s.id
+ FROM %(tagged_item)s INNER JOIN %(tag)s ON
+ %(tagged_item)s.tag_id = %(tag)s.id
WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
AND %(tagged_item)s.object_id IN
(
@@ -216,12 +221,14 @@ class TagManager(models.Manager):
%(min_count_sql)s
ORDER BY %(tag)s.name ASC""" % {
'tag': qn(self.model._meta.db_table),
- 'count_sql': counts and ', COUNT(%s.object_id)' % tagged_item_table or '',
+ 'count_sql': counts and ', COUNT(%s.object_id)' %
+ tagged_item_table or '',
'tagged_item': tagged_item_table,
'content_type_id': ContentType.objects.get_for_model(model).pk,
'tag_id_placeholders': ','.join(['%s'] * tag_count),
'tag_count': tag_count,
- 'min_count_sql': min_count is not None and ('HAVING COUNT(%s.object_id) >= %%s' % tagged_item_table) or '',
+ 'min_count_sql': min_count is not None and (
+ 'HAVING COUNT(%s.object_id) >= %%s' % tagged_item_table) or '',
}
params = [tag.pk for tag in tags] * 2
@@ -267,6 +274,7 @@ class TagManager(models.Manager):
min_count=min_count))
return calculate_cloud(tags, steps, distribution)
+
class TaggedItemManager(models.Manager):
"""
FIXME There's currently no way to get the ``GROUP BY`` and ``HAVING``
@@ -280,6 +288,7 @@ class TaggedItemManager(models.Manager):
Now that the queryset-refactor branch is in the trunk, this can be
tidied up significantly.
"""
+
def get_by_model(self, queryset_or_model, tags):
"""
Create a ``QuerySet`` containing instances of the specified
@@ -405,7 +414,8 @@ class TaggedItemManager(models.Manager):
related_content_type = ContentType.objects.get_for_model(model)
query = """
SELECT %(model_pk)s, COUNT(related_tagged_item.object_id) AS %(count)s
- FROM %(model)s, %(tagged_item)s, %(tag)s, %(tagged_item)s related_tagged_item
+ FROM %(model)s, %(tagged_item)s, %(tag)s,
+ %(tagged_item)s related_tagged_item
WHERE %(tagged_item)s.object_id = %%s
AND %(tagged_item)s.content_type_id = %(content_type_id)s
AND %(tag)s.id = %(tagged_item)s.tag_id
@@ -441,23 +451,27 @@ class TaggedItemManager(models.Manager):
cursor.execute(query, params)
object_ids = [row[0] for row in cursor.fetchall()]
if len(object_ids) > 0:
- # Use in_bulk here instead of an id__in lookup, because id__in would
- # clobber the ordering.
+ # Use in_bulk here instead of an id__in lookup,
+ # because id__in would clobber the ordering.
object_dict = queryset.in_bulk(object_ids)
- return [object_dict[object_id] for object_id in object_ids \
+ return [object_dict[object_id] for object_id in object_ids
if object_id in object_dict]
else:
return []
+
##########
# Models #
##########
+@python_2_unicode_compatible
class Tag(models.Model):
"""
A tag.
"""
- name = models.CharField(_('name'), max_length=50, unique=True, db_index=True)
+ name = models.CharField(
+ _('name'), max_length=settings.MAX_TAG_LENGTH,
+ unique=True, db_index=True)
objects = TagManager()
@@ -466,17 +480,30 @@ class Tag(models.Model):
verbose_name = _('tag')
verbose_name_plural = _('tags')
- def __unicode__(self):
+ def __str__(self):
return self.name
+
+@python_2_unicode_compatible
class TaggedItem(models.Model):
"""
Holds the relationship between a tag and the item being tagged.
"""
- tag = models.ForeignKey(Tag, verbose_name=_('tag'), related_name='items')
- content_type = models.ForeignKey(ContentType, verbose_name=_('content type'))
- object_id = models.PositiveIntegerField(_('object id'), db_index=True)
- object = generic.GenericForeignKey('content_type', 'object_id')
+ tag = models.ForeignKey(
+ Tag,
+ verbose_name=_('tag'),
+ related_name='items')
+
+ content_type = models.ForeignKey(
+ ContentType,
+ verbose_name=_('content type'))
+
+ object_id = models.PositiveIntegerField(
+ _('object id'),
+ db_index=True)
+
+ object = GenericForeignKey(
+ 'content_type', 'object_id')
objects = TaggedItemManager()
@@ -486,5 +513,5 @@ class TaggedItem(models.Model):
verbose_name = _('tagged item')
verbose_name_plural = _('tagged items')
- def __unicode__(self):
- return u'%s [%s]' % (self.object, self.tag)
+ def __str__(self):
+ return '%s [%s]' % (smart_text(self.object), smart_text(self.tag))
diff --git a/tagging/registry.py b/tagging/registry.py
new file mode 100644
index 0000000..30c00ae
--- /dev/null
+++ b/tagging/registry.py
@@ -0,0 +1,51 @@
+"""
+Registery for tagging.
+"""
+from tagging.managers import TagDescriptor
+from tagging.managers import ModelTaggedItemManager
+
+registry = []
+
+
+class AlreadyRegistered(Exception):
+ """
+ An attempt was made to register a model more than once.
+ """
+ pass
+
+
+def register(model, tag_descriptor_attr='tags',
+ tagged_item_manager_attr='tagged'):
+ """
+ Sets the given model class up for working with tags.
+ """
+ if model in registry:
+ raise AlreadyRegistered(
+ "The model '%s' has already been registered." %
+ model._meta.object_name)
+ if hasattr(model, tag_descriptor_attr):
+ raise AttributeError(
+ "'%s' already has an attribute '%s'. You must "
+ "provide a custom tag_descriptor_attr to register." % (
+ model._meta.object_name,
+ tag_descriptor_attr,
+ )
+ )
+ if hasattr(model, tagged_item_manager_attr):
+ raise AttributeError(
+ "'%s' already has an attribute '%s'. You must "
+ "provide a custom tagged_item_manager_attr to register." % (
+ model._meta.object_name,
+ tagged_item_manager_attr,
+ )
+ )
+
+ # Add tag descriptor
+ setattr(model, tag_descriptor_attr, TagDescriptor())
+
+ # Add custom manager
+ ModelTaggedItemManager().contribute_to_class(
+ model, tagged_item_manager_attr)
+
+ # Finally register in registry
+ registry.append(model)
diff --git a/tagging/settings.py b/tagging/settings.py
index 1d6224c..558349c 100644
--- a/tagging/settings.py
+++ b/tagging/settings.py
@@ -8,6 +8,6 @@ from django.conf import settings
# The maximum length of a tag's name.
MAX_TAG_LENGTH = getattr(settings, 'MAX_TAG_LENGTH', 50)
-# Whether to force all tags to lowercase before they are saved to the
-# database.
+# Whether to force all tags to lowercase
+# before they are saved to the database.
FORCE_LOWERCASE_TAGS = getattr(settings, 'FORCE_LOWERCASE_TAGS', False)
diff --git a/tagging/templatetags/__init__.py b/tagging/templatetags/__init__.py
index e69de29..ab524e2 100644
--- a/tagging/templatetags/__init__.py
+++ b/tagging/templatetags/__init__.py
@@ -0,0 +1,3 @@
+"""
+Templatetags module for tagging.
+"""
diff --git a/tagging/templatetags/tagging_tags.py b/tagging/templatetags/tagging_tags.py
index 11d31cc..bd38b30 100644
--- a/tagging/templatetags/tagging_tags.py
+++ b/tagging/templatetags/tagging_tags.py
@@ -1,12 +1,22 @@
+"""
+Templatetags for tagging.
+"""
+from django.template import Node
+from django.template import Library
+from django.template import Variable
+from django.template import TemplateSyntaxError
from django.db.models import get_model
-from django.template import Library, Node, TemplateSyntaxError, Variable, resolve_variable
from django.utils.translation import ugettext as _
-from tagging.models import Tag, TaggedItem
-from tagging.utils import LINEAR, LOGARITHMIC
+from tagging.utils import LINEAR
+from tagging.utils import LOGARITHMIC
+from tagging.models import Tag
+from tagging.models import TaggedItem
+
register = Library()
+
class TagsForModelNode(Node):
def __init__(self, model, context_var, counts):
self.model = model
@@ -16,10 +26,14 @@ class TagsForModelNode(Node):
def render(self, context):
model = get_model(*self.model.split('.'))
if model is None:
- raise TemplateSyntaxError(_('tags_for_model tag was given an invalid model: %s') % self.model)
- context[self.context_var] = Tag.objects.usage_for_model(model, counts=self.counts)
+ raise TemplateSyntaxError(
+ _('tags_for_model tag was given an invalid model: %s') %
+ self.model)
+ context[self.context_var] = Tag.objects.usage_for_model(
+ model, counts=self.counts)
return ''
+
class TagCloudForModelNode(Node):
def __init__(self, model, context_var, **kwargs):
self.model = model
@@ -29,11 +43,14 @@ class TagCloudForModelNode(Node):
def render(self, context):
model = get_model(*self.model.split('.'))
if model is None:
- raise TemplateSyntaxError(_('tag_cloud_for_model tag was given an invalid model: %s') % self.model)
- context[self.context_var] = \
- Tag.objects.cloud_for_model(model, **self.kwargs)
+ raise TemplateSyntaxError(
+ _('tag_cloud_for_model tag was given an invalid model: %s') %
+ self.model)
+ context[self.context_var] = Tag.objects.cloud_for_model(
+ model, **self.kwargs)
return ''
+
class TagsForObjectNode(Node):
def __init__(self, obj, context_var):
self.obj = Variable(obj)
@@ -44,6 +61,7 @@ class TagsForObjectNode(Node):
Tag.objects.get_for_object(self.obj.resolve(context))
return ''
+
class TaggedObjectsNode(Node):
def __init__(self, tag, model, context_var):
self.tag = Variable(tag)
@@ -53,11 +71,14 @@ class TaggedObjectsNode(Node):
def render(self, context):
model = get_model(*self.model.split('.'))
if model is None:
- raise TemplateSyntaxError(_('tagged_objects tag was given an invalid model: %s') % self.model)
- context[self.context_var] = \
- TaggedItem.objects.get_by_model(model, self.tag.resolve(context))
+ raise TemplateSyntaxError(
+ _('tagged_objects tag was given an invalid model: %s') %
+ self.model)
+ context[self.context_var] = TaggedItem.objects.get_by_model(
+ model, self.tag.resolve(context))
return ''
+
def do_tags_for_model(parser, token):
"""
Retrieves a list of ``Tag`` objects associated with a given model
@@ -86,19 +107,26 @@ def do_tags_for_model(parser, token):
bits = token.contents.split()
len_bits = len(bits)
if len_bits not in (4, 6):
- raise TemplateSyntaxError(_('%s tag requires either three or five arguments') % bits[0])
+ raise TemplateSyntaxError(
+ _('%s tag requires either three or five arguments') % bits[0])
if bits[2] != 'as':
- raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ raise TemplateSyntaxError(
+ _("second argument to %s tag must be 'as'") % bits[0])
if len_bits == 6:
if bits[4] != 'with':
- raise TemplateSyntaxError(_("if given, fourth argument to %s tag must be 'with'") % bits[0])
+ raise TemplateSyntaxError(
+ _("if given, fourth argument to %s tag must be 'with'") %
+ bits[0])
if bits[5] != 'counts':
- raise TemplateSyntaxError(_("if given, fifth argument to %s tag must be 'counts'") % bits[0])
+ raise TemplateSyntaxError(
+ _("if given, fifth argument to %s tag must be 'counts'") %
+ bits[0])
if len_bits == 4:
return TagsForModelNode(bits[1], bits[3], counts=False)
else:
return TagsForModelNode(bits[1], bits[3], counts=True)
+
def do_tag_cloud_for_model(parser, token):
"""
Retrieves a list of ``Tag`` objects for a given model, with tag
@@ -132,19 +160,25 @@ def do_tag_cloud_for_model(parser, token):
Examples::
{% tag_cloud_for_model products.Widget as widget_tags %}
- {% tag_cloud_for_model products.Widget as widget_tags with steps=9 min_count=3 distribution=log %}
+ {% tag_cloud_for_model products.Widget as widget_tags
+ with steps=9 min_count=3 distribution=log %}
"""
bits = token.contents.split()
len_bits = len(bits)
if len_bits != 4 and len_bits not in range(6, 9):
- raise TemplateSyntaxError(_('%s tag requires either three or between five and seven arguments') % bits[0])
+ raise TemplateSyntaxError(
+ _('%s tag requires either three or between five '
+ 'and seven arguments') % bits[0])
if bits[2] != 'as':
- raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ raise TemplateSyntaxError(
+ _("second argument to %s tag must be 'as'") % bits[0])
kwargs = {}
if len_bits > 5:
if bits[4] != 'with':
- raise TemplateSyntaxError(_("if given, fourth argument to %s tag must be 'with'") % bits[0])
+ raise TemplateSyntaxError(
+ _("if given, fourth argument to %s tag must be 'with'") %
+ bits[0])
for i in range(5, len_bits):
try:
name, value = bits[i].split('=')
@@ -152,32 +186,42 @@ def do_tag_cloud_for_model(parser, token):
try:
kwargs[str(name)] = int(value)
except ValueError:
- raise TemplateSyntaxError(_("%(tag)s tag's '%(option)s' option was not a valid integer: '%(value)s'") % {
- 'tag': bits[0],
- 'option': name,
- 'value': value,
- })
+ raise TemplateSyntaxError(
+ _("%(tag)s tag's '%(option)s' option was not "
+ "a valid integer: '%(value)s'") % {
+ 'tag': bits[0],
+ 'option': name,
+ 'value': value,
+ })
elif name == 'distribution':
if value in ['linear', 'log']:
- kwargs[str(name)] = {'linear': LINEAR, 'log': LOGARITHMIC}[value]
+ kwargs[str(name)] = {'linear': LINEAR,
+ 'log': LOGARITHMIC}[value]
else:
- raise TemplateSyntaxError(_("%(tag)s tag's '%(option)s' option was not a valid choice: '%(value)s'") % {
+ raise TemplateSyntaxError(
+ _("%(tag)s tag's '%(option)s' option was not "
+ "a valid choice: '%(value)s'") % {
+ 'tag': bits[0],
+ 'option': name,
+ 'value': value,
+ })
+ else:
+ raise TemplateSyntaxError(
+ _("%(tag)s tag was given an "
+ "invalid option: '%(option)s'") % {
'tag': bits[0],
'option': name,
- 'value': value,
})
- else:
- raise TemplateSyntaxError(_("%(tag)s tag was given an invalid option: '%(option)s'") % {
+ except ValueError:
+ raise TemplateSyntaxError(
+ _("%(tag)s tag was given a badly "
+ "formatted option: '%(option)s'") % {
'tag': bits[0],
- 'option': name,
+ 'option': bits[i],
})
- except ValueError:
- raise TemplateSyntaxError(_("%(tag)s tag was given a badly formatted option: '%(option)s'") % {
- 'tag': bits[0],
- 'option': bits[i],
- })
return TagCloudForModelNode(bits[1], bits[3], **kwargs)
+
def do_tags_for_object(parser, token):
"""
Retrieves a list of ``Tag`` objects associated with an object and
@@ -193,11 +237,14 @@ def do_tags_for_object(parser, token):
"""
bits = token.contents.split()
if len(bits) != 4:
- raise TemplateSyntaxError(_('%s tag requires exactly three arguments') % bits[0])
+ raise TemplateSyntaxError(
+ _('%s tag requires exactly three arguments') % bits[0])
if bits[2] != 'as':
- raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ raise TemplateSyntaxError(
+ _("second argument to %s tag must be 'as'") % bits[0])
return TagsForObjectNode(bits[1], bits[3])
+
def do_tagged_objects(parser, token):
"""
Retrieves a list of instances of a given model which are tagged with
@@ -218,13 +265,17 @@ def do_tagged_objects(parser, token):
"""
bits = token.contents.split()
if len(bits) != 6:
- raise TemplateSyntaxError(_('%s tag requires exactly five arguments') % bits[0])
+ raise TemplateSyntaxError(
+ _('%s tag requires exactly five arguments') % bits[0])
if bits[2] != 'in':
- raise TemplateSyntaxError(_("second argument to %s tag must be 'in'") % bits[0])
+ raise TemplateSyntaxError(
+ _("second argument to %s tag must be 'in'") % bits[0])
if bits[4] != 'as':
- raise TemplateSyntaxError(_("fourth argument to %s tag must be 'as'") % bits[0])
+ raise TemplateSyntaxError(
+ _("fourth argument to %s tag must be 'as'") % bits[0])
return TaggedObjectsNode(bits[1], bits[3], bits[5])
+
register.tag('tags_for_model', do_tags_for_model)
register.tag('tag_cloud_for_model', do_tag_cloud_for_model)
register.tag('tags_for_object', do_tags_for_object)
diff --git a/tagging/tests/._settings.py b/tagging/tests/._settings.py
deleted file mode 100644
index 6092bc4..0000000
--- a/tagging/tests/._settings.py
+++ /dev/null
Binary files differ
diff --git a/tagging/tests/._tags.txt b/tagging/tests/._tags.txt
deleted file mode 100644
index 3348eaa..0000000
--- a/tagging/tests/._tags.txt
+++ /dev/null
Binary files differ
diff --git a/tagging/tests/__init__.py b/tagging/tests/__init__.py
index e69de29..f020378 100644
--- a/tagging/tests/__init__.py
+++ b/tagging/tests/__init__.py
@@ -0,0 +1,3 @@
+"""
+Tests for tagging.
+"""
diff --git a/tagging/tests/models.py b/tagging/tests/models.py
index 0708686..1babd58 100644
--- a/tagging/tests/models.py
+++ b/tagging/tests/models.py
@@ -1,38 +1,51 @@
from django.db import models
+from django.utils.encoding import python_2_unicode_compatible
from tagging.fields import TagField
+
class Perch(models.Model):
size = models.IntegerField()
smelly = models.BooleanField(default=True)
+
+@python_2_unicode_compatible
class Parrot(models.Model):
state = models.CharField(max_length=50)
perch = models.ForeignKey(Perch, null=True)
- def __unicode__(self):
+ def __str__(self):
return self.state
class Meta:
ordering = ['state']
+
+@python_2_unicode_compatible
class Link(models.Model):
name = models.CharField(max_length=50)
- def __unicode__(self):
+ def __str__(self):
return self.name
class Meta:
ordering = ['name']
+
+@python_2_unicode_compatible
class Article(models.Model):
name = models.CharField(max_length=50)
- def __unicode__(self):
+ def __str__(self):
return self.name
class Meta:
ordering = ['name']
+
class FormTest(models.Model):
tags = TagField('Test', help_text='Test')
+
+
+class FormTestNull(models.Model):
+ tags = TagField(null=True)
diff --git a/tagging/tests/settings.py b/tagging/tests/settings.py
index 74eb909..3648f2e 100644
--- a/tagging/tests/settings.py
+++ b/tagging/tests/settings.py
@@ -1,27 +1,39 @@
+"""Tests settings"""
import os
-DIRNAME = os.path.dirname(__file__)
-DEFAULT_CHARSET = 'utf-8'
+SECRET_KEY = 'secret-key'
-test_engine = os.environ.get("TAGGING_TEST_ENGINE", "sqlite3")
+DATABASES = {
+ 'default': {
+ 'NAME': 'tagging.db',
+ 'ENGINE': 'django.db.backends.sqlite3'
+ }
+}
-DATABASE_ENGINE = test_engine
-DATABASE_NAME = os.environ.get("TAGGING_DATABASE_NAME", "tagging_test")
-DATABASE_USER = os.environ.get("TAGGING_DATABASE_USER", "")
-DATABASE_PASSWORD = os.environ.get("TAGGING_DATABASE_PASSWORD", "")
-DATABASE_HOST = os.environ.get("TAGGING_DATABASE_HOST", "localhost")
+DATABASE_ENGINE = os.environ.get('DATABASE_ENGINE')
+if DATABASE_ENGINE == 'postgres':
+ DATABASES = {
+ 'default': {
+ 'ENGINE': 'django.db.backends.postgresql_psycopg2',
+ 'NAME': 'tagging',
+ 'USER': 'postgres',
+ 'HOST': 'localhost'
+ }
+ }
+elif DATABASE_ENGINE == 'mysql':
+ DATABASES = {
+ 'default': {
+ 'ENGINE': 'django.db.backends.mysql',
+ 'NAME': 'zinnia',
+ 'USER': 'root',
+ 'HOST': 'localhost'
+ }
+ }
-if test_engine == "sqlite":
- DATABASE_NAME = os.path.join(DIRNAME, 'tagging_test.db')
- DATABASE_HOST = ""
-elif test_engine == "mysql":
- DATABASE_PORT = os.environ.get("TAGGING_DATABASE_PORT", 3306)
-elif test_engine == "postgresql_psycopg2":
- DATABASE_PORT = os.environ.get("TAGGING_DATABASE_PORT", 5432)
-
-
-INSTALLED_APPS = (
+INSTALLED_APPS = [
+ 'django.contrib.auth',
+ 'django.contrib.sessions',
'django.contrib.contenttypes',
'tagging',
'tagging.tests',
-)
+]
diff --git a/tagging/tests/tests.py b/tagging/tests/tests.py
index f5c9e37..c3ff3b6 100644
--- a/tagging/tests/tests.py
+++ b/tagging/tests/tests.py
@@ -1,434 +1,509 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
import os
+
from django import forms
+from django.utils import six
from django.db.models import Q
from django.test import TestCase
-from tagging.forms import TagField
+from django.test.utils import override_settings
+from django.core.exceptions import ImproperlyConfigured
+
from tagging import settings
-from tagging.models import Tag, TaggedItem
-from tagging.tests.models import Article, Link, Perch, Parrot, FormTest
-from tagging.utils import calculate_cloud, edit_string_for_tags, get_tag_list, get_tag, parse_tag_input
+from tagging.forms import TagField
+from tagging.forms import TagAdminForm
+from tagging.models import Tag
+from tagging.models import TaggedItem
+from tagging.tests.models import Article
+from tagging.tests.models import Link
+from tagging.tests.models import Perch
+from tagging.tests.models import Parrot
+from tagging.tests.models import FormTest
+from tagging.tests.models import FormTestNull
from tagging.utils import LINEAR
+from tagging.utils import get_tag
+from tagging.utils import get_tag_list
+from tagging.utils import calculate_cloud
+from tagging.utils import parse_tag_input
+from tagging.utils import edit_string_for_tags
#############
# Utilities #
#############
+
class TestParseTagInput(TestCase):
def test_with_simple_space_delimited_tags(self):
""" Test with simple space-delimited tags. """
-
- self.assertEquals(parse_tag_input('one'), [u'one'])
- self.assertEquals(parse_tag_input('one two'), [u'one', u'two'])
- self.assertEquals(parse_tag_input('one two three'), [u'one', u'three', u'two'])
- self.assertEquals(parse_tag_input('one one two two'), [u'one', u'two'])
-
+
+ self.assertEqual(parse_tag_input('one'), ['one'])
+ self.assertEqual(parse_tag_input('one two'), ['one', 'two'])
+ self.assertEqual(parse_tag_input('one one two two'), ['one', 'two'])
+ self.assertEqual(parse_tag_input('one two three'),
+ ['one', 'three', '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.assertEquals(parse_tag_input(',one'), [u'one'])
- self.assertEquals(parse_tag_input(',one two'), [u'one two'])
- self.assertEquals(parse_tag_input(',one two three'), [u'one two three'])
- self.assertEquals(parse_tag_input('a-one, a-two and a-three'),
- [u'a-one', u'a-two and a-three'])
-
+
+ self.assertEqual(parse_tag_input(',one'), ['one'])
+ self.assertEqual(parse_tag_input(',one two'), ['one two'])
+ self.assertEqual(parse_tag_input(',one two three'), ['one two three'])
+ self.assertEqual(parse_tag_input('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.assertEquals(parse_tag_input('"one'), [u'one'])
- self.assertEquals(parse_tag_input('"one two'), [u'one', u'two'])
- self.assertEquals(parse_tag_input('"one two three'), [u'one', u'three', u'two'])
- self.assertEquals(parse_tag_input('"one two"'), [u'one two'])
- self.assertEquals(parse_tag_input('a-one "a-two and a-three"'),
- [u'a-one', u'a-two and a-three'])
-
+ A completed quote will trigger this. Unclosed quotes are ignored.
+ """
+
+ self.assertEqual(parse_tag_input('"one'), ['one'])
+ self.assertEqual(parse_tag_input('"one two'), ['one', 'two'])
+ self.assertEqual(parse_tag_input('"one two three'),
+ ['one', 'three', 'two'])
+ self.assertEqual(parse_tag_input('"one two"'), ['one two'])
+ self.assertEqual(parse_tag_input('a-one "a-two and a-three"'),
+ ['a-one', 'a-two and a-three'])
+
def test_with_no_loose_commas(self):
""" Test with no loose commas -- split on spaces. """
- self.assertEquals(parse_tag_input('one two "thr,ee"'), [u'one', u'thr,ee', u'two'])
-
+ self.assertEqual(parse_tag_input('one two "thr,ee"'),
+ ['one', 'thr,ee', 'two'])
+
def test_with_loose_commas(self):
""" Loose commas - split on commas """
- self.assertEquals(parse_tag_input('"one", two three'), [u'one', u'two three'])
-
+ self.assertEqual(parse_tag_input('"one", two three'),
+ ['one', 'two three'])
+
def test_tags_with_double_quotes_can_contain_commas(self):
""" Double quotes can contain commas """
- self.assertEquals(parse_tag_input('a-one "a-two, and a-three"'),
- [u'a-one', u'a-two, and a-three'])
- self.assertEquals(parse_tag_input('"two", one, one, two, "one"'),
- [u'one', u'two'])
-
+ self.assertEqual(parse_tag_input('a-one "a-two, and a-three"'),
+ ['a-one', 'a-two, and a-three'])
+ self.assertEqual(parse_tag_input('"two", one, one, two, "one"'),
+ ['one', 'two'])
+ self.assertEqual(parse_tag_input('two", one'),
+ ['one', 'two'])
+
def test_with_naughty_input(self):
""" Test with naughty input. """
-
# Bad users! Naughty users!
- self.assertEquals(parse_tag_input(None), [])
- self.assertEquals(parse_tag_input(''), [])
- self.assertEquals(parse_tag_input('"'), [])
- self.assertEquals(parse_tag_input('""'), [])
- self.assertEquals(parse_tag_input('"' * 7), [])
- self.assertEquals(parse_tag_input(',,,,,,'), [])
- self.assertEquals(parse_tag_input('",",",",",",","'), [u','])
- self.assertEquals(parse_tag_input('a-one "a-two" and "a-three'),
- [u'a-one', u'a-three', u'a-two', u'and'])
-
+ self.assertEqual(parse_tag_input(None), [])
+ self.assertEqual(parse_tag_input(''), [])
+ self.assertEqual(parse_tag_input('"'), [])
+ self.assertEqual(parse_tag_input('""'), [])
+ self.assertEqual(parse_tag_input('"' * 7), [])
+ self.assertEqual(parse_tag_input(',,,,,,'), [])
+ self.assertEqual(parse_tag_input('",",",",",",","'), [','])
+ self.assertEqual(parse_tag_input('a-one "a-two" and "a-three'),
+ ['a-one', 'a-three', 'a-two', 'and'])
+
+
class TestNormalisedTagListInput(TestCase):
def setUp(self):
- self.cheese = Tag.objects.create(name='cheese')
self.toast = Tag.objects.create(name='toast')
-
+ self.cheese = Tag.objects.create(name='cheese')
+
def test_single_tag_object_as_input(self):
- self.assertEquals(get_tag_list(self.cheese), [self.cheese])
-
+ self.assertEqual(get_tag_list(self.cheese), [self.cheese])
+
def test_space_delimeted_string_as_input(self):
ret = get_tag_list('cheese toast')
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_comma_delimeted_string_as_input(self):
ret = get_tag_list('cheese,toast')
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_with_empty_list(self):
- self.assertEquals(get_tag_list([]), [])
-
+ self.assertEqual(get_tag_list([]), [])
+
def test_list_of_two_strings(self):
ret = get_tag_list(['cheese', 'toast'])
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_list_of_tag_primary_keys(self):
ret = get_tag_list([self.cheese.id, self.toast.id])
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_list_of_strings_with_strange_nontag_string(self):
ret = get_tag_list(['cheese', 'toast', 'ŠĐĆŽćžšđ'])
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_list_of_tag_instances(self):
ret = get_tag_list([self.cheese, self.toast])
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_tuple_of_instances(self):
ret = get_tag_list((self.cheese, self.toast))
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_with_tag_filter(self):
ret = get_tag_list(Tag.objects.filter(name__in=['cheese', 'toast']))
- self.assertEquals(len(ret), 2)
- self.failUnless(self.cheese in ret)
- self.failUnless(self.toast in ret)
-
+ self.assertEqual(len(ret), 2)
+ self.assertTrue(self.cheese in ret)
+ self.assertTrue(self.toast in ret)
+
def test_with_invalid_input_mix_of_string_and_instance(self):
try:
get_tag_list(['cheese', self.toast])
- except ValueError, ve:
- self.assertEquals(str(ve),
- 'If a list or tuple of tags is provided, they must all be tag names, Tag objects or Tag ids.')
- except Exception, e:
- raise self.failureException('the wrong type of exception was raised: type [%s] value [%]' %\
+ except ValueError as ve:
+ self.assertEqual(
+ str(ve),
+ 'If a list or tuple of tags is provided, they must all '
+ 'be tag names, Tag objects or Tag ids.')
+ except Exception as e:
+ raise self.failureException(
+ 'the wrong type of exception was raised: type [%s] value [%]' %
(str(type(e)), str(e)))
else:
- raise self.failureException('a ValueError exception was supposed to be raised!')
-
+ raise self.failureException(
+ 'a ValueError exception was supposed to be raised!')
+
def test_with_invalid_input(self):
try:
get_tag_list(29)
- except ValueError, ve:
- self.assertEquals(str(ve), 'The tag input given was invalid.')
- except Exception, e:
- raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
- (str(type(e)), str(e)))
+ except ValueError as ve:
+ self.assertEqual(str(ve), 'The tag input given was invalid.')
+ except Exception as e:
+ print('--', e)
+ raise self.failureException(
+ 'the wrong type of exception was raised: '
+ 'type [%s] value [%s]' % (str(type(e)), str(e)))
else:
- raise self.failureException('a ValueError exception was supposed to be raised!')
+ raise self.failureException(
+ 'a ValueError exception was supposed to be raised!')
def test_with_tag_instance(self):
- self.assertEquals(get_tag(self.cheese), self.cheese)
-
+ self.assertEqual(get_tag(self.cheese), self.cheese)
+
def test_with_string(self):
- self.assertEquals(get_tag('cheese'), self.cheese)
-
+ self.assertEqual(get_tag('cheese'), self.cheese)
+
def test_with_primary_key(self):
- self.assertEquals(get_tag(self.cheese.id), self.cheese)
-
+ self.assertEqual(get_tag(self.cheese.id), self.cheese)
+
def test_nonexistent_tag(self):
- self.assertEquals(get_tag('mouse'), None)
+ self.assertEqual(get_tag('mouse'), None)
+
class TestCalculateCloud(TestCase):
def setUp(self):
self.tags = []
- for line in open(os.path.join(os.path.dirname(__file__), 'tags.txt')).readlines():
+ for line in open(os.path.join(os.path.dirname(__file__),
+ 'tags.txt')).readlines():
name, count = line.rstrip().split()
tag = Tag(name=name)
tag.count = int(count)
self.tags.append(tag)
-
+
def test_default_distribution(self):
sizes = {}
for tag in calculate_cloud(self.tags, steps=5):
sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
-
+
# This isn't a pre-calculated test, just making sure it's consistent
- self.assertEquals(sizes[1], 48)
- self.assertEquals(sizes[2], 30)
- self.assertEquals(sizes[3], 19)
- self.assertEquals(sizes[4], 15)
- self.assertEquals(sizes[5], 10)
-
+ self.assertEqual(sizes[1], 48)
+ self.assertEqual(sizes[2], 30)
+ self.assertEqual(sizes[3], 19)
+ self.assertEqual(sizes[4], 15)
+ self.assertEqual(sizes[5], 10)
+
def test_linear_distribution(self):
sizes = {}
for tag in calculate_cloud(self.tags, steps=5, distribution=LINEAR):
sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
-
+
# This isn't a pre-calculated test, just making sure it's consistent
- self.assertEquals(sizes[1], 97)
- self.assertEquals(sizes[2], 12)
- self.assertEquals(sizes[3], 7)
- self.assertEquals(sizes[4], 2)
- self.assertEquals(sizes[5], 4)
-
+ self.assertEqual(sizes[1], 97)
+ self.assertEqual(sizes[2], 12)
+ self.assertEqual(sizes[3], 7)
+ self.assertEqual(sizes[4], 2)
+ self.assertEqual(sizes[5], 4)
+
def test_invalid_distribution(self):
try:
calculate_cloud(self.tags, steps=5, distribution='cheese')
- except ValueError, ve:
- self.assertEquals(str(ve), 'Invalid distribution algorithm specified: cheese.')
- except Exception, e:
- raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
- (str(type(e)), str(e)))
+ except ValueError as ve:
+ self.assertEqual(
+ str(ve), 'Invalid distribution algorithm specified: cheese.')
+ except Exception as e:
+ raise self.failureException(
+ 'the wrong type of exception was raised: '
+ 'type [%s] value [%s]' % (str(type(e)), str(e)))
else:
- raise self.failureException('a ValueError exception was supposed to be raised!')
-
+ raise self.failureException(
+ 'a ValueError exception was supposed to be raised!')
+
###########
# Tagging #
###########
+
class TestBasicTagging(TestCase):
def setUp(self):
self.dead_parrot = Parrot.objects.create(state='dead')
-
+
def test_update_tags(self):
Tag.objects.update_tags(self.dead_parrot, 'foo,bar,"ter"')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('foo') in tags)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('ter') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('foo') in tags)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('ter') in tags)
+
Tag.objects.update_tags(self.dead_parrot, '"foo" bar "baz"')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
def test_add_tag(self):
# start off in a known, mildly interesting state
Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
# try to add a tag that already exists
Tag.objects.add_tag(self.dead_parrot, 'foo')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
# now add a tag that doesn't already exist
Tag.objects.add_tag(self.dead_parrot, 'zip')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 4)
- self.failUnless(get_tag('zip') in tags)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 4)
+ self.assertTrue(get_tag('zip') in tags)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
def test_add_tag_invalid_input_no_tags_specified(self):
# start off in a known, mildly interesting state
Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
try:
Tag.objects.add_tag(self.dead_parrot, ' ')
- except AttributeError, ae:
- self.assertEquals(str(ae), 'No tags were given: " ".')
- except Exception, e:
- raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
- (str(type(e)), str(e)))
+ except AttributeError as ae:
+ self.assertEqual(str(ae), 'No tags were given: " ".')
+ except Exception as e:
+ raise self.failureException(
+ 'the wrong type of exception was raised: '
+ 'type [%s] value [%s]' % (str(type(e)), str(e)))
else:
- raise self.failureException('an AttributeError exception was supposed to be raised!')
-
+ raise self.failureException(
+ 'an AttributeError exception was supposed to be raised!')
+
def test_add_tag_invalid_input_multiple_tags_specified(self):
# start off in a known, mildly interesting state
Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
try:
Tag.objects.add_tag(self.dead_parrot, 'one two')
- except AttributeError, ae:
- self.assertEquals(str(ae), 'Multiple tags were given: "one two".')
- except Exception, e:
- raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
- (str(type(e)), str(e)))
+ except AttributeError as ae:
+ self.assertEqual(str(ae), 'Multiple tags were given: "one two".')
+ except Exception as e:
+ raise self.failureException(
+ 'the wrong type of exception was raised: '
+ 'type [%s] value [%s]' % (str(type(e)), str(e)))
else:
- raise self.failureException('an AttributeError exception was supposed to be raised!')
-
+ raise self.failureException(
+ 'an AttributeError exception was supposed to be raised!')
+
def test_update_tags_exotic_characters(self):
# start off in a known, mildly interesting state
Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
- Tag.objects.update_tags(self.dead_parrot, u'ŠĐĆŽćžšđ')
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
+ Tag.objects.update_tags(self.dead_parrot, 'ŠĐĆŽćžšđ')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 1)
- self.assertEquals(tags[0].name, u'ŠĐĆŽćžšđ')
-
- Tag.objects.update_tags(self.dead_parrot, u'你好')
+ self.assertEqual(len(tags), 1)
+ self.assertEqual(tags[0].name, 'ŠĐĆŽćžšđ')
+
+ Tag.objects.update_tags(self.dead_parrot, '你好')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 1)
- self.assertEquals(tags[0].name, u'你好')
-
+ self.assertEqual(len(tags), 1)
+ self.assertEqual(tags[0].name, '你好')
+
+ def test_unicode_tagged_object(self):
+ self.dead_parrot.state = "dëad"
+ self.dead_parrot.save()
+ Tag.objects.update_tags(self.dead_parrot, 'föo')
+ items = TaggedItem.objects.all()
+ self.assertEqual(len(items), 1)
+ self.assertEqual(six.text_type(items[0]), "dëad [föo]")
+
def test_update_tags_with_none(self):
# start off in a known, mildly interesting state
Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(get_tag('bar') in tags)
- self.failUnless(get_tag('baz') in tags)
- self.failUnless(get_tag('foo') in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(get_tag('bar') in tags)
+ self.assertTrue(get_tag('baz') in tags)
+ self.assertTrue(get_tag('foo') in tags)
+
Tag.objects.update_tags(self.dead_parrot, None)
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 0)
+ self.assertEqual(len(tags), 0)
+
class TestModelTagField(TestCase):
""" Test the 'tags' field on models. """
-
+
def test_create_with_tags_specified(self):
- f1 = FormTest.objects.create(tags=u'test3 test2 test1')
+ f1 = FormTest.objects.create(tags='test3 test2 test1')
tags = Tag.objects.get_for_object(f1)
test1_tag = get_tag('test1')
test2_tag = get_tag('test2')
test3_tag = get_tag('test3')
- self.failUnless(None not in (test1_tag, test2_tag, test3_tag))
- self.assertEquals(len(tags), 3)
- self.failUnless(test1_tag in tags)
- self.failUnless(test2_tag in tags)
- self.failUnless(test3_tag in tags)
-
+ self.assertTrue(None not in (test1_tag, test2_tag, test3_tag))
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(test1_tag in tags)
+ self.assertTrue(test2_tag in tags)
+ self.assertTrue(test3_tag in tags)
+
def test_update_via_tags_field(self):
- f1 = FormTest.objects.create(tags=u'test3 test2 test1')
+ f1 = FormTest.objects.create(tags='test3 test2 test1')
tags = Tag.objects.get_for_object(f1)
test1_tag = get_tag('test1')
test2_tag = get_tag('test2')
test3_tag = get_tag('test3')
- self.failUnless(None not in (test1_tag, test2_tag, test3_tag))
- self.assertEquals(len(tags), 3)
- self.failUnless(test1_tag in tags)
- self.failUnless(test2_tag in tags)
- self.failUnless(test3_tag in tags)
-
- f1.tags = u'test4'
+ self.assertTrue(None not in (test1_tag, test2_tag, test3_tag))
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(test1_tag in tags)
+ self.assertTrue(test2_tag in tags)
+ self.assertTrue(test3_tag in tags)
+
+ f1.tags = 'test4'
f1.save()
tags = Tag.objects.get_for_object(f1)
test4_tag = get_tag('test4')
- self.assertEquals(len(tags), 1)
- self.assertEquals(tags[0], test4_tag)
-
+ self.assertEqual(len(tags), 1)
+ self.assertEqual(tags[0], test4_tag)
+
f1.tags = ''
f1.save()
tags = Tag.objects.get_for_object(f1)
- self.assertEquals(len(tags), 0)
-
+ self.assertEqual(len(tags), 0)
+
+ def disabledtest_update_via_tags(self):
+ # TODO: make this test working by reverting
+ # https://github.com/Fantomas42/django-tagging/commit/bbc7f25ea471dd903f39e08684d84ce59081bdef
+ f1 = FormTest.objects.create(tags='one two three')
+ Tag.objects.get(name='three').delete()
+ t2 = Tag.objects.get(name='two')
+ t2.name = 'new'
+ t2.save()
+ f1again = FormTest.objects.get(pk=f1.pk)
+ self.assertFalse('three' in f1again.tags)
+ self.assertFalse('two' in f1again.tags)
+ self.assertTrue('new' in f1again.tags)
+
+ def test_creation_without_specifying_tags(self):
+ f1 = FormTest()
+ self.assertEqual(f1.tags, '')
+
+ def test_creation_with_nullable_tags_field(self):
+ f1 = FormTestNull()
+ self.assertEqual(f1.tags, '')
+
+
class TestSettings(TestCase):
def setUp(self):
self.original_force_lower_case_tags = settings.FORCE_LOWERCASE_TAGS
self.dead_parrot = Parrot.objects.create(state='dead')
-
+
def tearDown(self):
settings.FORCE_LOWERCASE_TAGS = self.original_force_lower_case_tags
-
+
def test_force_lowercase_tags(self):
""" Test forcing tags to lowercase. """
-
+
settings.FORCE_LOWERCASE_TAGS = True
-
+
Tag.objects.update_tags(self.dead_parrot, 'foO bAr Ter')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
+ self.assertEqual(len(tags), 3)
foo_tag = get_tag('foo')
bar_tag = get_tag('bar')
ter_tag = get_tag('ter')
- self.failUnless(foo_tag in tags)
- self.failUnless(bar_tag in tags)
- self.failUnless(ter_tag in tags)
-
+ self.assertTrue(foo_tag in tags)
+ self.assertTrue(bar_tag in tags)
+ self.assertTrue(ter_tag in tags)
+
Tag.objects.update_tags(self.dead_parrot, 'foO bAr baZ')
tags = Tag.objects.get_for_object(self.dead_parrot)
baz_tag = get_tag('baz')
- self.assertEquals(len(tags), 3)
- self.failUnless(bar_tag in tags)
- self.failUnless(baz_tag in tags)
- self.failUnless(foo_tag in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(bar_tag in tags)
+ self.assertTrue(baz_tag in tags)
+ self.assertTrue(foo_tag in tags)
+
Tag.objects.add_tag(self.dead_parrot, 'FOO')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 3)
- self.failUnless(bar_tag in tags)
- self.failUnless(baz_tag in tags)
- self.failUnless(foo_tag in tags)
-
+ self.assertEqual(len(tags), 3)
+ self.assertTrue(bar_tag in tags)
+ self.assertTrue(baz_tag in tags)
+ self.assertTrue(foo_tag in tags)
+
Tag.objects.add_tag(self.dead_parrot, 'Zip')
tags = Tag.objects.get_for_object(self.dead_parrot)
- self.assertEquals(len(tags), 4)
+ self.assertEqual(len(tags), 4)
zip_tag = get_tag('zip')
- self.failUnless(bar_tag in tags)
- self.failUnless(baz_tag in tags)
- self.failUnless(foo_tag in tags)
- self.failUnless(zip_tag in tags)
-
+ self.assertTrue(bar_tag in tags)
+ self.assertTrue(baz_tag in tags)
+ self.assertTrue(foo_tag in tags)
+ self.assertTrue(zip_tag in tags)
+
f1 = FormTest.objects.create()
- f1.tags = u'TEST5'
+ f1.tags = 'TEST5'
f1.save()
tags = Tag.objects.get_for_object(f1)
test5_tag = get_tag('test5')
- self.assertEquals(len(tags), 1)
- self.failUnless(test5_tag in tags)
- self.assertEquals(f1.tags, u'test5')
+ self.assertEqual(len(tags), 1)
+ self.assertTrue(test5_tag in tags)
+ self.assertEqual(f1.tags, 'test5')
+
class TestTagUsageForModelBaseCase(TestCase):
def test_tag_usage_for_model_empty(self):
- self.assertEquals(Tag.objects.usage_for_model(Parrot), [])
+ self.assertEqual(Tag.objects.usage_for_model(Parrot), [])
+
class TestTagUsageForModel(TestCase):
def setUp(self):
@@ -438,75 +513,85 @@ class TestTagUsageForModel(TestCase):
('no more', 4, True, 'foo ter'),
('late', 2, False, 'bar ter'),
)
-
+
for state, perch_size, perch_smelly, tags in parrot_details:
perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
parrot = Parrot.objects.create(state=state, perch=perch)
Tag.objects.update_tags(parrot, tags)
-
+
def test_tag_usage_for_model(self):
tag_usage = Tag.objects.usage_for_model(Parrot, counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', 3) in relevant_attribute_list)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
- self.failUnless((u'ter', 3) in relevant_attribute_list)
-
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 3) in relevant_attribute_list)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 3) in relevant_attribute_list)
+
def test_tag_usage_for_model_with_min_count(self):
- tag_usage = Tag.objects.usage_for_model(Parrot, min_count = 2)
+ tag_usage = Tag.objects.usage_for_model(Parrot, min_count=2)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', 3) in relevant_attribute_list)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
- self.failUnless((u'ter', 3) in relevant_attribute_list)
-
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 3) in relevant_attribute_list)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 3) in relevant_attribute_list)
+
def test_tag_usage_with_filter_on_model_objects(self):
- tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state='no more'))
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, counts=True, filters=dict(state='no more'))
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 2)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state__startswith='p'))
+ self.assertEqual(len(relevant_attribute_list), 2)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, counts=True, filters=dict(state__startswith='p'))
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__size__gt=4))
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, counts=True, filters=dict(perch__size__gt=4))
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__smelly=True))
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, counts=True, filters=dict(perch__smelly=True))
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, min_count=2, filters=dict(perch__smelly=True))
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, min_count=2, filters=dict(perch__smelly=True))
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=4))
- relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', False) in relevant_attribute_list)
- self.failUnless((u'baz', False) in relevant_attribute_list)
- self.failUnless((u'foo', False) in relevant_attribute_list)
- self.failUnless((u'ter', False) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=99))
- relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 0)
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, filters=dict(perch__size__gt=4))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts'))
+ for tag in tag_usage]
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', False) in relevant_attribute_list)
+ self.assertTrue(('baz', False) in relevant_attribute_list)
+ self.assertTrue(('foo', False) in relevant_attribute_list)
+ self.assertTrue(('ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(
+ Parrot, filters=dict(perch__size__gt=99))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts'))
+ for tag in tag_usage]
+ self.assertEqual(len(relevant_attribute_list), 0)
+
class TestTagsRelatedForModel(TestCase):
def setUp(self):
@@ -516,71 +601,134 @@ class TestTagsRelatedForModel(TestCase):
('no more', 4, True, 'foo ter'),
('late', 2, False, 'bar ter'),
)
-
+
for state, perch_size, perch_smelly, tags in parrot_details:
perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
parrot = Parrot.objects.create(state=state, perch=perch)
Tag.objects.update_tags(parrot, tags)
-
+
def test_related_for_model_with_tag_query_sets_as_input(self):
- related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, min_count=2)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=False)
+ related_tags = Tag.objects.related_for_model(
+ Tag.objects.filter(name__in=['bar']), Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ Tag.objects.filter(name__in=['bar']), Parrot, min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ Tag.objects.filter(name__in=['bar']), Parrot, counts=False)
relevant_attribute_list = [tag.name for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless(u'baz' in relevant_attribute_list)
- self.failUnless(u'foo' in relevant_attribute_list)
- self.failUnless(u'ter' in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter']), Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter', 'baz']), Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 0)
-
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue('baz' in relevant_attribute_list)
+ self.assertTrue('foo' in relevant_attribute_list)
+ self.assertTrue('ter' in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ Tag.objects.filter(name__in=['bar', 'ter']), Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ Tag.objects.filter(name__in=['bar', 'ter', 'baz']),
+ Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 0)
+
def test_related_for_model_with_tag_strings_as_input(self):
# Once again, with feeling (strings)
- related_tags = Tag.objects.related_for_model('bar', Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model('bar', Parrot, min_count=2)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model('bar', Parrot, counts=False)
+ related_tags = Tag.objects.related_for_model(
+ 'bar', Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ 'bar', Parrot, min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ 'bar', Parrot, counts=False)
relevant_attribute_list = [tag.name for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless(u'baz' in relevant_attribute_list)
- self.failUnless(u'foo' in relevant_attribute_list)
- self.failUnless(u'ter' in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(['bar', 'ter'], Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
-
- related_tags = Tag.objects.related_for_model(['bar', 'ter', 'baz'], Parrot, counts=True)
- relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
- self.assertEquals(len(relevant_attribute_list), 0)
-
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue('baz' in relevant_attribute_list)
+ self.assertTrue('foo' in relevant_attribute_list)
+ self.assertTrue('ter' in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ ['bar', 'ter'], Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(
+ ['bar', 'ter', 'baz'], Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count)
+ for tag in related_tags]
+ self.assertEqual(len(relevant_attribute_list), 0)
+
+
+class TestTagCloudForModel(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ def test_tag_cloud_for_model(self):
+ tag_cloud = Tag.objects.cloud_for_model(Parrot)
+ relevant_attribute_list = [(tag.name, tag.count, tag.font_size)
+ for tag in tag_cloud]
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 3, 4) in relevant_attribute_list)
+ self.assertTrue(('baz', 1, 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 2, 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 3, 4) in relevant_attribute_list)
+
+ def test_tag_cloud_for_model_filters(self):
+ tag_cloud = Tag.objects.cloud_for_model(Parrot,
+ filters={'state': 'no more'})
+ relevant_attribute_list = [(tag.name, tag.count, tag.font_size)
+ for tag in tag_cloud]
+ self.assertEqual(len(relevant_attribute_list), 2)
+ self.assertTrue(('foo', 1, 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1, 1) in relevant_attribute_list)
+
+ def test_tag_cloud_for_model_min_count(self):
+ tag_cloud = Tag.objects.cloud_for_model(Parrot, min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count, tag.font_size)
+ for tag in tag_cloud]
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 3, 4) in relevant_attribute_list)
+ self.assertTrue(('foo', 2, 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 3, 4) in relevant_attribute_list)
+
+
class TestGetTaggedObjectsByModel(TestCase):
def setUp(self):
parrot_details = (
@@ -589,112 +737,123 @@ class TestGetTaggedObjectsByModel(TestCase):
('no more', 4, True, 'foo ter'),
('late', 2, False, 'bar ter'),
)
-
+
for state, perch_size, perch_smelly, tags in parrot_details:
perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
parrot = Parrot.objects.create(state=state, perch=perch)
Tag.objects.update_tags(parrot, tags)
-
+
self.foo = Tag.objects.get(name='foo')
self.bar = Tag.objects.get(name='bar')
self.baz = Tag.objects.get(name='baz')
self.ter = Tag.objects.get(name='ter')
-
- self.pining_for_the_fjords_parrot = Parrot.objects.get(state='pining for the fjords')
+
+ self.pining_for_the_fjords_parrot = Parrot.objects.get(
+ state='pining for the fjords')
self.passed_on_parrot = Parrot.objects.get(state='passed on')
self.no_more_parrot = Parrot.objects.get(state='no more')
self.late_parrot = Parrot.objects.get(state='late')
-
+
def test_get_by_model_simple(self):
parrots = TaggedItem.objects.get_by_model(Parrot, self.foo)
- self.assertEquals(len(parrots), 2)
- self.failUnless(self.no_more_parrot in parrots)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 2)
+ self.assertTrue(self.no_more_parrot in parrots)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
parrots = TaggedItem.objects.get_by_model(Parrot, self.bar)
- self.assertEquals(len(parrots), 3)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 3)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
def test_get_by_model_intersection(self):
parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.baz])
- self.assertEquals(len(parrots), 0)
-
+ self.assertEqual(len(parrots), 0)
+
parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.bar])
- self.assertEquals(len(parrots), 1)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 1)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
parrots = TaggedItem.objects.get_by_model(Parrot, [self.bar, self.ter])
- self.assertEquals(len(parrots), 2)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
-
+ self.assertEqual(len(parrots), 2)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+
# Issue 114 - Intersection with non-existant tags
parrots = TaggedItem.objects.get_intersection_by_model(Parrot, [])
- self.assertEquals(len(parrots), 0)
-
+ self.assertEqual(len(parrots), 0)
+
def test_get_by_model_with_tag_querysets_as_input(self):
- parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'baz']))
- self.assertEquals(len(parrots), 0)
-
- parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'bar']))
- self.assertEquals(len(parrots), 1)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
- parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['bar', 'ter']))
- self.assertEquals(len(parrots), 2)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
-
+ parrots = TaggedItem.objects.get_by_model(
+ Parrot, Tag.objects.filter(name__in=['foo', 'baz']))
+ self.assertEqual(len(parrots), 0)
+
+ parrots = TaggedItem.objects.get_by_model(
+ Parrot, Tag.objects.filter(name__in=['foo', 'bar']))
+ self.assertEqual(len(parrots), 1)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(
+ Parrot, Tag.objects.filter(name__in=['bar', 'ter']))
+ self.assertEqual(len(parrots), 2)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+
def test_get_by_model_with_strings_as_input(self):
parrots = TaggedItem.objects.get_by_model(Parrot, 'foo baz')
- self.assertEquals(len(parrots), 0)
-
+ self.assertEqual(len(parrots), 0)
+
parrots = TaggedItem.objects.get_by_model(Parrot, 'foo bar')
- self.assertEquals(len(parrots), 1)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 1)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
parrots = TaggedItem.objects.get_by_model(Parrot, 'bar ter')
- self.assertEquals(len(parrots), 2)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
-
+ self.assertEqual(len(parrots), 2)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+
def test_get_by_model_with_lists_of_strings_as_input(self):
parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'baz'])
- self.assertEquals(len(parrots), 0)
-
+ self.assertEqual(len(parrots), 0)
+
parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'bar'])
- self.assertEquals(len(parrots), 1)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 1)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
parrots = TaggedItem.objects.get_by_model(Parrot, ['bar', 'ter'])
- self.assertEquals(len(parrots), 2)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
-
+ self.assertEqual(len(parrots), 2)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+
def test_get_by_nonexistent_tag(self):
# Issue 50 - Get by non-existent tag
parrots = TaggedItem.objects.get_by_model(Parrot, 'argatrons')
- self.assertEquals(len(parrots), 0)
-
+ self.assertEqual(len(parrots), 0)
+
def test_get_union_by_model(self):
parrots = TaggedItem.objects.get_union_by_model(Parrot, ['foo', 'ter'])
- self.assertEquals(len(parrots), 4)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.no_more_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 4)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.no_more_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
parrots = TaggedItem.objects.get_union_by_model(Parrot, ['bar', 'baz'])
- self.assertEquals(len(parrots), 3)
- self.failUnless(self.late_parrot in parrots)
- self.failUnless(self.passed_on_parrot in parrots)
- self.failUnless(self.pining_for_the_fjords_parrot in parrots)
-
+ self.assertEqual(len(parrots), 3)
+ self.assertTrue(self.late_parrot in parrots)
+ self.assertTrue(self.passed_on_parrot in parrots)
+ self.assertTrue(self.pining_for_the_fjords_parrot in parrots)
+
# Issue 114 - Union with non-existant tags
parrots = TaggedItem.objects.get_union_by_model(Parrot, [])
- self.assertEquals(len(parrots), 0)
+ self.assertEqual(len(parrots), 0)
+ parrots = TaggedItem.objects.get_union_by_model(Parrot, ['albert'])
+ self.assertEqual(len(parrots), 0)
+
+ Tag.objects.create(name='titi')
+ parrots = TaggedItem.objects.get_union_by_model(Parrot, ['titi'])
+ self.assertEqual(len(parrots), 0)
+
class TestGetRelatedTaggedItems(TestCase):
def setUp(self):
@@ -704,12 +863,12 @@ class TestGetRelatedTaggedItems(TestCase):
('no more', 4, True, 'foo ter'),
('late', 2, False, 'bar ter'),
)
-
+
for state, perch_size, perch_smelly, tags in parrot_details:
perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
parrot = Parrot.objects.create(state=state, perch=perch)
Tag.objects.update_tags(parrot, tags)
-
+
self.l1 = Link.objects.create(name='link 1')
Tag.objects.update_tags(self.l1, 'tag1 tag2 tag3 tag4 tag5')
self.l2 = Link.objects.create(name='link 2')
@@ -717,44 +876,46 @@ class TestGetRelatedTaggedItems(TestCase):
self.l3 = Link.objects.create(name='link 3')
Tag.objects.update_tags(self.l3, 'tag1')
self.l4 = Link.objects.create(name='link 4')
-
+
self.a1 = Article.objects.create(name='article 1')
Tag.objects.update_tags(self.a1, 'tag1 tag2 tag3 tag4')
-
+
def test_get_related_objects_of_same_model(self):
related_objects = TaggedItem.objects.get_related(self.l1, Link)
- self.assertEquals(len(related_objects), 2)
- self.failUnless(self.l2 in related_objects)
- self.failUnless(self.l3 in related_objects)
-
+ self.assertEqual(len(related_objects), 2)
+ self.assertTrue(self.l2 in related_objects)
+ self.assertTrue(self.l3 in related_objects)
+
related_objects = TaggedItem.objects.get_related(self.l4, Link)
- self.assertEquals(len(related_objects), 0)
-
+ self.assertEqual(len(related_objects), 0)
+
def test_get_related_objects_of_same_model_limited_number_of_results(self):
# This fails on Oracle because it has no support for a 'LIMIT' clause.
- # See http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:127412348064
-
+ # See http://bit.ly/1AYNEsa
+
# ask for no more than 1 result
related_objects = TaggedItem.objects.get_related(self.l1, Link, num=1)
- self.assertEquals(len(related_objects), 1)
- self.failUnless(self.l2 in related_objects)
-
+ self.assertEqual(len(related_objects), 1)
+ self.assertTrue(self.l2 in related_objects)
+
def test_get_related_objects_of_same_model_limit_related_items(self):
- related_objects = TaggedItem.objects.get_related(self.l1, Link.objects.exclude(name='link 3'))
- self.assertEquals(len(related_objects), 1)
- self.failUnless(self.l2 in related_objects)
-
+ related_objects = TaggedItem.objects.get_related(
+ self.l1, Link.objects.exclude(name='link 3'))
+ self.assertEqual(len(related_objects), 1)
+ self.assertTrue(self.l2 in related_objects)
+
def test_get_related_objects_of_different_model(self):
related_objects = TaggedItem.objects.get_related(self.a1, Link)
- self.assertEquals(len(related_objects), 3)
- self.failUnless(self.l1 in related_objects)
- self.failUnless(self.l2 in related_objects)
- self.failUnless(self.l3 in related_objects)
-
+ self.assertEqual(len(related_objects), 3)
+ self.assertTrue(self.l1 in related_objects)
+ self.assertTrue(self.l2 in related_objects)
+ self.assertTrue(self.l3 in related_objects)
+
Tag.objects.update_tags(self.a1, 'tag6')
related_objects = TaggedItem.objects.get_related(self.a1, Link)
- self.assertEquals(len(related_objects), 0)
-
+ self.assertEqual(len(related_objects), 0)
+
+
class TestTagUsageForQuerySet(TestCase):
def setUp(self):
parrot_details = (
@@ -763,102 +924,125 @@ class TestTagUsageForQuerySet(TestCase):
('no more', 4, True, 'foo ter'),
('late', 2, False, 'bar ter'),
)
-
+
for state, perch_size, perch_smelly, tags in parrot_details:
perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
parrot = Parrot.objects.create(state=state, perch=perch)
Tag.objects.update_tags(parrot, tags)
-
+
def test_tag_usage_for_queryset(self):
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state='no more'), counts=True)
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(state='no more'), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 2)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state__startswith='p'), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 2)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(state__startswith='p'), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(perch__size__gt=4), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'baz', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('baz', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(perch__smelly=True), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', 1) in relevant_attribute_list)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), min_count=2)
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 1) in relevant_attribute_list)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(perch__smelly=True), min_count=2)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4))
- relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 4)
- self.failUnless((u'bar', False) in relevant_attribute_list)
- self.failUnless((u'baz', False) in relevant_attribute_list)
- self.failUnless((u'foo', False) in relevant_attribute_list)
- self.failUnless((u'ter', False) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=99))
- relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 0)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(perch__size__gt=4))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts'))
+ for tag in tag_usage]
+ self.assertEqual(len(relevant_attribute_list), 4)
+ self.assertTrue(('bar', False) in relevant_attribute_list)
+ self.assertTrue(('baz', False) in relevant_attribute_list)
+ self.assertTrue(('foo', False) in relevant_attribute_list)
+ self.assertTrue(('ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(perch__size__gt=99))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts'))
+ for tag in tag_usage]
+ self.assertEqual(len(relevant_attribute_list), 0)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(Q(perch__size__gt=6) |
+ Q(state__startswith='l')), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), min_count=2)
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(Q(perch__size__gt=6) |
+ Q(state__startswith='l')), min_count=2)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')))
- relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', False) in relevant_attribute_list)
- self.failUnless((u'foo', False) in relevant_attribute_list)
- self.failUnless((u'ter', False) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state='passed on'), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.filter(Q(perch__size__gt=6) |
+ Q(state__startswith='l')))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts'))
+ for tag in tag_usage]
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', False) in relevant_attribute_list)
+ self.assertTrue(('foo', False) in relevant_attribute_list)
+ self.assertTrue(('ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.exclude(state='passed on'), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 3)
- self.failUnless((u'bar', 2) in relevant_attribute_list)
- self.failUnless((u'foo', 2) in relevant_attribute_list)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state__startswith='p'), min_count=2)
+ self.assertEqual(len(relevant_attribute_list), 3)
+ self.assertTrue(('bar', 2) in relevant_attribute_list)
+ self.assertTrue(('foo', 2) in relevant_attribute_list)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.exclude(state__startswith='p'), min_count=2)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 1)
- self.failUnless((u'ter', 2) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(Q(perch__size__gt=6) | Q(perch__smelly=False)), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 1)
+ self.assertTrue(('ter', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.exclude(Q(perch__size__gt=6) |
+ Q(perch__smelly=False)), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 2)
- self.failUnless((u'foo', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
- tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(perch__smelly=True).filter(state__startswith='l'), counts=True)
+ self.assertEqual(len(relevant_attribute_list), 2)
+ self.assertTrue(('foo', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(
+ Parrot.objects.exclude(perch__smelly=True).filter(
+ state__startswith='l'), counts=True)
relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
- self.assertEquals(len(relevant_attribute_list), 2)
- self.failUnless((u'bar', 1) in relevant_attribute_list)
- self.failUnless((u'ter', 1) in relevant_attribute_list)
-
+ self.assertEqual(len(relevant_attribute_list), 2)
+ self.assertTrue(('bar', 1) in relevant_attribute_list)
+ self.assertTrue(('ter', 1) in relevant_attribute_list)
+
+
################
# Model Fields #
################
@@ -869,33 +1053,121 @@ class TestTagFieldInForms(TestCase):
class TestForm(forms.ModelForm):
class Meta:
model = FormTest
-
+ fields = forms.ALL_FIELDS
+
form = TestForm()
- self.assertEquals(form.fields['tags'].__class__.__name__, 'TagField')
-
+ self.assertEqual(form.fields['tags'].__class__.__name__, 'TagField')
+
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.assertEquals(edit_string_for_tags([plain]), u'plain')
- self.assertEquals(edit_string_for_tags([plain, spaces]), u'plain, spa ces')
- self.assertEquals(edit_string_for_tags([plain, spaces, comma]), u'plain, spa ces, "com,ma"')
- self.assertEquals(edit_string_for_tags([plain, comma]), u'plain "com,ma"')
- self.assertEquals(edit_string_for_tags([comma, spaces]), u'"com,ma", spa ces')
-
+ self.assertEqual(edit_string_for_tags([plain]), 'plain')
+ self.assertEqual(edit_string_for_tags([plain, spaces]),
+ 'plain, spa ces')
+ self.assertEqual(edit_string_for_tags([plain, spaces, comma]),
+ 'plain, spa ces, "com,ma"')
+ self.assertEqual(edit_string_for_tags([plain, comma]),
+ 'plain "com,ma"')
+ self.assertEqual(edit_string_for_tags([comma, spaces]),
+ '"com,ma", spa ces')
+
def test_tag_d_validation(self):
- t = TagField()
- self.assertEquals(t.clean('foo'), u'foo')
- self.assertEquals(t.clean('foo bar baz'), u'foo bar baz')
- self.assertEquals(t.clean('foo,bar,baz'), u'foo,bar,baz')
- self.assertEquals(t.clean('foo, bar, baz'), u'foo, bar, baz')
- self.assertEquals(t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar'),
- u'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar')
- try:
- t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar')
- except forms.ValidationError, ve:
- self.assertEquals(str(ve), "[u'Each tag may be no more than 50 characters long.']")
- except Exception, e:
- raise e
- else:
- raise self.failureException('a ValidationError exception was supposed to have been raised.')
+ t = TagField(required=False)
+ self.assertEqual(t.clean(''), '')
+ self.assertEqual(t.clean('foo'), 'foo')
+ self.assertEqual(t.clean('foo bar baz'), 'foo bar baz')
+ self.assertEqual(t.clean('foo,bar,baz'), 'foo,bar,baz')
+ self.assertEqual(t.clean('foo, bar, baz'), 'foo, bar, baz')
+ self.assertEqual(
+ t.clean('foo qwertyuiopasdfghjklzxcvbnm'
+ 'qwertyuiopasdfghjklzxcvb bar'),
+ 'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar')
+ self.assertRaises(
+ forms.ValidationError, t.clean,
+ 'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar')
+
+ def test_tag_get_from_model(self):
+ FormTest.objects.create(tags='test3 test2 test1')
+ FormTest.objects.create(tags='toto titi')
+ self.assertEquals(FormTest.tags, 'test1 test2 test3 titi toto')
+
+
+#########
+# Forms #
+#########
+
+
+class TestTagAdminForm(TestCase):
+
+ def test_clean_name(self):
+ datas = {'name': 'tag'}
+ form = TagAdminForm(datas)
+ self.assertTrue(form.is_valid())
+
+ def test_clean_name_multi(self):
+ datas = {'name': 'tag error'}
+ form = TagAdminForm(datas)
+ self.assertFalse(form.is_valid())
+
+ def test_clean_name_too_long(self):
+ datas = {'name': 't' * (settings.MAX_TAG_LENGTH + 1)}
+ form = TagAdminForm(datas)
+ self.assertFalse(form.is_valid())
+
+#########
+# Views #
+#########
+
+
+@override_settings(
+ ROOT_URLCONF='tagging.tests.urls',
+ TEMPLATE_LOADERS=(
+ 'tagging.tests.utils.VoidLoader',
+ ),
+)
+class TestTaggedObjectList(TestCase):
+
+ def setUp(self):
+ self.a1 = Article.objects.create(name='article 1')
+ self.a2 = Article.objects.create(name='article 2')
+ Tag.objects.update_tags(self.a1, 'static tag test')
+ Tag.objects.update_tags(self.a2, 'static test')
+
+ def get_view(self, url, queries=1, code=200,
+ expected_items=1,
+ friendly_context='article_list',
+ template='tests/article_list.html'):
+ with self.assertNumQueries(queries):
+ response = self.client.get(url)
+ self.assertEquals(response.status_code, code)
+
+ if code == 200:
+ self.assertTrue(isinstance(response.context['tag'], Tag))
+ self.assertEqual(len(response.context['object_list']),
+ expected_items)
+ self.assertEqual(response.context['object_list'],
+ response.context[friendly_context])
+ self.assertTemplateUsed(response, template)
+ return response
+
+ def test_view_static(self):
+ self.get_view('/static/', expected_items=2)
+
+ def test_view_dynamic(self):
+ self.get_view('/tag/', expected_items=1)
+
+ def test_view_related(self):
+ response = self.get_view('/static/related/',
+ queries=2, expected_items=2)
+ self.assertEquals(len(response.context['related_tags']), 2)
+
+ def test_view_no_queryset_no_model(self):
+ self.assertRaises(ImproperlyConfigured, self.get_view,
+ '/no-query-no-model/')
+
+ def test_view_no_tag(self):
+ self.assertRaises(AttributeError, self.get_view, '/no-tag/')
+
+ def test_view_404(self):
+ self.get_view('/unavailable/', code=404)
diff --git a/tagging/tests/urls.py b/tagging/tests/urls.py
new file mode 100644
index 0000000..a78dc8b
--- /dev/null
+++ b/tagging/tests/urls.py
@@ -0,0 +1,20 @@
+"""Test urls for tagging."""
+from django.conf.urls import url
+
+from tagging.views import TaggedObjectList
+from tagging.tests.models import Article
+
+
+class StaticTaggedObjectList(TaggedObjectList):
+ tag = 'static'
+ queryset = Article.objects.all()
+
+
+urlpatterns = [
+ url(r'^static/$', StaticTaggedObjectList.as_view()),
+ url(r'^static/related/$', StaticTaggedObjectList.as_view(
+ related_tags=True)),
+ url(r'^no-tag/$', TaggedObjectList.as_view(model=Article)),
+ url(r'^no-query-no-model/$', TaggedObjectList.as_view()),
+ url(r'^(?P<tag>[^/]+(?u))/$', TaggedObjectList.as_view(model=Article)),
+]
diff --git a/tagging/tests/utils.py b/tagging/tests/utils.py
new file mode 100644
index 0000000..2f041d9
--- /dev/null
+++ b/tagging/tests/utils.py
@@ -0,0 +1,16 @@
+"""
+Tests utils for tagging.
+"""
+from django.template.loader import BaseLoader
+
+
+class VoidLoader(BaseLoader):
+ """
+ Template loader which is always returning
+ an empty template.
+ """
+ is_usable = True
+ _accepts_engine_in_init = True
+
+ def load_template_source(self, template_name, template_dirs=None):
+ return ('', 'voidloader:%s' % template_name)
diff --git a/tagging/utils.py b/tagging/utils.py
index e89bab0..6c1492f 100644
--- a/tagging/utils.py
+++ b/tagging/utils.py
@@ -3,17 +3,15 @@ Tagging utilities - from user tag input parsing to tag cloud
calculation.
"""
import math
-import types
+from django.utils import six
from django.db.models.query import QuerySet
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
from django.utils.translation import ugettext as _
-# Python 2.3 compatibility
-try:
- set
-except NameError:
- from sets import Set as set
+# Font size distribution algorithms
+LOGARITHMIC, LINEAR = 1, 2
+
def parse_tag_input(input):
"""
@@ -26,13 +24,13 @@ def parse_tag_input(input):
if not input:
return []
- input = force_unicode(input)
+ input = force_text(input)
# 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 input and u'"' not in input:
- words = list(set(split_strip(input, u' ')))
+ if ',' not in input and '"' not in input:
+ words = list(set(split_strip(input, ' ')))
words.sort()
return words
@@ -46,56 +44,55 @@ def parse_tag_input(input):
i = iter(input)
try:
while 1:
- c = i.next()
- if c == u'"':
+ c = next(i)
+ if c == '"':
if buffer:
- to_be_split.append(u''.join(buffer))
+ to_be_split.append(''.join(buffer))
buffer = []
# Find the matching quote
open_quote = True
- c = i.next()
- while c != u'"':
+ c = next(i)
+ while c != '"':
buffer.append(c)
- c = i.next()
+ c = next(i)
if buffer:
- word = u''.join(buffer).strip()
+ word = ''.join(buffer).strip()
if word:
words.append(word)
buffer = []
open_quote = False
else:
- if not saw_loose_comma and c == u',':
+ if not saw_loose_comma and c == ',':
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:
+ if open_quote and ',' in buffer:
saw_loose_comma = True
- to_be_split.append(u''.join(buffer))
+ to_be_split.append(''.join(buffer))
if to_be_split:
if saw_loose_comma:
- delimiter = u','
+ delimiter = ','
else:
- delimiter = u' '
+ delimiter = ' '
for chunk in to_be_split:
words.extend(split_strip(chunk, delimiter))
words = list(set(words))
words.sort()
return words
-def split_strip(input, delimiter=u','):
+
+def split_strip(input, delimiter=','):
"""
Splits ``input`` on ``delimiter``, stripping each resulting string
and returning a list of non-empty strings.
"""
- if not input:
- return []
-
words = [w.strip() for w in input.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
@@ -113,19 +110,20 @@ def edit_string_for_tags(tags):
use_commas = False
for tag in tags:
name = tag.name
- if u',' in name:
+ if ',' in name:
names.append('"%s"' % name)
continue
- elif u' ' in name:
+ elif ' ' in name:
if not use_commas:
use_commas = True
names.append(name)
if use_commas:
- glue = u', '
+ glue = ', '
else:
- glue = u' '
+ glue = ' '
return glue.join(names)
+
def get_queryset_and_model(queryset_or_model):
"""
Given a ``QuerySet`` or a ``Model``, returns a two-tuple of
@@ -139,6 +137,7 @@ def get_queryset_and_model(queryset_or_model):
except AttributeError:
return queryset_or_model._default_manager.all(), queryset_or_model
+
def get_tag_list(tags):
"""
Utility function for accepting tag input in a flexible manner.
@@ -164,32 +163,35 @@ def get_tag_list(tags):
return [tags]
elif isinstance(tags, QuerySet) and tags.model is Tag:
return tags
- elif isinstance(tags, types.StringTypes):
+ elif isinstance(tags, six.string_types):
return Tag.objects.filter(name__in=parse_tag_input(tags))
- elif isinstance(tags, (types.ListType, types.TupleType)):
+ elif isinstance(tags, (list, tuple)):
if len(tags) == 0:
return tags
contents = set()
for item in tags:
- if isinstance(item, types.StringTypes):
+ if isinstance(item, six.string_types):
contents.add('string')
elif isinstance(item, Tag):
contents.add('tag')
- elif isinstance(item, (types.IntType, types.LongType)):
+ elif isinstance(item, six.integer_types):
contents.add('int')
if len(contents) == 1:
if 'string' in contents:
- return Tag.objects.filter(name__in=[force_unicode(tag) \
+ return Tag.objects.filter(name__in=[force_text(tag)
for tag in tags])
elif 'tag' in contents:
return tags
elif 'int' in contents:
return Tag.objects.filter(id__in=tags)
else:
- raise ValueError(_('If a list or tuple of tags is provided, they must all be tag names, Tag objects or Tag ids.'))
+ raise ValueError(
+ _('If a list or tuple of tags is provided, '
+ 'they must all be tag names, Tag objects or Tag ids.'))
else:
raise ValueError(_('The tag input given was invalid.'))
+
def get_tag(tag):
"""
Utility function for accepting single tag input in a flexible
@@ -206,34 +208,35 @@ def get_tag(tag):
return tag
try:
- if isinstance(tag, types.StringTypes):
+ if isinstance(tag, six.string_types):
return Tag.objects.get(name=tag)
- elif isinstance(tag, (types.IntType, types.LongType)):
+ elif isinstance(tag, six.integer_types):
return Tag.objects.get(id=tag)
except Tag.DoesNotExist:
pass
return None
-# Font size distribution algorithms
-LOGARITHMIC, LINEAR = 1, 2
def _calculate_thresholds(min_weight, max_weight, steps):
delta = (max_weight - min_weight) / float(steps)
return [min_weight + i * delta for i in range(1, steps + 1)]
+
def _calculate_tag_weight(weight, max_weight, distribution):
"""
Logarithmic tag weight calculation is based on code from the
- `Tag Cloud`_ plugin for Mephisto, by Sven Fuchs.
+ *Tag Cloud* plugin for Mephisto, by Sven Fuchs.
- .. _`Tag Cloud`: http://www.artweb-design.de/projects/mephisto-plugin-tag-cloud
+ http://www.artweb-design.de/projects/mephisto-plugin-tag-cloud
"""
if distribution == LINEAR or max_weight == 1:
return weight
elif distribution == LOGARITHMIC:
return math.log(weight) * max_weight / math.log(max_weight)
- raise ValueError(_('Invalid distribution algorithm specified: %s.') % distribution)
+ raise ValueError(
+ _('Invalid distribution algorithm specified: %s.') % distribution)
+
def calculate_cloud(tags, steps=4, distribution=LOGARITHMIC):
"""
@@ -255,7 +258,8 @@ def calculate_cloud(tags, steps=4, distribution=LOGARITHMIC):
thresholds = _calculate_thresholds(min_weight, max_weight, steps)
for tag in tags:
font_set = False
- tag_weight = _calculate_tag_weight(tag.count, max_weight, distribution)
+ tag_weight = _calculate_tag_weight(
+ tag.count, max_weight, distribution)
for i in range(steps):
if not font_set and tag_weight <= thresholds[i]:
tag.font_size = i + 1
diff --git a/tagging/views.py b/tagging/views.py
index 9e7e2f5..527bdd7 100644
--- a/tagging/views.py
+++ b/tagging/views.py
@@ -2,17 +2,20 @@
Tagging related views.
"""
from django.http import Http404
+from django.views.generic.list import ListView
from django.utils.translation import ugettext as _
-from django.views.generic.list_detail import object_list
+from django.core.exceptions import ImproperlyConfigured
-from tagging.models import Tag, TaggedItem
-from tagging.utils import get_tag, get_queryset_and_model
+from tagging.models import Tag
+from tagging.models import TaggedItem
+from tagging.utils import get_tag
+from tagging.utils import get_queryset_and_model
-def tagged_object_list(request, queryset_or_model=None, tag=None,
- related_tags=False, related_tag_counts=True, **kwargs):
+
+class TaggedObjectList(ListView):
"""
A thin wrapper around
- ``django.views.generic.list_detail.object_list`` which creates a
+ ``django.views.generic.list.ListView`` which creates a
``QuerySet`` containing instances of the given queryset or model
tagged with the given tag.
@@ -26,27 +29,50 @@ def tagged_object_list(request, queryset_or_model=None, tag=None,
tag will have a ``count`` attribute indicating the number of items
which have it in addition to the given tag.
"""
- if queryset_or_model is None:
- try:
- queryset_or_model = kwargs.pop('queryset_or_model')
- except KeyError:
- raise AttributeError(_('tagged_object_list must be called with a queryset or a model.'))
-
- if tag is None:
- try:
- tag = kwargs.pop('tag')
- except KeyError:
- raise AttributeError(_('tagged_object_list must be called with a tag.'))
-
- tag_instance = get_tag(tag)
- if tag_instance is None:
- raise Http404(_('No Tag found matching "%s".') % tag)
- queryset = TaggedItem.objects.get_by_model(queryset_or_model, tag_instance)
- if not kwargs.has_key('extra_context'):
- kwargs['extra_context'] = {}
- kwargs['extra_context']['tag'] = tag_instance
- if related_tags:
- kwargs['extra_context']['related_tags'] = \
- Tag.objects.related_for_model(tag_instance, queryset_or_model,
- counts=related_tag_counts)
- return object_list(request, queryset, **kwargs)
+ tag = None
+ related_tags = False
+ related_tag_counts = True
+
+ def get_tag(self):
+ if self.tag is None:
+ try:
+ self.tag = self.kwargs.pop('tag')
+ except KeyError:
+ raise AttributeError(
+ _('TaggedObjectList must be called with a tag.'))
+
+ tag_instance = get_tag(self.tag)
+ if tag_instance is None:
+ raise Http404(_('No Tag found matching "%s".') % self.tag)
+
+ return tag_instance
+
+ def get_queryset_or_model(self):
+ if self.queryset is not None:
+ return self.queryset
+ elif self.model is not None:
+ return self.model
+ else:
+ raise ImproperlyConfigured(
+ "%(cls)s is missing a QuerySet. Define "
+ "%(cls)s.model, %(cls)s.queryset, or override "
+ "%(cls)s.get_queryset_or_model()." % {
+ 'cls': self.__class__.__name__
+ }
+ )
+
+ def get_queryset(self):
+ self.queryset_or_model = self.get_queryset_or_model()
+ self.tag_instance = self.get_tag()
+ return TaggedItem.objects.get_by_model(
+ self.queryset_or_model, self.tag_instance)
+
+ def get_context_data(self, **kwargs):
+ context = super(TaggedObjectList, self).get_context_data(**kwargs)
+ context['tag'] = self.tag_instance
+
+ if self.related_tags:
+ queryset, model = get_queryset_and_model(self.queryset_or_model)
+ context['related_tags'] = Tag.objects.related_for_model(
+ self.tag_instance, model, counts=self.related_tag_counts)
+ return context