reposnap 0.2.0__tar.gz → 0.2.1__tar.gz

{reposnap-0.2.0 → reposnap-0.2.1}/.gitignore

@@ -10,3 +10,4 @@ wheels/
 .venv
 .idea
 output.md
+pytest.ini

{reposnap-0.2.0 → reposnap-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: reposnap
-Version: 0.2.0
+Version: 0.2.1
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE
@@ -30,14 +30,14 @@ Description-Content-Type: text/markdown
 To use the `collect.py` script, run it with the following options:
 
 ```bash
-python -m collect <project_root> [-o OUTPUT] [-e EXCLUDE ...] [-x EXCLUDE_FILE] [--structure-only]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
 ```
 
-- `<project_root>`: The root directory of the project to document.
-- `-o, --output`: The name of the output Markdown file. Defaults to `repo-content-<timestamp>.md`.
-- `-e, --exclude`: Patterns of files or directories to exclude (supports multiple patterns).
-- `-x, --exclude-file`: A file (e.g., `.gitignore`) containing patterns of files or directories to exclude.
+- `path`: Path to the Git repository root folder
+- `-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
 

{reposnap-0.2.0 → reposnap-0.2.1}/README.md

@@ -18,14 +18,14 @@
 To use the `collect.py` script, run it with the following options:
 
 ```bash
-python -m collect <project_root> [-o OUTPUT] [-e EXCLUDE ...] [-x EXCLUDE_FILE] [--structure-only]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
 ```
 
-- `<project_root>`: The root directory of the project to document.
-- `-o, --output`: The name of the output Markdown file. Defaults to `repo-content-<timestamp>.md`.
-- `-e, --exclude`: Patterns of files or directories to exclude (supports multiple patterns).
-- `-x, --exclude-file`: A file (e.g., `.gitignore`) containing patterns of files or directories to exclude.
+- `path`: Path to the Git repository root folder
+- `-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
 

{reposnap-0.2.0 → reposnap-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.2.0"
+version = "0.2.1"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }
@@ -28,3 +28,6 @@ allow-direct-references = true
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/reposnap"]
+
+[project.scripts]
+reposnap = "collect:main"

reposnap-0.2.1/src/reposnap/core/collector.py

@@ -0,0 +1,30 @@
+# src/reposnap/core/collector.py
+
+from .file_system import FileSystem
+from .git_repo import GitRepo
+from .markdown_generator import MarkdownGenerator
+import pathspec
+import logging
+from pathlib import Path
+
+
+class ProjectContentCollector:
+    def __init__(self, root_dir: str, output_file: str, structure_only: bool, gitignore_patterns: list):
+        self.root_dir = Path(root_dir).resolve()
+        self.output_file = Path(output_file).resolve()
+        self.structure_only = structure_only
+        self.spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, gitignore_patterns)
+        self.file_system = FileSystem(self.root_dir)
+        self.git_repo = GitRepo(self.root_dir)
+        self.markdown_generator = MarkdownGenerator(
+            root_dir=self.root_dir,
+            output_file=self.output_file,
+            structure_only=self.structure_only
+        )
+        self.logger = logging.getLogger(__name__)
+
+    def collect_and_generate(self):
+        self.logger.info("Starting project content collection.")
+        git_files = self.git_repo.get_git_files()
+        tree_structure = self.file_system.build_tree_structure(git_files)
+        self.markdown_generator.generate_markdown(tree_structure, git_files, self.spec)

{reposnap-0.2.0 → reposnap-0.2.1}/src/reposnap/core/file_system.py

@@ -1,5 +1,6 @@
 # src/reposnap/core/file_system.py
 
+import logging
 from pathlib import Path
 
 class FileSystem:
@@ -8,12 +9,15 @@ class FileSystem:
 
     def build_tree_structure(self, files):
         tree = {}
+        logging.debug("\n>>> Processing Files for Tree Structure <<<")
         for file in files:
-            file_path = Path(file).resolve()
+            file_path = (self.root_dir / file).resolve()
+            logging.debug(f"Processing file:\n  File Path: {file_path}\n  Root Dir:  {self.root_dir}")
             relative_path = file_path.relative_to(self.root_dir).as_posix()
             parts = relative_path.split('/')
             current_level = tree
             for part in parts[:-1]:
                 current_level = current_level.setdefault(part, {})
             current_level[parts[-1]] = relative_path
