reposnap 0.5.0__tar.gz → 0.6.2__tar.gz

{reposnap-0.5.0 → reposnap-0.6.2}/.gitignore

@@ -11,3 +11,4 @@ wheels/
 .idea
 output.md
 pytest.ini
+.envrc

reposnap-0.6.2/.python-version

@@ -0,0 +1 @@
+3.12.6

{reposnap-0.5.0 → reposnap-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: reposnap
-Version: 0.5.0
+Version: 0.6.2
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE
@@ -39,7 +39,7 @@ Alternatively, you can clone the repository and install the required dependencie
 ```bash
 git clone https://github.com/username/reposnap.git
 cd reposnap
-pip install -r requirements.txt
+pip install -r requirements.lock
 ```
 
 ## Usage
@@ -49,10 +49,10 @@ pip install -r requirements.txt
 To use `reposnap` from the command line, run it with the following options:
 
 ```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] path
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] paths [paths ...]
 ```
 
-- `path`: Path to the Git repository or subdirectory.
+- `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
 - `-h, --help`: Show help message and exit.
 - `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
 - `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
@@ -94,7 +94,7 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 4. **Generate a Markdown file excluding certain files and directories**:
 
     ```bash
-    reposnap my_project/ -e "tests" -e "*.md"
+    reposnap my_project_folder my_project_folder_2 -e "tests" -e "*.md"
     ```
 
 5. **Exclude files and directories containing a substring**:

{reposnap-0.5.0 → reposnap-0.6.2}/README.md

@@ -26,7 +26,7 @@ Alternatively, you can clone the repository and install the required dependencie
 ```bash
 git clone https://github.com/username/reposnap.git
 cd reposnap
-pip install -r requirements.txt
+pip install -r requirements.lock
 ```
 
 ## Usage
@@ -36,10 +36,10 @@ pip install -r requirements.txt
 To use `reposnap` from the command line, run it with the following options:
 
 ```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] path
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] paths [paths ...]
 ```
 
-- `path`: Path to the Git repository or subdirectory.
+- `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
 - `-h, --help`: Show help message and exit.
 - `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
 - `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
@@ -81,7 +81,7 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 4. **Generate a Markdown file excluding certain files and directories**:
 
     ```bash
-    reposnap my_project/ -e "tests" -e "*.md"
+    reposnap my_project_folder my_project_folder_2 -e "tests" -e "*.md"
     ```
 
 5. **Exclude files and directories containing a substring**:

{reposnap-0.5.0 → reposnap-0.6.2}/pyproject.toml

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

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

