SimpleModel.__str__() - Code Metrics - Inspection of "Fix #133" - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#135)

by Iacopo

created 2016-04-19 23:01 UTC

SimpleModel.str() A

↳ Parent: SimpleModel

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	2
rs	10
cc	1

from __future__ import unicode_literals
from django.core.urlresolvers import reverse
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from parler.fields import TranslatedField
from parler.models import TranslatableModel, TranslatedFields, TranslatedFieldsModel
from parler.utils.context import switch_language


class ManualModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')


class ManualModelTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(ManualModel, related_name='translations')
    tr_title = models.CharField(max_length=200)


@python_2_unicode_compatible
class SimpleModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')

    translations = TranslatedFields(
        tr_title = models.CharField("Translated Title", max_length=200)
    )

    def __str__(self):
        return self.tr_title


@python_2_unicode_compatible
class DateTimeModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')
    datetime = models.DateTimeField()

    translations = TranslatedFields(
        tr_title=models.CharField("Translated Title", max_length=200)
    )

    def __str__(self):
        return self.tr_title


@python_2_unicode_compatible
class AnyLanguageModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')
    tr_title = TranslatedField(any_language=True)

    translations = TranslatedFields(
        tr_title = models.CharField(max_length=200)
    )

    def __str__(self):
        return self.tr_title


@python_2_unicode_compatible
class EmptyModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')

    # Still tracks how many languages there are, but no actual translated fields exist yet.
    # This is useful when the model is a parent object for inlines. The parent model defines the language tabs.
    translations = TranslatedFields()

    def __str__(self):
        return self.shared


@python_2_unicode_compatible
class ArticleSlugModel(TranslatableModel):
    translations = TranslatedFields(
        slug = models.SlugField()
    )

    def __str__(self):
        return self.slug

    def get_absolute_url(self):
        with switch_language(self):
            return reverse('article-slug-test-view', kwargs={'slug': self.slug})


class AbstractModel(TranslatableModel):
    # Already declared, but not yet linkable to a TranslatedFieldsModel
    tr_title = TranslatedField(any_language=True)

    class Meta:
        abstract = True


class ConcreteModel(AbstractModel):
    translations = TranslatedFields(
        tr_title = models.CharField("Translated Title", max_length=200)
    )


class UniqueTogetherModel(TranslatableModel):
    translations = TranslatedFields(
        slug = models.SlugField(),
        meta = {
            'unique_together': [
                ('slug', 'language_code',),
            ]
        }
    )


class Level1(TranslatableModel):
    l1_translations = TranslatedFields(
        l1_title = models.CharField(max_length=200)
    )


class Level2(Level1):
    l2_translations = TranslatedFields(
        l2_title = models.CharField(max_length=200)
    )


class ProxyBase(TranslatableModel):
    base_translations = TranslatedFields(
        base_title = models.CharField(max_length=200)
    )


class ProxyModel(ProxyBase):
    proxy_translations = TranslatedFields(
        proxy_title = models.CharField(max_length=200)
    )

    class Meta:
        proxy = True


class DoubleModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')


class DoubleModelTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(DoubleModel, related_name='base_translations')
    l1_title = models.CharField(max_length=200)


class DoubleModelMoreTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(DoubleModel, related_name='more_translations')
    l2_title = models.CharField(max_length=200)


class RegularModel(models.Model):
    # Normal model without translations. Test how replacing the field works.
    original_field = models.CharField(default="untranslated", max_length=255)


class CharModel(TranslatableModel):
    id = models.CharField(max_length=45, primary_key=True)


class CharModelTranslation(TranslatedFieldsModel):
    master = models.ForeignKey(CharModel)
    tr_title = models.CharField(max_length=200)


class ForeignKeyTranslationModel(TranslatableModel):
    translations = TranslatedFields(
        translated_foreign = models.ForeignKey('RegularModel'),
    )
    shared = models.CharField(max_length=200)


class TranslationRelated(TranslatableModel):
    shared = models.CharField(max_length=200)
    translation_relations = TranslatedField()


class TranslationRelatedTranslation(TranslatedFieldsModel):
    master = models.ForeignKey(TranslationRelated, related_name='translations')
    title = models.CharField(max_length=200)
    m2m_regular = models.ManyToManyField(RegularModel)


class TranslationRelatedRelation(models.Model):
    translation = models.ForeignKey(TranslationRelatedTranslation, related_name='translation_relations')
    name = models.CharField(max_length=200)


