reposnap 0.6.2__tar.gz → 0.6.3__tar.gz

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

@@ -12,3 +12,6 @@ wheels/
 output.md
 pytest.ini
 .envrc
+
+# pytest
+.pytest_cache/

reposnap-0.6.3/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Run reposnap",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "reposnap.interfaces.cli",
+            "console": "integratedTerminal",
+            "args": ["src/reposnap/controllers", "src/reposnap/interfaces", "README.md", "tests/reposnap"]
+        }
+    ]
+}

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

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

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

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

{reposnap-0.6.2 → reposnap-0.6.3}/src/reposnap/controllers/project_controller.py

@@ -1,9 +1,6 @@
-# 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
@@ -11,35 +8,33 @@ from typing import List, Optional
 class ProjectController:
     def __init__(self, args: Optional[object] = None):
         self.logger = logging.getLogger(__name__)
+        # Always determine repository root using Git (or cwd)
+        self.root_dir = self._get_repo_root().resolve()
         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.
+            # Treat positional arguments as literal file/directory names.
+            input_paths = [Path(p) for p in (args.paths if hasattr(args, 'paths') else [args.path])]
             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.")
+                candidate = (self.root_dir / p).resolve()
+                if candidate.exists():
+                    try:
+                        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.")
+                else:
+                    self.logger.warning(f"Path {p} does not exist relative to repository root {self.root_dir}.")
             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.args = None
             self.input_paths = []
-            self.output_file = Path('output.md').resolve()
+            self.output_file = self.root_dir / 'output.md'
             self.structure_only = False
-            self.args = None
             self.include_patterns = []
             self.exclude_patterns = []
         self.file_tree: Optional[FileTree] = None
@@ -49,25 +44,9 @@ class ProjectController:
 
     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).
