Merge branch 'feature/22-fix-publishing-of-fluent-contents' into develop

# Conflicts:
#	docs/changelog.md

Author: Greg Turner

docs/changelog.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## In development
+
+  * Fix bug where the content items and placeholders associated with a
+    fluent content model (other than a page) were not included in the
+    published copy.
+
+  * Provide `icekit.publishing.models.PublishableFluentContents` and
+    `icekit.publishing.admin.PublishableFluentContentsAdmin` as base
+    classes for fluent content models and admins, to help keep things
+    DRY.
+
+### Breaking changes
+
+  * Import model mixins `FluentFieldsMixin`, `LayoutFieldMixin`, and
+    `ReadabilityMixin` from `icekit.mixins` module instead of
+    `icekit.abstract_models`.
+
+  * Import admin mixin `FluentLayoutsMixin` from `icekit.admin_mixins`
+    module instead of `icekit.admin`.
+
 ## 0.14.1 (26 September 2016)
 
   * ICEkit gets a facelift. Content editing now looks cleaner and easier to
@@ -21,6 +41,7 @@
 
   * Tag Docker images during build on Travis CI for release versions.
 
+
 ## 0.14 (20 September 2016)
 
   * Update the recommended method of running projects via `Docker` and `go.sh`

docs/howto/page-types.md

@@ -83,7 +83,7 @@ Here's a rough guide:
 | Static               | Yes                     | No          | `FluentContentsPage`                                      | `FluentContentsPageAdmin`                      |
 | Static               | Yes                     | Yes         | `PublishableFluentContentsPage` (use `PlaceholderField`s) | `(FluentContentsPageAdmin, PublishingAdmin)`   |
 | Dynamic              | No                      | No          | `FluentFieldsMixin`                                       | `FluentLayoutsMixin`                           |
-| Dynamic              | No                      | Yes         | `(FluentFieldsMixin, PublishingModel)`                    | `(FluentLayoutsMixin, PublishingAdmin)`        |
+| Dynamic              | No                      | Yes         | `PublishableFluentContents`                               | `PublishableFluentContentsAdmin`               |
 | Dynamic              | Yes                     | No          | `AbstractUnpublishableLayoutPage`                         | `UnpublishableLayoutPageAdmin`                 |
 | Dynamic              | Yes                     | Yes         | `AbstractLayoutPage`                                      | `LayoutPageAdmin`                              |
 

docs/howto/plugins.md

@@ -74,14 +74,14 @@ with two mixin classes:
 
     # models.py
 
-    from icekit.abstract_models import FluentFieldsMixin
+    from icekit.mixins import FluentFieldsMixin
 
     class MyModel(FluentFieldsMixin, MyModelBase):
         ...
 
     # admin.py
 
-    from icekit.admin import FluentLayoutsMixin
+    from icekit.admin_mixins import FluentLayoutsMixin
 
     class MyModelAdmin(FluentLayoutsMixin, MyModelAdminBase):
         ...

docs/topics/publishing.md

@@ -41,6 +41,11 @@ To make a `FluentContentsPage` model publishable:
 * subclass your model from `icekit.publishing.models.PublishableFluentContentsPage`
 * subclass your model's admin from `FluentContentsPageAdmin` and `icekit.publishing.admin.PublishingAdmin`
 
+To make a fluent contents model (see [ContentsPlugins]) publishable:
+
+* subclass your model from `icekit.publishing.models.PublishableFluentContents`
+* subclass your model's admin from `icekit.publishing.admin.PublishableFluentContentsAdmin`
+
 #### Note: Validating slug uniqueness
 
 In publishable models, both the draft and published slugs will be identical,
@@ -248,3 +253,5 @@ rendering related content for the public and for site admins:
 There has been an issue discovered where `ManyToMany` fields referring both
 ways on models have the many to many data cloned for published and
 unpublished objects. This is currently being worked on.
+
+[ContentsPlugins]: ../howto/plugins.md

icekit/abstract_models.py

@@ -5,122 +5,14 @@
 # Compose concrete models from abstract models and mixins, to facilitate reuse.
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
-from django.template.defaultfilters import striptags
 from django.template.loader import get_template
 from django.utils import encoding, timezone
 from django.utils.translation import ugettext_lazy as _
 from fluent_contents.analyzer import get_template_placeholder_data
