reposnap 0.3.1__tar.gz → 0.3.2__tar.gz

{reposnap-0.3.1 → reposnap-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: reposnap
-Version: 0.3.1
+Version: 0.3.2
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE

{reposnap-0.3.1 → reposnap-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.3.1"
+version = "0.3.2"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }

reposnap-0.3.2/src/reposnap/controllers/project_controller.py

@@ -0,0 +1,74 @@
+# src/reposnap/controllers/project_controller.py
+
+import logging
+from pathlib import Path
+from reposnap.core.git_repo import GitRepo
+from reposnap.core.file_system import FileSystem
+from reposnap.core.markdown_generator import MarkdownGenerator
+from reposnap.models.file_tree import FileTree
+import pathspec
+from typing import List, Optional
+
+
+class ProjectController:
+    def __init__(self, args: object):
+        self.logger = logging.getLogger(__name__)
+        self.root_dir: Path = Path(args.path).resolve()
+        self.output_file: Path = Path(args.output).resolve()
+        self.structure_only: bool = args.structure_only
+        self.args: object = args
+        self.file_tree: Optional[FileTree] = None
+        self.gitignore_patterns: List[str] = self._load_gitignore_patterns()
+
+    def run(self) -> None:
+        self.collect_file_tree()
+        self.apply_filters()
+        self.generate_output()
+
+    def collect_file_tree(self) -> None:
+        self.logger.info("Collecting git files.")
+        git_repo: GitRepo = GitRepo(self.root_dir)
+        git_files: List[Path] = git_repo.get_git_files()
+        self.logger.debug(f"Git files before filtering: {git_files}")
+
+        self.logger.info("Building tree structure.")
+        file_system: FileSystem = FileSystem(self.root_dir)
+        tree_structure: dict = file_system.build_tree_structure(git_files)
+
+        self.file_tree = FileTree(tree_structure)
+        self.logger.debug(f"Tree structure: {self.file_tree.structure}")
+
+    def apply_filters(self) -> None:
+        self.logger.info("Applying filters to the file tree.")
+        spec: pathspec.PathSpec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns)
+        self.logger.debug(f"Filter patterns: {self.gitignore_patterns}")
+        self.file_tree.filter_files(spec)
+
+    def generate_output(self) -> None:
+        self.logger.info("Starting markdown generation.")
+        markdown_generator: MarkdownGenerator = MarkdownGenerator(
+            root_dir=self.root_dir,
+            output_file=self.output_file,
+            structure_only=self.structure_only
+        )
+        markdown_generator.generate_markdown(self.file_tree.structure, self.file_tree.get_all_files())
+        self.logger.info("Markdown generation completed.")
+
+    def _load_gitignore_patterns(self) -> List[str]:
+        gitignore_path: Path = self.root_dir / '.gitignore'
+        if not gitignore_path.exists():
+            for parent in self.root_dir.parents:
+                gitignore_path = parent / '.gitignore'
+                if gitignore_path.exists():
+                    break
+            else:
+                gitignore_path = None
+
+        if gitignore_path and gitignore_path.exists():
+            with gitignore_path.open('r') as gitignore:
+                patterns: List[str] = gitignore.readlines()
+            self.logger.debug(f"Patterns from .gitignore in {gitignore_path.parent}: {patterns}")
+            return patterns
+        else:
+            self.logger.debug(f"No .gitignore found starting from {self.root_dir}. Proceeding without patterns.")
+            return []

{reposnap-0.3.1 → reposnap-0.3.2}/src/reposnap/core/file_system.py

@@ -2,29 +2,31 @@
 
 import logging
 from pathlib import Path
+from typing import List, Dict, Any
+
 
 class FileSystem:
     def __init__(self, root_dir: Path):
-        self.root_dir = root_dir.resolve()
+        self.root_dir: Path = root_dir.resolve()
         self.logger = logging.getLogger(__name__)
 