+        Determine the repository root using Git if available,
+        otherwise use the current directory.
         """
-        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)
@@ -104,25 +83,33 @@ class ProjectController:
         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.
+        self.logger.info("Collecting files from Git tracked files if available.")
+        try:
+            from reposnap.core.git_repo import GitRepo
+            git_repo = GitRepo(self.root_dir)
+            all_files = git_repo.get_git_files()
+            self.logger.debug(f"Git tracked files: {all_files}")
+        except Exception as e:
+            self.logger.warning(f"Error obtaining Git tracked files: {e}.")
+            all_files = []
+        # If Git returns an empty list but files exist on disk, fall back to filesystem scan.
+        if not all_files:
+            file_list = [p for p in self.root_dir.rglob("*") if p.is_file()]
+            if file_list:
+                self.logger.info("Git tracked files empty, using filesystem scan fallback.")
+                all_files = []
+                for path in file_list:
+                    try:
+                        rel = path.relative_to(self.root_dir)
+                        all_files.append(rel)
+                    except ValueError:
+                        continue
         all_files = self._apply_include_exclude(all_files)
-        self.logger.debug(f"All files after include/exclude filtering: {all_files}")
+        self.logger.debug(f"All files after applying include/exclude: {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
-                ]
+                subset = [f for f in all_files if f == input_path or list(f.parts[:len(input_path.parts)]) == list(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)
@@ -164,6 +151,7 @@ class ProjectController:
 
     def generate_output(self) -> None:
         self.logger.info("Starting Markdown generation.")
+        from reposnap.core.markdown_generator import MarkdownGenerator
         markdown_generator = MarkdownGenerator(
             root_dir=self.root_dir,
             output_file=self.output_file,
@@ -175,6 +163,7 @@ class ProjectController:
     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)
+        from reposnap.core.markdown_generator import MarkdownGenerator
         markdown_generator = MarkdownGenerator(
             root_dir=self.root_dir,
             output_file=self.output_file,
@@ -194,14 +183,15 @@ class ProjectController:
         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():
+                candidate = parent / '.gitignore'
+                if candidate.exists():
+                    gitignore_path = candidate
                     break
             else:
                 gitignore_path = None
         if gitignore_path and gitignore_path.exists():
             with gitignore_path.open('r') as gitignore:
-                patterns = gitignore.readlines()
+                patterns = [line.strip() for line in gitignore if line.strip() and not line.strip().startswith('#')]
             self.logger.debug(f"Loaded .gitignore patterns from {gitignore_path.parent}: {patterns}")
             return patterns
         else:

{reposnap-0.6.2 → reposnap-0.6.3}/src/reposnap/models/file_tree.py

@@ -48,7 +48,8 @@ class FileTree:
                 if filtered_value:
                     filtered_subtree[key] = filtered_value
             else:
-                if not spec.match_file(current_path):
+                # Exclude the file if either the full path OR its basename matches a .gitignore pattern.
+                if not spec.match_file(current_path) and not spec.match_file(Path(current_path).name):
                     filtered_subtree[key] = value
         return filtered_subtree
 

reposnap-0.6.3/tests/reposnap/test_collected_tree.py

@@ -0,0 +1,133 @@
+# tests/reposnap/test_collected_tree.py
+
+import os
+import tempfile
+from pathlib import Path
+import pytest
+from reposnap.controllers.project_controller import ProjectController
+from unittest.mock import patch
+
+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):
+            os.makedirs(path, exist_ok=True)
+            create_directory_structure(path, content)
+        else:
+            with open(path, 'w') as f:
+                f.write(content)
+
+def traverse_tree(tree: dict, path=''):
+    files = []
+    for name, node in tree.items():
+        current_path = os.path.join(path, name)
+        if isinstance(node, dict):
+            files.extend(traverse_tree(node, current_path))
+        else:
+            files.append(current_path)
+    return files
+
+def test_collect_tree_all_files():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            'src': {
+                'module': {
+                    'a.py': 'print("a")',
+                    'b.txt': 'text',
+                }
+            },
+            'tests': {
+                'test_a.py': 'print("test")'
+            },
+            'README.md': '# Readme'
+        }
+        create_directory_structure(temp_dir, structure)
+        args = type('Args', (object,), {
+            'path': temp_dir,
+            'output': os.path.join(temp_dir, 'output.md'),
+            'structure_only': True,
+            'debug': False,
+            'include': [],
+            'exclude': []
+        })
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
+        collected = traverse_tree(controller.file_tree.structure)
+        expected = [
+            'README.md',
+            os.path.join('src', 'module', 'a.py'),
+            os.path.join('src', 'module', 'b.txt'),
+            os.path.join('tests', 'test_a.py')
+        ]
+        assert sorted(collected) == sorted(expected)
+
+def test_collect_tree_literal_path():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            'src': {
+                'module': {
+                    'a.py': 'print("a")',
+                    'b.txt': 'text',
+                }
+            },
+            'tests': {
+                'test_a.py': 'print("test")'
+            },
+            'README.md': '# Readme'
+        }
+        create_directory_structure(temp_dir, structure)
+        # Request only the 'src' directory.
+        args = type('Args', (object,), {
+            'paths': ['src'],
+            'output': os.path.join(temp_dir, 'output.md'),
+            'structure_only': True,
+            'debug': False,
+            'include': [],
+            'exclude': []
+        })
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
+        collected = traverse_tree(controller.file_tree.structure)
+        expected = [
+            os.path.join('src', 'module', 'a.py'),
+            os.path.join('src', 'module', 'b.txt')
+        ]
+        assert sorted(collected) == sorted(expected)
+
+def test_collect_tree_multiple_paths():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            'src': {
+                'module': {
+                    'a.py': 'print("a")',
+                }
+            },
+            'tests': {
+                'test_a.py': 'print("test")'
+            },
+            'README.md': '# Readme'
+        }
+        create_directory_structure(temp_dir, structure)
+        # Request multiple literal paths.
+        args = type('Args', (object,), {
+            'paths': ['README.md', 'tests'],
+            'output': os.path.join(temp_dir, 'output.md'),
+            'structure_only': True,
+            'debug': False,
+            'include': [],
+            'exclude': []
+        })
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
+        collected = traverse_tree(controller.file_tree.structure)
+        expected = [
+            'README.md',
+            os.path.join('tests', 'test_a.py')
+        ]
+        assert sorted(collected) == sorted(expected)

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

@@ -49,9 +49,10 @@ def test_project_controller_includes_py_files():
             'structure_only': False,
             'debug': False
         })
-
-        controller = ProjectController(args)
-        controller.run()
+        # Force repository root to be our temporary directory.
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.run()
 
         with open(args.output, 'r') as f:
             output_content = f.read()
@@ -64,7 +65,6 @@ def test_project_controller_includes_py_files():
 
 
 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',
@@ -79,14 +79,17 @@ def test_project_controller_run():
             'include': [],
             'exclude': []
         })
-        with patch('reposnap.controllers.project_controller.MarkdownGenerator') as MockMarkdownGenerator:
-            mock_instance = MagicMock()
-            MockMarkdownGenerator.return_value = mock_instance
+        # Patch _get_repo_root to force temp_dir as repo root.
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            # Patch the MarkdownGenerator in its actual module.
+            with patch('reposnap.core.markdown_generator.MarkdownGenerator') as MockMarkdownGenerator:
+                mock_instance = MagicMock()
+                MockMarkdownGenerator.return_value = mock_instance
 
-            controller = ProjectController(args)
-            controller.run()
+                controller = ProjectController(args)
+                controller.run()
 
-            mock_instance.generate_markdown.assert_called_once()
+                mock_instance.generate_markdown.assert_called_once()
 
 
 def test_include_pattern():
@@ -115,8 +118,9 @@ def test_include_pattern():
             'include': ['*.py'],
             'exclude': []
         })
-        controller = ProjectController(args)
-        controller.collect_file_tree()
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
 
         # Traverse the merged tree and collect file paths.
         included_files = []
@@ -165,11 +169,10 @@ def test_exclude_pattern():
             'include': [],
             'exclude': ['*.md', '*.txt']
         })
-        controller = ProjectController(args)
-        controller.collect_file_tree()
-
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
         included_files = []
-
         def traverse(tree, path=''):
             for name, node in tree.items():
                 current_path = os.path.join(path, name)
@@ -177,9 +180,7 @@ def test_exclude_pattern():
                     traverse(node, current_path)
                 else:
                     included_files.append(current_path)
-
         traverse(controller.file_tree.structure)
-
         expected_files = [
             os.path.join('src', 'module', 'file1.py'),
             os.path.join('src', 'module', 'submodule', 'file3.py'),
@@ -187,7 +188,6 @@ def test_exclude_pattern():
         ]
         assert sorted(included_files) == sorted(expected_files)
 
-
 def test_include_and_exclude_patterns():
     with tempfile.TemporaryDirectory() as temp_dir:
         structure = {
@@ -217,11 +217,10 @@ def test_include_and_exclude_patterns():
             'include': ['*foo*'],
             'exclude': ['*submodule*']
         })
-        controller = ProjectController(args)
-        controller.collect_file_tree()
-
+        with patch('reposnap.controllers.project_controller.ProjectController._get_repo_root', return_value=Path(temp_dir)):
+            controller = ProjectController(args)
+            controller.collect_file_tree()
         collected = []
-
         def traverse(tree, path=''):
             for name, node in tree.items():
                 current_path = os.path.join(path, name)
@@ -230,7 +229,6 @@ def test_include_and_exclude_patterns():
                     traverse(node, current_path)
                 else:
                     collected.append(current_path)
-
         traverse(controller.file_tree.structure)
         expected = [
             os.path.join('src'),