pelican-linkclass 2.1.3__tar.gz → 2.1.4__tar.gz

pelican_linkclass-2.1.4/CHANGELOG.md

@@ -0,0 +1,67 @@
+CHANGELOG
+=========
+
+2.1.4 - 2024-04-14
+------------------
+
+Ensure plugin is included in sdist build
+
+2.1.3 - 2024-04-07
+------------------
+
+Maintainance release (no user visible changes)
+
+* Add Python 3.12 to CI test matrix
+* Switch build system from Hatchling to PDM
+* Fix linters errors
+
+2.1.2 - 2023-10-31
+------------------
+
+Fix project name
+
+2.1.1 - 2023-10-31
+------------------
+
+Maintenance release:
+
+- Migrate to the new tooling standards
+- Improve code quality
+
+2.1.0 - 2023-04-13
+------------------
+
+The tuples in the LINKCLASS configuration variable have only two elements now. This makes the code consistent with the plugin documentation (README.md file) and resolves issue #34.
+
+2.0.4 - 2022-10-01
+------------------
+
+Update list of years in Copyright notices
+
+2.0.3 - 2022-07-15
+------------------
+
+In `test_linkclass.py`, use `io` instead of `six` to import `StringIO`.
+
+2.0.2 - 2021-12-17
+------------------
+
+Upgrade code to Python 3.6+ (thanks to Justin Mayer)
+
+2.0.1 - 2021-11-04
+------------------
+
+Maintenance release: Use .format() instead of % operator to format strings
+
+2.0.0 - 2021-02-17
+------------------
+
+Convert to namespace plugin for use with Pelican 4.5 and above
+
+[Justin Mayer](https://github.com/justinmayer) [PR #11](https://github.com/pelican-plugins/linkclass/pull/11/)
+
+
+1.0.0 - 2019-09-29
+------------------
+
+Initial release to PyPI

pelican_linkclass-2.1.4/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+Contributing
+============
+
+Contributions are welcome and much appreciated. Every little bit helps. You can contribute by improving the documentation, adding missing features, and fixing bugs. You can also help out by reviewing and commenting on [existing issues][].
+
+To start contributing to this plugin, review the [Contributing to Pelican][] documentation, beginning with the **Contributing Code** section.
+
+[existing issues]: https://github.com/pelican-plugins/linkclass/issues
+[Contributing to Pelican]: https://docs.getpelican.com/en/latest/contribute.html

{pelican_linkclass-2.1.3 → pelican_linkclass-2.1.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: pelican-linkclass
-Version: 2.1.3
+Version: 2.1.4
 Summary: Pelican plugin to set anchor tag's class attribute to differentiate between internal and external links
-Keywords: pelican plugin link class
-Author-Email: Rafael Laboissière <rafael@laboissiere.net>
+Keywords: pelican,plugin,link class
+Author-Email: =?utf-8?q?Rafael_Laboissi=C3=A8re?= <rafael@laboissiere.net>
 License: AGPL-3.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console

pelican_linkclass-2.1.4/pelican/plugins/linkclass/__init__.py

@@ -0,0 +1 @@
+from .linkclass import *  # NOQA: F403

pelican_linkclass-2.1.4/pelican/plugins/linkclass/linkclass.py

@@ -0,0 +1,51 @@
+"""Link Class Plugin for Pelican."""
+
+# Copyright (C) 2015, 2019, 2023  Rafael Laboissière
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Affero Public License as published by
+# the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see http://www.gnu.org/licenses/.
+
+
+from pelican import signals
+
+from .mdx_linkclass import LC_CONFIG, LinkClassExtension
+
+
+def addLinkClass(gen):
+    """Add LinkClass connector."""
+    if not gen.settings.get("MARKDOWN"):
+        from pelican.settings import DEFAULT_CONFIG
+
+        gen.settings["MARKDOWN"] = DEFAULT_CONFIG["MARKDOWN"]
+
+    if gen.settings.get("LINKCLASS"):
+        for param, default in gen.settings.get("LINKCLASS"):
+            LC_CONFIG[param] = default
+
+    if LinkClassExtension not in gen.settings["MARKDOWN"]:
+        config = {}
+        for key, value in LC_CONFIG.items():
+            config[key] = value
+        for key, value in gen.settings.items():
+            if key in LC_CONFIG:
+                config[key] = value
+        lcobj = LinkClassExtension(config)
+        try:
+            gen.settings["MARKDOWN"]["extensions"].append(lcobj)
+        except KeyError:
+            gen.settings["MARKDOWN"]["extensions"] = [lcobj]
+
+
+def register():
+    """Register the Link Class plugin with Pelican."""
+    signals.initialized.connect(addLinkClass)

pelican_linkclass-2.1.4/pelican/plugins/linkclass/mdx_linkclass.py

@@ -0,0 +1,105 @@
+"""Markdown extension for the Link Class plugin for Pelican."""
+
+# Copyright (C) 2015, 2017, 2019, 2023  Rafael Laboissière
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Affero Public License as published by
+# the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see http://www.gnu.org/licenses/.
+
+
+import re
+
+from markdown.extensions import Extension
+from markdown.inlinepatterns import (
+    LINK_RE,
+    REFERENCE_RE,
+    LinkInlineProcessor,
+    ReferenceInlineProcessor,
+)
+
+LC_CONFIG = {"INTERNAL_CLASS": "internal", "EXTERNAL_CLASS": "external"}
+LC_HELP = {
+    "INTERNAL_CLASS": "Name of the CSS class for internal links",
+    "EXTERNAL_CLASS": "Name of the CSS class for external links",
+}
+
+
+def add_class(elm, config):
+    """Utlity function for adding the appropriate class attribute."""
+    try:
+        m = re.match("^https?://", elm.get("href"))
+        elm.set("class", m and config["EXTERNAL_CLASS"] or config["INTERNAL_CLASS"])
+    except AttributeError:
+        pass
+    return elm
+
+
+class LinkClassExtension(Extension):
+    """Markdown extension for the Link Class plugin."""
+
+    def __init__(self, config):
+        """Initialize the class object."""
+        for key, value in LC_CONFIG.items():
+            self.config[key] = [value, LC_HELP[key]]
+        super().__init__(**config)
+
+    def extendMarkdown(self, md):
+        """Register the Markdown extension."""
+        # LinkClass instances is added to the list of inline pattern
+        # processors, with higher priority than the processor defined for the
+        # "link" and the "reference" objects, such that the normal behavior is
+        # overridden.
+        LinkClassPattern = LinkClass(LINK_RE, self.getConfigs())
+        LinkClassPattern.md = md
+        md.inlinePatterns.register(LinkClassPattern, "linkclass", 200)
+        ReferenceClassPattern = ReferenceClass(REFERENCE_RE, self.getConfigs())
+        ReferenceClassPattern.md = md
+        md.inlinePatterns.register(ReferenceClassPattern, "referenceclass", 200)
+
+
+class LinkClass(LinkInlineProcessor):
+    """Markdown inline pattern processor for adding class attribute to inline-style hyperlinks."""  # NOQA: E501
+
+    def __init__(self, pattern, config):
+        """Initialize the Markdwon inline pattern processor."""
+        super().__init__(pattern)
+        # Store the configuration dict
+        self.config = config
+
+    def handleMatch(self, m, data):
+        """Add the class attribute to the generated <a> element."""
+        # Build the <a> element using the parent class
+        elm, start, end = super().handleMatch(m, data)
+        # Return the <a> element with added class
+        return add_class(elm, self.config), start, end
+
+
+class ReferenceClass(ReferenceInlineProcessor):
+    """Markdown inline pattern processor for adding class attribute to inline-style references."""  # NOQA: E501
+
+    def __init__(self, pattern, config):
+        """Initialize the Markdwon inline pattern processor."""
+        super().__init__(pattern)
+        # Store the configuration dict
+        self.config = config
+
+    def handleMatch(self, m, data):
+        """Add the class attribute to the generated <a> element."""
+        # Build the <a> element using the parent class
+        elm, start, end = super().handleMatch(m, data)
+        # Return the <a> element with added class
+        return add_class(elm, self.config), start, end
+
+
+def makeExtension(config=None):
+    """Register the MarkDown extension."""
+    return LinkClassExtension(config=config)

pelican_linkclass-2.1.4/pelican/plugins/linkclass/test_linkclass.py

@@ -0,0 +1,212 @@
+"""Unit testing suite for the Link Class Plugin."""
+
+# Copyright (C) 2015, 2017, 2019, 2021-2023  Rafael Laboissière <rafael@laboissiere.net>  # noqa: E501
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Affero Public License as published by
+# the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see http://www.gnu.org/licenses/.
+
+# For running this test in a standalone-way, run:
+#     (cd .. ; python3 -Wd -m unittest discover)
+
+from io import StringIO
+import os
+import re
+from shutil import rmtree
+import sys
+from tempfile import mkdtemp
+import unittest
+
+from pelican import Pelican
+from pelican.settings import read_settings
+
+from . import linkclass
+
+INTERNAL_CLASS = "internal"
+EXTERNAL_CLASS = "external"
+
+INTERNAL_INLINE_TEXT = "internal inline text"
+INTERNAL_INLINE_LINK = "internal inline link"
+
+INTERNAL_REFERENCE_TEXT = "internal reference text"
+INTERNAL_REFERENCE_LABEL = "internal reference label"
+INTERNAL_REFERENCE_LINK = "internal-reference-link"
+
+EXTERNAL_INLINE_TEXT_HTTP = "external inline text http"
+EXTERNAL_INLINE_LINK_HTTP = "https://inline.org"
+
+EXTERNAL_REFERENCE_TEXT_HTTP = "external reference text http"
+EXTERNAL_REFERENCE_LABEL_HTTP = "external reference label http"
+EXTERNAL_REFERENCE_LINK_HTTP = "https://reference.org"
+
+EXTERNAL_INLINE_TEXT_HTTPS = "external inline text https"
+EXTERNAL_INLINE_LINK_HTTPS = "https://inline.org"
+
+EXTERNAL_REFERENCE_TEXT_HTTPS = "external reference text https"
+EXTERNAL_REFERENCE_LABEL_HTTPS = "external reference label https"
+EXTERNAL_REFERENCE_LINK_HTTPS = "https://reference.org"
+
+LINK_PATTERN = '<a class="{}" href="{}">{}</a>'
+
+TEST_FILE_STEM = "test"
+TEST_DIR_PREFIX = "pelicantests."
+
+
+class TestLinkClass(unittest.TestCase):
+    """Class for testing the <a> output elements generated by the Link Class plugin."""
+
+    def setUp(self, override=None):
+        self.output_path = mkdtemp(prefix=TEST_DIR_PREFIX)
+        self.content_path = mkdtemp(prefix=TEST_DIR_PREFIX)
+        settings = {
+            "PATH": self.content_path,
+            "OUTPUT_PATH": self.output_path,
+            "PLUGINS": [linkclass],
+            "CACHE_CONTENT": False,
+            "SITEURL": "http://example.org",
+            "TIMEZONE": "UTC",
+            "LINKCLASS": (
+                ("INTERNAL_CLASS", INTERNAL_CLASS),
+                ("EXTERNAL_CLASS", EXTERNAL_CLASS),
+            ),
+        }
+        if override:
+            settings.update(override)
+
+        # Generate the test Markdown source file
+        with open(
+            os.path.join(self.content_path, f"{TEST_FILE_STEM}.md"),
+            "w",
+        ) as fid:
+            template = """Title: Test
+Date: 1970-01-01
+
+This is an [{}]({}), inline-style link.
+This is an [{}]({}), inline-style link (with http URL).
+This is an [{}]({}), inline-style link (with https URL).
+
+This is an [{}][{}], reference-style link.
+This is an [{}][{}], reference-style link (with http URL).
+This is an [{}][{}], reference-style link (with https URL).
+
+ [{}]: {}
+ [{}]: {}
+ [{}]: {}
+
+"""
+            fid.write(
+                template.format(
+                    INTERNAL_INLINE_TEXT,
+                    INTERNAL_INLINE_LINK,
+                    EXTERNAL_INLINE_TEXT_HTTP,
+                    EXTERNAL_INLINE_LINK_HTTP,
+                    EXTERNAL_INLINE_TEXT_HTTPS,
+                    EXTERNAL_INLINE_LINK_HTTP,
+                    INTERNAL_REFERENCE_TEXT,
+                    INTERNAL_REFERENCE_LABEL,
+                    EXTERNAL_REFERENCE_TEXT_HTTP,
+                    EXTERNAL_REFERENCE_LABEL_HTTP,
+                    EXTERNAL_REFERENCE_TEXT_HTTPS,
+                    EXTERNAL_REFERENCE_LABEL_HTTPS,
+                    INTERNAL_REFERENCE_LABEL,
+                    INTERNAL_REFERENCE_LINK,
+                    EXTERNAL_REFERENCE_LABEL_HTTP,
+                    EXTERNAL_REFERENCE_LINK_HTTP,
+                    EXTERNAL_REFERENCE_LABEL_HTTPS,
+                    EXTERNAL_REFERENCE_LINK_HTTPS,
+                )
+            )
+
+        # Run the Pelican instance
+        self.settings = read_settings(override=settings)
+        pelican = Pelican(settings=self.settings)
+        saved_stdout = sys.stdout
+        sys.stdout = StringIO()
+        pelican.run()
+        sys.stdout = saved_stdout
+
+    def tearDown(self):
+        """Remove the temporary directories."""
+        rmtree(self.output_path)
+        rmtree(self.content_path)
+
+    def search(self, string):
+        """Search for a string in the article output."""
+        with open(
+            os.path.join(self.output_path, f"{TEST_FILE_STEM}.html"),
+        ) as fid:
+            found = False
+            for line in fid.readlines():
+                if re.search(string, line):
+                    found = True
+                    break
+        return found
+
+    def test_internal_inline(self):
+        """Test for the internal inline link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                INTERNAL_CLASS,
+                INTERNAL_INLINE_LINK,
+                INTERNAL_INLINE_TEXT,
+            )
+        )
+
+    def test_external_inline_http(self):
+        """Test for the external http inline link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                EXTERNAL_CLASS,
+                EXTERNAL_INLINE_LINK_HTTP,
+                EXTERNAL_INLINE_TEXT_HTTP,
+            )
+        )
+
+    def test_external_inline_https(self):
+        """Test for the external https inline link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                EXTERNAL_CLASS,
+                EXTERNAL_INLINE_LINK_HTTPS,
+                EXTERNAL_INLINE_TEXT_HTTPS,
+            )
+        )
+
+    def test_internal_reference(self):
+        """Test for the internal reference link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                INTERNAL_CLASS,
+                INTERNAL_REFERENCE_LINK,
+                INTERNAL_REFERENCE_TEXT,
+            )
+        )
+
+    def test_external_reference_http(self):
+        """Test for the external http reference link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                EXTERNAL_CLASS,
+                EXTERNAL_REFERENCE_LINK_HTTP,
+                EXTERNAL_REFERENCE_TEXT_HTTPS,
+            )
+        )
+
+    def test_external_reference_https(self):
+        """Test for the external https reference link."""
+        assert self.search(
+            LINK_PATTERN.format(
+                EXTERNAL_CLASS,
+                EXTERNAL_REFERENCE_LINK_HTTPS,
+                EXTERNAL_REFERENCE_TEXT_HTTPS,
+            )
+        )

{pelican_linkclass-2.1.3 → pelican_linkclass-2.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pelican-linkclass"
-version = "2.1.3"
+version = "2.1.4"
 description = "Pelican plugin to set anchor tag's class attribute to differentiate between internal and external links"
 authors = [
     { name = "Rafael Laboissière", email = "rafael@laboissiere.net" },
@@ -60,6 +60,20 @@ test = [
     "pytest-sugar>=0.9.7",
 ]
 
+[tool.pdm.build]
+source-includes = [
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "external-link.png",
+    "linkclass-example.png",
+]
+includes = [
+    "pelican/",
+]
+excludes = [
+    "tasks.py",
+]
+
 [tool.autopub]
 project-name = "Link Class"
 git-username = "botpub"

pelican_linkclass-2.1.3/tasks.py

@@ -1,99 +0,0 @@
-from inspect import cleandoc
-import logging
-import os
-from pathlib import Path
-from shutil import which
-
-from invoke import task
-
-logger = logging.getLogger(__name__)
-
-PKG_NAME = "linkclass"
-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.expanduser() / PKG_NAME)
-VENV = str(VENV_PATH.expanduser())
-BIN_DIR = "bin" if os.name != "nt" else "Scripts"
-VENV_BIN = Path(VENV) / Path(BIN_DIR)
-
-TOOLS = ("pdm", "pre-commit")
-PDM = which("pdm") if which("pdm") else (VENV_BIN / "pdm")
-CMD_PREFIX = f"{VENV_BIN}/" if ACTIVE_VENV else f"{PDM} run "
-PRECOMMIT = which("pre-commit") if which("pre-commit") else f"{CMD_PREFIX}pre-commit"
-PTY = os.name != "nt"
-
-
-@task
-def tests(c, deprecations=False):
-    """Run the test suite, optionally with `--deprecations`."""
-    deprecations_flag = "" if deprecations else "-W ignore::DeprecationWarning"
-    c.run(f"{CMD_PREFIX}pytest {deprecations_flag}", pty=PTY)
-
-
-@task
-def black(c, check=False, diff=False):
-    """Run Black auto-formatter, optionally with `--check` or `--diff`."""
-    check_flag, diff_flag = "", ""
-    if check:
-        check_flag = "--check"
-    if diff:
-        diff_flag = "--diff"
-    c.run(f"{CMD_PREFIX}black {check_flag} {diff_flag} {PKG_PATH} tasks.py", pty=PTY)
-
-
-@task
-def ruff(c, fix=False, diff=False):
-    """Run Ruff to ensure code meets project standards."""
-    diff_flag, fix_flag = "", ""
-    if fix:
-        fix_flag = "--fix"
-    if diff:
-        diff_flag = "--diff"
-    c.run(f"{CMD_PREFIX}ruff check {diff_flag} {fix_flag} .", pty=PTY)
-
-
-@task
-def lint(c, fix=False, diff=False):
-    """Check code style via linting tools."""
-    ruff(c, fix=fix, diff=diff)
-    black(c, check=(not fix), diff=diff)
-
-
-@task
-def tools(c):
-    """Install development tools in the virtual environment if not already on PATH."""
-    for tool in TOOLS:
-        if not which(tool):
-            logger.info(f"** Installing {tool} **")
-            c.run(f"{CMD_PREFIX}pip install {tool}")
-
-
-@task
-def precommit(c):
-    """Install pre-commit hooks to .git/hooks/pre-commit."""
-    logger.info("** Installing pre-commit hooks **")
-    c.run(f"{PRECOMMIT} install")
-
-
-@task
-def setup(c):
-    """Set up the development environment."""
-    if which("pdm") or ACTIVE_VENV:
-        tools(c)
-        c.run(f"{CMD_PREFIX}python -m pip install --upgrade pip", pty=PTY)
-        c.run(f"{PDM} update --dev", pty=PTY)
-        precommit(c)
-        logger.info("\nDevelopment environment should now be set up and ready!\n")
-    else:
-        error_message = """
-            PDM is not installed, and there is no active virtual environment available.
-            You can either manually create and activate a virtual environment, or you can
-            install PDM via:
-
-            curl -sSL https://raw.githubusercontent.com/pdm-project/pdm/main/install-pdm.py | python3 -
-
-            Once you have taken one of the above two steps, run `invoke setup` again.
-            """  # noqa: E501
-        raise SystemExit(cleandoc(error_message))