-from fluent_contents.models import \
-    ContentItemRelation, Placeholder, PlaceholderRelation
-from fluent_contents.rendering import render_content_items
-from icekit.tasks import store_readability_score
-from icekit.utils.readability.readability import Readability
-from unidecode import unidecode
 
 from . import fields, plugins
 
 
-# MIXINS ######################################################################
-
-
-class LayoutFieldMixin(models.Model):
-    """
-    Add ``layout`` field to models that already have ``contentitem_set`` and
-    ``placeholder_set`` fields.
-    """
-    layout = models.ForeignKey(
-        'icekit.Layout',
-        blank=True,
-        null=True,
-        related_name='%(app_label)s_%(class)s_related',
-    )
-
-    fallback_template = 'icekit/layouts/fallback_default.html'
-
-    class Meta:
-        abstract = True
-
-    def get_layout_template_name(self):
-        """
-        Return ``layout.template_name`` or `fallback_template``.
-        """
-        if self.layout:
-            return self.layout.template_name
-        return self.fallback_template
-
-
-class FluentFieldsMixin(LayoutFieldMixin):
-    """
-    Add ``layout``, ``contentitem_set`` and ``placeholder_set`` fields so we
-    can add modular content with ``django-fluent-contents``.
-    """
-    contentitem_set = ContentItemRelation()
-    placeholder_set = PlaceholderRelation()
-
-    class Meta:
-        abstract = True
-
-    # HACK: This is needed to work-around a `django-fluent-contents` issue
-    # where it cannot handle placeholders being added to a template after an
-    # object already has placeholder data in the database.
-    # See: https://github.com/edoburu/django-fluent-contents/pull/63
-    def add_missing_placeholders(self):
-        """
-        Add missing placeholders from templates. Return `True` if any missing
-        placeholders were created.
-        """
-        content_type = ContentType.objects.get_for_model(self)
-        result = False
-        if self.layout:
-            for data in self.layout.get_placeholder_data():
-                placeholder, created = Placeholder.objects.update_or_create(
-                    parent_type=content_type,
-                    parent_id=self.pk,
-                    slot=data.slot,
-                    defaults=dict(
-                        role=data.role,
-                        title=data.title,
-                    ))
-                result = result or created
-        return result
-
-    def placeholders(self):
-        # return a dict of placeholders, organised by slot, for access in templates
-        # use `page.placeholders.<slot_name>.get_content_items` to test if
-        # a placeholder has any items.
-        return dict([(p.slot, p) for p in self.placeholder_set.all().select_related()])
-
-
-# TODO: should be a sub-app.
-class ReadabilityMixin(models.Model):
-    readability_score = models.DecimalField(max_digits=4, decimal_places=2, null=True)
-
-    class Meta:
-        abstract = True
-
-    def extract_text(self):
-        # return the rendered content, with HTML tags stripped.
-        html = render_content_items(request=None, items=self.contentitem_set.all())
-        return striptags(html)
-
-    def calculate_readability_score(self):
-        try:
-            return Readability(unidecode(self.extract_text())).SMOGIndex()
-        except:
-            return None
-
-    def store_readability_score(self):
-        store_readability_score.delay(self._meta.app_label, self._meta.model_name, self.pk)
-
-    def save(self, *args, **kwargs):
-        r = super(ReadabilityMixin, self).save(*args, **kwargs)
-        self.store_readability_score()
-        return r
-
-
-# MODELS ######################################################################
-
-
 class AbstractBaseModel(models.Model):
     """
     Abstract base model.

icekit/admin.py

@@ -10,9 +10,6 @@
 from django.contrib.contenttypes.models import ContentType
 from django.http import JsonResponse
 from django.utils.translation import ugettext_lazy as _
-from fluent_contents.admin import PlaceholderEditorAdmin
-from fluent_contents.analyzer import get_template_placeholder_data
-from fluent_contents.models import PlaceholderData
 from polymorphic.admin import PolymorphicParentModelAdmin
 
 from icekit import models
@@ -44,37 +41,6 @@ def queryset(self, request, queryset):
 # MIXINS ######################################################################
 
 
-class FluentLayoutsMixin(PlaceholderEditorAdmin):
-    """
-    Mixin class for models that have a ``layout`` field and fluent content.
-    """
-
-    change_form_template = 'icekit/admin/fluent_layouts_change_form.html'
-
-    class Media:
-        js = ('icekit/admin/js/fluent_layouts.js', )
-
-    def formfield_for_foreignkey(self, db_field, *args, **kwargs):
-        """
-        Update queryset for ``layout`` field.
-        """
-        formfield = super(FluentLayoutsMixin, self).formfield_for_foreignkey(
-            db_field, *args, **kwargs)
-        if db_field.name == 'layout':
-            formfield.queryset = formfield.queryset.for_model(self.model)
-        return formfield
-
-    def get_placeholder_data(self, request, obj):
-        """
-        Get placeholder data from layout.
-        """
-        if not obj or not obj.layout:
-            data = [PlaceholderData(slot='main', role='m', title='Main')]
-        else:
-            data = obj.layout.get_placeholder_data()
-        return data
-
-
 class ChildModelPluginPolymorphicParentModelAdmin(PolymorphicParentModelAdmin):
     """
     Get child models and choice labels from registered plugins.

