pygitweb 0.1.0__py3-none-any.whl

pygitweb/settings.schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "PyGitWeb runtime settings persisted to ~/.pygitweb/settings.json (or PYGITWEB_SETTINGS_CONFIG).",
+  "type": "object",
+  "properties": {
+    "PROJECTROOT": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Root filesystem path under which git repositories live."
+    },
+    "PROJECTS_LIST": {
+      "type": "string",
+      "description": "Path used for listing projects (often same as PROJECTROOT)."
+    },
+    "PROJECT_MAXDEPTH": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Maximum directory depth when scanning for projects."
+    },
+    "SITE_NAME": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Site name shown in the web interface."
+    },
+    "EXPORT_OK": {
+      "type": "string",
+      "description": "If set, only repos with this file (or matching path) are listed."
+    },
+    "LIST_ALL": {
+      "type": "boolean",
+      "description": "When true, list all directories under project root without export_ok checks."
+    },
+    "STRICT_EXPORT": {
+      "type": "boolean",
+      "description": "When true, require export_ok (or path match) to list projects."
+    },
+    "GIT": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Path to the git executable."
+    },
+    "MAXLOAD": {
+      "type": ["number", "null"],
+      "description": "Max load average; 503 when exceeded. null to disable."
+    },
+    "AUTH": {
+      "type": ["boolean", "null"],
+      "description": "When true, authentication is enabled. null means default-on with a warning on first run."
+    },
+    "AUTH_CONFIG": {
+      "type": "string",
+      "description": "Path to the auth JSON file. Empty uses ~/.pygitweb/auth.json."
+    },
+    "SETTINGS_CONFIG": {
+      "type": "string",
+      "description": "Path to this settings JSON file. Empty uses ~/.pygitweb/settings.json."
+    }
+  },
+  "required": [
+    "PROJECTROOT",
+    "PROJECTS_LIST",
+    "PROJECT_MAXDEPTH",
+    "SITE_NAME",
+    "EXPORT_OK",
+    "LIST_ALL",
+    "STRICT_EXPORT",
+    "GIT",
+    "MAXLOAD",
+    "AUTH",
+    "AUTH_CONFIG",
+    "SETTINGS_CONFIG"
+  ]
+}

pygitweb/settings_config.py

