reposnap 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

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/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/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/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/interfaces/cli.py

@@ -2,9 +2,7 @@
 
 import argparse
 import logging
-import os
-from reposnap.core.collector import ProjectContentCollector
-from pathlib import Path
+from reposnap.controllers.project_controller import ProjectController
 
 
 def main():
@@ -20,27 +18,8 @@ def main():
     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()
+    controller = ProjectController(args)
+    controller.run()
 
 if __name__ == "__main__":
     main()

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/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.0.dist-info → reposnap-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: reposnap
-Version: 0.3.0
+Version: 0.3.2
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE
@@ -44,7 +44,7 @@ To use `reposnap`, run it with the following options:
 reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
 ```
 
-- `path`: Path to the Git repository root folder
+- `path`: Path to the Git repository or subdirectory
 - `-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.

reposnap-0.3.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+reposnap/__init__.py,sha256=FGadYKcWDEh_AL8PbUuUrcCZDlF510JZfdGhHdT6XQk,80
+reposnap/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/project_controller.py,sha256=0BPnQ0tJf0lNNgP_TSYWhU8DUUzDyCPzdwtIM6zlQbA,3131
+reposnap/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/core/file_system.py,sha256=82gwvmgrsWf63paMrIz-Z0eqIjbqt9_-vujdXlJJoFE,1074
+reposnap/core/git_repo.py,sha256=2u_ILkV-Ur7qr1WHmHM2yg44Ggft61RsdbZLsZaQ5NU,1256
+reposnap/core/markdown_generator.py,sha256=HJSn8ekNiGwFbMwRNZVdA6Y-4InSV3WDVdA-z8s-m0A,3032
+reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/interfaces/cli.py,sha256=2ThdHJ0LJTWHaNuBF7PdO2xNdeRP16I-BXHumk_PfuI,961
+reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/models/file_tree.py,sha256=6r7_q-3u03_B9mMUF-2HDL6TMkFkFKhbO191hwUB_gk,2026
+reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/utils/path_utils.py,sha256=NbjZkSScYTISQY4Ww22sSWPf26_mig3bYTKmdSO2U2A,384
+reposnap-0.3.2.dist-info/METADATA,sha256=PFh5yBs306pbvXYoBSZNhmOPLmASoEEJUr97BypZddw,2333
+reposnap-0.3.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+reposnap-0.3.2.dist-info/entry_points.txt,sha256=aaCuB0RZOLW2--ymW8VCEOm0Qz9KvTZCUjwQFZsGaDU,43
+reposnap-0.3.2.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.3.2.dist-info/RECORD,,

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.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-reposnap/__init__.py,sha256=FGadYKcWDEh_AL8PbUuUrcCZDlF510JZfdGhHdT6XQk,80
-reposnap/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/core/collector.py,sha256=UQNAaIqgALZmOvtSb7NDYaXmVp4-X4jSWikMMh_B0YY,2401
-reposnap/core/file_system.py,sha256=yFIaHtJYqw5t8Lx9Nu7yb3G7XcCP1v1aKP_hGfS_KfQ,974
-reposnap/core/git_repo.py,sha256=A8mdgmT9JGHllkFMx5Z_1gGp3Yw1dr-NFOw2-lH_DfA,1163
-reposnap/core/markdown_generator.py,sha256=vJl_ac3vDs4CEanjwQazQM9fepGeFtGxo3ozajdkhqA,2889
-reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/interfaces/cli.py,sha256=bU7QAg2wDzQwyAsRyq4zHLnO8nNiJGrWD24n7yZFEZk,1795
-reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/utils/path_utils.py,sha256=lMuZMMIX2lEE1o6V3QqifmyO5dO5fuA5OUXMxSvYcHI,290
-reposnap-0.3.0.dist-info/METADATA,sha256=hcDKEinduZiYYDMrl5NsYkv0qz0H3EG-Ls_LfU01WGE,2329
-reposnap-0.3.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-reposnap-0.3.0.dist-info/entry_points.txt,sha256=aaCuB0RZOLW2--ymW8VCEOm0Qz9KvTZCUjwQFZsGaDU,43
-reposnap-0.3.0.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
-reposnap-0.3.0.dist-info/RECORD,,