@@ -0,0 +1,209 @@
+# src/reposnap/controllers/project_controller.py
+
+import logging
+from pathlib import Path
+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: Optional[object] = None):
+        self.logger = logging.getLogger(__name__)
+        if args:
+            # Support both new 'paths' (multiple paths) and legacy 'path'
+            if hasattr(args, 'paths'):
+                input_paths = [Path(p) for p in args.paths]
+            else:
+                input_paths = [Path(args.path)]
+            self.args = args
+            # Determine repository root (using provided paths’ common parent if available)
+            self.root_dir = self._get_repo_root().resolve()
+            # Convert provided paths to be relative to the repository root.
+            self.input_paths = []
+            for p in input_paths:
+                try:
+                    candidate = (self.root_dir / p).resolve()
+                    rel = candidate.relative_to(self.root_dir)
+                    if rel != Path('.'):
+                        self.input_paths.append(rel)
+                except ValueError:
+                    self.logger.warning(f"Path {p} is not under repository root {self.root_dir}. Ignoring.")
+            self.output_file: Path = Path(args.output).resolve() if args.output else self.root_dir / 'output.md'
+            self.structure_only: bool = args.structure_only if hasattr(args, 'structure_only') else False
+            self.include_patterns: List[str] = args.include if hasattr(args, 'include') else []
+            self.exclude_patterns: List[str] = args.exclude if hasattr(args, 'exclude') else []
+        else:
+            self.root_dir = Path('.').resolve()
+            self.input_paths = []
+            self.output_file = Path('output.md').resolve()
+            self.structure_only = False
+            self.args = None
+            self.include_patterns = []
+            self.exclude_patterns = []
+        self.file_tree: Optional[FileTree] = None
+        self.gitignore_patterns: List[str] = []
+        if self.root_dir:
+            self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def _get_repo_root(self) -> Path:
+        """
+        Determine the repository root. If arguments were provided and those paths exist,
+        use the common parent directory of all provided paths. Otherwise, fall back to the
+        git repository working tree directory (or current directory if not a git repo).
+        """
+        if self.args is not None:
+            candidate_paths = []
+            if hasattr(self.args, 'paths'):
+                for p in self.args.paths:
+                    candidate = Path(p).resolve()
+                    if candidate.exists():
+                        candidate_paths.append(candidate)
+            elif hasattr(self.args, 'path'):
+                candidate = Path(self.args.path).resolve()
+                if candidate.exists():
+                    candidate_paths.append(candidate)
+            if candidate_paths:
+                from os.path import commonpath
+                common = Path(commonpath([str(p) for p in candidate_paths]))
+                return common
+        from git import Repo, InvalidGitRepositoryError
+        try:
+            repo = Repo(Path.cwd(), search_parent_directories=True)
+            return Path(repo.working_tree_dir).resolve()
+        except InvalidGitRepositoryError:
+            self.logger.warning("Not a git repository. Using current directory as root.")
+            return Path.cwd().resolve()
+
+    def set_root_dir(self, root_dir: Path) -> None:
+        self.root_dir = root_dir.resolve()
+        self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def get_file_tree(self) -> Optional[FileTree]:
+        return self.file_tree
+
+    def _apply_include_exclude(self, files: List[Path]) -> List[Path]:
+        """Filter a list of file paths using include and exclude patterns."""
+        def adjust_patterns(patterns):
+            adjusted = []
+            for p in patterns:
+                if any(ch in p for ch in ['*', '?', '[']):
+                    adjusted.append(p)
+                else:
+                    adjusted.append(f'*{p}*')
+            return adjusted
+        if self.include_patterns:
+            inc = adjust_patterns(self.include_patterns)
+            spec_inc = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, inc)
+            files = [f for f in files if spec_inc.match_file(f.as_posix())]
+        if self.exclude_patterns:
+            exc = adjust_patterns(self.exclude_patterns)
+            spec_exc = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, exc)
+            files = [f for f in files if not spec_exc.match_file(f.as_posix())]
+        return files
+
+    def collect_file_tree(self) -> None:
+        self.logger.info("Collecting files by walking the repository root.")
+        all_files = []
+        for path in self.root_dir.rglob("*"):
+            if path.is_file():
+                try:
+                    rel = path.relative_to(self.root_dir)
+                    all_files.append(rel)
+                except ValueError:
+                    continue
+        # Apply include/exclude filtering.
+        all_files = self._apply_include_exclude(all_files)
+        self.logger.debug(f"All files after include/exclude filtering: {all_files}")
+        if self.input_paths:
+            trees = []
+            for input_path in self.input_paths:
+                subset = [
+                    f for f in all_files
+                    if f == input_path or f.parts[:len(input_path.parts)] == input_path.parts
+                ]
+                self.logger.debug(f"Files for input path '{input_path}': {subset}")
+                if subset:
+                    tree = FileSystem(self.root_dir).build_tree_structure(subset)
+                    trees.append(tree)
+            if trees:
+                merged_tree = self.merge_trees(trees)
+            else:
+                merged_tree = {}
+        else:
+            merged_tree = FileSystem(self.root_dir).build_tree_structure(all_files)
+        self.logger.info("Merged tree built from input paths.")
+        self.file_tree = FileTree(merged_tree)
+        self.logger.debug(f"Merged tree structure: {self.file_tree.structure}")
+
+    def merge_trees(self, trees: List[dict]) -> dict:
+        """Recursively merge a list of tree dictionaries."""
+        merged = {}
+        for tree in trees:
+            merged = self._merge_two_trees(merged, tree)
+        return merged
+
+    def _merge_two_trees(self, tree1: dict, tree2: dict) -> dict:
+        merged = dict(tree1)
+        for key, value in tree2.items():
+            if key in merged:
+                if isinstance(merged[key], dict) and isinstance(value, dict):
+                    merged[key] = self._merge_two_trees(merged[key], value)
+                else:
+                    merged[key] = value
+            else:
+                merged[key] = value
+        return merged
+
+    def apply_filters(self) -> None:
+        self.logger.info("Applying .gitignore filters to the merged tree.")
+        spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns)
+        self.logger.debug(f".gitignore patterns: {self.gitignore_patterns}")
+        self.file_tree.filter_files(spec)
+
+    def generate_output(self) -> None:
+        self.logger.info("Starting Markdown generation.")
+        markdown_generator = 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(f"Markdown generated at {self.output_file}.")
+
+    def generate_output_from_selected(self, selected_files: set) -> None:
+        self.logger.info("Generating Markdown from selected files.")
+        pruned_tree = self.file_tree.prune_tree(selected_files)
+        markdown_generator = MarkdownGenerator(
+            root_dir=self.root_dir,
+            output_file=self.output_file,
+            structure_only=False,
+            hide_untoggled=True
+        )
+        markdown_generator.generate_markdown(pruned_tree, [Path(f) for f in selected_files])
+        self.logger.info(f"Markdown generated at {self.output_file}.")
+
+    def run(self) -> None:
+        """Run the entire process: collect files, apply filters, and generate Markdown."""
+        self.collect_file_tree()
+        self.apply_filters()
+        self.generate_output()
+
+    def _load_gitignore_patterns(self) -> List[str]:
+        gitignore_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 = gitignore.readlines()
+            self.logger.debug(f"Loaded .gitignore patterns from {gitignore_path.parent}: {patterns}")
+            return patterns
+        else:
+            self.logger.debug(f"No .gitignore found starting from {self.root_dir}.")
+            return []