+        logging.debug(">>> End of Processing <<<\n")
         return tree

reposnap-0.2.1/src/reposnap/core/git_repo.py

@@ -0,0 +1,21 @@
+# src/reposnap/core/git_repo.py
+
+import logging
+from git import Repo, InvalidGitRepositoryError
+
+class GitRepo:
+    def __init__(self, repo_path: str):
+        self.repo_path = repo_path
+
+    def get_git_files(self):
+        try:
+            repo = Repo(self.repo_path)
+            files = repo.git.ls_files().splitlines()
+            logging.debug(f"\n--- Retrieved Git Files from {repo.working_tree_dir} ---")
+            for file in files:
+                logging.debug(f"  - {file}")
+            logging.debug("--- End of Git Files ---\n")
+            return files
+        except InvalidGitRepositoryError:
+            logging.debug(f"Invalid Git repository at: {self.repo_path}")
+            return []

reposnap-0.2.1/src/reposnap/core/markdown_generator.py

@@ -0,0 +1,122 @@
+# src/reposnap/core/markdown_generator.py
+
+from pathlib import Path
+from ..utils.path_utils import format_tree
+import logging
+
+
+class MarkdownGenerator:
+    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False):
+        """
+        Initializes the MarkdownGenerator.
+
+        Args:
+            root_dir (Path): The root directory of the project.
+            output_file (Path): The path to the output Markdown file.
+            structure_only (bool): If True, only the directory structure is included without file contents.
+        """
+        self.root_dir = root_dir.resolve()
+        self.output_file = output_file.resolve()
+        self.structure_only = structure_only
+        self.logger = logging.getLogger(__name__)
+        self.logger.debug(f"Initialized MarkdownGenerator with root_dir={self.root_dir}, "
+                          f"output_file={self.output_file}, structure_only={self.structure_only}")
+
+    def generate_markdown(self, tree_structure: dict, git_files: list, spec=None):
+        """
+        Generates the Markdown file based on the provided tree structure and git files.
+
+        Args:
+            tree_structure (dict): The hierarchical structure of the project files.
+            git_files (list): List of files tracked by Git.
+            spec (pathspec.PathSpec, optional): PathSpec object for file exclusion based on patterns.
+        """
+        self.logger.info("Starting Markdown generation.")
+        self._write_header(tree_structure)
+
+        if not self.structure_only:
+            self._write_file_contents(git_files, spec)
+
+        self.logger.info(f"Markdown file generated successfully at: {self.output_file}")
+
+    def _write_header(self, tree_structure: dict):
+        """
+        Writes the header and project structure to the Markdown file.
+
+        Args:
+            tree_structure (dict): The hierarchical structure of the project files.
+        """
+        self.logger.debug("Writing Markdown header and project structure.")
+        try:
+            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):
+                    f.write(line)
+                f.write("```\n\n")
+            self.logger.debug("Header and project structure written successfully.")
+        except IOError as e:
+            self.logger.error(f"Failed to write header to {self.output_file}: {e}")
+            raise
+
+    def _write_file_contents(self, git_files: list, spec):
+        """
+        Writes the contents of each file to the Markdown file, excluding those matching the spec.
+
+        Args:
+            git_files (list): List of files tracked by Git.
+            spec (pathspec.PathSpec, optional): PathSpec object for file exclusion based on patterns.
+        """
+        self.logger.debug("Writing file contents to Markdown.")
+        for file in git_files:
+            file_path = self._resolve_file_path(file)
+
+            if not file_path.exists():
+                self.logger.debug(f"File not found: {file_path}. Skipping.")
+                continue
+
+            relative_path = file_path.relative_to(self.root_dir).as_posix()
+            if spec and spec.match_file(relative_path):
+                self.logger.debug(f"File excluded by spec: {relative_path}. Skipping.")
+                continue
+
+            self.logger.debug(f"Processing file: {file_path}")
+            self._write_file_content(file_path, relative_path)
+
+    def _resolve_file_path(self, file: str) -> Path:
+        """
+        Resolves the absolute path of a file relative to the root directory.
+
+        Args:
+            file (str): The file path relative to the root directory.
+
+        Returns:
+            Path: The absolute path to the file.
+        """
+        resolved_path = self.root_dir / file
+        self.logger.debug(f"Resolved file path: {file} to {resolved_path}")
+        return resolved_path
+
+    def _write_file_content(self, file_path: Path, relative_path: str):
+        """
+        Writes the content of a single file to the Markdown file with syntax highlighting.
+
+        Args:
+            file_path (Path): The absolute path to the file.
+            relative_path (str): The file path relative to the root directory.
+        """
+        try:
+            print(f"Attempting to read file: {file_path}")
+            with file_path.open('r', encoding='utf-8') as f:
+                content = f.read()
+                self.logger.debug(f"Read content from {file_path}")
+
+            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")
+                self.logger.debug(f"Wrote content of {relative_path} to Markdown.")
+        except IOError as e:
+            self.logger.error(f"Error reading or writing file {file_path}: {e}")
+        except Exception as e:
+            self.logger.error(f"Unexpected error processing file {file_path}: {e}")

