reposnap 0.3.2__py3-none-any.whl → 0.5.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

@@ -11,14 +11,25 @@ from typing import List, Optional
 
 
 class ProjectController:
-    def __init__(self, args: object):
+    def __init__(self, args: Optional[object] = None):
         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.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._load_gitignore_patterns()
+        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()
@@ -31,6 +42,30 @@ class ProjectController:
         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)
@@ -52,7 +87,20 @@ class ProjectController:
             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.")
+        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'

reposnap/core/markdown_generator.py

@@ -7,10 +7,11 @@ from typing import List, Dict, Any
 
 
 class MarkdownGenerator:
-    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False):
+    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[str, Any], files: List[Path]) -> None:
@@ -34,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.")
@@ -72,4 +73,3 @@ class MarkdownGenerator:
                 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

@@ -7,12 +7,18 @@ 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.')
     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=[],
+                        help='File/folder patterns to exclude.')
+
     args = parser.parse_args()
 
     log_level = logging.DEBUG if args.debug else logging.INFO
@@ -21,5 +27,6 @@ def main():
     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

@@ -52,3 +52,27 @@ class FileTree:
                     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

@@ -2,10 +2,12 @@
 from typing import Dict, Generator, Any
 
 
-def format_tree(tree: Dict[str, Any], indent: str = '') -> Generator[str, None, None]:
+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.5.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: reposnap
+Version: 0.5.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.
+- **Include and Exclude Patterns**: Use `--include` and `--exclude` to specify patterns for files and directories to include or exclude.
+
+## 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] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] 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.
+- `-i, --include`: File/folder patterns to include. For example, `-i "*.py"` includes only Python files.
+- `-e, --exclude`: File/folder patterns to exclude. For example, `-e "*.md"` excludes all Markdown files.
+
+#### Pattern Matching
+
+- **Pattern Interpretation**: Patterns follow gitignore-style syntax but with a twist.
+  - **Patterns without Wildcards**: If a pattern does not contain any wildcard characters (`*`, `?`, or `[`), it is treated as `*pattern*`. This means it will match any file or directory containing `pattern` in its name.
+  - **Patterns with Wildcards**: If a pattern contains wildcard characters, it retains its original behavior.
+
+- **Examples**:
+  - `-e "gui"`: Excludes any files or directories containing `"gui"` in their names.
+  - `-i "*.py"`: Includes only files ending with `.py`.
+  - `-e "*.test.*"`: Excludes files with `.test.` in their names.
+
+#### 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 including only Python files**:
+
+    ```bash
+    reposnap my_project/ -i "*.py"
+    ```
+
+4. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -e "tests" -e "*.md"
+    ```
+
+5. **Exclude files and directories containing a substring**:
+
+    ```bash
+    reposnap my_project/ -e "gui"
+    ```
+
+### 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.5.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=hDYNLE_OtusAZOb6sKyvSFtbc7j-DUuYcmFST7U5Dao,5638
+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=tq9OfVE1NvUYrsdr2ewx6nBhG76k8E-yucwVgTo-LM8,1302
+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.5.0.dist-info/METADATA,sha256=46SWe62RAuwLHzX6-2vUt5QchhHp8XoRpwCjvBeQLTE,5240
+reposnap-0.5.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+reposnap-0.5.0.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.5.0.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.5.0.dist-info/RECORD,,

reposnap-0.5.0.dist-info/entry_points.txt

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

reposnap-0.3.2.dist-info/METADATA

@@ -1,88 +0,0 @@
-Metadata-Version: 2.3
-Name: reposnap
-Version: 0.3.2
-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.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-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-0.3.2.dist-info/entry_points.txt

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