reposnap 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

reposnap/__init__.py

@@ -1,4 +0,0 @@
-from reposnap.interfaces.cli import main
-
-if __name__ == "__main__":
-    main()

reposnap/controllers/project_controller.py

@@ -0,0 +1,96 @@
+# 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] = []
+        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}")
+
+        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 []

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,31 @@
 
 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
+    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False, hide_untoggled: bool = False):
+        self.root_dir: Path = root_dir.resolve()
+        self.output_file: Path = output_file.resolve()
+        self.structure_only: bool = structure_only
+        self.hide_untoggled: bool = hide_untoggled
         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.
         """
@@ -32,7 +35,7 @@ class MarkdownGenerator:
             with self.output_file.open('w', encoding='utf-8') as f:
                 f.write("# Project Structure\n\n")
                 f.write("```\n")
-                for line in format_tree(tree_structure):
+                for line in format_tree(tree_structure, hide_untoggled=self.hide_untoggled):
                     f.write(line)
                 f.write("```\n\n")
             self.logger.debug("Header and project structure written successfully.")
@@ -40,16 +43,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,13 +60,13 @@ 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")

reposnap/interfaces/cli.py

@@ -2,14 +2,12 @@
 
 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():
     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('path', nargs='?', default='.', 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.')
@@ -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/interfaces/gui.py

@@ -0,0 +1,155 @@
+# src/reposnap/interfaces/gui.py
+
+import urwid
+from pathlib import Path
+from reposnap.controllers.project_controller import ProjectController
+
+
+class MyCheckBox(urwid.CheckBox):
+    def __init__(self, label, user_data=None, **kwargs):
+        super().__init__(label, **kwargs)
+        self.user_data = user_data
+
+
+class RepoSnapGUI:
+    def __init__(self):
+        self.controller = ProjectController()
+        self.root_dir = Path('.').resolve()
+        self.file_tree = None
+        self.selected_files = set()
+
+        self.main_loop = None
+        self.build_main_menu()
+
+    def build_main_menu(self):
+        self.root_dir_edit = urwid.Edit(('bold', "Root Directory: "), str(self.root_dir))
+        scan_button = urwid.Button("Scan", on_press=self.on_scan)
+
+        main_menu = urwid.Frame(
+            header=urwid.Text(('bold', "RepoSnap - Main Menu")),
+            body=urwid.Padding(
+                urwid.LineBox(
+                    urwid.ListBox(
+                        urwid.SimpleFocusListWalker([
+                            self.root_dir_edit
+                        ])
+                    ),
+                    title="Enter Root Directory"
+                ),
+                left=2, right=2
+            ),
+            footer=urwid.Padding(scan_button, align='center')
+        )
+
+        self.main_widget = main_menu
+
+    def on_scan(self, button):
+        self.root_dir = Path(self.root_dir_edit.edit_text).resolve()
+        self.controller.set_root_dir(self.root_dir)
+        self.controller.collect_file_tree()
+        self.file_tree = self.controller.get_file_tree()
+        self.build_file_tree_menu()
+
+    def build_file_tree_menu(self):
+        tree_widgets = self.build_tree_widget(self.file_tree.structure)
+        tree_listbox = urwid.ListBox(urwid.SimpleFocusListWalker(tree_widgets))
+        render_button = urwid.Button("Render", on_press=self.on_render)
+
+        tree_menu = urwid.Frame(
+            header=urwid.Text(('bold', f"File Tree of {self.root_dir}")),
+            body=urwid.LineBox(tree_listbox),
+            footer=urwid.Padding(render_button, align='center')
+        )
+
+        self.main_widget = tree_menu
+        self.refresh()
+
+    def build_tree_widget(self, tree_structure, parent_path="", level=0):
+        widgets = []
+        for key, value in sorted(tree_structure.items()):
+            node_path = f"{parent_path}/{key}".lstrip('/')
+            checkbox = MyCheckBox(
+                key,
+                user_data={'path': node_path, 'level': level},
+                state=False,
+                on_state_change=self.on_checkbox_change
+            )
+            indented_checkbox = urwid.Padding(checkbox, left=4*level)
+            widgets.append(indented_checkbox)
+            if isinstance(value, dict):
+                widgets.extend(self.build_tree_widget(value, node_path, level=level+1))
+        return widgets
+
+    def on_checkbox_change(self, checkbox, state):
+        user_data = checkbox.user_data
+        node_path = user_data['path']
+        level = user_data['level']
+        if state:
+            self.selected_files.add(node_path)
+        else:
+            self.selected_files.discard(node_path)
+        # Handle toggling all children
+        self.toggle_children(checkbox, state, level)
+
+    def toggle_children(self, checkbox, state, level):
+        listbox = self.main_widget.body.original_widget.body
+        walker = listbox
+        # Find the index of the Padding widget that contains the checkbox
+        idx = None
+        for i, widget in enumerate(walker):
+            if isinstance(widget, urwid.Padding) and widget.original_widget == checkbox:
+                idx = i
+                break
+        if idx is None:
+            return
+        idx += 1
+        while idx < len(walker):
+            widget = walker[idx]
+            if isinstance(widget, urwid.Padding):
+                checkbox_widget = widget.original_widget
+                widget_user_data = checkbox_widget.user_data
+                widget_level = widget_user_data['level']
+                if widget_level > level:
+                    checkbox_widget.set_state(state, do_callback=False)
+                    node_path = widget_user_data['path']
+                    if state:
+                        self.selected_files.add(node_path)
+                    else:
+                        self.selected_files.discard(node_path)
+                    idx += 1
+                else:
+                    break
+            else:
+                idx += 1
+
+    def on_render(self, button):
+        self.controller.generate_output_from_selected(self.selected_files)
+        message = urwid.Text(('bold', f"Markdown generated at {self.controller.output_file}"))
+        exit_button = urwid.Button("Exit", on_press=self.exit_program)
+        result_menu = urwid.Frame(
+            header=urwid.Text(('bold', "Success")),
+            body=urwid.Filler(message, valign='middle'),
+            footer=urwid.Padding(exit_button, align='center')
+        )
+        self.main_widget = result_menu
+        self.refresh()
+
+    def refresh(self):
+        if self.main_loop:
+            self.main_loop.widget = self.main_widget
+
+    def exit_program(self, button):
+        raise urwid.ExitMainLoop()
+
+    def run(self):
+        self.main_loop = urwid.MainLoop(self.main_widget)
+        self.main_loop.run()
+
+
+def main():
+    app = RepoSnapGUI()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

reposnap/models/file_tree.py

@@ -0,0 +1,78 @@
+# 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
+
+    def prune_tree(self, selected_files: set) -> Dict[str, Any]:
+        """
+        Prunes the tree to include only the selected files and their directories.
+
+        Args:
+            selected_files (set): Set of selected file paths.
+
+        Returns:
+            Dict[str, Any]: Pruned tree structure.
+        """
+        return self._prune_tree(self.structure, selected_files)
+
+    def _prune_tree(self, subtree: Dict[str, Any], selected_files: set, path_prefix: str = '') -> Dict[str, Any]:
+        pruned_subtree: Dict[str, Any] = {}
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip('/')
+            if isinstance(value, dict):
+                pruned_value: Dict[str, Any] = self._prune_tree(value, selected_files, current_path)
+                if pruned_value:
+                    pruned_subtree[key] = pruned_value
+            else:
+                if current_path in selected_files:
+                    pruned_subtree[key] = value
+        return pruned_subtree

reposnap/utils/path_utils.py

@@ -1,9 +1,13 @@
 # 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 = '', hide_untoggled: bool = False) -> Generator[str, None, None]:
     for key, value in tree.items():
-        if isinstance(value, dict):
+        if value == '<hidden>':
+            yield f"{indent}<...>\n"
+        elif isinstance(value, dict):
             yield f"{indent}{key}/\n"
-            yield from format_tree(value, indent + '    ')
+            yield from format_tree(value, indent + '    ', hide_untoggled)
         else:
             yield f"{indent}{key}\n"

reposnap-0.4.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.3
+Name: reposnap
+Version: 0.4.0
+Summary: Generate a Markdown file with all contents of your project
+Author: agoloborodko
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: pathlib>=1.0.1
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: urwid>=2.6.15
+Description-Content-Type: text/markdown
+
+# RepoSnap
+
+## Overview
+
+`reposnap` is a Python tool designed to generate a Markdown file that documents the structure and contents of a Git project. It provides both a command-line interface (CLI) and a graphical user interface (GUI) for ease of use. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
+
+## Features
+
+- **Command-Line Interface (CLI)**: Quickly generate documentation from the terminal.
+- **Graphical User Interface (GUI)**: A user-friendly GUI if you want to select files and directories interactively.
+- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
+- **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
+- **Gitignore Support**: Automatically respects `.gitignore` patterns to exclude files and directories.
+
+## Installation
+
+You can install `reposnap` using pip:
+
+```bash
+pip install reposnap
+```
+
+Alternatively, you can clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/username/reposnap.git
+cd reposnap
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Command-Line Interface
+
+To use `reposnap` from the command line, run it with the following options:
+
+```bash
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
+```
+
+- `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.
+- `--debug`: Enable debug-level logging.
+
+#### Examples
+
+1. **Generate a full project structure with file contents**:
+
+    ```bash
+    reposnap .
+    ```
+
+2. **Generate a project structure only**:
+
+    ```bash
+    reposnap my_project/ --structure-only
+    ```
+
+3. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -o output.md
+    ```
+
+### Graphical User Interface
+
+`reposnap` also provides a GUI for users who prefer an interactive interface.
+
+To launch the GUI, simply run:
+
+```bash
+reposnap-gui
+```
+
+#### Using the GUI
+
+1. **Select Root Directory**: When the GUI opens, you can specify the root directory of your Git project. By default, it uses the current directory.
+
+2. **Scan the Project**: Click the "Scan" button to analyze the project. The GUI will display the file tree of your project.
+
+3. **Select Files and Directories**: Use the checkboxes to select which files and directories you want to include in the Markdown documentation. Toggling a directory checkbox will toggle all its child files and directories.
+
+4. **Generate Markdown**: After selecting the desired files, click the "Render" button. The Markdown file will be generated and saved as `output.md` in the current directory.
+
+5. **Exit**: Click the "Exit" button to close the GUI.
+
+## Testing
+
+To run the tests, use the following command:
+
+```bash
+pytest tests/
+```
+
+Ensure that you have the `pytest` library installed:
+
+```bash
+pip install pytest
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgments
+
+- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
+- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.
+- [Urwid](https://urwid.org/) - Used for creating the GUI interface.

reposnap-0.4.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+reposnap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/project_controller.py,sha256=JVxCc5MH_GOvEwTAaasuqxd1XSgKFbdQDjUEwmg4pUk,4211
+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=DkH7Gdo-fWevSyp9nqIyOG6qVOT6kk36xndR6X5vskM,3148
+reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/interfaces/cli.py,sha256=fpJBTmGw8A8dVLdYEtERV7L2P-8lzBlmwIvD3NhTD-Q,985
+reposnap/interfaces/gui.py,sha256=pzWQbW55gBNZu4tXRdBFic39upGtYxew91FSiEvalj0,5421
+reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/models/file_tree.py,sha256=SQ1cKW066uh1F1BcF8AXuw4Q-l6rkybxjdJEcLFjewg,3052
+reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/utils/path_utils.py,sha256=7072816LCP8Q8XBydn0iknmfrObPO_-2rFqpbAvPrjY,501
+reposnap-0.4.0.dist-info/METADATA,sha256=rOGqK2qsMgpPeYzwrxn0p5trlPFSs0kFqVqMhZBi4KM,3929
+reposnap-0.4.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+reposnap-0.4.0.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.4.0.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.4.0.dist-info/RECORD,,

reposnap-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+reposnap = reposnap.interfaces.cli:main
+reposnap-gui = reposnap.interfaces.gui:main

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

@@ -1,88 +0,0 @@
-Metadata-Version: 2.3
-Name: reposnap
-Version: 0.3.1
-Summary: Generate a Markdown file with all contents of your project
-Author: agoloborodko
-License-File: LICENSE
-Requires-Python: >=3.8
-Requires-Dist: gitpython>=3.1.43
-Requires-Dist: pathlib>=1.0.1
-Requires-Dist: pathspec>=0.12.1
-Description-Content-Type: text/markdown
-
-# RepoSnap
-
-## Overview
-
-`reposnap` is a Python script designed to generate a Markdown file that documents the structure and contents of a git project. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
-
-## Features
-
-- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
-- **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
-
-## Installation
-```bash
-pip install reposnap
-```
-
-Alternatively, you can clone the repository and install the required dependencies:
-
-```bash
-git clone https://github.com/username/reposnap.git
-cd reposnap
-pip install -r requirements.lock
-```
-
-## Usage
-
-### Command-Line Interface
-
-To use `reposnap`, run it with the following options:
-
-```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
-```
-
-- `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.
-- `--debug`: Enable debug-level logging.
-
-### Examples
-
-1. **Generate a full project structure with file contents**:
-
-    ```bash
-    reposnap .
-    ```
-
-2. **Generate a project structure only**:
-
-    ```bash
-    reposnap my_project/ --structure-only
-    ```
-
-3. **Generate a Markdown file excluding certain files and directories**:
-
-    ```bash
-    reposnap my_project/ -o output.md
-    ```
-
-## Testing
-
-To run the tests, use `rye`:
-
-```bash
-rye test
-```
-
-## License
-
-This project is licensed under the MIT License.
-
-## Acknowledgments
-
-- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
-- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.

reposnap-0.3.1.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.1.dist-info/METADATA,sha256=L_Cy9iGwDuqxR5ZU1LmJrvnjoMRr-vhX9WP_OtNw7p0,2333
-reposnap-0.3.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-reposnap-0.3.1.dist-info/entry_points.txt,sha256=aaCuB0RZOLW2--ymW8VCEOm0Qz9KvTZCUjwQFZsGaDU,43
-reposnap-0.3.1.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
-reposnap-0.3.1.dist-info/RECORD,,

reposnap-0.3.1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-reposnap = reposnap:main