More category fixes

README.md

@@ -20,6 +20,13 @@ or not, use:
         <a href="{{ SITEURL }}/{{ cat.url }}">{{ cat }}</a>{{ ', ' if not loop.last }}
     {% endfor %}
 
+Additionally, this plugin adds `category.subcategories`: a `list` of categories
+that have `category` as a parent.
+
+    {% for subcat in category.subcategories %}
+        <a href="{{ SITEURL }}/{{subcat.url}}">{{subcat.shortname|capitalize}}</a>
+    {% endfor %}
+
 ## Nested categories
 (This is a reimplementation of the `subcategory` plugin.)
 
@@ -73,4 +80,4 @@ categories always follow their parent:
 
     aba
     aba/dat
-    abaala
+    abaala

RELEASE.md

@@ -0,0 +1,4 @@
+Release type: minor
+
+Added subcategories to categories to be able to cycle through which subcategories are present for a category.
+Updated plugin to better work with modern pelican standards (by updating tasks.py and ensuring proper code formatting)

pelican/plugins/more_categories/more_categories.py

@@ -3,7 +3,7 @@
 Title: More Categories
 Description: adds support for multiple categories per article and nested
 categories
-Requirements: Pelican 3.8 or higher
+Requirements: Pelican 4.2.0 or higher
 """
 
 from collections import defaultdict
@@ -19,13 +19,13 @@ class Category(URLWrapper):
     @property
     def _name(self):
         if self.parent:
-            return self.parent._name + '/' + self.shortname
+            return self.parent._name + "/" + self.shortname
         return self.shortname
 
     @_name.setter
     def _name(self, val):
-        if '/' in val:
-            parentname, val = val.rsplit('/', 1)
+        if "/" in val:
+            parentname, val = val.rsplit("/", 1)
             self.parent = self.__class__(parentname, self.settings)
         else:
             self.parent = None
@@ -38,14 +38,13 @@ def name(self, val):
     @property
     def slug(self):
         if self._slug is None:
-            if 'CATEGORY_REGEX_SUBSTITUTIONS' in self.settings:
-                subs = self.settings['CATEGORY_REGEX_SUBSTITUTIONS']
+            if "CATEGORY_REGEX_SUBSTITUTIONS" in self.settings:
+                subs = self.settings["CATEGORY_REGEX_SUBSTITUTIONS"]
             else:
-                subs = self.settings.get('SLUG_REGEX_SUBSTITUTIONS', [])
+                subs = self.settings.get("SLUG_REGEX_SUBSTITUTIONS", [])
             self._slug = slugify(self.shortname, regex_subs=subs)
-            print(self._slug)
             if self.parent:
-                self._slug = self.parent.slug + '/' + self._slug
+                self._slug = self.parent.slug + "/" + self._slug
         return self._slug
 
     @property
@@ -56,14 +55,14 @@ def ancestors(self):
 
     def as_dict(self):
         d = super(Category, self).as_dict()
-        d['shortname'] = self.shortname
+        d["shortname"] = self.shortname
         return d
 
 
 def get_categories(generator, metadata):
-    categories = text_type(metadata.get('category')).split(',')
-    metadata['categories'] = [Category(name, generator.settings) for name in categories]
-    metadata['category'] = metadata['categories'][0]
+    categories = text_type(metadata.get("category")).split(",")
+    metadata["categories"] = [Category(name, generator.settings) for name in categories]
+    metadata["category"] = metadata["categories"][0]
 
 
 def create_categories(generator):
@@ -75,9 +74,24 @@ def create_categories(generator):
 
     generator.categories = sorted(
         list(cat_dct.items()),
-        reverse=generator.settings.get('REVERSE_CATEGORY_ORDER') or False,
+        reverse=generator.settings.get("REVERSE_CATEGORY_ORDER") or False,
     )
-    generator._update_context(['categories'])
+    generator._update_context(["categories"])
+
+    # Add subcategories
+    cats = {}
+    for category, articles in generator.categories:
+        for anc in category.ancestors:
+            if anc != category:
+                if anc.slug in cats:
+                    cats[anc.slug].append(category)
+                else:
+                    cats[anc.slug] = [category]
+    for category, articles in generator.categories:
+        if category.slug in cats:
+            category.subcategories = cats[category.slug]
+        else:
+            category.subcategories = []
 
 
 def register():

pelican/plugins/more_categories/test_more_categories.py

@@ -14,21 +14,21 @@
 class TestArticlesGenerator(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.temp_path = mkdtemp(prefix='pelicantests.')
+        cls.temp_path = mkdtemp(prefix="pelicantests.")
         more_categories.register()
         settings = get_settings()
-        settings['DEFAULT_CATEGORY'] = 'default'
-        settings['CACHE_CONTENT'] = False
-        settings['PLUGINS'] = more_categories
+        settings["DEFAULT_CATEGORY"] = "default"
+        settings["CACHE_CONTENT"] = False
+        settings["PLUGINS"] = more_categories
         context = get_context(settings)
 
         base_path = os.path.dirname(os.path.abspath(__file__))
-        test_data_path = os.path.join(base_path, 'test_data')
+        test_data_path = os.path.join(base_path, "test_data")
         cls.generator = ArticlesGenerator(
             context=context,
             settings=settings,
             path=test_data_path,
-            theme=settings['THEME'],
+            theme=settings["THEME"],
             output_path=cls.temp_path,
         )
         cls.generator.generate_context()
@@ -42,14 +42,14 @@ def test_generate_categories(self):
         including ancestor categories"""
 
         cats_generated = [cat.name for cat, _ in self.generator.categories]
