Merge pull request #621 from mothsART/tag_cloud_with_badges

Tag cloud with badges

tag_cloud/README.rst

@@ -42,19 +42,33 @@ Setting name (followed by default value)            What does it do?
 ``TAG_CLOUD_SORTING = 'random'``                    The tag cloud ordering scheme.  Valid values:
                                                     random, alphabetically, alphabetically-rev, size and
                                                     size-rev
+``TAG_CLOUD_BADGE = True``                          Optionnal setting : can bring **badges**, which mean
+                                                    say : display the number of each tags present
+                                                    on all articles.
 ================================================    =====================================================
 
 The default theme does not include a tag cloud, but it is pretty easy to add one::
 
     <ul class="tagcloud">
         {% for tag in tag_cloud %}
-            <li class="tag-{{ tag.1 }}"><a href="{{ SITEURL }}/{{ tag.0.url }}">{{ tag.0 }}</a></li>
+            <li class="tag-{{ tag.1 }}">
+                <a href="{{ SITEURL }}/{{ tag.0.url }}">
+                {{ tag.0 }}
+                    {% if TAG_CLOUD_BADGE %}
+                        <span class="badge">{{ tag.2 }}</span>
+                    {% endif %}
+                </a>
+            </li>
         {% endfor %}
     </ul>
 
 You should then also define CSS styles with appropriate classes (tag-1 to tag-N,
 where N matches ``TAG_CLOUD_STEPS``), tag-1 being the most frequent, and
 define a ``ul.tagcloud`` class with appropriate list-style to create the cloud.
