git-ember 1.2.1__tar.gz → 1.3.0__tar.gz

{git_ember-1.2.1 → git_ember-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-ember
-Version: 1.2.1
+Version: 1.3.0
 Summary: A GitHub-style heatmap of commits for your terminal
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{git_ember-1.2.1 → git_ember-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "git-ember"
-version = "1.2.1"
+version = "1.3.0"
 description = "A GitHub-style heatmap of commits for your terminal"
 readme = "README.md"
 requires-python = ">=3.11"

{git_ember-1.2.1 → git_ember-1.3.0}/src/git_ember.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-ember
-Version: 1.2.1
+Version: 1.3.0
 Summary: A GitHub-style heatmap of commits for your terminal
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{git_ember-1.2.1 → git_ember-1.3.0}/src/git_ember.egg-info/SOURCES.txt

@@ -9,5 +9,9 @@ src/git_ember.egg-info/top_level.txt
 src/gitember/__init__.py
 src/gitember/cli.py
 src/gitember/colors.py
+src/gitember/config.py
 src/gitember/git.py
-src/gitember/render.py
+src/gitember/render.py
+tests/test_config.py
+tests/test_git.py
+tests/test_render.py

{git_ember-1.2.1 → git_ember-1.3.0}/src/gitember/cli.py

@@ -1,13 +1,13 @@
 import argparse
 import calendar
 import datetime as dt
-import os
 import sys
 import time
 from pathlib import Path
 
 from gitember import __version__
 from gitember.colors import get_color_scheme, RESET, LIGHT_GRAY
+from gitember.config import config_file_path, ALLOWED_CONFIG_KEYS, load_config, save_config
 from gitember.git import (
     run_git_log,
     get_recent_commits,
@@ -18,87 +18,10 @@ from gitember.git import (
     get_default_branch,
     get_streaks,
 )
-from gitember.render import render_grid, render_branch_tree, calculate_thresholds
+from gitember.render import render_grid, render_branch_tree, calculate_thresholds, render_legend
 
 
-def config_file_path() -> Path:
-    """Get the path to the config file.
-
-    Returns:
-        Path to config.toml in platform-specific config directory.
-    """
-    if sys.platform.startswith("win"):
-        base = os.getenv("APPDATA")
-        if base:
-            base_path = Path(base)
-        else:
-            base_path = Path.home() / "AppData" / "Roaming"
-    else:
-        xdg = os.getenv("XDG_CONFIG_HOME")
-        if xdg:
-            base_path = Path(xdg)
-        else:
-            base_path = Path.home() / ".config"
-    return base_path / "git-ember" / "config.toml"
-
-
-ALLOWED_CONFIG_KEYS = {"color", "border"}
-# NOTE: branch is intentionally excluded from config to avoid user confusion
-
-
-def load_config() -> dict:
-    """Load config from file, returning defaults if not exists.
-
-    Returns:
-        Dict with keys: color, border.
-    """
-    path = config_file_path()
-    if not path.exists():
-        return {
-            "color": "green",
-            "border": "=",
-        }
-
-    config = {"color": "green", "border": "="}
-    try:
-        text = path.read_text(encoding="utf-8")
-    except OSError:
-        return config
-
-    # Simple TOML-like parsing: key=value, ignore comments
-    for line in text.splitlines():
-        stripped = line.strip()
-        # Skip empty lines and comments
-        if not stripped or stripped.startswith("#"):
-            continue
-        if "=" in stripped:
-            key, _, value = stripped.partition("=")
-            key = key.strip()
-            # Strip quotes from value - handles both "value" and 'value'
-            value = value.strip().strip('"').strip("'")
-            # Only allow predefined keys (whitelist for security)
-            if key in ALLOWED_CONFIG_KEYS:
-                config[key] = value
-    return config
-
-
-def save_config(config: dict) -> None:
-    """Save config to file.
-
-    Args:
-        config: Dict with keys: week_start, style, color, border.
-    """
-    path = config_file_path()
-    try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        lines = []
-        for k, v in config.items():
-            if k in ALLOWED_CONFIG_KEYS:
-                escaped = v.replace('"', '\\"')
-                lines.append(f'{k} = "{escaped}"')
-        path.write_text("\n".join(lines), encoding="utf-8")
-    except OSError:
-        pass
+__all__ = ["main"]
 
 
 def parse_args() -> argparse.Namespace:
@@ -198,6 +121,19 @@ def parse_args() -> argparse.Namespace:
         type=str,
         help="Show commits before this date (YYYY-MM-DD)",
     )
+    parser.add_argument(
+        "--week-start",
+        type=str,
+        choices=["sunday", "monday"],
+        default="sunday",
+        help="First day of week: sunday or monday (default: sunday)",
+    )
+    parser.add_argument(
+        "--author",
+        "-A",
+        type=str,
+        help="Filter commits by author name or email (partial match)",
+    )
     parser.add_argument(
         "--version",
         "-V",
@@ -244,6 +180,8 @@ def main() -> None:
     border_char = args.border[0] if args.border else "="  # prevent escape codes
     ascii_mode = args.ascii
     branch = args.branch
+    week_start = args.week_start or config.get("week_start", "sunday")
+    author = args.author
 
     if branch:
         valid_branches = get_branches(repo_path)
@@ -255,6 +193,8 @@ def main() -> None:
         new_config = config.copy()
         if args.color:
             new_config["color"] = args.color
+        if args.week_start is not None:
+            new_config["week_start"] = args.week_start
         save_config(new_config)
 
     color_scheme = get_color_scheme(color_name)
@@ -267,6 +207,9 @@ def main() -> None:
 
     custom_range = args.after or args.before
 
+    start_date = dt.date.today() - dt.timedelta(days=365)
+    end_date = dt.date.today()
+
     if args.after:
         try:
             start_date = dt.date.fromisoformat(args.after)
@@ -303,7 +246,9 @@ def main() -> None:
                 end_date = dt.date(year, 12, 31)
 
         try:
-            counts = run_git_log(start_date, end_date, repo_path, branch=branch)
+            counts = run_git_log(
+                start_date, end_date, repo_path, branch=branch, author=author
+            )
         except ValueError as e:
             print(f"Error: {e}")
             sys.exit(1)
@@ -315,24 +260,26 @@ def main() -> None:
             end_date,
             counts,
             color_scheme,
-            "sunday",
+            week_start,
             border_char,
             ascii_mode,
             thresholds=thresholds,
         )
 
+        legend = render_legend(thresholds, color_scheme, ascii_mode)
+
         if custom_range:
-            output_parts.append(heatmap)
+            output_parts.append(f"{heatmap}\n    {legend}")
         elif num_iterations > 1:
-            output_parts.append(f"[{year}]\n{heatmap}")
+            output_parts.append(f"[{year}]\n{heatmap}\n    {legend}")
         else:
-            output_parts.append(heatmap)
+            output_parts.append(f"{heatmap}\n    {legend}")
 
     output_parts.reverse()
     print("\n" + "\n".join(output_parts))
 
     if args.tree:
-        tree_commits = get_branch_tree(repo_path, branch=branch)
+        tree_commits = get_branch_tree(repo_path, branch=branch, author=author)
         default_branch = get_default_branch(repo_path)
         tree_output = render_branch_tree(
             tree_commits,
@@ -348,7 +295,7 @@ def main() -> None:
     show_stats = args.stats or extended
 
     if show_stats:
-        stats = get_repo_stats(repo_path, branch=branch)
+        stats = get_repo_stats(repo_path, branch=branch, author=author)
 
         print("\n--- Statistics ---")
         print(f"  Total commits:  {stats.get('total_commits', 0)}")
@@ -365,7 +312,7 @@ def main() -> None:
         streak_start_date = dt.date.today() - dt.timedelta(days=years * 365)
         streak_end_date = dt.date.today()
         streak_counts = run_git_log(
-            streak_start_date, streak_end_date, repo_path, branch=branch
+            streak_start_date, streak_end_date, repo_path, branch=branch, author=author
         )
         streaks = get_streaks(streak_counts)
 
@@ -384,7 +331,7 @@ def main() -> None:
 
     if extended:
         print("\n--- Recent Commits ---")
-        for commit in get_recent_commits(repo_path, branch=branch):
+        for commit in get_recent_commits(repo_path, branch=branch, author=author):
             commit_color = color_scheme.get(3)
             author_color = color_scheme.get(2)
 
@@ -404,10 +351,10 @@ def main() -> None:
             )
             print(f"      {commit['message']}")
 
-        print("\n--- Top Contributors ---")
-        author_color = color_scheme.get(2)
-        for author, count in get_top_contributors(repo_path, branch=branch):
-            print(f"  {count:>4}  {author_color}{author}{RESET}")
+print("\n--- Top Contributors ---")
+        contrib_color = color_scheme.get(2)
+        for contrib, count in get_top_contributors(repo_path, branch=branch, author=author):
+            print(f"  {count:>4}  {contrib_color}{contrib}{RESET}")
 
 
 if __name__ == "__main__":

{git_ember-1.2.1 → git_ember-1.3.0}/src/gitember/colors.py

@@ -2,6 +2,15 @@ RESET = "\x1b[0m"
 LIGHT_GRAY = "\x1b[38;5;250m"
 
 
+__all__ = [
+    "COLOR_SCHEMES",
+    "ColorScheme",
+    "get_color_scheme",
+    "RESET",
+    "LIGHT_GRAY",
+]
+
+
 class ColorScheme:
     """Color scheme with 5 intensity levels (0-4)."""
 

git_ember-1.3.0/src/gitember/config.py

@@ -0,0 +1,91 @@
+import os
+import sys
+from pathlib import Path
+
+
+__all__ = [
+    "config_file_path",
+    "ALLOWED_CONFIG_KEYS",
+    "load_config",
+    "save_config",
+]
+
+
+def config_file_path() -> Path:
+    """Get the path to the config file.
+
+    Returns:
+        Path to config.toml in platform-specific config directory.
+    """
+    if sys.platform.startswith("win"):
+        base = os.getenv("APPDATA")
+        if base:
+            base_path = Path(base)
+        else:
+            base_path = Path.home() / "AppData" / "Roaming"
+    else:
+        xdg = os.getenv("XDG_CONFIG_HOME")
+        if xdg:
+            base_path = Path(xdg)
+        else:
+            base_path = Path.home() / ".config"
+    return base_path / "git-ember" / "config.toml"
+
+
+ALLOWED_CONFIG_KEYS = {"color", "border", "week_start"}
+# NOTE: branch is intentionally excluded from config to avoid user confusion
+
+
+def load_config() -> dict:
+    """Load config from file, returning defaults if not exists.
+
+    Returns:
+        Dict with keys: color, border.
+    """
+    path = config_file_path()
+    if not path.exists():
+        return {
+            "color": "green",
+            "border": "=",
+        }
+
+    config = {"color": "green", "border": "="}
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return config
+
+    # Simple TOML-like parsing: key=value, ignore comments
+    for line in text.splitlines():
+        stripped = line.strip()
+        # Skip empty lines and comments
+        if not stripped or stripped.startswith("#"):
+            continue
+        if "=" in stripped:
+            key, _, value = stripped.partition("=")
+            key = key.strip()
+            # Strip quotes from value - handles both "value" and 'value'
+            value = value.strip().strip('"').strip("'")
+            # Only allow predefined keys (whitelist for security)
+            if key in ALLOWED_CONFIG_KEYS:
+                config[key] = value
+    return config
+
+
+def save_config(config: dict) -> None:
+    """Save config to file.
+
+    Args:
+        config: Dict with keys: week_start, style, color, border.
+    """
+    path = config_file_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        lines = []
+        for k, v in config.items():
+            if k in ALLOWED_CONFIG_KEYS:
+                escaped = v.replace('"', '\\"')
+                lines.append(f'{k} = "{escaped}"')
+        path.write_text("\n".join(lines), encoding="utf-8")
+    except OSError:
+        pass

{git_ember-1.2.1 → git_ember-1.3.0}/src/gitember/git.py

@@ -7,6 +7,18 @@ import re
 COMMIT_PREFIX = "COMMIT:"
 
 
+__all__ = [
+    "run_git_log",
+    "get_branches",
+    "get_default_branch",
+    "get_recent_commits",
+    "get_top_contributors",
+    "get_repo_stats",
+    "get_streaks",
+    "get_branch_tree",
+]
+
+
 def _validate_path(path: str) -> None:
     """Validate path doesn't contain git options or special characters.
 
@@ -39,12 +51,31 @@ def _validate_branch(branch: str) -> None:
         raise ValueError(f"Invalid characters in branch name: {branch}")
 
 
-def _build_log_args(branch: str | None, repo_path: str) -> List[str]:
+def _validate_author(author: str) -> None:
+    """Validate author string doesn't contain git options or special characters.
+
+    Raises:
+        ValueError: If author is invalid.
+    """
+    if not author:
+        raise ValueError("Author cannot be empty")
+
+    if author.startswith("-"):
+        raise ValueError(f"Invalid author: {author}")
+
+    if re.search(r"[;&|`$()]", author):
+        raise ValueError(f"Invalid characters in author: {author}")
+
+
+def _build_log_args(
+    branch: str | None, repo_path: str, default_branch: str | None = None
+) -> List[str]:
     """Build git log arguments for branch filtering.
 
     Args:
         branch: Optional branch name to filter by.
         repo_path: Path to git repository.
+        default_branch: Optional default branch name for comparison.
 
     Returns:
         List of git log arguments (may be empty).
@@ -52,8 +83,7 @@ def _build_log_args(branch: str | None, repo_path: str) -> List[str]:
     if not branch:
         return ["--all"]
 
-    default_branch = get_default_branch(repo_path)
-    if branch != default_branch:
+    if default_branch and branch != default_branch:
         return [branch, "--not", default_branch]
     return [branch]
 
@@ -63,6 +93,7 @@ def run_git_log(
     end_date: dt.date,
     repo_path: str,
     branch: str | None = None,
+    author: str | None = None,
 ) -> Dict[dt.date, int]:
     """Get commit counts per day within a date range.
 
@@ -71,6 +102,7 @@ def run_git_log(
         end_date: End of date range (inclusive).
         repo_path: Path to git repository.
         branch: Optional branch name to filter by. Defaults to all branches.
+        author: Optional author to filter by. Defaults to all authors.
 
     Returns:
         Dict mapping date to commit count.
@@ -83,6 +115,9 @@ def run_git_log(
     if branch:
         _validate_branch(branch)
 
+    if author:
+        _validate_author(author)
+
     try:
         subprocess.run(
             ["git", "-C", repo_path, "rev-parse", "--is-inside-work-tree"],
@@ -103,7 +138,11 @@ def run_git_log(
         "log",
     ]
 
-    cmd.extend(_build_log_args(branch, repo_path))
+    default_branch = get_default_branch(repo_path) if branch else None
+    cmd.extend(_build_log_args(branch, repo_path, default_branch))
+
+    if author:
+        cmd.append(f"--author={author}")
 
     cmd.extend(
         [
@@ -178,7 +217,7 @@ def get_default_branch(repo_path: str) -> str:
 
     # Fallback: get current HEAD branch if it's not main/master
     result = subprocess.run(
-        ["git", "-C", repo_path, "symbolic-ref", "refs/heads/HEAD"],
+        ["git", "-C", repo_path, "symbolic-ref", "HEAD"],
         capture_output=True,
         text=True,
     )
@@ -192,7 +231,7 @@ def get_default_branch(repo_path: str) -> str:
 
 
 def get_recent_commits(
-    repo_path: str, count: int = 5, branch: str | None = None
+    repo_path: str, count: int = 5, branch: str | None = None, author: str | None = None
 ) -> List[Dict[str, str]]:
     """Get recent commits with metadata.
 
@@ -200,6 +239,7 @@ def get_recent_commits(
         repo_path: Path to git repository.
         count: Number of commits to retrieve.
         branch: Optional branch name to filter by.
+        author: Optional author to filter by.
 
     Returns:
         List of dicts with keys: hash, author, date, timestamp, message.
@@ -209,6 +249,10 @@ def get_recent_commits(
     if branch:
         _validate_branch(branch)
 
+    if author:
+        _validate_author(author)
+
+    default_branch = get_default_branch(repo_path) if branch else None
     cmd = [
         "git",
         "-C",
@@ -218,7 +262,10 @@ def get_recent_commits(
         "--pretty=format:%h|%an|%ad %at|%s",
         "--date=short",
     ]
-    cmd.extend(_build_log_args(branch, repo_path))
+    cmd.extend(_build_log_args(branch, repo_path, default_branch))
+
+    if author:
+        cmd.append(f"--author={author}")
 
     result = subprocess.run(cmd, capture_output=True, text=True)
 
@@ -247,7 +294,10 @@ def get_recent_commits(
 
 
 def get_top_contributors(
-    repo_path: str, limit: int = 10, branch: str | None = None
+    repo_path: str,
+    limit: int = 10,
+    branch: str | None = None,
+    author: str | None = None,
 ) -> List[Tuple[str, int]]:
     """Get top contributors by commit count.
 
@@ -255,6 +305,7 @@ def get_top_contributors(
         repo_path: Path to git repository.
         limit: Maximum number of contributors to return.
         branch: Optional branch name to filter by.
+        author: Optional author to filter by.
 
     Returns:
         List of (author, commit_count) tuples, sorted by count descending.
@@ -264,6 +315,10 @@ def get_top_contributors(
     if branch:
         _validate_branch(branch)
 
+    if author:
+        _validate_author(author)
+
+    default_branch = get_default_branch(repo_path) if branch else None
     cmd = [
         "git",
         "-C",
@@ -272,7 +327,10 @@ def get_top_contributors(
         "-s",
         "-n",
     ]
-    cmd.extend(_build_log_args(branch, repo_path))
+    cmd.extend(_build_log_args(branch, repo_path, default_branch))
+
+    if author:
+        cmd.append(f"--author={author}")
 
     result = subprocess.run(cmd, capture_output=True, text=True)
 
@@ -294,12 +352,15 @@ def get_top_contributors(
     return contributors[:limit]
 
 
-def get_repo_stats(repo_path: str, branch: str | None = None) -> Dict[str, Any]:
+def get_repo_stats(
+    repo_path: str, branch: str | None = None, author: str | None = None
+) -> Dict[str, Any]:
     """Get repository statistics.
 
     Args:
         repo_path: Path to git repository.
         branch: Optional branch name to filter by.
+        author: Optional author to filter by.
 
     Returns:
         Dict with keys: total_commits, num_authors, first_commit_date,
@@ -310,21 +371,26 @@ def get_repo_stats(repo_path: str, branch: str | None = None) -> Dict[str, Any]:
     if branch:
         _validate_branch(branch)
 
-    log_args = _build_log_args(branch, repo_path)
+    if author:
+        _validate_author(author)
 
-    result = subprocess.run(
-        [
-            "git",
-            "-C",
-            repo_path,
-            "log",
-            "--format=%an|%at|%ad",
-            "--date=format:%d-%m-%Y %H:%M",
-        ]
-        + log_args,
-        capture_output=True,
-        text=True,
-    )
+    default_branch = get_default_branch(repo_path) if branch else None
+    log_args = _build_log_args(branch, repo_path, default_branch)
+
+    cmd = [
+        "git",
+        "-C",
+        repo_path,
+        "log",
+        "--format=%an|%at|%ad",
+        "--date=format:%d-%m-%Y %H:%M",
+    ]
+    cmd.extend(log_args)
+
+    if author:
+        cmd.append(f"--author={author}")
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
 
     if result.returncode != 0:
         err = result.stderr.strip() or result.stdout.strip()
@@ -448,7 +514,10 @@ def _parse_graph_line(line: str) -> tuple[str, str]:
 
 
 def get_branch_tree(
-    repo_path: str, branch: str | None = None, limit: int = 20
+    repo_path: str,
+    branch: str | None = None,
+    limit: int = 20,
+    author: str | None = None,
 ) -> List[Dict[str, Any]]:
     """Get branch tree data for visualization.
 
@@ -456,10 +525,11 @@ def get_branch_tree(
         repo_path: Path to git repository.
         branch: Optional branch name to filter by.
         limit: Maximum number of commits to return.
+        author: Optional author to filter by.
 
     Returns:
         List of dicts with keys: hash, message, date, branches, graph_line.
-        Connector-only rows (/, \\ lines) are included with an empty hash
+        Connector-only rows (/, \ lines) are included with an empty hash
         so the renderer can display branch split/merge lines correctly.
     """
     _validate_path(repo_path)
@@ -467,7 +537,11 @@ def get_branch_tree(
     if branch:
         _validate_branch(branch)
 
-    log_args = _build_log_args(branch, repo_path)
+    if author:
+        _validate_author(author)
+
+    default_branch = get_default_branch(repo_path) if branch else None
+    log_args = _build_log_args(branch, repo_path, default_branch)
 
     cmd = (
         [
@@ -483,6 +557,9 @@ def get_branch_tree(
         + [f"-{limit}"]
     )
 
+    if author:
+        cmd.append(f"--author={author}")
+
     result = subprocess.run(cmd, capture_output=True, text=True)
     if result.returncode != 0:
         return []

{git_ember-1.2.1 → git_ember-1.3.0}/src/gitember/render.py

@@ -5,9 +5,61 @@ from typing import Any, Dict, List, Optional
 from gitember.colors import RESET, LIGHT_GRAY, ColorScheme
 
 
+__all__ = [
+    "render_grid",
+    "render_branch_tree",
+    "calculate_thresholds",
+    "render_legend",
+    "choose_level",
+    "build_date_range",
+    "DEFAULT_THRESHOLDS",
+]
+
+
 DEFAULT_THRESHOLDS = (0, 1, 3, 6, 10)
 
 
+def render_legend(
+    thresholds: tuple, color_scheme: ColorScheme, ascii_mode: bool = False
+) -> str:
+    """Render a legend row showing all intensity levels.
+
+    Args:
+        thresholds: Tuple of 5 threshold values.
+        color_scheme: Color scheme for the blocks.
+        ascii_mode: Use ASCII characters instead of Unicode.
+
+    Returns:
+        Single string with legend, no trailing newline.
+    """
+    if ascii_mode:
+        block_chars = ["  ", "..", "::", "==", "##"]
+    else:
+        block_chars = ["  ", "░░", "▒▒", "▓▓", "██"]
+
+    parts = []
+
+    t = thresholds
+    parts.append(f"{color_scheme.get(0)}No commits{RESET}")
+
+    if t[1] != t[2]:
+        label = f"{t[1]}-{t[2]}"
+        parts.append(f"{color_scheme.get(1)}{block_chars[1]}{label}{RESET}")
+
+    if t[2] != t[3]:
+        label = f"{t[3] + 1}-{t[4]}"
+        parts.append(f"{color_scheme.get(2)}{block_chars[2]}{label}{RESET}")
+
+    if t[3] != t[4]:
+        label = f"{t[4] + 1}+"
+        parts.append(f"{color_scheme.get(3)}{block_chars[3]}{label}{RESET}")
+
+    label = f"{t[4] + 1}+"
+    parts.append(f"{color_scheme.get(4)}{block_chars[4]}{label}{RESET}")
+
+    return " ".join(parts)
+
+
 def calculate_thresholds(counts: Dict[dt.date, int], mode: str = "auto") -> tuple:
     """Calculate intensity thresholds based on scaling mode.
 
@@ -200,7 +252,7 @@ def render_branch_tree(
     commits: List[Dict[str, Any]],
     default_branch: Optional[str] = None,
     selected_branch: Optional[str] = None,
-    color_scheme: Optional["ColorScheme"] = None,
+    color_scheme: Optional[ColorScheme] = None,
     ascii_mode: bool = False,
     compact: bool = False,
 ) -> str:

git_ember-1.3.0/tests/test_config.py

@@ -0,0 +1,62 @@
+import datetime as dt
+from pathlib import Path
+
+import pytest
+
+from gitember import config, git
+
+
+def test_load_config_defaults(tmp_path, monkeypatch):
+    """When no config file exists, returns dict with color and border keys."""
+    monkeypatch.setattr(
+        config, "config_file_path", lambda: tmp_path / "nonexistent.toml"
+    )
+    result = config.load_config()
+    assert "color" in result
+    assert "border" in result
+    assert result["color"] == "green"
+    assert result["border"] == "="
+
+
+def test_save_and_load_roundtrip(tmp_path, monkeypatch):
+    """Saving a config dict and loading it back returns the same values."""
+    test_file = tmp_path / "config.toml"
+    monkeypatch.setattr(config, "config_file_path", lambda: test_file)
+
+    config.save_config({"color": "blue", "border": "*", "week_start": "monday"})
+    result = config.load_config()
+
+    assert result["color"] == "blue"
+    assert result["border"] == "*"
+    assert result["week_start"] == "monday"
+
+
+def test_load_config_ignores_unknown_keys(tmp_path, monkeypatch):
+    """A config file containing an unknown key does not include it in the returned dict."""
+    test_file = tmp_path / "config.toml"
+    monkeypatch.setattr(config, "config_file_path", lambda: test_file)
+
+    test_file.write_text('color = "blue"\nbadkey = "value"\n')
+    result = config.load_config()
+
+    assert "badkey" not in result
+    assert result["color"] == "blue"
+
+
+def test_save_config_only_writes_allowed_keys(tmp_path, monkeypatch):
+    """Passing a dict with an extra key does not write that key to disk."""
+    test_file = tmp_path / "config.toml"
+    monkeypatch.setattr(config, "config_file_path", lambda: test_file)
+
+    config.save_config({"color": "blue", "secret": "password"})
+    content = test_file.read_text()
+
+    assert "secret" not in content
+    assert "color" in content
+
+
+def test_config_file_path_returns_path():
+    """Returns a Path object ending in config.toml."""
+    result = config.config_file_path()
+    assert isinstance(result, Path)
+    assert result.name == "config.toml"

git_ember-1.3.0/tests/test_git.py

@@ -0,0 +1,94 @@
+import datetime as dt
+
+import pytest
+
+from gitember import git
+
+
+def test_run_git_log_empty_repo(repo):
+    """Returns empty dict when no commits exist in range."""
+    result = git.run_git_log(
+        dt.date(2024, 1, 1),
+        dt.date(2024, 12, 31),
+        str(repo),
+    )
+    assert result == {}
+
+
+def test_run_git_log_counts_commits(repo_with_commits):
+    """Returns non-empty dict when commits exist in date range."""
+    result = git.run_git_log(
+        dt.date(2024, 1, 1),
+        dt.date(2024, 12, 31),
+        str(repo_with_commits),
+    )
+    assert len(result) > 0
+
+
+def test_run_git_log_invalid_path(tmp_path):
+    """Raises ValueError for a non-git directory."""
+    with pytest.raises(ValueError):
+        git.run_git_log(
+            dt.date(2024, 1, 1),
+            dt.date(2024, 12, 31),
+            str(tmp_path),
+        )
+
+
+def test_get_branches_returns_list(repo):
+    """Returns a list of branches, possibly empty for fresh repos."""
+    result = git.get_branches(str(repo))
+    assert isinstance(result, list)
+
+
+def test_get_default_branch(repo):
+    """Returns a non-empty string for a valid repo."""
+    result = git.get_default_branch(str(repo))
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+def test_get_streaks_empty():
+    """Empty dict returns all zeros."""
+    result = git.get_streaks({})
+    assert result["current_streak"] == 0
+    assert result["longest_streak"] == 0
+
+
+def test_get_streaks_consecutive():
+    """3 consecutive days with commits returns current_streak or longest_streak >= 3."""
+    counts = {
+        dt.date(2024, 1, 1): 1,
+        dt.date(2024, 1, 2): 1,
+        dt.date(2024, 1, 3): 1,
+    }
+    result = git.get_streaks(counts)
+    assert result["current_streak"] >= 3 or result["longest_streak"] >= 3
+
+
+def test_get_streaks_gap_resets():
+    """A gap in dates resets the streak count."""
+    counts = {
+        dt.date(2024, 1, 1): 1,
+        dt.date(2024, 1, 2): 1,
+        dt.date(2024, 1, 4): 1,
+    }
+    result = git.get_streaks(counts)
+    assert result["longest_streak"] == 2
+    assert result["current_streak"] == 0
+
+
+def test_get_top_contributors_ordering(repo_with_commits):
+    """Author with more commits appears first."""
+    result = git.get_top_contributors(str(repo_with_commits))
+    assert len(result) >= 2
+    assert result[0][1] >= result[1][1]
+
+
+def test_get_repo_stats_keys(repo_with_commits):
+    """Returned dict contains all expected keys."""
+    result = git.get_repo_stats(str(repo_with_commits))
+    assert "total_commits" in result
+    assert "num_authors" in result
+    assert "first_commit_date" in result
+    assert "last_commit_date" in result

git_ember-1.3.0/tests/test_render.py

@@ -0,0 +1,158 @@
+import datetime as dt
+
+from gitember import render
+from gitember.colors import ColorScheme
+
+
+def test_choose_level_zero():
+    """Count of 0 always returns level 0."""
+    for count in [0]:
+        level = render.choose_level(count, (0, 1, 3, 6, 10))
+        assert level == 0
+
+
+def test_choose_level_boundaries():
+    """Counts at each threshold boundary map to the correct level."""
+    thresholds = (0, 2, 5, 8, 12)
+    assert render.choose_level(0, thresholds) == 0
+    assert render.choose_level(1, thresholds) == 1
+    assert render.choose_level(2, thresholds) == 1
+    assert render.choose_level(3, thresholds) == 2
+    assert render.choose_level(5, thresholds) == 2
+    assert render.choose_level(6, thresholds) == 3
+    assert render.choose_level(8, thresholds) == 3
+    assert render.choose_level(9, thresholds) == 4
+    assert render.choose_level(12, thresholds) == 4
+    assert render.choose_level(100, thresholds) == 4
+
+
+def test_choose_level_max():
+    """A very large count returns level 4."""
+    level = render.choose_level(10000, (0, 1, 3, 6, 10))
+    assert level == 4
+
+
+def test_build_date_range_single_day():
+    """Start == end returns a list of one date."""
+    date = dt.date(2024, 1, 1)
+    result = render.build_date_range(date, date)
+    assert len(result) == 1
+    assert result[0] == date
+
+
+def test_build_date_range_span():
+    """Correct number of days returned for a known range."""
+    start = dt.date(2024, 1, 1)
+    end = dt.date(2024, 1, 10)
+    result = render.build_date_range(start, end)
+    assert len(result) == 10
+
+
+def test_build_date_range_order():
+    """Dates are in ascending order."""
+    start = dt.date(2024, 1, 5)
+    end = dt.date(2024, 1, 10)
+    result = render.build_date_range(start, end)
+    for i in range(len(result) - 1):
+        assert result[i] < result[i + 1]
+
+
+def test_calculate_thresholds_auto():
+    """Verify the 5 returned values are non-decreasing and first value is 0."""
+    counts = {dt.date(2024, 1, i): i % 10 for i in range(1, 30)}
+    result = render.calculate_thresholds(counts, mode="auto")
+    assert len(result) == 5
+    assert result[0] == 0
+    for i in range(1, 5):
+        assert result[i] >= result[i - 1]
+
+
+def test_calculate_thresholds_adaptive():
+    """Same monotonicity check with a realistic counts dict."""
+    counts = {
+        dt.date(2024, 1, 1): 0,
+        dt.date(2024, 1, 2): 1,
+        dt.date(2024, 1, 3): 2,
+        dt.date(2024, 1, 4): 5,
+        dt.date(2024, 1, 5): 10,
+    }
+    result = render.calculate_thresholds(counts, mode="adaptive")
+    assert len(result) == 5
+    assert result[0] == 0
+    for i in range(1, 5):
+        assert result[i] >= result[i - 1]
+
+
+def test_calculate_thresholds_empty():
+    """Empty counts dict does not raise and returns a valid 5-tuple."""
+    result = render.calculate_thresholds({}, mode="auto")
+    assert len(result) == 5
+    assert result[0] == 0
+
+
+def test_render_legend_skips_duplicate_thresholds():
+    """When two adjacent threshold values are equal, that level does not appear."""
+    thresholds = (0, 1, 1, 1, 5)
+    scheme = ColorScheme("test", [""] * 5)
+    legend = render.render_legend(thresholds, scheme, ascii_mode=True)
+    assert "2-1" not in legend
+    assert "1-1" not in legend
+
+
+def test_render_legend_contains_all_levels():
+    """With well-spread thresholds, all 4 block levels appear in the output."""
+    thresholds = (0, 2, 5, 10, 20)
+    scheme = ColorScheme("test", [""] * 5)
+    legend = render.render_legend(thresholds, scheme, ascii_mode=True)
+    assert ".." in legend
+    assert "::" in legend
+    assert "==" in legend
+    assert "##" in legend
+
+
+def test_render_grid_returns_string():
+    """Smoke test that render_grid returns a non-empty string for a small date range."""
+    counts = {dt.date(2024, 1, 1): 0, dt.date(2024, 1, 2): 1}
+    scheme = ColorScheme("green", [""] * 5)
+    result = render.render_grid(
+        dt.date(2024, 1, 1),
+        dt.date(2024, 1, 7),
+        counts,
+        scheme,
+        "sunday",
+        "=",
+        False,
+    )
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+def test_render_grid_month_labels():
+    """Output contains at least one 3-letter month abbreviation."""
+    counts = {dt.date(2024, 6, 15): 1}
+    scheme = ColorScheme("green", [""] * 5)
+    result = render.render_grid(
+        dt.date(2024, 6, 1),
+        dt.date(2024, 6, 30),
+        counts,
+        scheme,
+        "sunday",
+        "=",
+        False,
+    )
+    months = [
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec",
+    ]
+    has_month = any(m in result for m in months)
+    assert has_month, "Expected at least one month label in output"