-    def build_tree_structure(self, files):
+    def build_tree_structure(self, files: List[Path]) -> Dict[str, Any]:
         """
         Builds a hierarchical tree structure from the list of files.
 
         Args:
-            files (list of Path): List of file paths relative to root_dir.
+            files (List[Path]): List of file paths relative to root_dir.
 
         Returns:
-            dict: Nested dictionary representing the directory structure.
+            Dict[str, Any]: Nested dictionary representing the directory structure.
         """
-        tree = {}
+        tree: Dict[str, Any] = {}
         self.logger.debug("Building tree structure.")
         for relative_path in files:
             parts = relative_path.parts
             current_level = tree
             for part in parts[:-1]:
                 current_level = current_level.setdefault(part, {})
-            current_level[parts[-1]] = relative_path.as_posix()
+            current_level[parts[-1]] = None  # Indicate a file node
         self.logger.debug(f"Tree structure built: {tree}")
         return tree

{reposnap-0.3.1 → reposnap-0.3.2}/src/reposnap/core/git_repo.py

@@ -3,23 +3,25 @@
 import logging
 from pathlib import Path
 from git import Repo, InvalidGitRepositoryError
+from typing import List
+
 
 class GitRepo:
     def __init__(self, repo_path: Path):
-        self.repo_path = repo_path.resolve()
+        self.repo_path: Path = repo_path.resolve()
         self.logger = logging.getLogger(__name__)
 
-    def get_git_files(self):
+    def get_git_files(self) -> List[Path]:
         try:
-            repo = Repo(self.repo_path, search_parent_directories=True)
-            repo_root = Path(repo.working_tree_dir).resolve()
-            git_files = repo.git.ls_files().splitlines()
+            repo: Repo = Repo(self.repo_path, search_parent_directories=True)
+            repo_root: Path = Path(repo.working_tree_dir).resolve()
+            git_files: List[str] = repo.git.ls_files().splitlines()
             self.logger.debug(f"Git files from {repo_root}: {git_files}")
-            git_files_relative = []
+            git_files_relative: List[Path] = []
             for f in git_files:
-                absolute_path = (repo_root / f).resolve()
+                absolute_path: Path = (repo_root / f).resolve()
                 try:
-                    relative_path = absolute_path.relative_to(self.repo_path)
+                    relative_path: Path = absolute_path.relative_to(self.repo_path)
                     git_files_relative.append(relative_path)
                 except ValueError:
                     # Skip files not under root_dir
@@ -28,3 +30,4 @@ class GitRepo:
         except InvalidGitRepositoryError:
             self.logger.error(f"Invalid Git repository at: {self.repo_path}")
             return []
+

{reposnap-0.3.1 → reposnap-0.3.2}/src/reposnap/core/markdown_generator.py

@@ -2,28 +2,30 @@
 
 import logging
 from pathlib import Path
-from ..utils.path_utils import format_tree
+from reposnap.utils.path_utils import format_tree
+from typing import List, Dict, Any
+
 
 class MarkdownGenerator:
     def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False):
-        self.root_dir = root_dir.resolve()
-        self.output_file = output_file.resolve()
-        self.structure_only = structure_only
+        self.root_dir: Path = root_dir.resolve()
+        self.output_file: Path = output_file.resolve()
+        self.structure_only: bool = structure_only
         self.logger = logging.getLogger(__name__)
 
-    def generate_markdown(self, tree_structure: dict, files: list):
+    def generate_markdown(self, tree_structure: Dict[str, Any], files: List[Path]) -> None:
         """
         Generates the Markdown file based on the provided tree structure and files.
 
         Args:
-            tree_structure (dict): The hierarchical structure of the project files.
-            files (list of Path): List of file paths to include in the markdown.
+            tree_structure (Dict[str, Any]): The hierarchical structure of the project files.
+            files (List[Path]): List of file paths to include in the markdown.
         """
         self._write_header(tree_structure)
         if not self.structure_only:
             self._write_file_contents(files)
 
-    def _write_header(self, tree_structure: dict):
+    def _write_header(self, tree_structure: Dict[str, Any]) -> None:
         """
         Writes the header and project structure to the Markdown file.
         """
@@ -40,16 +42,16 @@ class MarkdownGenerator:
             self.logger.error(f"Failed to write header to {self.output_file}: {e}")
             raise
 