@@ -0,0 +1,122 @@
+"""
+PyGitWeb settings file: ~/.pygitweb/settings.json (or PYGITWEB_SETTINGS_CONFIG).
+
+On first run, loads from environment and writes the file. When the file exists,
+loads from JSON then applies explicit environment/.env overrides (with a warning).
+Changes via the settings UI or setattr persist back to the file.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+	from pygitweb.config import Settings
+
+DEFAULT_SETTINGS_CONFIG_PATH = Path.home() / ".pygitweb" / "settings.json"
+
+_persist_enabled = False
+_batch_update = False
+_active_path: Path | None = None
+_setattr_patched = False
+
+
+def settings_config_path() -> Path:
+	explicit = __import__("os").environ.get("PYGITWEB_SETTINGS_CONFIG", "").strip()
+	if explicit:
+		return Path(explicit).expanduser()
+	return DEFAULT_SETTINGS_CONFIG_PATH
+
+
+def write_settings_file(settings: Settings, path: Path | None = None) -> None:
+	target = path or _active_path or settings_config_path()
+	target.parent.mkdir(parents=True, exist_ok=True)
+	target.write_text(
+		json.dumps(settings.model_dump(mode="json"), indent=2) + "\n",
+		encoding="utf-8",
+	)
+
+
+def _warn_env_overrides(path: Path, fields: list[str]) -> None:
+	names = ", ".join(fields)
+	print(
+		f"WARNING: PyGitWeb: environment overrides settings file {path}\n         Overridden field(s): {names}\n",
+		file=sys.stderr,
+	)
+
+
+def _apply_env_overrides(base: Settings) -> list[str]:
+	from pygitweb.config import Settings
+
+	env_settings = Settings()
+	overrides: list[str] = []
+	for name in env_settings.model_fields_set:
+		env_val = getattr(env_settings, name)
+		if getattr(base, name) == env_val:
+			continue
+		setattr(base, name, env_val)
+		overrides.append(name)
+	return overrides
+
+
+def _patch_settings_setattr() -> None:
+	global _setattr_patched
+	if _setattr_patched:
+		return
+
+	from pygitweb.config import Settings
+
+	original = Settings.__setattr__
+
+	def _setattr(self: Settings, name: str, value: object) -> None:
+		original(self, name, value)
+		if not _persist_enabled or _batch_update:
+			return
+		if name not in Settings.model_fields:
+			return
+		write_settings_file(self)
+
+	Settings.__setattr__ = _setattr  # type: ignore[method-assign]
+	_setattr_patched = True
+
+
+def init_settings() -> Settings:
+	from pygitweb.config import Settings, _finalize_auth_settings
+
+	global _persist_enabled, _active_path
+
+	_persist_enabled = False
+	path = settings_config_path()
+	_active_path = path
+
+	if path.is_file():
+		settings = Settings.model_validate_json(path.read_text(encoding="utf-8"))
+		overrides = _apply_env_overrides(settings)
+		if overrides:
+			_warn_env_overrides(path, overrides)
+	else:
+		settings = Settings()
+
+	_finalize_auth_settings(settings)
+	write_settings_file(settings, path)
+	_patch_settings_setattr()
+	_persist_enabled = True
+	return settings
+
+
+@contextmanager
+def settings_batch_update(settings: Settings):
+	"""Apply multiple setting changes and persist once."""
+	global _batch_update
+
+	_batch_update = True
+	try:
+		yield
+	finally:
+		_batch_update = False
+		if _persist_enabled:
+			write_settings_file(settings)

pygitweb/settings_config_test.py

@@ -0,0 +1,101 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from pygitweb.config import Settings
+from pygitweb.settings_config import init_settings, settings_batch_update, write_settings_file
+
+
+@pytest.fixture
+def settings_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+	path = tmp_path / "settings.json"
+	monkeypatch.setenv("PYGITWEB_SETTINGS_CONFIG", str(path))
+	monkeypatch.setenv("PYGITWEB_AUTH", "0")
+	return path
+
+
+def test_creates_settings_file_from_environment(settings_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+	monkeypatch.setenv("PYGITWEB_SITE_NAME", "FromEnv")
+	settings = init_settings()
+	assert settings_path.is_file()
+	data = json.loads(settings_path.read_text(encoding="utf-8"))
+	assert data["SITE_NAME"] == "FromEnv"
+	assert settings.SITE_NAME == "FromEnv"
+
+
+def test_loads_existing_settings_file(settings_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+	settings_path.write_text(
+		json.dumps({
+			"PROJECTROOT": "/var/git",
+			"PROJECTS_LIST": "/var/git",
+			"PROJECT_MAXDEPTH": 2,
+			"SITE_NAME": "FromFile",
+			"EXPORT_OK": "",
+			"LIST_ALL": True,
+			"STRICT_EXPORT": False,
+			"GIT": "git",
+			"MAXLOAD": None,
+			"AUTH": False,
+			"AUTH_CONFIG": "",
+			"SETTINGS_CONFIG": "",
+		})
+		+ "\n",
+		encoding="utf-8",
+	)
+	monkeypatch.delenv("PYGITWEB_SITE_NAME", raising=False)
+	settings = init_settings()
+	assert settings.SITE_NAME == "FromFile"
+	assert settings.PROJECT_MAXDEPTH == 2
+
+
+def test_env_overrides_settings_file(settings_path: Path, monkeypatch: pytest.MonkeyPatch, capsys) -> None:
+	settings_path.write_text(
+		json.dumps({
+			"PROJECTROOT": "/var/git",
+			"PROJECTS_LIST": "/var/git",
+			"PROJECT_MAXDEPTH": 1,
+			"SITE_NAME": "FromFile",
+			"EXPORT_OK": "",
+			"LIST_ALL": True,
+			"STRICT_EXPORT": False,
+			"GIT": "git",
+			"MAXLOAD": None,
+			"AUTH": False,
+			"AUTH_CONFIG": "",
+			"SETTINGS_CONFIG": "",
+		})
+		+ "\n",
+		encoding="utf-8",
+	)
+	monkeypatch.setenv("PYGITWEB_SITE_NAME", "FromEnv")
+	settings = init_settings()
+	assert settings.SITE_NAME == "FromEnv"
+	assert json.loads(settings_path.read_text(encoding="utf-8"))["SITE_NAME"] == "FromEnv"
+	err = capsys.readouterr().err
+	assert "environment overrides settings file" in err
+	assert "SITE_NAME" in err
+
+
+def test_setattr_persists_to_file(settings_path: Path) -> None:
+	settings = init_settings()
+	settings.SITE_NAME = "Updated"
+	assert json.loads(settings_path.read_text(encoding="utf-8"))["SITE_NAME"] == "Updated"
+
+
+def test_batch_update_persists_once(settings_path: Path) -> None:
+	settings = init_settings()
+	with settings_batch_update(settings):
+		settings.SITE_NAME = "BatchOne"
+		settings.GIT = "/usr/bin/git"
+	data = json.loads(settings_path.read_text(encoding="utf-8"))
+	assert data["SITE_NAME"] == "BatchOne"
+	assert data["GIT"] == "/usr/bin/git"
+
+
+def test_write_settings_file_roundtrip(settings_path: Path) -> None:
+	settings = Settings(AUTH=False, SITE_NAME="Roundtrip")
+	write_settings_file(settings, settings_path)
+	loaded = Settings.model_validate_json(settings_path.read_text(encoding="utf-8"))
+	assert loaded.SITE_NAME == "Roundtrip"
+	assert loaded.AUTH is False

pygitweb/settings_permissions_test.py

@@ -0,0 +1,76 @@
+from collections.abc import Generator
+from unittest.mock import patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+from pygitweb.auth_config import AuthConfig, LocalUser
+from pygitweb.main import app
+from pygitweb.permissions import PERMISSION_SETTINGS, PermissionsMap
+
+_SETTINGS_AUTH = AuthConfig(
+	auth_mode="local",
+	local_users=[LocalUser(user="admin", password="secret"), LocalUser(user="viewer", password="secret")],
+	oauth_permissions=PermissionsMap.model_validate({
+		"*": [],
+		PERMISSION_SETTINGS: ["admin"],
+	}),
+)
+
+
+@pytest.fixture
+def client() -> Generator[TestClient, None, None]:
+	with TestClient(app) as c:
+		yield c
+
+
+@pytest.fixture
+def settings_auth() -> Generator[AuthConfig, None, None]:
+	with (
+		patch("pygitweb.auth_config.auth_config", _SETTINGS_AUTH),
+		patch("pygitweb.auth.auth_config", _SETTINGS_AUTH),
+		patch("pygitweb.main.auth_config", _SETTINGS_AUTH),
+	):
+		yield _SETTINGS_AUTH
+
+
+def _login(client: TestClient, username: str) -> None:
+	client.post(
+		"/login",
+		data={"username": username, "password": "secret", "next": "/"},
+		follow_redirects=False,
+	)
+
+
+def test_settings_open_when_auth_disabled(client: TestClient) -> None:
+	from pygitweb.config import settings
+
+	with patch.object(settings, "AUTH", False):
+		r = client.get("/settings/pygitweb")
+	assert r.status_code == 200
+
+
+def test_settings_forbidden_without_login(client: TestClient, settings_auth: AuthConfig) -> None:
+	from pygitweb.config import settings
+
+	with patch.object(settings, "AUTH", True):
+		r = client.get("/settings/pygitweb")
+	assert r.status_code == 401
+
+
+def test_settings_allowed_with_grant(client: TestClient, settings_auth: AuthConfig) -> None:
+	from pygitweb.config import settings
+
+	with patch.object(settings, "AUTH", True):
+		_login(client, "admin")
+		r = client.get("/settings/pygitweb")
+	assert r.status_code == 200
+
+
+def test_settings_forbidden_without_grant(client: TestClient, settings_auth: AuthConfig) -> None:
+	from pygitweb.config import settings
+
+	with patch.object(settings, "AUTH", True):
+		_login(client, "viewer")
+		r = client.get("/settings/pygit2")
+	assert r.status_code == 403

pygitweb/static/blob-view.js

@@ -0,0 +1,133 @@
+(function(){
+  var el = document.getElementById('Highlight-script');
+  function run() {
+    var code = document.querySelector('.blob-content code');
+    if (code && typeof hljs !== 'undefined') hljs.highlightElement(code);
+    applyBlobLineSelection();
+  }
+  function parseLinesParam() {
+    var params = new URLSearchParams(window.location.search);
+    var s = params.get('lines');
+    if (!s) return [];
+    var re = /L(\d+)(?:C(\d+))?(?:-L(\d+)(?:C(\d+))?)?/g;
+    var ranges = [];
+    var m;
+    while ((m = re.exec(s)) !== null) {
+      var startLine = parseInt(m[1], 10);
+      var startCol = m[2] ? parseInt(m[2], 10) : null;
+      var endLine = m[3] !== undefined ? parseInt(m[3], 10) : null;
+      var endCol = m[4] ? parseInt(m[4], 10) : null;
+      ranges.push({ startLine: startLine, startCol: startCol, endLine: endLine, endCol: endCol });
+    }
+    return ranges;
+  }
+  function wrapCodeInLineSpans(code) {
+    var lines = [];
+    var current = [];
+    function flushLine() {
+      if (current.length) {
+        lines.push(current);
+        current = [];
+      }
+    }
+    var nodes = Array.from(code.childNodes);
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+      if (node.nodeType === Node.TEXT_NODE) {
+        var parts = node.textContent.split('\n');
+        for (var j = 0; j < parts.length; j++) {
+          if (j > 0) flushLine();
+          current.push(parts[j]);
+        }
+      } else {
+        current.push(node);
+      }
+    }
+    flushLine();
+    code.replaceChildren();
+    for (var i = 0; i < lines.length; i++) {
+      var span = document.createElement('span');
+      span.setAttribute('data-line', String(i + 1));
+      for (var k = 0; k < lines[i].length; k++) {
+        var item = lines[i][k];
+        if (typeof item === 'string') {
+          span.appendChild(document.createTextNode(item));
+        } else {
+          span.appendChild(item);
+        }
+      }
+      code.appendChild(span);
+      if (i < lines.length - 1) code.appendChild(document.createTextNode('\n'));
+    }
+    return code.querySelectorAll('[data-line]');
+  }
+  function wrapCharacterRangeInSpan(lineSpan, startChar, endChar) {
+    startChar = Math.max(0, startChar);
+    var len = lineSpan.textContent.length;
+    endChar = endChar == null ? len : Math.min(len, endChar);
+    if (startChar >= endChar) return;
+    var walker = document.createTreeWalker(lineSpan, NodeFilter.SHOW_TEXT);
+    var charIdx = 0;
+    var startNode = null, startOff = 0, endNode = null, endOff = 0;
+    var n;
+    while ((n = walker.nextNode())) {
+      var nLen = n.length;
+      if (startNode == null && charIdx + nLen > startChar) {
+        startNode = n;
+        startOff = startChar - charIdx;
+      }
+      if (endNode == null && charIdx + nLen >= endChar) {
+        endNode = n;
+        endOff = endChar - charIdx;
+        break;
+      }
+      charIdx += nLen;
+    }
+    if (!startNode || !endNode) return;
+    try {
+      var range = document.createRange();
+      range.setStart(startNode, startOff);
+      range.setEnd(endNode, endOff);
+      var span = document.createElement('span');
+      span.className = 'blob-selection';
+      range.surroundContents(span);
+    } catch (e) {}
+  }
+  function applyBlobLineSelection() {
+    var code = document.querySelector('.blob-content code');
+    if (!code) return;
+    var ranges = parseLinesParam();
+    if (!ranges.length) return;
+    var lineSpans = wrapCodeInLineSpans(code);
+    var firstTarget = null;
+    for (var r = 0; r < ranges.length; r++) {
+      var range = ranges[r];
+      var startLine = range.startLine;
+      var startCol = range.startCol;
+      var endLine = range.endLine != null ? range.endLine : startLine;
+      var endCol = range.endCol;
+      for (var i = startLine; i <= endLine; i++) {
+        var span = code.querySelector('[data-line="' + i + '"]');
+        if (!span) continue;
+        if (firstTarget === null) firstTarget = span;
+        var lineLen = span.textContent.length;
+        var startCh = (i === startLine && startCol != null) ? startCol - 1 : 0;
+        var endCh = (i === endLine && endCol != null) ? endCol : lineLen;
+        if (startCh === 0 && endCh >= lineLen) {
+          span.classList.add('blob-line-selected');
+        } else {
+          wrapCharacterRangeInSpan(span, startCh, endCh);
+        }
+      }
+    }
+    if (firstTarget) {
+      firstTarget.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
+    }
+  }
+  if (el) {
+    if (el.getAttribute('data-loaded')) run();
+    else el.addEventListener('load', function(){ el.setAttribute('data-loaded','1'); run(); });
+  } else {
+    run();
+  }
+})();