{reposnap-0.2.0 → reposnap-0.2.1}/src/reposnap/interfaces/cli.py

@@ -1,21 +1,30 @@
 # src/reposnap/interfaces/cli.py
 
 import argparse
+import logging
 from reposnap.core.collector import ProjectContentCollector
 
+
 def main():
     parser = argparse.ArgumentParser(description='Generate a Markdown representation of a Git repository.')
     parser.add_argument('path', help='Path to the Git repository.')
     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.')
+
     args = parser.parse_args()
 
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logging.basicConfig(level=log_level, format='%(asctime)s - %(levelname)s - %(message)s')
+
     with open(f"{args.path}/.gitignore", 'r') as gitignore:
         patterns = gitignore.readlines()
+        logging.debug(f"Patterns from .gitignore in {args.path}: {patterns}")
 
     collector = ProjectContentCollector(args.path, args.output, args.structure_only, patterns)
     collector.collect_and_generate()
 
+
 if __name__ == "__main__":
     main()

reposnap-0.2.1/tests/reposnap/test_file_system.py

@@ -0,0 +1,69 @@
+# tests/reposnap/test_file_system.py
+
+import pytest
+from pathlib import Path
+from reposnap.core.file_system import FileSystem
+
+
+@pytest.fixture
+def file_system(tmp_path):
+    # Initialize FileSystem with tmp_path as the root directory
+    return FileSystem(str(tmp_path))
+
+
+def test_build_tree_structure(file_system, tmp_path):
+    # Ensure intermediate directories are created
+    (tmp_path / 'dir1').mkdir(parents=True, exist_ok=True)
+    (tmp_path / 'dir2').mkdir(parents=True, exist_ok=True)
+
+    # Write files into the created directories
+    (tmp_path / 'dir1' / 'file1.py').write_text('content')
+    (tmp_path / 'dir2' / 'file2.py').write_text('content')
+
+    # Build tree structure based on the files in tmp_path
+    tree_structure = file_system.build_tree_structure([
+        str(tmp_path / 'dir1' / 'file1.py'),
+        str(tmp_path / 'dir2' / 'file2.py')
+    ])
+    assert 'dir1' in tree_structure
+    assert 'file1.py' in tree_structure['dir1']
+    assert 'dir2' in tree_structure
+    assert 'file2.py' in tree_structure['dir2']
+
+
+def test_relative_path_resolution(file_system, tmp_path):
+    # Create a mock .gitignore file in the root directory
+    gitignore_file = tmp_path / '.gitignore'
+    gitignore_file.write_text('*.pyc\n')
+
+    # Add a relative path to the git_files list
+    git_files = ['.gitignore']
+
+    # Mock the root_dir to simulate the environment
+    root_dir = tmp_path
+
+    # Simulate the file system processing
+    tree_structure = file_system.build_tree_structure(git_files)
+
+    # Check if .gitignore was correctly resolved relative to the root directory
+    expected_path = '.gitignore'
+    assert tree_structure['.gitignore'] == expected_path, \
+        f"Expected {expected_path}, but got {tree_structure['.gitignore']}"
+
+
+def test_incorrect_path_resolution(file_system, tmp_path):
+    # Create a mock .gitignore file in a different directory (simulating reposnap)
+    wrong_dir = Path('/Users/andrey.goloborodko/PycharmProjects/reposnap')
+    wrong_gitignore_file = wrong_dir / '.gitignore'
+    wrong_gitignore_file.touch()  # Create an empty .gitignore file
+
+    # Add a relative path to the git_files list
+    git_files = ['.gitignore']
+
+    # Simulate the file system processing and manually resolve .gitignore incorrectly
+    tree_structure = file_system.build_tree_structure(git_files)
+
+    # Check if .gitignore was incorrectly resolved to the wrong directory
+    incorrect_path = wrong_gitignore_file.resolve().as_posix()
+    assert tree_structure['.gitignore'] != incorrect_path, \
+        f"Expected path NOT to be {incorrect_path}, but it was resolved as such"

reposnap-0.2.1/tests/reposnap/test_markdown_generator.py

@@ -0,0 +1,70 @@
+import pytest
+from reposnap.core.markdown_generator import MarkdownGenerator
+from unittest.mock import call
+from pathlib import Path
+
+
+@pytest.fixture
+def resources_dir():
+    return Path(__file__).parent.parent / "resources"
+
+
+@pytest.fixture
+def markdown_generator_factory(resources_dir, tmp_path):
+    def _factory(structure_only=False):
+        # Use a temporary directory for the output file
+        output_file = tmp_path / "output.md"
+        return MarkdownGenerator(root_dir=resources_dir, output_file=output_file, structure_only=structure_only)
+
+    return _factory
+
+
+@pytest.mark.parametrize("git_files,expected_calls", [
+    (
+            ['existing_file.py', 'missing_file.py', 'another_existing_file.py'],
+            [
+                "## existing_file.py\n\n",
+                "```python\n",
+                'print("Hello, world!")\n',
+                '```\n\n',
+                "## another_existing_file.py\n\n",
+                "```python\n",
+                'print("Another file")\n',
+                '```\n\n'
+            ]
+    ),
+])
+def test_generate_markdown_with_missing_files(resources_dir, markdown_generator_factory, git_files, expected_calls):
+    markdown_generator = markdown_generator_factory(structure_only=False)
+
+    # Generate the markdown file and verify the output
+    markdown_generator.generate_markdown({}, git_files)
+    output_content = markdown_generator.output_file.read_text()
+
+    # Join expected calls into a single string
+    expected_content = ''.join(expected_calls)
+
+    assert expected_content in output_content
+
+
+def test_generate_markdown_structure_only(markdown_generator_factory):
+    tree_structure = {'dir': {'file.py': 'file.py'}}
+
+    expected_calls = [
+        "# Project Structure\n\n",
+        "```\n",
+        "dir/\n",
+        "    file.py\n",
+        "```\n\n"
+    ]
+
+    markdown_generator = markdown_generator_factory(structure_only=True)
+
+    # Generate the markdown file and verify the output
+    markdown_generator.generate_markdown(tree_structure, [])
+    output_content = markdown_generator.output_file.read_text()
+
+    # Join expected calls into a single string
+    expected_content = ''.join(expected_calls)
+
+    assert output_content == expected_content

reposnap-0.2.1/tests/resources/another_existing_file.py

@@ -0,0 +1 @@
+print("Another file")

reposnap-0.2.1/tests/resources/existing_file.py

@@ -0,0 +1 @@
+print("Hello, world!")

reposnap-0.2.0/src/reposnap/core/collector.py

@@ -1,21 +0,0 @@
-# src/reposnap/core/collector.py
-
-from .file_system import FileSystem
-from .git_repo import GitRepo
-from .markdown_generator import MarkdownGenerator
-import pathspec
-
-class ProjectContentCollector:
-    def __init__(self, root_dir: str, output_file: str, structure_only: bool, gitignore_patterns: list):
-        self.root_dir = root_dir
-        self.output_file = output_file
-        self.structure_only = structure_only
-        self.spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, gitignore_patterns)
-        self.file_system = FileSystem(root_dir)
-        self.git_repo = GitRepo(root_dir)
-        self.markdown_generator = MarkdownGenerator()
-
-    def collect_and_generate(self):
-        git_files = self.git_repo.get_git_files()
-        tree_structure = self.file_system.build_tree_structure(git_files)
-        self.markdown_generator.generate_markdown(self.output_file, tree_structure, git_files, self.spec, self.structure_only)

reposnap-0.2.0/src/reposnap/core/git_repo.py

@@ -1,14 +0,0 @@
-# src/reposnap/core/git_repo.py
-
-from git import Repo, InvalidGitRepositoryError
-
-class GitRepo:
-    def __init__(self, repo_path: str):
-        self.repo_path = repo_path
-
-    def get_git_files(self):
-        try:
-            repo = Repo(self.repo_path)
-            return repo.git.ls_files().splitlines()
-        except InvalidGitRepositoryError:
-            return []

reposnap-0.2.0/src/reposnap/core/markdown_generator.py

@@ -1,24 +0,0 @@
-# src/reposnap/core/markdown_generator.py
-
-from pathlib import Path
-from ..utils.path_utils import format_tree
-
-class MarkdownGenerator:
-    def generate_markdown(self, output_file, tree_structure, git_files, spec, structure_only=False):
-        with open(output_file, 'w') as f:
-            f.write("# Project Structure\n\n")
-            f.write("```\n")
-            for line in format_tree(tree_structure):
-                f.write(line)
-            f.write("```\n\n")
-
-            if not structure_only:
-                for file in git_files:
-                    relative_path = Path(file).relative_to(Path(output_file).parent).as_posix()
-                    if spec and not spec.match_file(relative_path):
-                        # Only read the file if spec is not None and does not match
-                        with open(Path(output_file).parent / file, 'r') as file_content:
-                            f.write(f"## {relative_path}\n\n")
-                            f.write(f"```\n{file_content.read()}\n```\n\n")
-
-        print(f"Markdown file generated: {output_file}")

reposnap-0.2.0/tests/reposnap/test_file_system.py

@@ -1,28 +0,0 @@
-# src/reposnap/tests/test_file_system.py
-
-import pytest
-from reposnap.core.file_system import FileSystem
-
-@pytest.fixture
-def file_system(tmp_path):
-    # Initialize FileSystem with tmp_path as the root directory
-    return FileSystem(str(tmp_path))
-
-def test_build_tree_structure(file_system, tmp_path):
-    # Ensure intermediate directories are created
-    (tmp_path / 'dir1').mkdir(parents=True, exist_ok=True)
-    (tmp_path / 'dir2').mkdir(parents=True, exist_ok=True)
-
-    # Write files into the created directories
-    (tmp_path / 'dir1' / 'file1.py').write_text('content')
-    (tmp_path / 'dir2' / 'file2.py').write_text('content')
-
-    # Build tree structure based on the files in tmp_path
-    tree_structure = file_system.build_tree_structure([
-        str(tmp_path / 'dir1' / 'file1.py'),
-        str(tmp_path / 'dir2' / 'file2.py')
-    ])
-    assert 'dir1' in tree_structure
-    assert 'file1.py' in tree_structure['dir1']
-    assert 'dir2' in tree_structure
-    assert 'file2.py' in tree_structure['dir2']

reposnap-0.2.0/tests/reposnap/test_markdown_generator.py

@@ -1,15 +0,0 @@
-# src/reposnap/tests/test_markdown_generator.py
-
-import pytest  # noqa
-from reposnap.core.markdown_generator import MarkdownGenerator
-from unittest.mock import mock_open, patch
-
-def test_generate_markdown():
-    mock_open_func = mock_open()
-    with patch('builtins.open', mock_open_func):
-        markdown_generator = MarkdownGenerator()
-        markdown_generator.generate_markdown('output.md', {'dir': {'file.py': 'file.py'}}, ['file.py'], None)
-
-    mock_open_func.assert_called_once_with('output.md', 'w')
-    handle = mock_open_func()
-    handle.write.assert_called()