mkdocs-simple-plugin 3.2.1__tar.gz → 3.2.3__tar.gz

{mkdocs_simple_plugin-3.2.1 → mkdocs_simple_plugin-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs-simple-plugin
-Version: 3.2.1
+Version: 3.2.3
 Summary: Plugin for adding simple wiki site creation from markdown files interspersed within your code with MkDocs.
 Project-URL: Documentation, http://www.althack.dev/mkdocs-simple-plugin
 Project-URL: Homepage, http://www.althack.dev/mkdocs-simple-plugin

{mkdocs_simple_plugin-3.2.1 → mkdocs_simple_plugin-3.2.3}/mkdocs_simple_plugin/plugin.py

@@ -335,11 +335,15 @@ class SimplePlugin(BasePlugin):
         # Read previous config first so updates don't get overwritten
         config_site_dir = get_config_site_dir(config.config_file_path)
 
-        # Set the build docs dir to tmp location if not set by user
-        if not self.config['build_dir'] and self.config['merge_docs_dir']:
-            self.config['build_dir'] = config['docs_dir']
-        else:
-            self.config['build_dir'] = self.tmp_build_dir
+        # If the build_dir isn't set by the user,
+        # set it to one of the following locations:
+        if not self.config['build_dir']:
+            if self.config['merge_docs_dir']:
+                # the build_dir to the docs_dir if merging
+                self.config['build_dir'] = config['docs_dir']
+            else:
+                # or a temp directory
+                self.config['build_dir'] = self.tmp_build_dir
 
         utils.log.info(
             "mkdocs-simple-plugin: build_dir: %s",
@@ -392,6 +396,7 @@ class SimplePlugin(BasePlugin):
                 dest_dir=config.site_dir,
                 use_directory_urls=config["use_directory_urls"]
             )
+            file.generated_by = "mkdocs_simple_plugin"
             if file.src_uri in files.src_uris:
                 files.remove(file)
             files.append(file)

{mkdocs_simple_plugin-3.2.1 → mkdocs_simple_plugin-3.2.3}/mkdocs_simple_plugin/simple.py

@@ -3,6 +3,7 @@ import fnmatch
 import os
 import pathlib
 import stat
+from typing import List, Dict
 
 from shutil import copy2 as copy
 from dataclasses import dataclass
@@ -51,68 +52,77 @@ class Simple():
         self.folders = set(folders)
         self.doc_glob = set(include)
         self.ignore_glob = set(ignore)
-        self.ignore_hidden = ignore_hidden  # to be deprecated
-        self.hidden_prefix = set([".", "__"])  # to be deprecated
+        self.ignore_hidden = ignore_hidden  # TODO[athackst] deprecate
+        self.hidden_prefix = set([".", "__"])  # TODO[athackst] deprecate
         self.ignore_paths = set(ignore_paths)
         self.semiliterate = []
         for item in semiliterate:
             self.semiliterate.append(Semiliterate(**item))
-
-    def get_files(self) -> list:
+        self.ignore_patterns: Dict[pathlib.Path, List[str]] = {}
+        self.root_path: pathlib.Path = pathlib.Path()
+
+    def process_mkdocsignore_files(self):
+        """Process all .mkdocsignore files and update ignore_glob."""
+        for mkdocsignore in self.root_path.rglob('.mkdocsignore'):
+            relative_path = mkdocsignore.parent.relative_to(self.root_path)
+            patterns = []
+            with mkdocsignore.open(mode="r", encoding="utf-8") as txt_file:
+                for line in txt_file:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        patterns.append(line)
+
+            if not patterns:
+                # If .mkdocsignore is empty, ignore everything in this directory
+                # and below
+                pattern = str(relative_path / '**')
+                self.ignore_glob.add(pattern)
+            else:
+                for pattern in patterns:
+                    if relative_path != pathlib.Path('.'):
+                        pattern = str(relative_path / pattern)
+                    self.ignore_glob.add(pattern)
+
+    def process_ignore_folders(self):
+        """Update ignore glob to include folders."""
+        self.ignore_glob.update(
+            [f"{pattern}/**" for pattern in self.ignore_glob])
+
+    def get_files(self) -> List[str]:
         """Get a list of files to process, excluding ignored files."""
-        files = []
-        # Get all of the entries that match the include pattern.
-        entries = []
+        # Process all .mkdocsignore files first
+        self.process_mkdocsignore_files()
+        self.process_ignore_folders()  # TODO[athackst] deprecate
+        files = set()
         for pattern in self.folders:
-            entries.extend(pathlib.Path().glob(pattern))
-        # Ignore any entries that match the ignore pattern
-        entries[:] = [
-            entry for entry in entries
-            if not self.is_path_ignored(str(entry))]
-        # Add any files
-        files[:] = [
-            os.path.normpath(entry) for entry in entries if entry.is_file()]
-        # Iterate through directories to get files
-        for entry in entries:
-            for root, directories, filenames in os.walk(entry):
-                files.extend([os.path.join(root, f)
-                             for f in filenames if not self.is_ignored(root, f)]
-                             )
-                directories[:] = [
-                    d for d in directories if not self.is_ignored(root, d)]
-        return files
-
-    def is_ignored(self, base_path: str, name: str) -> bool:
-        """Check if directory and filename should be ignored."""
-        return self.is_path_ignored(os.path.join(base_path, name))
-
-    def is_path_ignored(self, path: str = None) -> bool:
+            for entry in pathlib.Path().glob(pattern):
+                if entry.is_dir():
+                    files.update(str(f) for f in entry.rglob(
+                        '*') if self.is_valid_file(f))
+                elif self.is_valid_file(entry):
+                    files.add(str(entry))
+        return list(files)
+
+    def is_valid_file(self, path: pathlib.Path) -> bool:
+        """Check if file is valid (not ignored and matches doc_glob)."""
+        if self.is_ignored(path):
+            return False
+        if not path.is_file():
+            return False
+        return True
+
+    def is_ignored(self, path: pathlib.Path) -> bool:
         """Check if path should be ignored."""
-        path = os.path.normpath(path)
-        base_path = os.path.dirname(path)
-
-        # Check if its an internally required ignore path
-        for ignored in self.ignore_paths:
-            if os.path.abspath(path).startswith(ignored):
-                return True
-
-        # Update ignore patterns from .mkdocsignore file
-        mkdocsignore = os.path.join(base_path, ".mkdocsignore")
-        if os.path.exists(mkdocsignore):
-            ignore_list = []
-            with open(mkdocsignore, mode="r", encoding="utf-8") as txt_file:
-                ignore_list = txt_file.read().splitlines()
-                # Remove all comment lines
-                ignore_list = [x for x in ignore_list if not x.startswith('#')]
-            if not ignore_list:
-                ignore_list = ["*"]
-            self.ignore_glob.update(
-                set(os.path.join(base_path, filter) for filter in ignore_list))
-        # Check for ignore paths in patterns
-        if any(fnmatch.fnmatch(path, filter)
-                for filter in self.ignore_glob):
+        rel_path = path.relative_to(self.root_path)
+
+        # Check ignore_paths (absolute paths)
+        if any(path.resolve().is_relative_to(ignored)
+               for ignored in self.ignore_paths):
             return True
-        return False
+
+        # Check all ignore patterns
+        return any(fnmatch.fnmatch(str(rel_path), pattern)
+                   for pattern in self.ignore_glob)
 
     def is_doc_file(self, name: str) -> bool:
         """Check if file is a desired doc file."""