icekit/admin_mixins.py

@@ -0,0 +1,33 @@
+from fluent_contents.admin import PlaceholderEditorAdmin
+from fluent_contents.models import PlaceholderData
+
+
+class FluentLayoutsMixin(PlaceholderEditorAdmin):
+    """
+    Mixin class for models that have a ``layout`` field and fluent content.
+    """
+
+    change_form_template = 'icekit/admin/fluent_layouts_change_form.html'
+
+    class Media:
+        js = ('icekit/admin/js/fluent_layouts.js', )
+
+    def formfield_for_foreignkey(self, db_field, *args, **kwargs):
+        """
+        Update queryset for ``layout`` field.
+        """
+        formfield = super(FluentLayoutsMixin, self).formfield_for_foreignkey(
+            db_field, *args, **kwargs)
+        if db_field.name == 'layout':
+            formfield.queryset = formfield.queryset.for_model(self.model)
+        return formfield
+
+    def get_placeholder_data(self, request, obj):
+        """
+        Get placeholder data from layout.
+        """
+        if not obj or not obj.layout:
+            data = [PlaceholderData(slot='main', role='m', title='Main')]
+        else:
+            data = obj.layout.get_placeholder_data()
+        return data

icekit/articles/abstract_models.py

@@ -1,12 +1,6 @@
-from icekit.abstract_models import FluentFieldsMixin
-from icekit.publishing.models import PublishingModel
+from icekit.publishing.models import PublishableFluentContents
 from django.db import models
 
-# TODO: this should ideally be in icekit.abstract_models, but doing so
-# creates circular import errors.
-class PublishableFluentModel(FluentFieldsMixin, PublishingModel):
-    class Meta:
-        abstract = True
 
 class TitleSlugMixin(models.Model):
     # TODO: this should perhaps become part of a wider ICEkit mixin that covers
@@ -22,12 +16,11 @@ def __unicode__(self):
         return self.title
 
 
-class PublishableArticle(PublishableFluentModel, TitleSlugMixin):
+class PublishableArticle(PublishableFluentContents, TitleSlugMixin):
     '''
     Basic Article type (ie that forms the basis of independent collections of
     publishable things).
     '''
 
     class Meta:
         abstract = True
-

icekit/articles/admin.py

@@ -1,18 +1,11 @@
 from django.contrib import admin
 
-from icekit.admin import FluentLayoutsMixin
-from icekit.publishing.admin import PublishingAdmin
-
-class PublishableFluentModelAdmin(PublishingAdmin, FluentLayoutsMixin):
-    """
-    Add publishing features for non-Page rich content models
-    """
-    pass
+from icekit.publishing.admin import PublishableFluentContentsAdmin
 
 
 class TitleSlugAdmin(admin.ModelAdmin):
     prepopulated_fields = {"slug": ("title",)}
 
 
-class PublishableArticleAdmin(PublishableFluentModelAdmin, TitleSlugAdmin):
+class PublishableArticleAdmin(PublishableFluentContentsAdmin, TitleSlugAdmin):
     pass

icekit/management/commands/add_missing_placeholders.py

@@ -1,7 +1,7 @@
 from django.apps import apps
 from django.core.management.base import NoArgsCommand
 from django.utils.encoding import force_text
-from icekit.abstract_models import FluentFieldsMixin
+from icekit.mixins import FluentFieldsMixin
 
 
 class Command(NoArgsCommand):