ignorante 0.1.0__tar.gz

ignorante-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jasper van Merle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ignorante-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: ignorante
+Version: 0.1.0
+Summary: CLI to generate .gitignore files by combining templates from github/gitignore, interactively or by name
+Keywords: gitignore,cli
+Author: Jasper van Merle
+Author-email: Jasper van Merle <jaspervmerle@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: platformdirs>=4.10.1
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: typer>=0.27.0
+Requires-Python: >=3.12

ignorante-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "ignorante"
+version = "0.1.0"
+description = "CLI to generate .gitignore files by combining templates from github/gitignore, interactively or by name"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Jasper van Merle", email = "jaspervmerle@gmail.com" }]
+keywords = ["gitignore", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Version Control :: Git",
+    "Programming Language :: Python :: 3"
+]
+requires-python = ">=3.12"
+dependencies = [
+    "platformdirs>=4.10.1",
+    "questionary>=2.1.1",
+    "typer>=0.27.0",
+]
+
+[project.scripts]
+ignorante = "ignorante.__main__:main"
+
+[build-system]
+requires = ["uv_build>=0.11.30,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.22",
+    "ty>=0.0.61",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+extend-select = ["I"]

ignorante-0.1.0/src/ignorante/__init__.py

@@ -0,0 +1,5 @@
+import importlib.metadata
+
+IGNORANTE = "ignorante"
+
+__version__ = importlib.metadata.version(IGNORANTE)

ignorante-0.1.0/src/ignorante/__main__.py

@@ -0,0 +1,53 @@
+import sys
+from pathlib import Path
+from typing import Annotated
+
+from typer import Argument, Exit, Option, Typer
+
+from ignorante import __version__
+from ignorante.generate import generate_gitignore
+from ignorante.interactive import select_templates
+
+app = Typer(context_settings={"help_option_names": ["--help", "-h"]}, add_completion=False)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print(__version__)
+        raise Exit()
+
+
+@app.command()
+def cli(
+    templates: Annotated[
+        list[str] | None,
+        Argument(help="Names of gitignore templates to combine. Omit to select templates interactively."),
+    ] = None,
+    output: Annotated[
+        Path | None,
+        Option("-o", "--output", help="Write the generated .gitignore to this file instead of stdout."),
+    ] = None,
+    version: Annotated[
+        bool | None,
+        Option("-v", "--version", help="Print the version and exit.", callback=version_callback, is_eager=True),
+    ] = None,
+) -> None:
+    try:
+        names = templates if templates else select_templates()
+        content = generate_gitignore(names)
+    except (RuntimeError, ValueError) as error:
+        print(error, file=sys.stderr)
+        raise Exit(1) from error
+
+    if output is not None:
+        output.write_text(content)
+    else:
+        print(content, end="")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

ignorante-0.1.0/src/ignorante/generate.py

@@ -0,0 +1,27 @@
+from ignorante.templates import find_templates, sort_key
+
+
+def generate_gitignore(names: list[str]) -> str:
+    """Fetch and combine the given gitignore templates into a single file."""
+    if not names:
+        return ""
+
+    sorted_names = sorted((name.strip().lower() for name in names), key=sort_key)
+
+    templates = find_templates()
+    name_by_lower_name = {name.lower(): name for name in templates}
+
+    sections = []
+    for lower_name in sorted_names:
+        name = name_by_lower_name.get(lower_name)
+
+        if name is None:
+            raise ValueError(f"Unknown gitignore template: {lower_name!r}")
+
+        sections.append(f"### {name} ###\n{templates[name].read_text().strip()}")
+
+    command = f"uvx ignorante {' '.join(sorted_names)}"
+    header = f"# Created with https://github.com/jmerle/ignorante\n# Update by running `{command}`"
+    footer = f"# End of `{command}`"
+
+    return "\n\n".join([header, *sections, footer]) + "\n"

ignorante-0.1.0/src/ignorante/interactive.py

@@ -0,0 +1,22 @@
+import questionary
+
+from ignorante.templates import find_templates, sort_key
+
+
+def select_templates() -> list[str]:
+    """Prompt the user to interactively select gitignore templates.
+
+    Returns the names of the selected templates, in their original casing.
+    """
+    names = sorted(find_templates(), key=sort_key)
+    selected = questionary.checkbox(
+        "Select gitignore templates to include",
+        choices=names,
+        use_jk_keys=False,
+        use_search_filter=True,
+    ).ask()
+
+    if selected is None:
+        raise RuntimeError("Aborted.")
+
+    return selected

ignorante-0.1.0/src/ignorante/repository.py

@@ -0,0 +1,48 @@
+import subprocess
+import time
+from pathlib import Path
+from shutil import which
+
+from platformdirs import user_cache_path
+
+from ignorante import IGNORANTE
+
+REPOSITORY_URL = "https://github.com/github/gitignore.git"
+UPDATE_INTERVAL = 60 * 60 * 24  # 1 day, in seconds
+
+
+def get_repository() -> Path:
+    """Return the root of a local, always up-to-date clone of github/gitignore.
+
+    The clone lives in the user's cache directory. It is created on first use
+    and pulled at most once a day on subsequent calls.
+    """
+    if which("git") is None:
+        raise RuntimeError("git is required by ignorante but was not found on PATH.")
+
+    repo_path = user_cache_path(IGNORANTE, ensure_exists=True) / "gitignore"
+
+    if not (repo_path / ".git").exists():
+        _run_git("clone", "--depth", "1", REPOSITORY_URL, str(repo_path))
+    elif _seconds_since_last_pull(repo_path) >= UPDATE_INTERVAL:
+        _run_git("pull", "--depth", "1", cwd=repo_path)
+
+    return repo_path
+
+
+def _seconds_since_last_pull(repo_path: Path) -> float:
+    # git touches .git/FETCH_HEAD on every fetch/pull, so its mtime doubles as a
+    # "last updated" timestamp without needing to persist one ourselves.
+    fetch_head = repo_path / ".git" / "FETCH_HEAD"
+
+    if not fetch_head.exists():
+        return float("inf")
+
+    return time.time() - fetch_head.stat().st_mtime
+
+
+def _run_git(*args: str, cwd: Path | None = None) -> None:
+    result = subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        raise RuntimeError(f"git {args[0]} failed: {result.stderr.strip()}")

ignorante-0.1.0/src/ignorante/templates.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from ignorante.repository import get_repository
+
+
+def find_templates() -> dict[str, Path]:
+    """Map every template name, in original casing, to its file.
+
+    e.g. "Python" -> repo/Python.gitignore, "Global/Linux" -> repo/Global/Linux.gitignore,
+    "community/Golang/Hugo" -> repo/community/Golang/Hugo.gitignore.
+    """
+    repo = get_repository()
+    return {path.relative_to(repo).with_suffix("").as_posix(): path for path in repo.rglob("*.gitignore")}
+
+
+def sort_key(name: str) -> tuple[int, str]:
+    """Sort key that groups root-level templates first, then Global/, then community/.
+
+    Each group is sorted lexicographically, case-insensitively, within itself.
+    """
+    group = {"global": 1, "community": 2}.get(name.split("/", 1)[0].lower(), 0)
+    return group, name.lower()