-    def _write_file_contents(self, files: list):
+    def _write_file_contents(self, files: List[Path]) -> None:
         """
         Writes the contents of each file to the Markdown file.
 
         Args:
-            files (list of Path): List of file paths relative to root_dir.
+            files (List[Path]): List of file paths relative to root_dir.
         """
         self.logger.debug("Writing file contents to Markdown.")
         for relative_path in files:
-            file_path = self.root_dir / relative_path
+            file_path: Path = self.root_dir / relative_path
 
             if not file_path.exists():
                 self.logger.debug(f"File not found: {file_path}. Skipping.")
@@ -57,16 +59,17 @@ class MarkdownGenerator:
 
             self._write_file_content(file_path, relative_path.as_posix())
 
-    def _write_file_content(self, file_path: Path, relative_path: str):
+    def _write_file_content(self, file_path: Path, relative_path: str) -> None:
         """
         Writes the content of a single file to the Markdown file with syntax highlighting.
         """
         try:
             with file_path.open('r', encoding='utf-8') as f:
-                content = f.read()
+                content: str = f.read()
             with self.output_file.open('a', encoding='utf-8') as f:
                 f.write(f"## {relative_path}\n\n")
                 f.write("```python\n" if file_path.suffix == '.py' else "```\n")
                 f.write(f"{content}\n```\n\n")
         except IOError as e:
             self.logger.error(f"Error reading or writing file {file_path}: {e}")
+

reposnap-0.3.2/src/reposnap/interfaces/cli.py

@@ -0,0 +1,25 @@
+# src/reposnap/interfaces/cli.py
+
+import argparse
+import logging
+from reposnap.controllers.project_controller import ProjectController
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate a Markdown representation of a Git repository.')
+    parser.add_argument('path', help='Path to the Git repository or subdirectory.')
+    parser.add_argument('-o', '--output', help='Output Markdown file', default='output.md')
+    parser.add_argument('--structure-only', action='store_true',
+                        help='Only include the file structure without content.')
+    parser.add_argument('--debug', action='store_true', help='Enable debug-level logging.')
+
+    args = parser.parse_args()
+
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logging.basicConfig(level=log_level, format='%(asctime)s - %(levelname)s - %(message)s')
+
+    controller = ProjectController(args)
+    controller.run()
+
+if __name__ == "__main__":
+    main()

reposnap-0.3.2/src/reposnap/models/file_tree.py

@@ -0,0 +1,54 @@
+# src/reposnap/models/file_tree.py
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Any
+import pathspec
+
+
+class FileTree:
+    def __init__(self, structure: Dict[str, Any]):
+        self.structure: Dict[str, Any] = structure
+        self.logger = logging.getLogger(__name__)
+
+    def get_all_files(self) -> List[Path]:
+        """
+        Recursively retrieve all file paths from the tree.
+        Returns:
+            List[Path]: List of file paths relative to root_dir.
+        """
+        return self._extract_files(self.structure)
+
+    def _extract_files(self, subtree: Dict[str, Any], path_prefix: str = '') -> List[Path]:
+        files: List[Path] = []
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip('/')
+            if isinstance(value, dict):
+                files.extend(self._extract_files(value, current_path))
+            else:
+                files.append(Path(current_path))
+        return files
+
+    def filter_files(self, spec: pathspec.PathSpec) -> None:
+        """
+        Filters files in the tree structure based on the provided pathspec.
+
+        Args:
+            spec (pathspec.PathSpec): The pathspec for filtering files.
+        """
+        self.logger.debug("Filtering files in the file tree.")
+        self.structure = self._filter_tree(self.structure, spec)
+
+    def _filter_tree(self, subtree: Dict[str, Any], spec: pathspec.PathSpec, path_prefix: str = '') -> Dict[str, Any]:
+        filtered_subtree: Dict[str, Any] = {}
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip('/')
+            if isinstance(value, dict):
+                filtered_value: Dict[str, Any] = self._filter_tree(value, spec, current_path)
+                if filtered_value:
+                    filtered_subtree[key] = filtered_value
+            else:
+                if not spec.match_file(current_path):
+                    filtered_subtree[key] = value
+        return filtered_subtree
+

{reposnap-0.3.1 → reposnap-0.3.2}/src/reposnap/utils/path_utils.py

@@ -1,6 +1,8 @@
 # src/reposnap/utils/path_utils.py
+from typing import Dict, Generator, Any
 
-def format_tree(tree, indent=''):
+
+def format_tree(tree: Dict[str, Any], indent: str = '') -> Generator[str, None, None]:
     for key, value in tree.items():
         if isinstance(value, dict):
             yield f"{indent}{key}/\n"

{reposnap-0.3.1 → reposnap-0.3.2}/tests/reposnap/test_cli.py

@@ -1,4 +1,4 @@
-# src/reposnap/tests/test_cli.py
+# tests/reposnap/test_cli.py
 
 import pytest
 from unittest.mock import patch, MagicMock
@@ -6,11 +6,13 @@ import os
 import tempfile
 from reposnap.interfaces.cli import main
 
+
 def create_file(file_path: str, content: str = ''):
     """Helper function to create a file with the given content."""
     with open(file_path, 'w') as f:
         f.write(content)
 
+
 def create_directory_structure(base_dir: str, structure: dict):
     """
     Helper function to create directories and files based on a given structure.
@@ -66,12 +68,13 @@ def temp_dir():
         create_directory_structure(temp_dir, structure)
         yield temp_dir
 
-@patch('reposnap.interfaces.cli.ProjectContentCollector')
-def test_cli(mock_collector, temp_dir):
-    mock_collector_instance = MagicMock()
-    mock_collector.return_value = mock_collector_instance
+
+@patch('reposnap.interfaces.cli.ProjectController')
+def test_cli(mock_controller, temp_dir):
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
 
     with patch('sys.argv', ['cli.py', str(temp_dir), '--structure-only']):
         main()
 
-    mock_collector_instance.collect_and_generate.assert_called_once()
+    mock_controller_instance.run.assert_called_once()

{reposnap-0.3.1 → reposnap-0.3.2}/tests/reposnap/test_file_system.py

@@ -47,5 +47,4 @@ def test_relative_path_resolution(file_system, tmp_path):
 
     # Check if .gitignore was correctly resolved relative to the root directory
     expected_path = '.gitignore'
-    assert tree_structure['.gitignore'] == expected_path, \
-        f"Expected {expected_path}, but got {tree_structure['.gitignore']}"
+    assert '.gitignore' in tree_structure, "'.gitignore' not found in tree_structure"

reposnap-0.3.2/tests/reposnap/test_file_tree.py

@@ -0,0 +1,28 @@
+# tests/reposnap/test_file_tree.py
+
+import pytest
+from reposnap.models.file_tree import FileTree
+from pathlib import Path
+import pathspec
+
+
+def test_file_tree_filter_files():
+    tree_structure = {
+        'dir1': {
+            'file1.py': 'dir1/file1.py',
+            'file2.log': 'dir1/file2.log'
+        },
+        'file3.py': 'file3.py',
+        'file4.log': 'file4.log'
+    }
+    file_tree = FileTree(tree_structure)
+    patterns = ['*.log']
+    spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, patterns)
+    file_tree.filter_files(spec)
+    expected_structure = {
+        'dir1': {
+            'file1.py': 'dir1/file1.py'
+        },
+        'file3.py': 'file3.py'
+    }
+    assert file_tree.structure == expected_structure

reposnap-0.3.2/tests/reposnap/test_project_controller.py

@@ -0,0 +1,97 @@
+# tests/reposnap/test_project_controller.py
+
+import pytest
+import tempfile
+import os
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from reposnap.controllers.project_controller import ProjectController
+
+
+def create_file(file_path: str, content: str = ''):
+    with open(file_path, 'w') as f:
+        f.write(content)
+
+
+def create_directory_structure(base_dir: str, structure: dict):
+    for name, content in structure.items():
+        path = os.path.join(base_dir, name)
+        if isinstance(content, dict):
+            os.makedirs(path, exist_ok=True)
+            create_directory_structure(path, content)
+        else:
+            create_file(path, content)
+
+
+def test_project_controller_includes_py_files():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        gitignore_content = """
+        *.py[oc]
+        """
+        structure = {
+            'src': {
+                'module': {
+                    'file1.py': 'print("File 1")',
+                    'file2.py': 'print("File 2")',
+                    'file3.pyc': 'Compiled code',
+                }
+            },
+            '.gitignore': gitignore_content,
+        }
+
+        create_directory_structure(temp_dir, structure)
+
+        args = type('Args', (object,), {
+            'path': temp_dir,
+            'output': os.path.join(temp_dir, 'output.md'),
+            'structure_only': False,
+            'debug': False
+        })
+
+        with patch('reposnap.controllers.project_controller.GitRepo') as MockGitRepo:
+            mock_git_repo_instance = MockGitRepo.return_value
+            mock_git_repo_instance.get_git_files.return_value = [
+                Path('src/module/file1.py'),
+                Path('src/module/file2.py'),
+                Path('.gitignore')
+            ]
+
+            controller = ProjectController(args)
+            controller.run()
+
+        # Read the output file
+        with open(args.output, 'r') as f:
+            output_content = f.read()
+
+        # Check that contents of .py files are included
+        assert 'print("File 1")' in output_content
+        assert 'print("File 2")' in output_content
+        # .pyc files should be ignored
+        assert 'Compiled code' not in output_content
+
+
+@patch('reposnap.controllers.project_controller.MarkdownGenerator')
+@patch('reposnap.controllers.project_controller.FileSystem')
+@patch('reposnap.controllers.project_controller.GitRepo')
+def test_project_controller_run(mock_git_repo, mock_file_system, mock_markdown_generator):
+    # Setup mocks
+    mock_git_repo_instance = MagicMock()
+    mock_file_system_instance = MagicMock()
+    mock_markdown_generator_instance = MagicMock()
+
+    mock_git_repo.return_value = mock_git_repo_instance
+    mock_file_system.return_value = mock_file_system_instance
+    mock_markdown_generator.return_value = mock_markdown_generator_instance
+
+    mock_git_repo_instance.get_git_files.return_value = ['file1.py', 'file2.py']
+    mock_file_system_instance.build_tree_structure.return_value = {'dir': {'file1.py': 'file1.py'}}
+
+    args = MagicMock()
+    args.path = 'root_dir'
+    args.output = 'output.md'
+    args.structure_only = False
+
+    controller = ProjectController(args)
+    controller.run()
+
+    mock_markdown_generator_instance.generate_markdown.assert_called_once()

reposnap-0.3.1/src/reposnap/core/collector.py

@@ -1,64 +0,0 @@
-# src/reposnap/core/collector.py
-
-import logging
-from pathlib import Path
-import pathspec
-from .git_repo import GitRepo
-from .file_system import FileSystem
-from .markdown_generator import MarkdownGenerator
-
-
-class ProjectContentCollector:
-    def __init__(self, root_dir: str, output_file: str, structure_only: bool, gitignore_patterns: list):
-        self.logger = logging.getLogger(__name__)
-        self.root_dir = Path(root_dir).resolve()
-        self.output_file = Path(output_file).resolve()
-        self.structure_only = structure_only
-        self.gitignore_patterns = gitignore_patterns
-        self.spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, gitignore_patterns)
-
-        # Initialize components
-        self.git_repo = GitRepo(self.root_dir)
-        self.file_system = FileSystem(self.root_dir)
-        self.markdown_generator = MarkdownGenerator(
-            root_dir=self.root_dir,
-            output_file=self.output_file,
-            structure_only=self.structure_only
-        )
-
-        # Collect files and build tree during initialization
-        self.files = self.collect_files()
-        self.tree_structure = self.build_tree_structure()
-
-    def collect_files(self):
-        """
-        Collects and filters files to be included in the documentation.
-        """
-        self.logger.info("Collecting git files.")
-        git_files = self.git_repo.get_git_files()
-        self.logger.debug(f"Git files before filtering: {git_files}")
-
-        # Filter files based on .gitignore patterns
-        filtered_files = [
-            f for f in git_files if not self.spec.match_file(str(f))
-        ]
-        self.logger.debug(f"Git files after filtering: {filtered_files}")
-
-        return filtered_files  # Paths relative to root_dir
-
-    def build_tree_structure(self):
-        """
-        Builds the tree structure from the collected files.
-        """
-        self.logger.info("Building tree structure.")
-        tree = self.file_system.build_tree_structure(self.files)
-        self.logger.debug(f"Tree structure: {tree}")
-        return tree
-
-    def collect_and_generate(self):
-        """
-        Initiates the markdown generation process.
-        """
-        self.logger.info("Starting markdown generation.")
-        self.markdown_generator.generate_markdown(self.tree_structure, self.files)
-        self.logger.info("Markdown generation completed.")

reposnap-0.3.1/src/reposnap/interfaces/cli.py

@@ -1,46 +0,0 @@
-# src/reposnap/interfaces/cli.py
-
-import argparse
-import logging
-import os
-from reposnap.core.collector import ProjectContentCollector
-from pathlib import Path
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Generate a Markdown representation of a Git repository.')
-    parser.add_argument('path', help='Path to the Git repository or subdirectory.')
-    parser.add_argument('-o', '--output', help='Output Markdown file', default='output.md')
-    parser.add_argument('--structure-only', action='store_true',
-                        help='Only include the file structure without content.')
-    parser.add_argument('--debug', action='store_true', help='Enable debug-level logging.')
-
-    args = parser.parse_args()
-
-    log_level = logging.DEBUG if args.debug else logging.INFO
-    logging.basicConfig(level=log_level, format='%(asctime)s - %(levelname)s - %(message)s')
-
-    path = Path(args.path).resolve()
-    gitignore_path = path / '.gitignore'
-    if not gitignore_path.exists():
-        # Search for .gitignore in parent directories
-        for parent in path.parents:
-            gitignore_path = parent / '.gitignore'
-            if gitignore_path.exists():
-                break
-        else:
-            gitignore_path = None
-
-    if gitignore_path and gitignore_path.exists():
-        with gitignore_path.open('r') as gitignore:
-            patterns = gitignore.readlines()
-        logging.debug(f"Patterns from .gitignore in {gitignore_path.parent}: {patterns}")
-    else:
-        patterns = []
-        logging.debug(f"No .gitignore found starting from {args.path}. Proceeding without patterns.")
-
-    collector = ProjectContentCollector(str(path), args.output, args.structure_only, patterns)
-    collector.collect_and_generate()
-
-if __name__ == "__main__":
-    main()

reposnap-0.3.1/tests/reposnap/test_collector.py

@@ -1,27 +0,0 @@
-# src/reposnap/tests/test_collector.py
-
-import pytest  # noqa
-from unittest.mock import patch, MagicMock
-from reposnap.core.collector import ProjectContentCollector
-
-
-@patch('reposnap.core.collector.MarkdownGenerator')
-@patch('reposnap.core.collector.FileSystem')
-@patch('reposnap.core.collector.GitRepo')
-def test_collect_and_generate(mock_git_repo, mock_file_system, mock_markdown_generator):
-    # Setup mocks
-    mock_git_repo_instance = MagicMock()
-    mock_file_system_instance = MagicMock()
-    mock_markdown_generator_instance = MagicMock()
-
-    mock_git_repo.return_value = mock_git_repo_instance
-    mock_file_system.return_value = mock_file_system_instance
-    mock_markdown_generator.return_value = mock_markdown_generator_instance
-
-    mock_git_repo_instance.get_git_files.return_value = ['file1.py', 'file2.py']
-    mock_file_system_instance.build_tree_structure.return_value = {'dir': {'file1.py': 'file1.py'}}
-
-    collector = ProjectContentCollector('root_dir', 'output.md', False, ['*.log'])
-    collector.collect_and_generate()
-
-    mock_markdown_generator_instance.generate_markdown.assert_called_once()