+You should copy/paste this **badge** CSS rule ``ul.tagcloud .list-group-item <span>.badge``
+if you're using ``TAG_CLOUD_BADGE`` setting. (this rule, potentially long , is suggested to avoid
+conflicts with CSS libs as twitter Bootstrap)
+
 For example::
 
     ul.tagcloud {
@@ -76,4 +90,9 @@ For example::
 
     ...
 
+    ul.tagcloud .list-group-item <span>.badge {
+        background-color: grey;
+        color: white;
+    }
+
 By default the tags in the cloud are sorted randomly, but if you prefers to have it alphabetically use the `alphabetically` (ascending) and `alphabetically-rev` (descending). Also is possible to sort the tags by it's size (number of articles with this specific tag) using the values `size` (ascending) and `size-rev` (descending).

tag_cloud/tag_cloud.py

@@ -7,26 +7,30 @@ This plugin generates a tag cloud from available tags
 from __future__ import unicode_literals
 
 from collections import defaultdict
-from operator import attrgetter, itemgetter
+from operator import itemgetter
 
 import logging
 import math
 import random
 
-from pelican import signals, contents
+from pelican import signals
 
 logger = logging.getLogger(__name__)
 
+
 def set_default_settings(settings):
     settings.setdefault('TAG_CLOUD_STEPS', 4)
     settings.setdefault('TAG_CLOUD_MAX_ITEMS', 100)
     settings.setdefault('TAG_CLOUD_SORTING', 'random')
+    settings.setdefault('TAG_CLOUD_BADGE', False)
+
 
 def init_default_config(pelican):
     from pelican.settings import DEFAULT_CONFIG
     set_default_settings(DEFAULT_CONFIG)
     if(pelican):
-           set_default_settings(pelican.settings)
+            set_default_settings(pelican.settings)
+
 
 def generate_tag_cloud(generator):
     tag_cloud = defaultdict(int)
@@ -43,12 +47,18 @@ def generate_tag_cloud(generator):
     steps = generator.settings.get('TAG_CLOUD_STEPS')
 
     # calculate word sizes
-    tag_cloud = [
-        (
+    def generate_tag(tag, count):
+        tag = (
             tag,
             int(math.floor(steps - (steps - 1) * math.log(count)
                 / (math.log(max_count)or 1)))
         )
+        if generator.settings.get('TAG_CLOUD_BADGE'):
+            tag += (count,)
+        return tag
+
+    tag_cloud = [
+        generate_tag(tag, count)
         for tag, count in tag_cloud
     ]
 
@@ -69,10 +79,11 @@ def generate_tag_cloud(generator):
                        "falling back to 'random'", sorting)
         random.shuffle(tag_cloud)
 
-    #make available in context
+    # make available in context
     generator.tag_cloud = tag_cloud
     generator._update_context(['tag_cloud'])
 
+
 def register():
     signals.initialized.connect(init_default_config)
     signals.article_generator_finalized.connect(generate_tag_cloud)

tag_cloud/test_data/article_3.md

@@ -0,0 +1,5 @@
+Title: Article3
+tags: pelican, plugins
+
+content3, yeah!
+

tag_cloud/test_data/article_4.md

@@ -0,0 +1,5 @@
+Title: Article4
+tags: pelican, fun
+
+content4, yeah!
+

tag_cloud/test_data/article_5.md

@@ -0,0 +1,5 @@
+Title: Article5
+tags: plugins, pelican, fun
+
+content5, yeah!
+

tag_cloud/test_tag_cloud.py

@@ -1,4 +1,5 @@
-import unittest, os, sys
+import unittest
+import os
 import six
 import tag_cloud
 
@@ -9,6 +10,7 @@ from pelican.urlwrappers import Tag
 CUR_DIR = os.path.dirname(__file__)
 CONTENT_DIR = os.path.join(CUR_DIR, 'test_data')
 
+
 class TestTagCloudGeneration(unittest.TestCase):
 
     @classmethod
@@ -25,59 +27,76 @@ class TestTagCloudGeneration(unittest.TestCase):
             path=CONTENT_DIR, theme=cls._settings['THEME'], output_path=None)
         cls.generator.generate_context()
 
-
     def test_tag_cloud_random(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
+        self.generator.settings['TAG_CLOUD_BADGE'] = False
         tag_cloud.generate_tag_cloud(self.generator)
         expected = [
-                (Tag('plugins', self._settings), 1),
-                (Tag('fun', self._settings), 4),
-                (Tag('python', self._settings), 4),
-                (Tag('pelican', self._settings), 1)
-            ]
+            (Tag('pelican', self._settings), 1),
+            (Tag('plugins', self._settings), 2),
+            (Tag('fun', self._settings), 3),
+            (Tag('python', self._settings), 10)
+        ]
+        six.assertCountEqual(self, self.generator.tag_cloud, expected)
+
+    def test_tag_cloud_badge(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
+        self.generator.settings['TAG_CLOUD_BADGE'] = True
+        tag_cloud.generate_tag_cloud(self.generator)
+        expected = [
+            (Tag('pelican', self._settings), 1, 5),
+            (Tag('plugins', self._settings), 2, 4),
+            (Tag('fun', self._settings), 3, 3),
+            (Tag('python', self._settings), 10, 1)
+        ]
         six.assertCountEqual(self, self.generator.tag_cloud, expected)
 
     def test_tag_cloud_alphabetical(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
         self.generator.settings['TAG_CLOUD_SORTING'] = 'alphabetically'
         tag_cloud.generate_tag_cloud(self.generator)
         expected = [
-                (Tag('fun', self._settings), 4),
-                (Tag('pelican', self._settings), 1),
-                (Tag('plugins', self._settings), 1),
-                (Tag('python', self._settings), 4)
-            ]
+            (Tag('fun', self._settings), 3),
+            (Tag('pelican', self._settings), 1),
+            (Tag('plugins', self._settings), 2),
+            (Tag('python', self._settings), 10)
+        ]
         self.assertEqual(self.generator.tag_cloud, expected)
-    
+
     def test_tag_cloud_alphabetical_rev(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
         self.generator.settings['TAG_CLOUD_SORTING'] = 'alphabetically-rev'
         tag_cloud.generate_tag_cloud(self.generator)
         expected = [
-                (Tag('python', self._settings), 4),
-                (Tag('plugins', self._settings), 1),
-                (Tag('pelican', self._settings), 1),
-                (Tag('fun', self._settings), 4)
-            ]
+            (Tag('python', self._settings), 10),
+            (Tag('plugins', self._settings), 2),
+            (Tag('pelican', self._settings), 1),
+            (Tag('fun', self._settings), 3)
+        ]
         self.assertEqual(self.generator.tag_cloud, expected)
 
     def test_tag_cloud_size(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
         self.generator.settings['TAG_CLOUD_SORTING'] = 'size'
         tag_cloud.generate_tag_cloud(self.generator)
         expected = [
-                (Tag('pelican', self._settings), 1),
-                (Tag('plugins', self._settings), 1),
-                (Tag('fun', self._settings), 4),
-                (Tag('python', self._settings), 4)
-            ]
+            (Tag('pelican', self._settings), 1),
+            (Tag('plugins', self._settings), 2),
+            (Tag('fun', self._settings), 3),
+            (Tag('python', self._settings), 10)
+        ]
         self.assertEqual(self.generator.tag_cloud, expected)
 
     def test_tag_cloud_size_rev(self):
+        self.generator.settings['TAG_CLOUD_STEPS'] = 10
         self.generator.settings['TAG_CLOUD_SORTING'] = 'size-rev'
         tag_cloud.generate_tag_cloud(self.generator)
         expected = [
-                (Tag('fun', self._settings), 4),
-                (Tag('python', self._settings), 4),
-                (Tag('pelican', self._settings), 1),
-                (Tag('plugins', self._settings), 1)
-            ]
+            (Tag('python', self._settings), 10),
+            (Tag('fun', self._settings), 3),
+            (Tag('plugins', self._settings), 2),
+            (Tag('pelican', self._settings), 1)
+        ]
         self.assertEqual(self.generator.tag_cloud, expected)
 
 if __name__ == "__main__":