gitlatex 2.0.1__tar.gz → 2.1.0__tar.gz

{gitlatex-2.0.1/gitlatex.egg-info → gitlatex-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitlatex
-Version: 2.0.1
+Version: 2.1.0
 Summary: A simple UI for LaTeX projects with Git support. Clone repos, edit, compile, and push.
 License-Expression: ISC
 Project-URL: Homepage, https://github.com/abdussamiakanda/gitlatex
@@ -261,7 +261,11 @@ An Overleaf-style review panel for leaving comments on your text.
 - **Shared through Git.** Each thread is a small JSON file in
   `.gitlatex/comments/` inside the project, so comments are pushed and pulled
   with your files. Each thread has its own file, so two people starting threads
-  at the same time won't get merge conflicts.
+  at the same time won't get merge conflicts, and replies made on both sides of
+  a pull are combined automatically (the app registers a git merge driver for
+  these files, so this also works for `git pull` in a terminal).
+  See [docs/sync-and-conflicts.md](docs/sync-and-conflicts.md) for how push,
+  pull and conflicts are handled.
 - Comments **stay attached to their text** as you edit, find it again after a
   pull, and follow a file when you rename it. Deleting a file removes its
   comments.

{gitlatex-2.0.1 → gitlatex-2.1.0}/README.md

@@ -233,7 +233,11 @@ An Overleaf-style review panel for leaving comments on your text.
 - **Shared through Git.** Each thread is a small JSON file in
   `.gitlatex/comments/` inside the project, so comments are pushed and pulled
   with your files. Each thread has its own file, so two people starting threads
-  at the same time won't get merge conflicts.
+  at the same time won't get merge conflicts, and replies made on both sides of
+  a pull are combined automatically (the app registers a git merge driver for
+  these files, so this also works for `git pull` in a terminal).
+  See [docs/sync-and-conflicts.md](docs/sync-and-conflicts.md) for how push,
+  pull and conflicts are handled.
 - Comments **stay attached to their text** as you edit, find it again after a
   pull, and follow a file when you rename it. Deleting a file removes its
   comments.

gitlatex-2.1.0/docs/sync-and-conflicts.md

@@ -0,0 +1,206 @@
+# Syncing with coauthors: push, pull and conflicts
+
+gitlatex projects are shared through Git, so two people working at once
+eventually change the same thing. This page covers what the app does
+automatically when that happens, what it reports when it can't, and how to fix
+the rest by hand.
+
+- **Push** commits everything and uploads it. If a coauthor pushed first, the
+  app pulls their commits in, puts yours on top, and pushes again.
+- **Pull** downloads the remote's commits and rebases your unpushed commits on
+  top of them. Uncommitted edits are set aside and put back afterwards.
+- **Review comments** replied to on both sides are combined, never conflicted.
+- **A real conflict** (both of you changed the same lines of a `.tex` file) is
+  never left half-done: the app undoes the pull, puts the project back as it
+  was, and lists the files involved.
+
+The code lives in `gitlatex/routes/git.py` (push and pull),
+`gitlatex/services/comments.py` and `gitlatex/services/comments_merge.py`
+(review comment threads). Tests are in `tests/test_sync.py`.
+
+## Two people, one remote
+
+Alice commits but doesn't push. Meanwhile Bob pushes:
+
+```
+remote:  X ── B
+Alice:   X ── A      (committed, not pushed)
+```
+
+Alice's push can't simply go through: it would throw away Bob's commit, so Git
+rejects it (`[rejected] (fetch first)`). Nothing is lost; Alice has to take
+Bob's commit first.
+
+### What Push does
+
+1. Stages and commits everything (`git add -A`, then commit with your message).
+2. Pushes. If the remote rejects it because it has newer commits:
+3. Pulls with rebase (see below), so the history becomes `X ── B ── A`.
+4. Pushes again.
+
+When the two of you changed different parts of the project, one click does
+all of it. The toast says *"Your coauthors' newer changes were pulled in
+first"*, and the editor reloads the files that changed.
+
+If step 3 hits a real conflict, the push stops with **409** and a message like:
+
+> Could not push: someone else pushed changes to the same lines first. Changed
+> on both sides: main.tex. Your commit is saved here but not pushed yet.
+
+Your commit stays in your local history, and the project is exactly as it was
+before you pressed Push.
+
+If someone pushes again between steps 3 and 4, the push stops with *"the
+remote changed again while pushing. Try again."*
+
+### What Pull does
+
+Pull runs `git pull --rebase --autostash`:
+
+- **`--rebase`**: your unpushed commits go on top of the remote's, with no
+  "Merge branch …" commit every time two people work at once.
+- **`--autostash`**: uncommitted edits are set aside before the pull and put
+  back afterwards.
+
+A pull is always either finished or fully undone, never left half-merged:
+
+| Situation | Result |
+| --- | --- |
+| Different lines changed | Pulled. Your commits sit on top of the remote's. |
+| Same lines changed in **commits** | Rebase aborted. 409 listing the files. |
+| Same lines changed by **uncommitted** edits | Pull undone and your edits restored. 409 listing the files. |
+| Only build output conflicts (`main.pdf`, `main.synctex.gz`, `.aux`, …) | Your copy is kept and the pull finishes. The next compile rewrites it anyway. |
+| Review comment threads changed on both sides | Merged automatically (see below). |
+
+## Review comments
+
+Each review thread is one JSON file in `.gitlatex/comments/<id>.json`, and a
+reply appends to that file's `messages` list. So if Alice and Bob both reply to
+the same thread before syncing, both change the end of the same list, and a
+plain Git merge always conflicts there.
+
+### The merge driver
+
+`gitlatex/services/comments_merge.py` is a
+[Git merge driver](https://git-scm.com/docs/gitattributes#_defining_a_custom_merge_driver):
+Git runs it instead of its usual line-by-line merge whenever both sides changed
+the same thread file. It merges the fields like this:
+
+| Field | Rule |
+| --- | --- |
+| `messages` | Union of both sides by `id`, sorted by `date`; the opening message stays first. A message in the common ancestor that one side no longer has was deleted there, so it stays deleted. |
+| `resolved`, `resolvedBy`, `resolvedAt` | Treated as one change. The side that changed it wins; if both did, the later `resolvedAt` wins. |
+| `range`, `quote`, `file` | The side that changed it wins, otherwise ours. The editor finds the text again from `quote` after a pull anyway. |
+| Anything that isn't valid JSON | The driver exits with 1 and Git falls back to a normal conflict. |
+
+### How it is registered
+
+`comments.install_merge_driver()` runs whenever a project is opened, selected
+or cloned, and before every pull. It writes two things, both inside the
+project's own `.git` folder, so nothing new shows up in the project's files or
+commits:
+
+```ini
+# .git/config
+[merge "gitlatex-comments"]
+    name = gitlatex review comment threads
+    driver = '/path/to/python' '/path/to/gitlatex/services/comments_merge.py' %O %A %B
+```
+
+```
+# .git/info/attributes
+.gitlatex/comments/*.json merge=gitlatex-comments
+```
+
+A merge driver is a command on one machine, so it can't be shared through the
+repository: each copy of the project sets up its own. Once registered, it also
+works for `git pull` and `git merge` in a terminal. If the app is moved or
+reinstalled, the next time a project is opened the command is updated.
+
+### Threads with conflict markers
+
+A thread file can still end up with `<<<<<<<` markers, for example from a merge
+made on a machine without the app. Such a file isn't valid JSON. It used to be
+skipped without a word, so the thread just disappeared from the panel. Now the
+panel shows a yellow card in its place, *"This thread has a merge conflict"*,
+with the path of the file. Renaming the commented file leaves the conflicted
+thread file untouched.
+
+## Fixing a conflict by hand
+
+The app has no screen for resolving conflicts in `.tex` files yet. When it
+reports one, open a terminal in the project folder:
+
+```sh
+git pull --rebase          # stops at the first conflict
+git status                 # lists the files marked "both modified"
+```
+
+In each file, choose what to keep between the markers, then delete the marker
+lines:
+
+```latex
+<<<<<<< HEAD
+Bob's version of the paragraph.
+=======
+Alice's version of the paragraph.
+>>>>>>> Alice's commit
+```
+
+During a rebase, the `HEAD` side is the remote (Bob), and the other side is
+your commit being replayed. Then:
+
+```sh
+git add main.tex
+git rebase --continue      # repeat for each stopped commit
+git push
+```
+
+`git rebase --abort` goes back to where you started at any point.
+
+**A conflicted comment thread** (only possible without the merge driver):
+merge the two `messages` lists, keeping every message from both sides in date
+order. Check the commas between entries and remove the marker lines. Take
+`range` and `quote` from either side.
+
+```json
+"messages": [
+  { "id": "a1…", "author": "Alice", "date": "2026-09-29T10:00:00", "text": "Is this right?" },
+  { "id": "b2…", "author": "Bob",   "date": "2026-09-29T11:00:00", "text": "Yes" },
+  { "id": "c3…", "author": "Alice", "date": "2026-09-29T11:05:00", "text": "Also check eq. 3" }
+]
+```
+
+## What changed
+
+Before these changes:
+
+- **Push reported success when the push was rejected.** GitPython reports a
+  rejected push in its result instead of raising, and the result wasn't
+  checked. The commit never reached the remote, and nobody was told.
+- **Pull failed when both sides had new commits**, with *"Need to specify how
+  to reconcile divergent branches"* (Git 2.27 and later, when `pull.rebase`
+  isn't set).
+- **Uncommitted edits on the same lines** as incoming changes left conflict
+  markers inside the `.tex` file, while the pull reported success.
+- **Replies on both sides of a comment thread** always conflicted, and the
+  thread then disappeared from the review panel.
+
+| File | Change |
+| --- | --- |
+| `gitlatex/routes/git.py` | `_push()` detects rejected pushes. `_pull_rebase()` pulls with rebase, keeps local build output, and undoes anything that conflicts. Push retries after pulling. Conflicts return 409 with a `conflicts` list. |
+| `gitlatex/services/comments_merge.py` | New: the merge driver for comment threads. |
+| `gitlatex/services/comments.py` | `install_merge_driver()`. Conflicted thread files are listed as placeholders instead of being skipped. |
+| `gitlatex/routes/repos.py`, `gitlatex/routes/workspace.py` | Register the merge driver when a project is opened, selected or cloned. |
+| `web/src/storage/server.ts`, `web/src/state/actions.ts` | Push reports `pulled`. The editor reloads and says so. |
+| `web/src/editor/review.ts`, `web/src/editor/review.css` | The merge-conflict card in the review panel. |
+| `tests/test_sync.py` | New: unit tests for the merge driver, and two-clone tests of push and pull through the app. |
+
+Run the tests with:
+
+```sh
+python3 -m unittest discover tests
+```
+
+The classic editor at `/classic` shows the new push and pull messages, but its
+review panel doesn't have the merge-conflict card.

{gitlatex-2.0.1 → gitlatex-2.1.0}/gitlatex/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.1'
-__version_tuple__ = version_tuple = (2, 0, 1)
+__version__ = version = '2.1.0'
+__version_tuple__ = version_tuple = (2, 1, 0)
 
-__commit_id__ = commit_id = 'ga0d651549'
+__commit_id__ = commit_id = 'g71d35ed41'

{gitlatex-2.0.1 → gitlatex-2.1.0}/gitlatex/routes/__init__.py

@@ -14,6 +14,7 @@ blueprint below - nothing else in the app needs to know about it.
     snippets      the user's own editor snippets
     review        comment threads on lines of project files
     git          push, pull, status, history and diffs
+    scm           the Source control panel: staging, conflicts, branches, publish
     workspace     the file API behind the editor UI in web/
     engine        the in-browser TeX engine and its package shelf
 
@@ -30,6 +31,7 @@ from gitlatex.routes import (
     projectindex,
     repos,
     review,
+    scm,
     snippets,
     spell,
     synctex,
@@ -48,6 +50,7 @@ BLUEPRINTS = (
     snippets.bp,
     review.bp,
     git.bp,
+    scm.bp,
     workspace.bp,
     engine.bp,
     pages.bp,

{gitlatex-2.0.1 → gitlatex-2.1.0}/gitlatex/routes/git.py

@@ -1,7 +1,6 @@
 """Git operations: push, pull, status, history and diffs."""
 
 import datetime
-import re
 import os
 
 from flask import Blueprint, jsonify, request
@@ -11,6 +10,7 @@ from gitlatex.http import with_project_lock
 from gitlatex.services.git_backend import NULL_TREE, GitCommandError, Repo
 from gitlatex.services.gitrepo import _blob_text, _close_repo, _numstat, _open_repo
 from gitlatex.services.paths import resolve_repo_path
+from gitlatex.services.sync import Conflict, clear_stale_build_outputs, pull_rebase, push_current
 
 bp = Blueprint("git", __name__)
 
@@ -41,9 +41,24 @@ def push():
                 repo.index.commit(message)
                 committed = True
                 print("Commit:", message)
-            repo.remotes.origin.push()
+            pulled = False
+            if not push_current(repo):
+                # Someone pushed first. Put our commits on top of theirs and
+                # try once more, so the common case needs no second click.
+                print("Push rejected; pulling first")
+                try:
+                    pull_rebase(repo)
+                except Conflict as c:
+                    return _conflict_response(c, committed,
+                                              "Could not push: someone else pushed changes to the same lines first.")
+                pulled = True
+                if not push_current(repo):
+                    return jsonify(
+                        error="Could not push: the remote changed again while pushing. Try again.",
+                        committed=committed, pulled=True,
+                    ), 409
             print("Pushed to origin")
-            return jsonify(success=True, committed=committed)
+            return jsonify(success=True, committed=committed, pulled=pulled)
         finally:
             if getattr(repo, "close", None):
                 try:
@@ -102,58 +117,16 @@ def _json_message():
     return message.strip() if isinstance(message, str) else ""
 
 
-# What TeX writes next to a document. Committed copies are common (people
-# commit main.pdf), and every compile rewrites them locally.
-_BUILD_OUTPUT = re.compile(
-    r"\.(synctex\.gz|synctex|aux|log|out|toc|lof|lot|fls|fdb_latexmk|bcf|run\.xml|blg|bbl|nav|snm|vrb|xdv)$",
-    re.IGNORECASE,
-)
-
-
-def _is_build_output(root, path):
-    if _BUILD_OUTPUT.search(path):
-        return True
-    # A PDF is build output only when it is a document's own PDF (main.pdf next
-    # to main.tex); figure PDFs are the user's files.
-    if path.lower().endswith(".pdf"):
-        return os.path.isfile(os.path.join(root, path[:-4] + ".tex"))
-    return False
-
-
-def _clear_stale_build_outputs(repo):
-    """Drop local build outputs that the incoming commits replace.
-
-    Compiling rewrites main.pdf (PDFs embed a timestamp) and writes
-    main.synctex.gz, so a project that commits them always looks modified, and
-    `git pull` refuses to overwrite them. They are regenerated by the next
-    compile anyway, so the remote's copies win. Only files the remote actually
-    changes are touched; the user's own edits are left to --autostash.
-    Returns the paths cleared.
-    """
-    try:
-        if not repo.remotes or repo.head.is_detached or repo.active_branch.tracking_branch() is None:
-            return []
-        repo.git.fetch("--quiet")
-        incoming = repo.git.diff("--name-only", "HEAD...@{u}").splitlines()
-    except (GitCommandError, TypeError, ValueError):
-        return []
-    root = repo.working_tree_dir
-    modified = set(repo.git.diff("--name-only").splitlines()) | set(repo.git.diff("--name-only", "--cached").splitlines())
-    untracked = set(repo.untracked_files)
-    cleared = []
-    for path in incoming:
-        if not _is_build_output(root, path):
-            continue
-        try:
-            if path in modified:
-                repo.git.checkout("HEAD", "--", path)
-                cleared.append(path)
-            elif path in untracked:
-                os.remove(os.path.join(root, path))
-                cleared.append(path)
-        except (GitCommandError, OSError) as e:
-            print("Could not clear", path, e)
-    return cleared
+def _conflict_response(conflict, committed, headline):
+    """409 for a pull that was undone because of conflicting edits."""
+    files = conflict.files
+    listed = ", ".join(files) if files else "some files"
+    kept = "Your commit is saved here but not pushed yet." if committed else "Nothing was changed on your side."
+    return jsonify(
+        error="%s Changed on both sides: %s. %s Resolve it in a terminal with `git pull --rebase`, "
+              "or agree with your coauthor which version to keep." % (headline, listed, kept),
+        conflicts=files, committed=committed,
+    ), 409
 
 
 @bp.route("/pull", methods=["POST"])
@@ -167,15 +140,11 @@ def pull():
         repo = Repo(state.current_repo_path)
         try:
             before = repo.head.commit.hexsha if repo.head.is_valid() else None
-            cleared = _clear_stale_build_outputs(repo)
-            # --autostash sets the user's own uncommitted edits aside and puts
-            # them back after the merge; older gits don't support it for merges.
+            cleared = clear_stale_build_outputs(repo)
             try:
-                output = repo.git.pull("--autostash")
-            except GitCommandError as e:
-                if "--autostash" not in str(e) and "autostash" not in str(e).lower():
-                    raise
-                output = repo.git.pull()
+                output = pull_rebase(repo)
+            except Conflict as c:
+                return _conflict_response(c, False, "Could not pull: you and the remote changed the same lines.")
             after = repo.head.commit.hexsha if repo.head.is_valid() else None
             print("Pulled from origin" + (" (replaced local build output: %s)" % ", ".join(cleared) if cleared else ""))
             return jsonify(success=True, output=output, changed=before != after, cleared=cleared)

{gitlatex-2.0.1 → gitlatex-2.1.0}/gitlatex/routes/repos.py

@@ -10,7 +10,7 @@ import sys
 from flask import Blueprint, jsonify
 
 from gitlatex import state
-from gitlatex.services import paths
+from gitlatex.services import comments, paths
 from gitlatex.services.git_backend import Repo, git_rmtree
 from gitlatex.http import _json
 from gitlatex.services.paths import count_files_in_dir, parse_owner_from_remote_url
@@ -194,6 +194,8 @@ def select_repo():
     state.current_repo_path = repo_path
     git_dir = os.path.join(repo_path, ".git")
     has_git = os.path.isdir(git_dir)
+    if has_git:
+        comments.install_merge_driver(repo_path)
     print("Selected repo:", name)
     return jsonify(success=True, hasGit=has_git)
 
@@ -212,6 +214,7 @@ def clone_repo():
     try:
         Repo.clone_from(repo_url, repo_path)
         print("Cloned", repo_name)
+        comments.install_merge_driver(repo_path)
         state.current_repo_path = repo_path
         return jsonify(success=True)
     except Exception as e:

gitlatex-2.1.0/gitlatex/routes/scm.py

@@ -0,0 +1,221 @@
+"""Source control API for the editor's Source control panel (services/scm.py).
+
+    GET  /api/scm/status            branch, upstream, ahead/behind, staged/changes/conflicts
+    POST /api/scm/stage             {paths?}   stage files (all when omitted)
+    POST /api/scm/unstage           {paths?}
+    POST /api/scm/discard           {paths}    drop working-tree changes
+    POST /api/scm/resolve           {path, side: current|incoming}
+    POST /api/scm/mark-resolved     {path}
+    POST /api/scm/abort             abort the merge / rebase in progress
+    POST /api/scm/commit            {message}
+    POST /api/scm/pull | push | sync | fetch
+    GET  /api/scm/branches          POST /api/scm/checkout {name, create?}
+    GET  /api/scm/publish-options   POST /api/scm/publish {url? | name?, private?}
+    GET  /api/scm/diff?path=&staged=1
+
+Pull and push rebase like /pull and /push (services/sync.py), but a real
+conflict is left in the files for the editor to resolve. Everything that
+changes files holds state.project_lock, like the editor's writes.
+"""
+
+import functools
+
+from flask import Blueprint, jsonify, request
+
+from gitlatex import state
+from gitlatex.http import _json, with_project_lock
+from gitlatex.services import scm
+from gitlatex.services.git_backend import GitCommandError, Repo
+from gitlatex.services.gitrepo import _close_repo
+
+bp = Blueprint("scm", __name__)
+
+
+def _git_error(e):
+    """The useful part of a failed git command: its stderr, without GitPython's framing."""
+    text = (getattr(e, "stderr", "") or str(e)).strip()
+    if text.startswith("stderr:"):
+        text = text[len("stderr:"):]
+    return text.strip().strip("'").strip() or str(e)
+
+
+def with_repo(view):
+    """Open the current project's repository, pass it in, and turn failures into JSON errors."""
+
+    @functools.wraps(view)
+    def wrapper(*args, **kwargs):
+        if not state.current_repo_path:
+            return jsonify(error="No project open"), 400
+        if Repo is None:
+            return jsonify(error="GitPython not installed"), 500
+        try:
+            repo = Repo(state.current_repo_path)
+        except Exception:
+            return jsonify(error="This project is not a Git repository."), 400
+        try:
+            return view(repo, *args, **kwargs)
+        except ValueError as e:
+            return jsonify(error=str(e)), 400
+        except GitCommandError as e:
+            return jsonify(error=_git_error(e)), 500
+        finally:
+            _close_repo(repo)
+
+    return wrapper
+
+
+def _paths():
+    paths = _json().get("paths")
+    return [p for p in paths if isinstance(p, str) and p] if isinstance(paths, list) else None
+
+
+def _ok(repo, **extra):
+    """Every change returns the fresh status, so the panel redraws from one response."""
+    return jsonify(success=True, status=scm.status(repo), **extra)
+
+
+@bp.route("/api/scm/status")
+@with_repo
+def get_status(repo):
+    return jsonify(scm.status(repo))
+
+
+@bp.route("/api/scm/stage", methods=["POST"])
+@with_project_lock
+@with_repo
+def stage(repo):
+    scm.stage(repo, _paths())
+    return _ok(repo)
+
+
+@bp.route("/api/scm/unstage", methods=["POST"])
+@with_project_lock
+@with_repo
+def unstage(repo):
+    scm.unstage(repo, _paths(), has_commits=scm.status(repo)["hasCommits"])
+    return _ok(repo)
+
+
+@bp.route("/api/scm/discard", methods=["POST"])
+@with_project_lock
+@with_repo
+def discard(repo):
+    paths = _paths()
+    if not paths:
+        raise ValueError("No files given")
+    scm.discard(repo, paths)
+    return _ok(repo)
+
+
+@bp.route("/api/scm/resolve", methods=["POST"])
+@with_project_lock
+@with_repo
+def resolve(repo):
+    data = _json()
+    side = data.get("side")
+    if side not in ("current", "incoming") or not data.get("path"):
+        raise ValueError("Give a path and side: current or incoming")
+    scm.take_side(repo, data["path"], side)
+    return _ok(repo)
+
+
+@bp.route("/api/scm/mark-resolved", methods=["POST"])
+@with_project_lock
+@with_repo
+def mark_resolved(repo):
+    path = _json().get("path")
+    if not path:
+        raise ValueError("No path given")
+    scm.mark_resolved(repo, path)
+    return _ok(repo)
+
+
+@bp.route("/api/scm/abort", methods=["POST"])
+@with_project_lock
+@with_repo
+def abort(repo):
+    scm.abort(repo)
+    return _ok(repo)
+
+
+@bp.route("/api/scm/commit", methods=["POST"])
+@with_project_lock
+@with_repo
+def commit(repo):
+    return _ok(repo, **scm.commit(repo, (_json().get("message") or "").strip()))
+
+
+@bp.route("/api/scm/pull", methods=["POST"])
+@with_project_lock
+@with_repo
+def pull(repo):
+    return _ok(repo, **scm.pull(repo))
+
+
+@bp.route("/api/scm/push", methods=["POST"])
+@with_project_lock
+@with_repo
+def push(repo):
+    return _ok(repo, **scm.push(repo))
+
+
+@bp.route("/api/scm/sync", methods=["POST"])
+@with_project_lock
+@with_repo
+def sync(repo):
+    """Pull, then push if the pull left nothing to resolve (VS Code's Sync Changes)."""
+    result = scm.pull(repo)
+    if not result["conflicts"] and scm.status(repo)["ahead"]:
+        pushed = scm.push(repo)
+        result = {**pushed, "cleared": result["cleared"] + pushed["cleared"]}
+    return _ok(repo, **result)
+
+
+@bp.route("/api/scm/fetch", methods=["POST"])
+@with_repo
+def fetch(repo):
+    if repo.remotes:
+        repo.git.fetch("--all", "--prune")
+    return _ok(repo)
+
+
+@bp.route("/api/scm/branches")
+@with_repo
+def branches(repo):
+    return jsonify(scm.branches(repo))
+
+
+@bp.route("/api/scm/checkout", methods=["POST"])
+@with_project_lock
+@with_repo
+def checkout(repo):
+    data = _json()
+    name = (data.get("name") or "").strip()
+    if not name:
+        raise ValueError("No branch name given")
+    scm.checkout(repo, name, create=bool(data.get("create")))
+    return _ok(repo)
+
+
+@bp.route("/api/scm/publish-options")
+def publish_options():
+    return jsonify(gh=scm.gh_ready())
+
+
+@bp.route("/api/scm/publish", methods=["POST"])
+@with_project_lock
+@with_repo
+def publish(repo):
+    data = _json()
+    url = (data.get("url") or "").strip() or None
+    output = scm.publish(repo, url=url, name=data.get("name"), private=data.get("private", True) is not False)
+    return _ok(repo, output=output)
+
+
+@bp.route("/api/scm/diff")
+@with_repo
+def diff(repo):
+    path = (request.args.get("path") or "").replace("\\", "/")
+    if not path:
+        raise ValueError("No path given")
+    return jsonify(scm.diff(repo, path, staged=request.args.get("staged") in ("1", "true")))

{gitlatex-2.0.1 → gitlatex-2.1.0}/gitlatex/routes/workspace.py

@@ -115,6 +115,8 @@ def open_project():
     state.current_repo_path = full
     files, folders = _read_project(full)
     has_git = os.path.isdir(os.path.join(full, ".git"))
+    if has_git:
+        comments.install_merge_driver(full)
     print("Opened project:", os.path.basename(full))
     return jsonify(name=os.path.basename(full), hasGit=has_git, files=files, folders=folders)