glreview 0.1.0__py3-none-any.whl

glreview/config.py

@@ -0,0 +1,149 @@
+"""Configuration loading from pyproject.toml."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+@dataclass
+class PriorityRule:
+    """A rule for assigning priority to modules based on path patterns."""
+
+    pattern: str
+    level: str = "medium"
+    reviewers_required: int = 1
+
+    def matches(self, path: str) -> bool:
+        """Check if this rule matches the given path."""
+        return fnmatch(path, self.pattern)
+
+
+@dataclass
+class Config:
+    """Configuration for glreview."""
+
+    # Source patterns to discover modules
+    sources: list[str] = field(default_factory=lambda: ["src/**/*.py"])
+
+    # Patterns to exclude
+    exclude: list[str] = field(default_factory=lambda: ["**/_version.py"])
+
+    # Path to the registry file
+    registry: str = "review_registry.json"
+
+    # GitLab issue labels
+    issue_labels: list[str] = field(default_factory=lambda: ["review"])
+
+    # Path to custom issue template (optional)
+    issue_template: str | None = None
+
+    # Priority rules (in order of precedence)
+    priority_rules: list[PriorityRule] = field(default_factory=list)
+
+    # Named reviewer teams
+    teams: dict[str, list[str]] = field(default_factory=dict)
+
+    # Project root directory
+    root: Path = field(default_factory=Path.cwd)
+
+    def get_priority(self, path: str) -> tuple[str, int]:
+        """Get the priority level and required reviewers for a path.
+
+        Returns:
+            Tuple of (level, reviewers_required)
+        """
+        for rule in self.priority_rules:
+            if rule.matches(path):
+                return rule.level, rule.reviewers_required
+
+        # Default
+        return "medium", 1
+
+    @property
+    def registry_path(self) -> Path:
+        """Get the absolute path to the registry file."""
+        return self.root / self.registry
+
+
+def load_config(project_root: Path | None = None) -> Config:
+    """Load configuration from pyproject.toml.
+
+    Args:
+        project_root: Path to the project root. If None, searches upward
+            from cwd for pyproject.toml.
+
+    Returns:
+        Config object with loaded settings.
+    """
+    if project_root is None:
+        project_root = find_project_root()
+
+    pyproject_path = project_root / "pyproject.toml"
+
+    if not pyproject_path.exists():
+        # Return defaults
+        return Config(root=project_root)
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    tool_config = data.get("tool", {}).get("glreview", {})
+
+    # Parse priority rules
+    priority_rules = []
+    for rule_data in tool_config.get("priority", []):
+        priority_rules.append(
+            PriorityRule(
+                pattern=rule_data.get("pattern", "**/*.py"),
+                level=rule_data.get("level", "medium"),
+                reviewers_required=rule_data.get("reviewers_required", 1),
+            )
+        )
+
+    return Config(
+        sources=tool_config.get("sources", ["src/**/*.py"]),
+        exclude=tool_config.get("exclude", ["**/_version.py"]),
+        registry=tool_config.get("registry", "review_registry.json"),
+        issue_labels=tool_config.get("issue_labels", ["review"]),
+        issue_template=tool_config.get("issue_template"),
+        priority_rules=priority_rules,
+        teams=tool_config.get("teams", {}),
+        root=project_root,
+    )
+
+
+def find_project_root(start: Path | None = None) -> Path:
+    """Find the project root by searching upward for pyproject.toml or .git.
+
+    Args:
+        start: Starting directory. Defaults to cwd.
+
+    Returns:
+        Path to the project root.
+
+    Raises:
+        FileNotFoundError: If no project root can be found.
+    """
+    if start is None:
+        start = Path.cwd()
+
+    current = start.resolve()
+
+    while current != current.parent:
+        if (current / "pyproject.toml").exists():
+            return current
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+
+    # Fall back to start directory
+    return start.resolve()

glreview/discovery.py

@@ -0,0 +1,73 @@
+"""Module discovery from glob patterns."""
+
+from __future__ import annotations
+
+from fnmatch import fnmatch
+from pathlib import Path
+
+
+def discover_modules(
+    root: Path,
+    patterns: list[str],
+    exclude: list[str] | None = None,
+) -> list[str]:
+    """Discover modules matching glob patterns.
+
+    Args:
+        root: Project root directory.
+        patterns: Glob patterns to match (e.g., ["src/**/*.py"]).
+        exclude: Patterns to exclude.
+
+    Returns:
+        List of relative paths to discovered modules.
+    """
+    exclude = exclude or []
+    modules = set()
+
+    for pattern in patterns:
+        for path in root.glob(pattern):
+            if not path.is_file():
+                continue
+
+            rel_path = str(path.relative_to(root))
+
+            # Check exclusions
+            excluded = False
+            for exc_pattern in exclude:
+                if fnmatch(rel_path, exc_pattern):
+                    excluded = True
+                    break
+
+            if not excluded:
+                modules.add(rel_path)
+
+    return sorted(modules)
+
+
+def sync_registry(
+    root: Path,
+    patterns: list[str],
+    exclude: list[str] | None = None,
+    existing: dict[str, any] | None = None,
+    get_priority: callable | None = None,
+) -> tuple[list[str], list[str]]:
+    """Sync registry with discovered modules.
+
+    Args:
+        root: Project root directory.
+        patterns: Glob patterns for discovery.
+        exclude: Patterns to exclude.
+        existing: Existing module paths in registry.
+        get_priority: Function to get (level, reviewers_required) for a path.
+
+    Returns:
+        Tuple of (added_paths, removed_paths).
+    """
+    existing = existing or {}
+    discovered = set(discover_modules(root, patterns, exclude))
+    current = set(existing.keys())
+
+    added = discovered - current
+    removed = current - discovered
+
+    return sorted(added), sorted(removed)

glreview/git.py

@@ -0,0 +1,217 @@
+"""Git operations for tracking commits and diffs."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+class GitError(Exception):
+    """Error running git command."""
+
+    pass
+
+
+def run_git(
+    *args: str,
+    cwd: Path | None = None,
+    check: bool = True,
+) -> subprocess.CompletedProcess:
+    """Run a git command.
+
+    Args:
+        *args: Git command arguments.
+        cwd: Working directory.
+        check: Whether to raise on non-zero exit.
+
+    Returns:
+        Completed process with stdout/stderr.
+
+    Raises:
+        GitError: If check=True and command fails.
+    """
+    result = subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+
+    if check and result.returncode != 0:
+        raise GitError(f"git {' '.join(args)} failed: {result.stderr}")
+
+    return result
+
+
+def get_current_commit(cwd: Path | None = None, short: bool = True) -> str:
+    """Get the current HEAD commit SHA.
+
+    Args:
+        cwd: Working directory.
+        short: If True, return short SHA (7 chars).
+
+    Returns:
+        Commit SHA string.
+    """
+    args = ["rev-parse"]
+    if short:
+        args.append("--short")
+    args.append("HEAD")
+
+    result = run_git(*args, cwd=cwd)
+    return result.stdout.strip()
+
+
+def get_full_commit(short_sha: str, cwd: Path | None = None) -> str | None:
+    """Expand a short SHA to full SHA.
+
+    Args:
+        short_sha: Short commit SHA.
+        cwd: Working directory.
+
+    Returns:
+        Full commit SHA, or None if not found.
+    """
+    result = run_git("rev-parse", short_sha, cwd=cwd, check=False)
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def has_changes_since(
+    filepath: str,
+    since_commit: str,
+    cwd: Path | None = None,
+) -> bool:
+    """Check if a file has changed since a given commit.
+
+    Args:
+        filepath: Path to the file (relative to repo root).
+        since_commit: Commit SHA to compare against.
+        cwd: Working directory.
+
+    Returns:
+        True if the file has changes, False otherwise.
+    """
+    if not since_commit:
+        return True  # Never reviewed means "has changes"
+
+    full_commit = get_full_commit(since_commit, cwd=cwd)
+    if not full_commit:
+        return True  # Can't find commit, assume changes
+
+    result = run_git(
+        "diff", "--quiet", full_commit, "HEAD", "--", filepath,
+        cwd=cwd,
+        check=False,
+    )
+
+    return result.returncode != 0  # Non-zero means changes exist
+
+
+def get_changed_files(
+    base: str = "HEAD~1",
+    head: str = "HEAD",
+    cwd: Path | None = None,
+) -> list[str]:
+    """Get list of files changed between two commits.
+
+    Args:
+        base: Base commit.
+        head: Head commit.
+        cwd: Working directory.
+
+    Returns:
+        List of changed file paths.
+    """
+    result = run_git(
+        "diff", "--name-only", f"{base}...{head}",
+        cwd=cwd,
+        check=False,
+    )
+
+    if result.returncode != 0:
+        return []
+
+    return [f for f in result.stdout.strip().split("\n") if f]
+
+
+def get_remote_url(cwd: Path | None = None) -> str | None:
+    """Get the origin remote URL.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Remote URL or None.
+    """
+    result = run_git("remote", "get-url", "origin", cwd=cwd, check=False)
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def get_gitlab_project(cwd: Path | None = None) -> str | None:
+    """Extract GitLab project path from remote URL.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Project path (e.g., "user/project") or None.
+    """
+    url = get_remote_url(cwd=cwd)
+    if not url:
+        return None
+
+    # Handle SSH: git@git.ligo.org:user/project.git
+    if url.startswith("git@"):
+        path = url.split(":")[-1]
+    # Handle HTTPS: https://git.ligo.org/user/project.git
+    elif "://" in url:
+        path = "/".join(url.split("/")[-2:])
+    else:
+        return None
+
+    return path.removesuffix(".git")
+
+
+def get_gitlab_host(cwd: Path | None = None) -> str | None:
+    """Extract GitLab host from remote URL.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Host (e.g., "git.ligo.org") or None.
+    """
+    url = get_remote_url(cwd=cwd)
+    if not url:
+        return None
+
+    # Handle SSH: git@git.ligo.org:user/project.git
+    if url.startswith("git@"):
+        return url.split("@")[1].split(":")[0]
+    # Handle HTTPS: https://git.ligo.org/user/project.git
+    elif "://" in url:
+        return url.split("/")[2]
+    else:
+        return None
+
+
+def count_lines(filepath: str, cwd: Path | None = None) -> int:
+    """Count the number of lines in a file.
+
+    Args:
+        filepath: Path to the file.
+        cwd: Working directory.
+
+    Returns:
+        Number of lines, or 0 if file doesn't exist.
+    """
+    full_path = (cwd or Path.cwd()) / filepath
+    if not full_path.exists():
+        return 0
+
+    with open(full_path) as f:
+        return sum(1 for _ in f)