1			from __future__ import unicode_literals
2			from django.core.urlresolvers import reverse
3			from django.db import models
4			from django.utils.encoding import python_2_unicode_compatible
5			from parler.fields import TranslatedField
6			from parler.models import TranslatableModel, TranslatedFields, TranslatedFieldsModel
7			from parler.utils.context import switch_language
8
9
10			class ManualModel(TranslatableModel):
11			shared = models.CharField(max_length=200, default='')
12
13
14			class ManualModelTranslations(TranslatedFieldsModel):
15			master = models.ForeignKey(ManualModel, related_name='translations')
16			tr_title = models.CharField(max_length=200)
17
18
19			@python_2_unicode_compatible
20			class SimpleModel(TranslatableModel):
21			shared = models.CharField(max_length=200, default='')
22
23			translations = TranslatedFields(
24			tr_title = models.CharField("Translated Title", max_length=200)
25			)
26
27			def __str__(self):
28			return self.tr_title
29
30
31			@python_2_unicode_compatible
32			class DateTimeModel(TranslatableModel):
33			shared = models.CharField(max_length=200, default='')
34			datetime = models.DateTimeField()
35
36			translations = TranslatedFields(
37			tr_title=models.CharField("Translated Title", max_length=200)
38			)
39
40			def __str__(self):
41			return self.tr_title
42
43
44			@python_2_unicode_compatible
45			class AnyLanguageModel(TranslatableModel):
46			shared = models.CharField(max_length=200, default='')
47			tr_title = TranslatedField(any_language=True)
48
49			translations = TranslatedFields(
50			tr_title = models.CharField(max_length=200)
51			)
52
53			def __str__(self):
54			return self.tr_title
55
56
57			@python_2_unicode_compatible
58			class EmptyModel(TranslatableModel):
59			shared = models.CharField(max_length=200, default='')
60
61			# Still tracks how many languages there are, but no actual translated fields exist yet.
62			# This is useful when the model is a parent object for inlines. The parent model defines the language tabs.
63			translations = TranslatedFields()
64
65			def __str__(self):
66			return self.shared
67
68
69			@python_2_unicode_compatible
70			class ArticleSlugModel(TranslatableModel):
71			translations = TranslatedFields(
72			slug = models.SlugField()
73			)
74
75			def __str__(self):
76			return self.slug
77
78			def get_absolute_url(self):
79			with switch_language(self):
80			return reverse('article-slug-test-view', kwargs={'slug': self.slug})
81
82
83			class AbstractModel(TranslatableModel):
84			# Already declared, but not yet linkable to a TranslatedFieldsModel
85			tr_title = TranslatedField(any_language=True)
86
87			class Meta:
88			abstract = True
89
90
91			class ConcreteModel(AbstractModel):
92			translations = TranslatedFields(
93			tr_title = models.CharField("Translated Title", max_length=200)
94			)
95
96
97			class UniqueTogetherModel(TranslatableModel):
98			translations = TranslatedFields(
99			slug = models.SlugField(),
100			meta = {
101			'unique_together': [
102			('slug', 'language_code',),
103			]
104			}
105			)
106
107
108			class Level1(TranslatableModel):
109			l1_translations = TranslatedFields(
110			l1_title = models.CharField(max_length=200)
111			)
112
113
114			class Level2(Level1):
115			l2_translations = TranslatedFields(
116			l2_title = models.CharField(max_length=200)
117			)
118
119
120			class ProxyBase(TranslatableModel):
121			base_translations = TranslatedFields(
122			base_title = models.CharField(max_length=200)
123			)
124
125
126			class ProxyModel(ProxyBase):
127			proxy_translations = TranslatedFields(
128			proxy_title = models.CharField(max_length=200)
129			)
130
131			class Meta:
132			proxy = True
133
134
135			class DoubleModel(TranslatableModel):
136			shared = models.CharField(max_length=200, default='')
137
138
139			class DoubleModelTranslations(TranslatedFieldsModel):
140			master = models.ForeignKey(DoubleModel, related_name='base_translations')
141			l1_title = models.CharField(max_length=200)
142
143
144			class DoubleModelMoreTranslations(TranslatedFieldsModel):
145			master = models.ForeignKey(DoubleModel, related_name='more_translations')
146			l2_title = models.CharField(max_length=200)
147
148
149			class RegularModel(models.Model):
150			# Normal model without translations. Test how replacing the field works.
151			original_field = models.CharField(default="untranslated", max_length=255)
152
153
154			class CharModel(TranslatableModel):
155			id = models.CharField(max_length=45, primary_key=True)
156
157
158			class CharModelTranslation(TranslatedFieldsModel):
159			master = models.ForeignKey(CharModel)
160			tr_title = models.CharField(max_length=200)
161
162
163			class ForeignKeyTranslationModel(TranslatableModel):
164			translations = TranslatedFields(
165			translated_foreign = models.ForeignKey('RegularModel'),
166			)
167			shared = models.CharField(max_length=200)
168
169
170			class TranslationRelated(TranslatableModel):
171			shared = models.CharField(max_length=200)
172			translation_relations = TranslatedField()
173
174
175			class TranslationRelatedTranslation(TranslatedFieldsModel):
176			master = models.ForeignKey(TranslationRelated, related_name='translations')
177			title = models.CharField(max_length=200)
178			m2m_regular = models.ManyToManyField(RegularModel)
179
180
181			class TranslationRelatedRelation(models.Model):
182			translation = models.ForeignKey(TranslationRelatedTranslation, related_name='translation_relations')
183			name = models.CharField(max_length=200)
184

edoburu / django-parler

Pull Request — master (#135)

SimpleModel.__str__() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

SimpleModel.str() A