This commit is contained in:
338
src/main/java/com/aranroig/editor/Edit.java
Normal file
338
src/main/java/com/aranroig/editor/Edit.java
Normal file
@@ -0,0 +1,338 @@
|
||||
package com.aranroig.editor;
|
||||
|
||||
import net.minecraft.core.UUIDUtil;
|
||||
import net.minecraft.network.RegistryFriendlyByteBuf;
|
||||
import net.minecraft.network.codec.ByteBufCodecs;
|
||||
import net.minecraft.network.codec.StreamCodec;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Deque;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* A character-level change to a document: a walk over the text saying which
|
||||
* characters to keep ({@link Retain}), which to remove ({@link Delete}) and what
|
||||
* to write ({@link Insert}). Anything the walk does not mention is left alone.
|
||||
*
|
||||
* <p>Describing a change this way, instead of as one "replace this range with
|
||||
* that text", is what makes shared editing possible. Two players can write
|
||||
* against the same version of a file at the same time; before such a change is
|
||||
* used anywhere other than where it was written it is <em>transformed</em>
|
||||
* against the changes that went in first ({@link #transformAgainst(Edit)},
|
||||
* {@link #transformPair(Edit, Edit)}), which re-expresses it against the text it
|
||||
* is about to meet. Deleting around somebody else's freshly typed text, typing
|
||||
* inside a selection they are throwing away, both merge instead of one of the
|
||||
* two losing.</p>
|
||||
*
|
||||
* <p>{@code author} and {@code seq} survive every transform. They give two
|
||||
* inserts at the same offset a total order, so every player ends up with the
|
||||
* characters in the same sequence, and they tell the server which edits came
|
||||
* from the sender itself (those are already in the buffer the sender typed
|
||||
* into, so the server must not apply them twice).</p>
|
||||
*/
|
||||
public record Edit(UUID author, long seq, List<Edit.Component> components) {
|
||||
|
||||
/** One step of the walk over a document. */
|
||||
public sealed interface Component permits Retain, Insert, Delete {
|
||||
}
|
||||
|
||||
/** Keep {@code count} characters of the document as they are. */
|
||||
public record Retain(int count) implements Component {
|
||||
}
|
||||
|
||||
/** Write {@code text} at this point of the document. */
|
||||
public record Insert(String text) implements Component {
|
||||
}
|
||||
|
||||
/** Remove {@code count} characters from the document. */
|
||||
public record Delete(int count) implements Component {
|
||||
}
|
||||
|
||||
private static final StreamCodec<RegistryFriendlyByteBuf, Component> COMPONENT_CODEC = new StreamCodec<>() {
|
||||
@Override
|
||||
public Component decode(RegistryFriendlyByteBuf buf) {
|
||||
return switch (buf.readByte()) {
|
||||
case 1 -> new Insert(ByteBufCodecs.STRING_UTF8.decode(buf));
|
||||
case 2 -> new Delete(ByteBufCodecs.VAR_INT.decode(buf));
|
||||
default -> new Retain(ByteBufCodecs.VAR_INT.decode(buf));
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public void encode(RegistryFriendlyByteBuf buf, Component component) {
|
||||
if (component instanceof Insert insert) {
|
||||
buf.writeByte(1);
|
||||
ByteBufCodecs.STRING_UTF8.encode(buf, insert.text());
|
||||
} else if (component instanceof Delete delete) {
|
||||
buf.writeByte(2);
|
||||
ByteBufCodecs.VAR_INT.encode(buf, delete.count());
|
||||
} else {
|
||||
buf.writeByte(0);
|
||||
ByteBufCodecs.VAR_INT.encode(buf, ((Retain) component).count());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
public static final StreamCodec<RegistryFriendlyByteBuf, Edit> STREAM_CODEC =
|
||||
StreamCodec.composite(
|
||||
UUIDUtil.STREAM_CODEC,
|
||||
Edit::author,
|
||||
|
||||
ByteBufCodecs.VAR_LONG,
|
||||
Edit::seq,
|
||||
|
||||
COMPONENT_CODEC.apply(ByteBufCodecs.list()),
|
||||
Edit::components,
|
||||
|
||||
Edit::new
|
||||
);
|
||||
|
||||
// ── Building edits ────────────────────────────────────────────────────
|
||||
|
||||
/** A change that leaves the document as it is. */
|
||||
public static Edit none(UUID author, long seq) {
|
||||
return new Edit(author, seq, List.of());
|
||||
}
|
||||
|
||||
/** {@code text} written at {@code position}, nothing removed. */
|
||||
public static Edit insertion(UUID author, long seq, int position, String text) {
|
||||
return replace(author, seq, position, 0, text);
|
||||
}
|
||||
|
||||
/** {@code count} characters removed at {@code position}, nothing written back. */
|
||||
public static Edit deletion(UUID author, long seq, int position, int count) {
|
||||
return replace(author, seq, position, count, "");
|
||||
}
|
||||
|
||||
/**
|
||||
* The shape the text editor produces with every keystroke: remove
|
||||
* {@code deleteLength} characters at {@code position} and write
|
||||
* {@code insert} there.
|
||||
*/
|
||||
public static Edit replace(UUID author, long seq, int position, int deleteLength, String insert) {
|
||||
List<Component> components = new ArrayList<>(3);
|
||||
if (position > 0) components.add(new Retain(position));
|
||||
if (deleteLength > 0) components.add(new Delete(deleteLength));
|
||||
if (!insert.isEmpty()) components.add(new Insert(insert));
|
||||
return new Edit(author, seq, components);
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
for (Component component : components) {
|
||||
if (component instanceof Insert || component instanceof Delete) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/** How many characters of the document this edit reads; 0 for a pure insert. */
|
||||
public int baseLength() {
|
||||
int total = 0;
|
||||
for (Component component : components) {
|
||||
if (component instanceof Retain retain) total += retain.count();
|
||||
else if (component instanceof Delete delete) total += delete.count();
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
// ── Applying ──────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Runs this edit over {@code base}. Counts that do not fit the text are
|
||||
* clamped rather than thrown at: a document that stopped matching its
|
||||
* version is repaired by resyncing, not by crashing the editor.
|
||||
*/
|
||||
public String apply(String base) {
|
||||
if (isEmpty()) return base;
|
||||
|
||||
StringBuilder result = new StringBuilder(base.length());
|
||||
int index = 0;
|
||||
|
||||
for (Component component : components) {
|
||||
if (component instanceof Retain retain) {
|
||||
int count = Math.min(retain.count(), base.length() - index);
|
||||
if (count <= 0) break;
|
||||
result.append(base, index, index + count);
|
||||
index += count;
|
||||
} else if (component instanceof Delete delete) {
|
||||
int count = Math.min(delete.count(), base.length() - index);
|
||||
if (count <= 0) break;
|
||||
index += count;
|
||||
} else if (component instanceof Insert insert) {
|
||||
result.append(insert.text());
|
||||
}
|
||||
}
|
||||
if (index < base.length()) result.append(base, index, base.length());
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Where a caret at {@code caret} ends up once this edit is applied: text
|
||||
* inserted before it pushes it along, text deleted around it collapses it
|
||||
* onto the deletion point. Text inserted at the caret's own offset goes in
|
||||
* front of it, which is where the editor expects its own typing to land.
|
||||
*/
|
||||
public int shiftPosition(int caret) {
|
||||
int read = 0; // how far into the base document the walk has got
|
||||
int written = 0;
|
||||
|
||||
for (Component component : components) {
|
||||
if (read >= caret) break;
|
||||
|
||||
if (component instanceof Retain retain) {
|
||||
int count = Math.min(retain.count(), caret - read);
|
||||
read += count;
|
||||
written += count;
|
||||
} else if (component instanceof Delete delete) {
|
||||
read += Math.min(delete.count(), caret - read);
|
||||
// written does not move: the caret collapses onto the deletion
|
||||
} else if (component instanceof Insert insert) {
|
||||
written += insert.text().length();
|
||||
}
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
// ── Transforming ──────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* This edit re-expressed against a document that already contains
|
||||
* {@code other}. Both are assumed to have been written against the same
|
||||
* base document; applying the result after {@code other} has the effect this
|
||||
* edit was meant to have there.
|
||||
*/
|
||||
public Edit transformAgainst(Edit other) {
|
||||
return transformPair(this, other)[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Both edits expressed against each other's result: returns
|
||||
* {@code [this↑other, other↑this]}. Applying {@code this↑other} after
|
||||
* {@code other} gives the same document as applying {@code other↑this}
|
||||
* after {@code this}, which is what every player's copy converging on
|
||||
* rests upon.
|
||||
*/
|
||||
public static Edit[] transformPair(Edit left, Edit right) {
|
||||
List<Component> leftResult = new ArrayList<>();
|
||||
List<Component> rightResult = new ArrayList<>();
|
||||
|
||||
Deque<Component> leftOp = new ArrayDeque<>(left.components());
|
||||
Deque<Component> rightOp = new ArrayDeque<>(right.components());
|
||||
|
||||
while (!leftOp.isEmpty() || !rightOp.isEmpty()) {
|
||||
// Whichever edit ran out says nothing about what is left of the
|
||||
// document, which is the same as keeping it.
|
||||
Component l = leftOp.peekFirst();
|
||||
Component r = rightOp.peekFirst();
|
||||
boolean lVirtual = l == null;
|
||||
boolean rVirtual = r == null;
|
||||
if (l == null) l = new Retain(remaining(r));
|
||||
if (r == null) r = new Retain(remaining(l));
|
||||
|
||||
if (l instanceof Insert lInsert && !(r instanceof Insert)) {
|
||||
// Our text goes in before whatever the other edit does next. An
|
||||
// insert is never swallowed by a concurrent deletion.
|
||||
add(leftResult, lInsert);
|
||||
add(rightResult, new Retain(lInsert.text().length()));
|
||||
leftOp.pollFirst();
|
||||
continue;
|
||||
}
|
||||
if (r instanceof Insert rInsert && !(l instanceof Insert)) {
|
||||
add(rightResult, rInsert);
|
||||
add(leftResult, new Retain(rInsert.text().length()));
|
||||
rightOp.pollFirst();
|
||||
continue;
|
||||
}
|
||||
if (l instanceof Insert lInsert && r instanceof Insert rInsert) {
|
||||
// Two players typed at the same offset: authorship decides who
|
||||
// ends up in front, the same way round in both directions.
|
||||
if (left.precedes(right)) {
|
||||
add(leftResult, lInsert);
|
||||
add(rightResult, new Retain(lInsert.text().length()));
|
||||
leftOp.pollFirst();
|
||||
} else {
|
||||
add(rightResult, rInsert);
|
||||
add(leftResult, new Retain(rInsert.text().length()));
|
||||
rightOp.pollFirst();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// Neither side writes text here: both steps cover the same stretch
|
||||
// of the original document.
|
||||
int count = Math.min(remaining(l), remaining(r));
|
||||
boolean lDeletes = l instanceof Delete;
|
||||
boolean rDeletes = r instanceof Delete;
|
||||
|
||||
if (lDeletes && !rDeletes) add(leftResult, new Delete(count)); // they deleted it; we still want it gone
|
||||
else if (rDeletes && !lDeletes) add(rightResult, new Delete(count));
|
||||
else if (!lDeletes && !rDeletes) {
|
||||
add(leftResult, new Retain(count));
|
||||
add(rightResult, new Retain(count));
|
||||
}
|
||||
// Both deleting: the characters are gone either way, nothing to say.
|
||||
|
||||
consume(leftOp, count, lVirtual);
|
||||
consume(rightOp, count, rVirtual);
|
||||
}
|
||||
|
||||
return new Edit[]{
|
||||
new Edit(left.author, left.seq, leftResult),
|
||||
new Edit(right.author, right.seq, rightResult),
|
||||
};
|
||||
}
|
||||
|
||||
/** Collects a component, merging it into the previous one where possible. */
|
||||
private static void add(List<Component> components, Component component) {
|
||||
if (component instanceof Retain retain && retain.count() == 0) return;
|
||||
if (component instanceof Delete delete && delete.count() == 0) return;
|
||||
if (component instanceof Insert insert && insert.text().isEmpty()) return;
|
||||
|
||||
int last = components.size() - 1;
|
||||
if (last >= 0) {
|
||||
Component previous = components.get(last);
|
||||
if (previous instanceof Retain a && component instanceof Retain b) {
|
||||
components.set(last, new Retain(a.count() + b.count()));
|
||||
return;
|
||||
}
|
||||
if (previous instanceof Delete a && component instanceof Delete b) {
|
||||
components.set(last, new Delete(a.count() + b.count()));
|
||||
return;
|
||||
}
|
||||
if (previous instanceof Insert a && component instanceof Insert b) {
|
||||
components.set(last, new Insert(a.text() + b.text()));
|
||||
return;
|
||||
}
|
||||
}
|
||||
components.add(component);
|
||||
}
|
||||
|
||||
/** Characters a step covers: for inserts, the length of the text written. */
|
||||
private static int remaining(Component component) {
|
||||
if (component instanceof Retain retain) return retain.count();
|
||||
if (component instanceof Delete delete) return delete.count();
|
||||
return ((Insert) component).text().length();
|
||||
}
|
||||
|
||||
/** Advances a walk by {@code count} characters, splitting the step it lands in. */
|
||||
private static void consume(Deque<Component> components, int count, boolean virtual) {
|
||||
if (virtual) return; // nothing there to advance; it is re-derived next round
|
||||
Component head = components.pollFirst();
|
||||
int left = remaining(head) - count;
|
||||
if (left > 0) {
|
||||
components.addFirst(head instanceof Retain ? new Retain(left) : new Delete(left));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Total order over two edits, used only to decide which of two inserts at
|
||||
* the same offset comes first. It deliberately ignores positions, so it
|
||||
* still says the same thing after both have been transformed.
|
||||
*/
|
||||
public boolean precedes(Edit other) {
|
||||
int byAuthor = author.compareTo(other.author);
|
||||
if (byAuthor != 0) return byAuthor < 0;
|
||||
return seq < other.seq;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user