-        cats_expected = ['default', 'foo', 'foo/bar', 'foo/b#az']
+        cats_expected = ["default", "foo", "foo/bar", "foo/b#az"]
         self.assertEqual(sorted(cats_generated), sorted(cats_expected))
 
     def test_categories_slug(self):
         """Test whether category slug substitutions are used"""
 
         slugs_generated = [cat.slug for cat, _ in self.generator.categories]
-        slugs_expected = ['default', 'foo', 'foo/bar', 'foo/baz']
+        slugs_expected = ["default", "foo", "foo/bar", "foo/baz"]
         self.assertEqual(sorted(slugs_generated), sorted(slugs_expected))
 
     def test_assign_articles_to_categories(self):

pyproject.toml

@@ -46,7 +46,7 @@ invoke = "^1.3"
 isort = "^4.3"
 livereload = "^2.6"
 markdown = "^3.1.1"
-pytest = "^5.0"
+pytest = "5.3.5"
 pytest-cov = "^2.7"
 pytest-pythonpath = "^0.7.3"
 pytest-sugar = "^0.9.2"

tasks.py

@@ -1,34 +1,93 @@
+import os
 from pathlib import Path
+from shutil import which
 
 from invoke import task
 
-PKG_NAME = 'more_categories'
-PKG_PATH = Path(f'pelican/plugins/{PKG_NAME}')
-FLAKE8 = 'flake8'
-ISORT = 'isort'
-PYTEST = 'pytest'
+PKG_NAME = "more_categories"
+PKG_PATH = Path(f"pelican/plugins/{PKG_NAME}")
+
+ACTIVE_VENV = os.environ.get("VIRTUAL_ENV", None)
+VENV_HOME = Path(os.environ.get("WORKON_HOME", "~/.local/share/virtualenvs"))
+VENV_PATH = Path(ACTIVE_VENV) if ACTIVE_VENV else (VENV_HOME / PKG_NAME)
+VENV = str(VENV_PATH.expanduser())
+
+TOOLS = ["poetry", "pre-commit"]
+POETRY = which("poetry") if which("poetry") else (VENV / Path("bin") / "poetry")
+PRECOMMIT = (
+    which("pre-commit") if which("pre-commit") else (VENV / Path("bin") / "pre-commit")
+)
+
+LINT_TOOLS = ["flake8", "isort", "black"]
 
 
 @task
 def tests(c):
     """Run the test suite"""
-    c.run(f'{PYTEST}', pty=True)
+    c.run(f"{VENV}/bin/pytest", pty=True)
 
 
 @task
-def isort(c, check=False):
-    check_flag = ''
+def black(c, check=False, diff=False):
+    """Run Black auto-formatter, optionally with --check or --diff"""
+    check_flag, diff_flag = "", ""
     if check:
-        check_flag = '-c'
-    c.run(f'{ISORT} {check_flag} --recursive {PKG_PATH}/* tasks.py')
+        check_flag = "--check"
+    if diff:
+        diff_flag = "--diff"
+    c.run(f"{VENV}/bin/black {check_flag} {diff_flag} {PKG_PATH} tasks.py")
+
+
+@task
+def isort(c, check=False, diff=False):
+    check_flag, diff_flag = "", ""
+    if check:
+        check_flag = "-c"
+    if diff:
+        diff_flag = "--diff"
+    c.run(
+        f"{VENV}/bin/isort {check_flag} {diff_flag} --recursive {PKG_PATH}/* tasks.py"
+    )
 
 
 @task
 def flake8(c):
-    c.run(f'{FLAKE8} {PKG_PATH} tasks.py')
+    c.run(f"{VENV}/bin/flake8 {PKG_PATH} tasks.py")
 
 
 @task
 def lint(c):
-    isort(c, check=True)
+    lint_tools(c)
     flake8(c)
+    isort(c, check=True)
+    black(c, check=True)
+
+
+@task
+def lint_tools(c):
+    """Install lint tools in the virtual environment if not already on PATH"""
+    for tool in LINT_TOOLS:
+        if not which(tool):
+            c.run(f"{VENV}/bin/pip install {tool}")
+
+
+@task
+def tools(c):
+    """Install tools in the virtual environment if not already on PATH"""
+    for tool in TOOLS:
+        if not which(tool):
+            c.run(f"{VENV}/bin/pip install {tool}")
+
+
+@task
+def precommit(c):
+    """Install pre-commit hooks to .git/hooks/pre-commit"""
+    c.run(f"{PRECOMMIT} install")
+
+
+@task
+def setup(c):
+    c.run(f"{VENV}/bin/pip install -U pip")
+    tools(c)
+    c.run(f"{POETRY} install")
+    precommit(c)