{reposnap-0.5.0 → reposnap-0.6.2}/src/reposnap/core/markdown_generator.py

@@ -58,7 +58,11 @@ class MarkdownGenerator:
                 self.logger.debug(f"File not found: {file_path}. Skipping.")
                 continue
 
-            self._write_file_content(file_path, relative_path.as_posix())
+            try:
+                self._write_file_content(file_path, relative_path.as_posix())
+            except UnicodeDecodeError as e:
+                self.logger.error(f"UnicodeDecodeError for file {file_path}: {e}")
+
 
     def _write_file_content(self, file_path: Path, relative_path: str) -> None:
         """

{reposnap-0.5.0 → reposnap-0.6.2}/src/reposnap/interfaces/cli.py

@@ -6,14 +6,19 @@ 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', nargs='?', default='.', help='Path to the Git repository or subdirectory.')
+    parser = argparse.ArgumentParser(
+        description='Generate a Markdown representation of a Git repository.'
+    )
+    # Changed positional argument to allow one or more paths.
+    parser.add_argument(
+        'paths',
+        nargs='+',
+        help='One or more paths (files or directories) to include in the Markdown output.'
+    )
     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.')
-
-    # New arguments for include and exclude patterns
     parser.add_argument('-i', '--include', nargs='*', default=[],
                         help='File/folder patterns to include.')
     parser.add_argument('-e', '--exclude', nargs='*', default=[],

{reposnap-0.5.0 → reposnap-0.6.2}/tests/reposnap/test_project_controller.py

@@ -14,6 +14,9 @@ def create_file(file_path: str, content: str = ''):
 
 
 def create_directory_structure(base_dir: str, structure: dict):
+    """
+    Recursively creates directories and files based on the provided structure.
+    """
     for name, content in structure.items():
         path = os.path.join(base_dir, name)
         if isinstance(content, dict):
@@ -26,8 +29,8 @@ def create_directory_structure(base_dir: str, structure: dict):
 def test_project_controller_includes_py_files():
     with tempfile.TemporaryDirectory() as temp_dir:
         gitignore_content = """
