mkdocs-include-markdown-plugin 7.0.0__tar.gz → 7.1.1__tar.gz

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/.gitignore

@@ -17,5 +17,6 @@ venv*/
 .mypy_cache/
 *.so
 .prettier-cache
+/*.html
 
 site/

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mkdocs-include-markdown-plugin
-Version: 7.0.0
+Version: 7.1.1
 Summary: Mkdocs Markdown includer plugin.
 Project-URL: Source, https://github.com/mondeja/mkdocs-include-markdown-plugin
 Project-URL: Documentation, https://github.com/mondeja/mkdocs-include-markdown-plugin#documentation
@@ -9,8 +9,7 @@ Project-URL: Changelog, https://github.com/mondeja/mkdocs-include-markdown-plugi
 Author: Joe Rickerby
 Author-email: Álvaro Mondéjar Rubio <mondejar1994@gmail.com>
 Maintainer-email: Álvaro Mondéjar Rubio <mondejar1994@gmail.com>
-License-Expression: Apache-2.0
-License-File: LICENSE
+License: Apache-2.0
 Keywords: includer,markdown,mkdocs,plugin
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
@@ -144,6 +143,20 @@ You can include it in the installation of the plugin adding the `cache` extra:
 mkdocs-include-markdown-plugin[cache]
 ```
 
+<!-- mdpo-disable-next-line -->
+
+#### `directives`
+
+Customize the names of the directives.
+
+```yaml
+plugins:
+  - include-markdown:
+      directives:
+        include-markdown: include-md
+        include: replace
+```
+
 ### Reference
 
 This plugin provides two directives, one to include Markdown files and another

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/README.md

@@ -109,6 +109,20 @@ You can include it in the installation of the plugin adding the `cache` extra:
 mkdocs-include-markdown-plugin[cache]
 ```
 
+<!-- mdpo-disable-next-line -->
+
+#### `directives`
+
+Customize the names of the directives.
+
+```yaml
+plugins:
+  - include-markdown:
+      directives:
+        include-markdown: include-md
+        include: replace
+```
+
 ### Reference
 
 This plugin provides two directives, one to include Markdown files and another

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs-include-markdown-plugin"
-version = "7.0.0"
+version = "7.1.1"
 description = "Mkdocs Markdown includer plugin."
 readme = "README.md"
 license = "Apache-2.0"

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/cache.py

@@ -2,18 +2,14 @@
 
 from __future__ import annotations
 
-import base64
 import hashlib
 import os
+import stat
 import time
+from importlib.util import find_spec
 
 
-try:
-    from platformdirs import user_data_dir
-except ImportError:  # pragma: no cover
-    CACHE_AVAILABLE = False
-else:
-    CACHE_AVAILABLE = True
+CACHE_AVAILABLE = find_spec('platformdirs') is not None
 
 
 class Cache:
@@ -29,24 +25,28 @@ class Cache:
 
     def get_creation_time_from_fpath(self, fpath: str) -> int:
         """Get creation time of an entry in the cache given its path."""
-        with open(fpath, encoding='utf-8') as f:
+        with open(fpath, 'rb') as f:
             return int(f.readline())
 
     @classmethod
     def generate_unique_key_from_url(cls, url: str) -> str:
         """Generate a unique key from an URL."""
-        return base64.urlsafe_b64encode(
-            hashlib.sha3_512(url.encode()).digest(),
-        ).decode('utf-8')
+        return hashlib.blake2b(url.encode(), digest_size=16).digest().hex()
 
     def read_file(self, fpath: str, encoding: str = 'utf-8') -> str:  # noqa: D102
-        with open(fpath, encoding=encoding) as f:
-            return f.read().split('\n', 1)[1]
+        f = open(fpath, encoding=encoding)  # noqa: SIM115
+        content = f.read().split('\n', 1)[1]
+        f.close()
+        return content
 
     def get_(self, url: str, encoding: str = 'utf-8') -> str | None:  # noqa: D102
         key = self.generate_unique_key_from_url(url)
         fpath = os.path.join(self.cache_dir, key)
-        if os.path.isfile(fpath):
+        try:
+            is_file = stat.S_ISREG(os.stat(fpath).st_mode)
+        except (FileNotFoundError, OSError):  # pragma: no cover
+            return None
+        if is_file:
             creation_time = self.get_creation_time_from_fpath(fpath)
             if time.time() < creation_time + self.expiration_seconds:
                 return self.read_file(fpath, encoding=encoding)
@@ -56,9 +56,10 @@ class Cache:
     def set_(self, url: str, value: str, encoding: str = 'utf-8') -> None:  # noqa: D102
         key = self.generate_unique_key_from_url(url)
         fpath = os.path.join(self.cache_dir, key)
-        with open(fpath, 'w', encoding=encoding) as f:
-            f.write(f'{int(time.time())}\n')
-            f.write(value)
+        with open(fpath, 'wb') as fp:
+            now = f'{int(time.time())}\n'
+            fp.write(now.encode(encoding))
+            fp.write(value.encode(encoding))
 
     def clean(self) -> None:
         """Clean expired entries from the cache."""
@@ -74,9 +75,13 @@ def get_cache_directory() -> str | None:
     if not CACHE_AVAILABLE:
         return None
 
+    try:
+        from platformdirs import user_data_dir
+    except ImportError:
+        return None
+
     cache_dir = user_data_dir('mkdocs-include-markdown-plugin')
-    if not os.path.isdir(cache_dir):
-        os.makedirs(cache_dir)
+    os.makedirs(cache_dir, exist_ok=True)
 
     return cache_dir
 

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/config.py

@@ -25,3 +25,11 @@ class PluginConfig(Config):  # noqa: D101
     exclude = ListOfItems(MkType(str), default=[])
     cache = MkType(int, default=0)
     recursive = MkType(bool, default=True)
+    directives = MkType(
+        dict,
+        default={
+            '__default': '',
+            'include': 'include',
+            'include-markdown': 'include-markdown',
+        },
+    )

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/directive.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import functools
 import os
 import re
+import stat
 import string
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
@@ -21,8 +23,8 @@ class DirectiveBoolArgument:  # noqa: D101
     regex: re.Pattern[str]
 
 
-if TYPE_CHECKING:
-    from typing import Literal, TypedDict
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import Callable, Literal, TypedDict
 
     DirectiveBoolArgumentsDict = dict[str, DirectiveBoolArgument]
 
@@ -73,11 +75,13 @@ TRUE_FALSE_BOOL_STR = {
 }
 
 
+@functools.lru_cache
 def arg(arg: str) -> re.Pattern[str]:
     """Return a compiled regexp to match a boolean argument."""
     return re.compile(rf'{arg}=([{RE_ESCAPED_PUNCTUATION}\w]*)')
 
 
+@functools.lru_cache
 def str_arg(arg: str) -> re.Pattern[str]:
     """Return a compiled regexp to match a string argument."""
     return re.compile(
@@ -87,21 +91,23 @@ def str_arg(arg: str) -> re.Pattern[str]:
 
 
 ARGUMENT_REGEXES = {
-    'start': str_arg('start'),
-    'end': str_arg('end'),
-    'exclude': str_arg('exclude'),
-    'encoding': str_arg('encoding'),
+    'start': functools.partial(str_arg, 'start'),
+    'end': functools.partial(str_arg, 'end'),
+    'exclude': functools.partial(str_arg, 'exclude'),
+    'encoding': functools.partial(str_arg, 'encoding'),
 
     # bool
-    'comments': arg('comments'),
-    'preserve-includer-indent': arg('preserve-includer-indent'),
-    'dedent': arg('dedent'),
-    'trailing-newlines': arg('trailing-newlines'),
-    'rewrite-relative-urls': arg('rewrite-relative-urls'),
-    'recursive': arg('recursive'),
+    'comments': functools.partial(arg, 'comments'),
+    'preserve-includer-indent': functools.partial(
+        arg, 'preserve-includer-indent',
+    ),
+    'dedent': functools.partial(arg, 'dedent'),
+    'trailing-newlines': functools.partial(arg, 'trailing-newlines'),
+    'rewrite-relative-urls': functools.partial(arg, 'rewrite-relative-urls'),
+    'recursive': functools.partial(arg, 'recursive'),
 
     # int
-    'heading-offset': arg('heading-offset'),
+    'heading-offset': functools.partial(arg, 'heading-offset'),
 }
 
 INCLUDE_DIRECTIVE_ARGS = {
@@ -110,26 +116,29 @@ INCLUDE_DIRECTIVE_ARGS = {
     )
 }
 
-INCLUDE_MARKDOWN_DIRECTIVE_ARGS = set(ARGUMENT_REGEXES)
+WARN_INVALID_DIRECTIVE_ARGS_REGEX = re.compile(
+    rf'[\w-]*=[{RE_ESCAPED_PUNCTUATION}\w]*',
+)
 
 
 def warn_invalid_directive_arguments(
     arguments_string: str,
-    directive_lineno: int,
+    directive_lineno: Callable[[], int],
     directive: Literal['include', 'include-markdown'],
     page_src_path: str | None,
     docs_dir: str,
 ) -> None:
     """Warns about the invalid arguments passed to a directive."""
-    arg_re = re.compile(rf'[\w-]*=[{RE_ESCAPED_PUNCTUATION}\w]*')
     valid_args = (
         INCLUDE_DIRECTIVE_ARGS if directive == 'include'
-        else INCLUDE_MARKDOWN_DIRECTIVE_ARGS
+        else set(ARGUMENT_REGEXES)
     )
-    for arg_value in re.findall(arg_re, arguments_string):
+    for arg_value in WARN_INVALID_DIRECTIVE_ARGS_REGEX.findall(
+        arguments_string,
+    ):
         if arg_value.split('=', 1)[0] not in valid_args:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             logger.warning(
                 f"Invalid argument '{arg_value}' in"
@@ -166,7 +175,7 @@ def parse_string_argument(match: re.Match[str]) -> str | None:
 
 
 def create_include_tag(
-        opening_tag: str, closing_tag: str, tag: str = 'include',
+        opening_tag: str, closing_tag: str, tag: str,
 ) -> re.Pattern[str]:
     """Create a regex pattern to match an inclusion tag directive.
 
@@ -174,9 +183,9 @@ def create_include_tag(
     INCLUDE_TAG_RE by the effective tag.
     """
     return re.compile(
-        INCLUDE_TAG_RE.replace(' include', f' {tag}').replace(
-            '$OPENING_TAG', re.escape(opening_tag),
-        ).replace('$CLOSING_TAG', re.escape(closing_tag)),
+        INCLUDE_TAG_RE.replace(' include', f' {tag}', 1).replace(
+            '$OPENING_TAG', re.escape(opening_tag), 1,
+        ).replace('$CLOSING_TAG', re.escape(closing_tag), 1),
         flags=re.VERBOSE | re.DOTALL,
     )
 
@@ -193,7 +202,7 @@ def parse_bool_options(
     for option_name in option_names:
         bool_options[option_name] = DirectiveBoolArgument(
             value=defaults[option_name],  # type: ignore
-            regex=ARGUMENT_REGEXES[option_name],
+            regex=ARGUMENT_REGEXES[option_name](),
         )
 
     for arg_name, arg in bool_options.items():
@@ -209,7 +218,7 @@ def parse_bool_options(
     return bool_options, invalid_args
 
 
-def resolve_file_paths_to_include(
+def resolve_file_paths_to_include(  # noqa: PLR0912
     include_string: str,
     includer_page_src_path: str | None,
     docs_dir: str,
@@ -220,22 +229,29 @@ def resolve_file_paths_to_include(
         return [include_string], True
 
     if process.is_absolute_path(include_string):
-        if os.name == 'nt':  # pragma: nt cover
+        if os.name == 'nt':  # pragma: no cover
             # Windows
             fpath = os.path.normpath(include_string)
-            if not os.path.isfile(fpath):
+            try:
+                is_file = stat.S_ISREG(os.stat(fpath).st_mode)
+            except (FileNotFoundError, OSError):
+                is_file = False
+            if not is_file:
                 return [], False
 
             return process.filter_paths(
                 [fpath], ignore_paths,
             ), False
+
+        try:
+            is_file = stat.S_ISREG(os.stat(include_string).st_mode)
+        except (FileNotFoundError, OSError):
+            is_file = False
         return process.filter_paths(
-            glob.iglob(
-                os.path.normpath(include_string),
-                flags=GLOB_FLAGS,
+            [include_string] if is_file else glob.iglob(
+                include_string, flags=GLOB_FLAGS,
             ),
-            ignore_paths,
-        ), False
+            ignore_paths), False
 
     if process.is_relative_path(include_string):
         if includer_page_src_path is None:  # pragma: no cover
@@ -247,29 +263,41 @@ def resolve_file_paths_to_include(
         root_dir = os.path.abspath(
             os.path.dirname(includer_page_src_path),
         )
-        return process.filter_paths(
-            (
-                os.path.normpath(os.path.join(root_dir, fp))
-                for fp in glob.iglob(
-                    include_string,
-                    flags=GLOB_FLAGS,
-                    root_dir=root_dir,
-                )
-            ), ignore_paths,
-        ), False
-
-    # relative to docs_dir
-    return process.filter_paths(
-        (
-            os.path.normpath(os.path.join(docs_dir, fp))
+        paths = []
+        include_path = os.path.join(root_dir, include_string)
+        try:
+            is_file = stat.S_ISREG(os.stat(include_path).st_mode)
+        except (FileNotFoundError, OSError):
+            is_file = False
+        if is_file:
+            paths.append(include_path)
+        else:
             for fp in glob.iglob(
                 include_string,
                 flags=GLOB_FLAGS,
-                root_dir=docs_dir,
-            )
-        ),
-        ignore_paths,
-    ), False
+                root_dir=root_dir,
+            ):
+                paths.append(os.path.join(root_dir, fp))
+        return process.filter_paths(paths, ignore_paths), False
+
+    # relative to docs_dir
+    paths = []
+    root_dir = docs_dir
+    include_path = os.path.join(root_dir, include_string)
+    try:
+        is_file = stat.S_ISREG(os.stat(include_path).st_mode)
+    except (FileNotFoundError, OSError):
+        is_file = False
+    if is_file:
+        paths.append(include_path)
+    else:
+        for fp in glob.iglob(
+            include_string,
+            flags=GLOB_FLAGS,
+            root_dir=root_dir,
+        ):
+            paths.append(os.path.join(root_dir, fp))
+    return process.filter_paths(paths, ignore_paths), False
 
 
 def resolve_file_paths_to_exclude(

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/event.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import functools
 import html
 import os
 import re
@@ -17,6 +18,7 @@ from mkdocs_include_markdown_plugin.cache import Cache
 from mkdocs_include_markdown_plugin.directive import (
     ARGUMENT_REGEXES,
     GLOB_FLAGS,
+    create_include_tag,
     parse_bool_options,
     parse_filename_argument,
     parse_string_argument,
@@ -28,7 +30,7 @@ from mkdocs_include_markdown_plugin.files_watcher import FilesWatcher
 from mkdocs_include_markdown_plugin.logger import logger
 
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from typing import Literal, TypedDict
 
     from mkdocs.structure.pages import Page
@@ -104,7 +106,8 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             match: re.Match[str],
     ) -> str:
         directive_match_start = match.start()
-        directive_lineno = process.lineno_from_content_start(
+        directive_lineno = functools.partial(
+            process.lineno_from_content_start,
             markdown,
             directive_match_start,
         )
@@ -114,7 +117,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         filename, raw_filename = parse_filename_argument(match)
         if filename is None:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 "Found no path passed including with 'include'"
@@ -131,13 +134,13 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             docs_dir,
         )
 
-        exclude_match = ARGUMENT_REGEXES['exclude'].search(arguments_string)
+        exclude_match = ARGUMENT_REGEXES['exclude']().search(arguments_string)
         ignore_paths = [*settings_ignore_paths]
         if exclude_match is not None:
             exclude_string = parse_string_argument(exclude_match)
             if exclude_string is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'exclude' argument in 'include'"
@@ -159,7 +162,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
 
         if not file_paths_to_include:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 f"No files found including '{raw_filename}' at {location}",
@@ -176,7 +179,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         )
         if invalid_bool_args:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 f"Invalid value for '{invalid_bool_args[0]}' argument of"
@@ -184,12 +187,12 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                 f' Possible values are true or false.',
             )
 
-        start_match = ARGUMENT_REGEXES['start'].search(arguments_string)
+        start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
         if start_match:
             start = parse_string_argument(start_match)
             if start is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'start' argument in 'include' directive at"
@@ -198,12 +201,12 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         else:
             start = defaults['start']
 
-        end_match = ARGUMENT_REGEXES['end'].search(arguments_string)
+        end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
         if end_match:
             end = parse_string_argument(end_match)
             if end is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'end' argument in 'include' directive at"
@@ -212,12 +215,13 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         else:
             end = defaults['end']
 
-        encoding_match = ARGUMENT_REGEXES['encoding'].search(arguments_string)
+        encoding_match = ARGUMENT_REGEXES['encoding']().search(
+            arguments_string)
         if encoding_match:
             encoding = parse_string_argument(encoding_match)
             if encoding is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'encoding' argument in 'include'"
@@ -294,7 +298,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                 ])
                 plural_suffix = 's' if len(file_paths_to_include) > 1 else ''
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 logger.warning(
                     f"Delimiter {delimiter_name} '{delimiter_value}'"
@@ -313,7 +317,8 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             match: re.Match[str],
     ) -> str:
         directive_match_start = match.start()
-        directive_lineno = process.lineno_from_content_start(
+        directive_lineno = functools.partial(
+            process.lineno_from_content_start,
             markdown,
             directive_match_start,
         )
@@ -324,7 +329,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         filename, raw_filename = parse_filename_argument(match)
         if filename is None:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 "Found no path passed including with 'include-markdown'"
@@ -341,13 +346,13 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             docs_dir,
         )
 
-        exclude_match = ARGUMENT_REGEXES['exclude'].search(arguments_string)
+        exclude_match = ARGUMENT_REGEXES['exclude']().search(arguments_string)
         ignore_paths = [*settings_ignore_paths]
         if exclude_match is not None:
             exclude_string = parse_string_argument(exclude_match)
             if exclude_string is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'exclude' argument in 'include-markdown'"
@@ -368,7 +373,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
 
         if not file_paths_to_include:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 f"No files found including '{raw_filename}' at {location}",
@@ -388,7 +393,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         )
         if invalid_bool_args:
             location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno,
+                page_src_path, docs_dir, directive_lineno(),
             )
             raise PluginError(
                 f"Invalid value for '{invalid_bool_args[0]}' argument of"
@@ -397,12 +402,12 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             )
 
         # start and end arguments
-        start_match = ARGUMENT_REGEXES['start'].search(arguments_string)
+        start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
         if start_match:
             start = parse_string_argument(start_match)
             if start is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'start' argument in 'include-markdown'"
@@ -411,12 +416,12 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         else:
             start = defaults['start']
 
-        end_match = ARGUMENT_REGEXES['end'].search(arguments_string)
+        end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
         if end_match:
             end = parse_string_argument(end_match)
             if end is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'end' argument in 'include-markdown'"
@@ -425,12 +430,13 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         else:
             end = defaults['end']
 
-        encoding_match = ARGUMENT_REGEXES['encoding'].search(arguments_string)
+        encoding_match = ARGUMENT_REGEXES['encoding']().search(
+            arguments_string)
         if encoding_match:
             encoding = parse_string_argument(encoding_match)
             if encoding is None:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'encoding' argument in 'include-markdown'"
@@ -440,14 +446,14 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             encoding = defaults['encoding']
 
         # heading offset
-        offset_match = ARGUMENT_REGEXES['heading-offset'].search(
+        offset_match = ARGUMENT_REGEXES['heading-offset']().search(
             arguments_string,
         )
         if offset_match:
             offset_raw_value = offset_match[1]
             if offset_raw_value == '':
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     "Invalid empty 'heading-offset' argument in"
@@ -457,7 +463,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                 offset = int(offset_raw_value)
             except ValueError:
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
                     f"Invalid 'heading-offset' argument \"{offset_raw_value}\""
@@ -579,7 +585,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                 ])
                 plural_suffix = 's' if len(file_paths_to_include) > 1 else ''
                 location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno,
+                    page_src_path, docs_dir, directive_lineno(),
                 )
                 logger.warning(
                     f"Delimiter {delimiter_name} '{delimiter_value}' of"
@@ -630,8 +636,16 @@ def on_page_markdown(
         page.file.abs_src_path,
         docs_dir,
         {
-            'include': plugin._include_tag,
-            'include-markdown': plugin._include_markdown_tag,
+            'include': create_include_tag(
+                config.opening_tag,
+                config.closing_tag,
+                config.directives.get('include', 'include'),
+            ),
+            'include-markdown': create_include_tag(
+                config.opening_tag,
+                config.closing_tag,
+                config.directives.get('include-markdown', 'include-markdown'),
+            ),
         },
         {
             'encoding': config.encoding,

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/plugin.py

@@ -7,20 +7,18 @@ from functools import cached_property
 from typing import TYPE_CHECKING
 
 from mkdocs.exceptions import PluginError
-from mkdocs.livereload import LiveReloadServer
 from mkdocs.plugins import BasePlugin, event_priority
 
 
-if TYPE_CHECKING:
-    import re
+if TYPE_CHECKING:  # pragma: no cover
 
     from mkdocs.config.defaults import MkDocsConfig
+    from mkdocs.livereload import LiveReloadServer
     from mkdocs.structure.files import Files
     from mkdocs.structure.pages import Page
 
 from mkdocs_include_markdown_plugin.cache import Cache, initialize_cache
 from mkdocs_include_markdown_plugin.config import PluginConfig
-from mkdocs_include_markdown_plugin.directive import create_include_tag
 from mkdocs_include_markdown_plugin.event import (
     on_page_markdown as _on_page_markdown,
 )
@@ -44,22 +42,18 @@ class IncludeMarkdownPlugin(BasePlugin[PluginConfig]):
             cache.clean()
             self._cache = cache
 
-        return config
-
-    @cached_property
-    def _include_tag(self) -> re.Pattern[str]:
-        return create_include_tag(
-            self.config.opening_tag,
-            self.config.closing_tag,
-        )
+        if '__default' not in self.config.directives:  # pragma: no cover
+            for directive in self.config.directives:
+                if directive not in {
+                    'include', 'include-markdown',
+                }:
+                    raise PluginError(
+                        f"Invalid directive name '{directive}' at 'directives'"
+                        ' global setting. Valid values are "include" and'
+                        ' "include-markdown".',
+                    )
 
-    @cached_property
-    def _include_markdown_tag(self) -> re.Pattern[str]:
-        return create_include_tag(
-            self.config.opening_tag,
-            self.config.closing_tag,
-            tag='include-markdown',
-        )
+        return config
 
     @cached_property
     def _files_watcher(self) -> FilesWatcher:

{mkdocs_include_markdown_plugin-7.0.0 → mkdocs_include_markdown_plugin-7.1.1}/src/mkdocs_include_markdown_plugin/process.py

@@ -6,13 +6,12 @@ import functools
 import io
 import os
 import re
+import stat
 from collections.abc import Callable, Iterator
-from typing import TYPE_CHECKING, Any
-from urllib.parse import urlparse, urlunparse
-from urllib.request import Request, urlopen
+from typing import TYPE_CHECKING
 
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from typing import Any
 
     from mkdocs_include_markdown_plugin.cache import Cache
@@ -51,9 +50,9 @@ MARKDOWN_LINK_REGEX = re.compile(  # noqa: DUO138
             )
           \]
           \(             # literal paren
-            [ \t]*
+            \s*
             <?(.*?)>?    # href = $3
-            [ \t]*
+            \s*
             (            # $4
               (['"])     # quote char = $5
               (.*?)      # Title = $6
@@ -145,10 +144,7 @@ def transform_p_by_p_skipping_codeblocks(  # noqa: PLR0912, PLR0915
     for line in io.StringIO(markdown):
         if not _current_fcodeblock_delimiter:
             lstripped_line = line.lstrip()
-            if (
-                lstripped_line.startswith('```')
-                or lstripped_line.startswith('~~~')
-            ):
+            if lstripped_line.startswith(('```', '~~~')):
                 _current_fcodeblock_delimiter = lstripped_line[:3]
                 process_current_paragraph()
                 current_paragraph = ''
@@ -226,10 +222,7 @@ def transform_line_by_line_skipping_codeblocks(
     for line in io.StringIO(markdown):
         if not _current_fcodeblock_delimiter:
             lstripped_line = line.lstrip()
-            if (
-                lstripped_line.startswith('```')
-                or lstripped_line.startswith('~~~')
-            ):
+            if lstripped_line.startswith(('```', '~~~')):
                 _current_fcodeblock_delimiter = lstripped_line[:3]
             else:
                 line = func(line)  # noqa: PLW2901
@@ -252,28 +245,34 @@ def rewrite_relative_urls(
     ``destination_path``.
     """
     def rewrite_url(url: str) -> str:
+        from urllib.parse import urlparse, urlunparse
+
+        if is_relative_path(url):
+            return url
+
         scheme, netloc, path, params, query, fragment = urlparse(url)
 
         # absolute or mail
         if path.startswith('/') or scheme == 'mailto':
             return url
 
-        trailing_slash = path.endswith('/')
-
-        path = os.path.relpath(
+        new_path = os.path.relpath(
             os.path.join(os.path.dirname(source_path), path),
             os.path.dirname(destination_path),
         )
 
         # ensure forward slashes are used, on Windows
-        path = path.replace('\\', '/').replace('//', '/')
+        new_path = new_path.replace('\\', '/').replace('//', '/')
 
-        if trailing_slash:
-            # the above operation removes a trailing slash. Add it back if it
-            # was present in the input
-            path = path + '/'
+        try:
+            if path[-1] == '/':
+                # the above operation removes a trailing slash,
+                # so add it back if it was present in the input
+                new_path += '/'
+        except IndexError:  # pragma: no cover
+            pass
 
-        return urlunparse((scheme, netloc, path, params, query, fragment))
+        return urlunparse((scheme, netloc, new_path, params, query, fragment))
 
     def found_href(m: re.Match[str], url_group_index: int = -1) -> str:
         match_start, match_end = m.span(0)
@@ -359,9 +358,10 @@ def filter_inclusions(  # noqa: PLR0912
         if end not in text_to_include:
             expected_end_not_found = True
 
+        start_split = text_to_include.split(start)
         text_parts = (
-            text_to_include.split(start)[1:]
-            if start in text_to_include else [text_to_include]
+            start_split[1:]
+            if len(start_split) > 1 else [text_to_include]
         )
 
         for start_text in text_parts:
@@ -382,25 +382,39 @@ def _transform_negative_offset_func_factory(
         offset: int,
 ) -> Callable[[str], str]:
     heading_prefix = '#' * abs(offset)
-    return lambda line: line if not line.startswith('#') else (
-        heading_prefix + line.lstrip('#')
-        if line.startswith(heading_prefix)
-        else '#' + line.lstrip('#')
-    )
+
+    def transform(line: str) -> str:
+        try:
+            if line[0] != '#':
+                return line
+        except IndexError:  # pragma: no cover
+            return line
+        if line.startswith(heading_prefix):
+            return heading_prefix + line.lstrip('#')
+        return '#' + line.lstrip('#')
+
+    return transform
 
 
 def _transform_positive_offset_func_factory(
         offset: int,
 ) -> Callable[[str], str]:
     heading_prefix = '#' * offset
-    return lambda line: (
-        heading_prefix + line if line.startswith('#') else line
-    )
+
+    def transform(line: str) -> str:
+        try:
+            prefix = line[0]
+        except IndexError:  # pragma: no cover
+            return line
+        else:
+            return heading_prefix + line if prefix == '#' else line
+
+    return transform
 
 
 def increase_headings_offset(markdown: str, offset: int = 0) -> str:
     """Increases the headings depth of a snippet of Makdown content."""
-    if not offset:
+    if not offset:  # pragma: no cover
         return markdown
     return transform_line_by_line_skipping_codeblocks(
         markdown,
@@ -444,18 +458,27 @@ def filter_paths(
             continue
 
         # ignore by dirpath (relative or absolute)
-        if (os.sep).join(filepath.split(os.sep)[:-1]) in ignore_paths:
+        fp_split = filepath.split(os.sep)
+        fp_split.pop()
+        if (os.sep).join(fp_split) in ignore_paths:
             continue
 
         # ignore if is a directory
-        if not os.path.isdir(filepath):
-            response.append(filepath)
+        try:
+            if not stat.S_ISDIR(os.stat(filepath).st_mode):
+                response.append(filepath)
+        except (FileNotFoundError, OSError):  # pragma: no cover
+            continue
     response.sort()
     return response
 
 
 def is_url(string: str) -> bool:
     """Determine if a string is an URL."""
+    if ':' not in string:  # fast path
+        return False
+    from urllib.parse import urlparse
+
     try:
         result = urlparse(string)
         return all([result.scheme, result.netloc])
@@ -470,13 +493,15 @@ def is_relative_path(string: str) -> bool:
 
 def is_absolute_path(string: str) -> bool:
     """Check if a string looks like an absolute path."""
-    return os.path.isabs(string) or string.startswith((os.sep, '/'))
+    return string.startswith((os.sep, '/'))
 
 
 def read_file(file_path: str, encoding: str) -> str:
     """Read a file and return its content."""
-    with open(file_path, encoding=encoding) as f:
-        return f.read()
+    f = open(file_path, encoding=encoding)  # noqa: SIM115
+    content = f.read()
+    f.close()
+    return content
 
 
 def read_url(
@@ -485,6 +510,8 @@ def read_url(
         encoding: str = 'utf-8',
 ) -> Any:
     """Read an HTTP location and return its content."""
+    from urllib.request import Request, urlopen
+
     if http_cache is not None:
         cached_content = http_cache.get_(url, encoding)
         if cached_content is not None: