initial commit of script

Author: chrisw-dev

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+    python-test:
+      runs-on: ubuntu-latest
+  
+      steps:
+        - name: Checkout code
+          uses: actions/checkout@v4
+  
+        - name: Set up Python
+          uses: actions/setup-python@v5
+          with:
+            python-version: 3.12
+  
+        - name: Test the tree_view_cli package
+          run: |
+            python3.12 -m venv env
+            source env/bin/activate
+            python3.12 -m pip install --upgrade pip
+            pip install -r test_requirements.txt
+            coverage run -m pytest
+            deactivate
+            rm -rf env

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "."
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

README.md

@@ -0,0 +1,96 @@
+# tree-view-cli
+
+`tree-view-cli` is a Python script that generates a tree-like representation of a directory structure. It's designed to be simple, fast, and customizable, providing an easy way to visualize file system hierarchies directly from the command line.
+
+## Features
+
+- Generate a tree view of any directory
+- Respect `.gitignore` rules, providing an accurate representation of version-controlled projects
+- Customizable depth limit
+- Alphabetical sorting of files and directories
+- Cyclic reference detection to prevent infinite loops
+- Cross-platform compatibility (works on any system with Python 3.6+)
+
+## Requirements
+
+- Python 3.6 or higher
+
+## Installation
+
+1. Clone this repository or download the `tree_view_cli.py` script.
+2. Make the script executable (on Unix-like systems):
+
+   ```bash
+   chmod +x tree_view_cli.py
+   ```
+
+3. Optionally, you can add the script's directory to your PATH for easier access.
+
+## Usage
+
+Basic usage:
+
+```bash
+python tree_view_cli.py /path/to/directory
+```
+
+To limit the depth of the tree:
+
+```bash
+python tree_view_cli.py /path/to/directory --max-depth 2
+```
+
+### Options
+
+- `directory`: The path to the directory you want to visualize (required)
+- `--max-depth`: Maximum depth to display (optional, default is unlimited)
+
+## Example Output
+
+```
+my-project/
+├── src/
+│   ├── main.py
+│   └── utils/
+│       ├── helper.py
+│       └── config.py
+├── tests/
+│   ├── test_main.py
+│   └── test_utils.py
+├── README.md
+└── requirements.txt
+```
+
+Note: The output will exclude files and directories specified in .gitignore files.
+
+## Development
+
+### Running Tests
+
+To run the tests, you'll need pytest installed. You can install it with:
+
+```bash
+pip install pytest
+```
+
+Then, run the tests with:
+
+```bash
+pytest test_tree_view_cli.py
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is open source and available under the [MIT License](LICENSE).
+
+## Contact
+
+If you have any questions or encounter any issues, please feel free to open an issue in this repository.
+
+---
+
+Happy tree viewing!

test_requirements.txt

@@ -0,0 +1 @@
+pytest

test_tree_view_cli.py

@@ -0,0 +1,90 @@
+import pytest
+import tempfile
+import os
+from pathlib import Path
+from tree_view_cli import DirectoryTreeGenerator
+
+@pytest.fixture
+def temp_directory():
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        yield Path(tmpdirname)
+
+def create_file_structure(root):
+    (root / "dir1" / "subdir1").mkdir(parents=True)
+    (root / "dir1" / "subdir2").mkdir(parents=True)
+    (root / "dir1" / "file1.txt").touch()
+    (root / "dir1" / "subdir1" / "file2.txt").touch()
+    (root / "dir1" / "subdir2" / "file3.txt").touch()
+
+def test_basic_structure(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "dir1" in captured.out
+    assert "subdir1" in captured.out
+    assert "subdir2" in captured.out
+    assert "file1.txt" in captured.out
+    assert "file2.txt" in captured.out
+    assert "file3.txt" in captured.out
+
+def test_max_depth(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    tree_gen = DirectoryTreeGenerator(temp_directory, max_depth=1)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "dir1" in captured.out
+    assert "subdir1" not in captured.out
+    assert "file2.txt" not in captured.out
+
+def test_gitignore_file(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    with open(temp_directory / ".gitignore", "w") as f:
+        f.write("**/file1.txt\n")
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "file1.txt" not in captured.out
+    assert "file2.txt" in captured.out
+
+def test_gitignore_directory(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    with open(temp_directory / ".gitignore", "w") as f:
+        f.write("dir1/\n")
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "dir1" not in captured.out
+
+def test_gitignore_subdirectory(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    with open(temp_directory / ".gitignore", "w") as f:
+        f.write("**/subdir1\n")
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "subdir1" not in captured.out
+    assert "subdir2" in captured.out
+
+# def test_cyclic_reference(temp_directory, capsys):
+#     (temp_directory / "dir1" / "subdir1").mkdir(parents=True)
+#     os.symlink(temp_directory / "dir1", temp_directory / "dir1" / "subdir1" / "cycle")
+#     tree_gen = DirectoryTreeGenerator(temp_directory)
+#     tree_gen.generate_tree()
+#     captured = capsys.readouterr()
+#     assert "Cyclic reference to" in captured.out
+
+def test_empty_directory(temp_directory, capsys):
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert captured.out.strip() == temp_directory.name + "/"
+
+def test_git_directory_excluded(temp_directory, capsys):
+    create_file_structure(temp_directory)
+    (temp_directory / ".git").mkdir()
+    tree_gen = DirectoryTreeGenerator(temp_directory)
+    tree_gen.generate_tree()
+    captured = capsys.readouterr()
+    assert "dir1" in captured.out
+    assert ".git" not in captured.out

tree_view_cli.py

@@ -0,0 +1,120 @@
+import os
+import argparse
+from pathlib import Path
+import fnmatch
+import re
+
+class DirectoryTreeGenerator:
+    def __init__(self, root_dir, max_depth=float('inf')):
+        self.root_dir = Path(root_dir).resolve()
+        self.max_depth = max_depth
+        self.gitignore_patterns = self.load_gitignore_patterns()
+
+    def load_gitignore_patterns(self):
+        patterns = []
+        current_dir = self.root_dir
+        while current_dir != current_dir.parent:
+            gitignore_file = current_dir / '.gitignore'
+            if gitignore_file.is_file():
+                with open(gitignore_file, 'r') as f:
+                    patterns.extend([line.strip() for line in f if line.strip() and not line.startswith('#')])
+            current_dir = current_dir.parent
+        return patterns
+
+    def gitignore_pattern_to_regex(self, pattern: str) -> str:
+        """
+        Convert a .gitignore pattern to a regular expression.
+
+        Args:
+            pattern (str): The .gitignore pattern.
+
+        Returns:
+            str: The corresponding regular expression.
+        """
+        # Escape special characters
+        pattern = re.escape(pattern)
+        
+        # Replace escaped wildcards with regex equivalents
+        pattern = pattern.replace(r'\*\*', '.*')
+        pattern = pattern.replace(r'\*', '[^/]*')
+        pattern = pattern.replace(r'\?', '.')
+
+        # Check if the pattern is for a directory
+        if pattern.endswith(r'/'):
+            # Match the directory and its contents
+            pattern = pattern[:-2] + r'(/.*)?'
+        else:
+            # Add start and end anchors for non-directory patterns
+            pattern = '^' + pattern + '$'
+        
+        return pattern
+
+    def should_ignore(self, path: Path) -> bool:
+        """
+        Determine if a given path should be ignored based on .gitignore patterns.
+
+        Args:
+            path (Path): The path to check.
+
+        Returns:
+            bool: True if the path should be ignored, False otherwise.
+        """
+        # Get the relative path from the root directory
+        rel_path = path.relative_to(self.root_dir)
+
+        # Convert the relative path to a string
+        rel_path_str = str(rel_path)
+
+        # Check if the path is the .git directory or inside it
+        if rel_path_str == ".git" or rel_path_str.startswith(".git/"):
+            return True
+
+        # Check if the relative path matches any pattern in the .gitignore patterns
+        for pattern in self.gitignore_patterns:
+            # Convert the pattern to a regex
+            regex = self.gitignore_pattern_to_regex(pattern)
+            if re.match(regex, rel_path_str):
+                return True
+
+        # If no patterns match, return False
+        return False
+
+    def generate_tree(self):
+        print(f"{self.root_dir.name}/")
+        self._generate_tree(self.root_dir, "", 0, set())
+
+    def _generate_tree(self, directory, prefix, depth, visited):
+        if depth >= self.max_depth:
+            return
+
+        entries = sorted(directory.iterdir(), key=lambda x: (x.is_file(), x.name.lower()))
+        
+        for i, entry in enumerate(entries):
+            if self.should_ignore(entry):
+                continue
+
+            is_last = i == len(entries) - 1
+            current_prefix = "└── " if is_last else "├── "
+            print(f"{prefix}{current_prefix}{entry.name}")
+
+            if entry.is_dir() and not entry.is_symlink():
+                canonical_path = entry.resolve()
+                if canonical_path in visited:
+                    print(f"{prefix}{'    ' if is_last else '│   '}[Cyclic reference to {entry.name}]")
+                    continue
+
+                new_prefix = prefix + ("    " if is_last else "│   ")
+                new_visited = visited.union({canonical_path})
+                self._generate_tree(entry, new_prefix, depth + 1, new_visited)
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a directory tree.")
+    parser.add_argument("directory", help="The directory to generate the tree for.")
+    parser.add_argument("--max-depth", type=int, default=float('inf'), help="Maximum depth to traverse.")
+    args = parser.parse_args()
+
+    tree_generator = DirectoryTreeGenerator(args.directory, args.max_depth)
+    tree_generator.generate_tree()
+
+if __name__ == "__main__":
+    main()