-        *.py[oc]
-        """
+*.py[oc]
+"""
         structure = {
             'src': {
                 'module': {
@@ -38,7 +41,6 @@ def test_project_controller_includes_py_files():
             },
             '.gitignore': gitignore_content,
         }
-
         create_directory_structure(temp_dir, structure)
 
         args = type('Args', (object,), {
@@ -48,57 +50,43 @@ def test_project_controller_includes_py_files():
             '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()
 
-            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
+        # Check that the contents of the Python files are included
         assert 'print("File 1")' in output_content
         assert 'print("File 2")' in output_content
-        # .pyc files should be ignored
+        # The .pyc file should be filtered out by .gitignore
         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
-
-    # Use Path objects instead of strings
-    mock_git_repo_instance.get_git_files.return_value = [Path('file1.py'), Path('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
-    args.include = []
-    args.exclude = []
-    args.debug = False  # Add if necessary
+def test_project_controller_run():
+    # This test patches only MarkdownGenerator to verify that generate_markdown is called.
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            'file1.txt': 'content',
+            'file2.py': 'print("hello")',
+        }
+        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,
+            'include': [],
+            'exclude': []
+        })
+        with patch('reposnap.controllers.project_controller.MarkdownGenerator') as MockMarkdownGenerator:
+            mock_instance = MagicMock()
+            MockMarkdownGenerator.return_value = mock_instance
 
-    controller = ProjectController(args)
-    controller.run()
+            controller = ProjectController(args)
+            controller.run()
 
-    mock_markdown_generator_instance.generate_markdown.assert_called_once()
+            mock_instance.generate_markdown.assert_called_once()
 
 
 def test_include_pattern():
@@ -118,9 +106,7 @@ def test_include_pattern():
             'setup.py': 'setup code',
             'notes.txt': 'Some notes',
         }
-
         create_directory_structure(temp_dir, structure)
-
         args = type('Args', (object,), {
             'path': temp_dir,
             'output': os.path.join(temp_dir, 'output.md'),
@@ -129,25 +115,10 @@ def test_include_pattern():
             'include': ['*.py'],
             'exclude': []
         })
+        controller = ProjectController(args)
+        controller.collect_file_tree()
 
-        # Mock the GitRepo class
-        with patch('reposnap.controllers.project_controller.GitRepo') as MockGitRepo:
-            mock_git_repo_instance = MockGitRepo.return_value
-
-            # Collect all files under temp_dir
-            all_files = []
-            for root, dirs, files in os.walk(temp_dir):
-                for name in files:
-                    file_path = Path(root) / name
-                    rel_path = file_path.relative_to(temp_dir)
-                    all_files.append(rel_path)
-
-            mock_git_repo_instance.get_git_files.return_value = all_files
-
-            controller = ProjectController(args)
-            controller.collect_file_tree()
-
-        # Get the list of files included in the tree
+        # Traverse the merged tree and collect file paths.
         included_files = []
 
         def traverse(tree, path=''):
@@ -165,7 +136,6 @@ def test_include_pattern():
             os.path.join('src', 'module', 'submodule', 'file3.py'),
             'setup.py',
         ]
-
         assert sorted(included_files) == sorted(expected_files)
 
 
@@ -186,9 +156,7 @@ def test_exclude_pattern():
             'setup.py': 'setup code',
             'notes.txt': 'Some notes',
         }
-
         create_directory_structure(temp_dir, structure)
-
         args = type('Args', (object,), {
             'path': temp_dir,
             'output': os.path.join(temp_dir, 'output.md'),
@@ -197,22 +165,8 @@ def test_exclude_pattern():
             'include': [],
             'exclude': ['*.md', '*.txt']
         })
-
-        with patch('reposnap.controllers.project_controller.GitRepo') as MockGitRepo:
-            mock_git_repo_instance = MockGitRepo.return_value
-
-            # Collect all files under temp_dir
-            all_files = []
-            for root, dirs, files in os.walk(temp_dir):
-                for name in files:
-                    file_path = Path(root) / name
-                    rel_path = file_path.relative_to(temp_dir)
-                    all_files.append(rel_path)
-
-            mock_git_repo_instance.get_git_files.return_value = all_files
-
-            controller = ProjectController(args)
-            controller.collect_file_tree()
+        controller = ProjectController(args)
+        controller.collect_file_tree()
 
         included_files = []
 
@@ -231,7 +185,6 @@ def test_exclude_pattern():
             os.path.join('src', 'module', 'submodule', 'file3.py'),
             'setup.py',
         ]
-
         assert sorted(included_files) == sorted(expected_files)
 
 
@@ -255,9 +208,7 @@ def test_include_and_exclude_patterns():
             'setup.py': 'setup code',
             'notes.txt': 'Some notes',
         }
-
         create_directory_structure(temp_dir, structure)
-
         args = type('Args', (object,), {
             'path': temp_dir,
             'output': os.path.join(temp_dir, 'output.md'),
@@ -266,41 +217,95 @@ def test_include_and_exclude_patterns():
             'include': ['*foo*'],
             'exclude': ['*submodule*']
         })
+        controller = ProjectController(args)
+        controller.collect_file_tree()
 
-        with patch('reposnap.controllers.project_controller.GitRepo') as MockGitRepo:
-            mock_git_repo_instance = MockGitRepo.return_value
-
-            # Collect all files under temp_dir
-            all_files = []
-            for root, dirs, files in os.walk(temp_dir):
-                for name in files:
-                    file_path = Path(root) / name
-                    rel_path = file_path.relative_to(temp_dir)
-                    all_files.append(rel_path)
-
-            mock_git_repo_instance.get_git_files.return_value = all_files
-
-            controller = ProjectController(args)
-            controller.collect_file_tree()
-
-        included_files = []
+        collected = []
 
         def traverse(tree, path=''):
             for name, node in tree.items():
                 current_path = os.path.join(path, name)
                 if isinstance(node, dict):
-                    included_files.append(current_path)
+                    collected.append(current_path)
                     traverse(node, current_path)
                 else:
-                    included_files.append(current_path)
+                    collected.append(current_path)
 
         traverse(controller.file_tree.structure)
-
-        expected_files = [
+        expected = [
             os.path.join('src'),
             os.path.join('src', 'foo_module'),
             os.path.join('src', 'foo_module', 'foo_file1.py'),
-            os.path.join('src', 'foo_module', 'file2.py'),  # Include this file
+            os.path.join('src', 'foo_module', 'file2.py'),
         ]
+        assert sorted(collected) == sorted(expected)
 
-        assert sorted(included_files) == sorted(expected_files)
+
+def test_project_controller_multiple_paths():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Define a structure similar to the provided example.
+        structure = {
+            'README.md': 'Project README content',
+            'pyproject.toml': 'project configuration',
+            'LICENSE': 'MIT License',
+            'src': {
+                'reposnap': {
+                    '__init__.py': '',
+                    'controllers': {
+                        '__init__.py': '',
+                        'project_controller.py': 'print("controller")',
+                    },
+                    'core': {
+                        '__init__.py': '',
+                        'file_system.py': 'print("filesystem")',
+                        'git_repo.py': 'print("git")',
+                        'markdown_generator.py': 'print("markdown")',
+                    },
+                    'interfaces': {
+                        '__init__.py': '',
+                        'cli.py': 'print("cli")',
+                        'gui.py': 'print("gui")',
+                    },
+                    'models': {
+                        '__init__.py': '',
+                        'file_tree.py': 'print("file tree")',
+                    },
+                    'utils': {
+                        '__init__.py': '',
+                        'path_utils.py': 'print("path utils")',
+                    },
+                },
+            },
+            'tests': {
+                '__init__.py': '',
+                'some_test.py': 'print("test")'
+            },
+            'extras': {
+                'notes.txt': 'Some notes'
+            }
+        }
+        create_directory_structure(temp_dir, structure)
+
+        # Create args with multiple paths.
+        args = type('Args', (object,), {
+            'paths': ['README.md', 'src', 'pyproject.toml'],
+            'output': os.path.join(temp_dir, 'output.md'),
+            'structure_only': True,
+            'debug': False,
+            'include': [],
+            'exclude': []
+        })
+        # Patch _get_repo_root to return our temp_dir.
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
+
+        tree = controller.file_tree.structure
+        # The merged tree should only include keys for the provided paths.
+        assert 'README.md' in tree
+        assert 'pyproject.toml' in tree
+        assert 'src' in tree
+        # Keys that are not part of the requested paths (like LICENSE, tests, extras) should be absent.
+        assert 'LICENSE' not in tree
+        assert 'tests' not in tree
+        assert 'extras' not in tree

reposnap-0.5.0/.python-version

@@ -1 +0,0 @@
-3.12.4

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

@@ -1,122 +0,0 @@
-# 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: Optional[object] = None):
-        self.logger = logging.getLogger(__name__)
-        self.root_dir: Path = Path(args.path).resolve() if args else Path('.').resolve()
-        self.output_file: Path = Path(args.output).resolve() if args else Path('output.md').resolve()
-        self.structure_only: bool = args.structure_only if args else False
-        self.args: object = args
-        self.file_tree: Optional[FileTree] = None
-        self.gitignore_patterns: List[str] = []
-        self.include_patterns: List[str] = args.include if args and hasattr(args, 'include') else []
-        self.exclude_patterns: List[str] = args.exclude if args and hasattr(args, 'exclude') else []
-        if self.root_dir:
-            self.gitignore_patterns = self._load_gitignore_patterns()
-
-    def set_root_dir(self, root_dir: Path) -> None:
-        self.root_dir = root_dir
-        self.gitignore_patterns = self._load_gitignore_patterns()
-
-    def get_file_tree(self) -> Optional[FileTree]:
-        return self.file_tree
-
-    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}")
-
-        # Adjust patterns
-        def adjust_patterns(patterns):
-            adjusted = []
-            for pattern in patterns:
-                if '*' in pattern or '?' in pattern or '[' in pattern:
-                    adjusted.append(pattern)
-                else:
-                    adjusted.append(f'*{pattern}*')
-            return adjusted
-
-        # Apply include patterns
-        if self.include_patterns:
-            adjusted_include_patterns = adjust_patterns(self.include_patterns)
-            include_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_include_patterns)
-            git_files = [f for f in git_files if include_spec.match_file(f.as_posix())]
-            self.logger.debug(f"Git files after include patterns: {git_files}")
-
-        # Apply exclude patterns
-        if self.exclude_patterns:
-            adjusted_exclude_patterns = adjust_patterns(self.exclude_patterns)
-            exclude_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_exclude_patterns)
-            git_files = [f for f in git_files if not exclude_spec.match_file(f.as_posix())]
-            self.logger.debug(f"Git files after exclude patterns: {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(f"Markdown generated at {self.output_file}.")
-
-    def generate_output_from_selected(self, selected_files: set) -> None:
-        self.logger.info("Generating markdown from selected files.")
-        # Build a pruned tree structure based on selected files
-        pruned_tree = self.file_tree.prune_tree(selected_files)
-        markdown_generator: MarkdownGenerator = MarkdownGenerator(
-            root_dir=self.root_dir,
-            output_file=self.output_file,
-            structure_only=False,
-            hide_untoggled=True
-        )
-        markdown_generator.generate_markdown(pruned_tree, [Path(f) for f in selected_files])
-        self.logger.info(f"Markdown generated at {self.output_file}.")
-
-    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 []