perttool 0.1.0-alpha.2

package/dist/mutation/task.js

@@ -0,0 +1,644 @@
+import { fieldNamed } from "../model/syntax.js";
+import { mutationDiagnostic } from "./diagnostics.js";
+import { appendDeclarationEdit, contentEndOffset, contentTextEndOffset, deleteDeclarationEdit, deleteFieldEdit, fieldInsertionOffset, insertionText, leadingCommentStart, lineIndexAt, majorLineEnding, serializeTags, serializeTextField, splitPhysicalLines, } from "./source.js";
+const fieldOrder = [
+    "title",
+    "description",
+    "duration",
+    "estimate",
+    "status",
+    "priority",
+    "requires",
+    "owner",
+    "tags",
+    "blocked_reason",
+    "source",
+];
+const fieldRank = new Map(fieldOrder.map((name, index) => [name, name === "estimate" ? 2 : index]));
+fieldRank.set("duration", 2);
+const taskStatuses = new Set(["planned", "active", "blocked", "done"]);
+const clearableFields = new Set([
+    "description",
+    "status",
+    "priority",
+    "owner",
+    "blocked_reason",
+    "source",
+    "tags",
+    "requires",
+]);
+function validEstimate(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const estimate = value;
+    return (typeof estimate.optimistic === "string" &&
+        typeof estimate.mostLikely === "string" &&
+        typeof estimate.pessimistic === "string");
+}
+function validRequirement(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const requirement = value;
+    return (typeof requirement.resourceId === "string" &&
+        Number.isSafeInteger(requirement.units));
+}
+function validStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function taskDefinitionError(value) {
+    if (value === null || typeof value !== "object")
+        return "task definitionがobjectではありません";
+    const task = value;
+    const knownFields = new Set([
+        "title",
+        "description",
+        "duration",
+        "estimate",
+        "status",
+        "priority",
+        "requirements",
+        "owner",
+        "tags",
+        "blockedReason",
+        "source",
+    ]);
+    if (Object.keys(task).some((name) => !knownFields.has(name))) {
+        return "task definitionに未対応fieldが含まれています";
+    }
+    if (typeof task["title"] !== "string")
+        return "task titleがstringではありません";
+    if ((task["duration"] === undefined) === (task["estimate"] === undefined)) {
+        return "durationまたはestimateのexactly oneを必要とします";
+    }
+    if (task["duration"] !== undefined && typeof task["duration"] !== "string") {
+        return "durationがstringではありません";
+    }
+    if (task["estimate"] !== undefined && !validEstimate(task["estimate"])) {
+        return "estimateはoptimistic、mostLikely、pessimisticのstringを必要とします";
+    }
+    for (const name of ["description", "owner", "blockedReason", "source"]) {
+        if (task[name] !== undefined && typeof task[name] !== "string") {
+            return `${name}がstringではありません`;
+        }
+    }
+    if (task["status"] !== undefined && !taskStatuses.has(task["status"])) {
+        return "statusがtask statusではありません";
+    }
+    if (task["priority"] !== undefined && !Number.isSafeInteger(task["priority"])) {
+        return "priorityがsafe integerではありません";
+    }
+    if (task["tags"] !== undefined && !validStringArray(task["tags"])) {
+        return "tagsがstring arrayではありません";
+    }
+    if (task["requirements"] !== undefined &&
+        (!Array.isArray(task["requirements"]) || !task["requirements"].every(validRequirement))) {
+        return "requirementsがresourceIdとsafe integer unitsのarrayではありません";
+    }
+    return undefined;
+}
+function taskMutationRequestError(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return "mutation requestがobjectではありません";
+    }
+    const request = value;
+    const kind = request["kind"];
+    if (kind !== "task.add" &&
+        kind !== "task.set" &&
+        kind !== "task.remove" &&
+        kind !== "task.finish") {
+        return "mutation kindが未対応です";
+    }
+    if (typeof request["id"] !== "string")
+        return "mutation idがstringではありません";
+    const fieldsByKind = {
+        "task.add": new Set(["kind", "id", "from", "to", "task"]),
+        "task.set": new Set([
+            "kind",
+            "id",
+            "from",
+            "to",
+            "set",
+            "clear",
+            "addTags",
+            "removeTags",
+            "upsertRequirements",
+            "removeRequirements",
+        ]),
+        "task.remove": new Set(["kind", "id"]),
+        "task.finish": new Set(["kind", "id"]),
+    };
+    if (Object.keys(request).some((name) => !fieldsByKind[kind].has(name))) {
+        return `${kind} requestに未対応fieldが含まれています`;
+    }
+    return undefined;
+}
+function canonicalDuration(value) {
+    const match = /^(\d+)(?:\.(\d+))?([dhp])$/.exec(value);
+    if (match === null)
+        return value;
+    const whole = match[1].replace(/^0+(?=\d)/, "");
+    const fraction = (match[2] ?? "").replace(/0+$/, "");
+    return `${whole}${fraction === "" ? "" : `.${fraction}`}${match[3]}`;
+}
+function serializeEstimate(estimate, lineEnding) {
+    return [
+        "  estimate:",
+        `    optimistic ${canonicalDuration(estimate.optimistic)}`,
+        `    most_likely ${canonicalDuration(estimate.mostLikely)}`,
+        `    pessimistic ${canonicalDuration(estimate.pessimistic)}`,
+    ].join(lineEnding);
+}
+function serializeRequirements(requirements, lineEnding) {
+    return [
+        "  requires:",
+        ...requirements.map(({ resourceId, units }) => `    ${resourceId} ${units}`),
+    ].join(lineEnding);
+}
+function serializeField(name, value, lineEnding) {
+    switch (name) {
+        case "title":
+        case "owner":
+        case "source":
+            return `  ${name} ${JSON.stringify(value)}`;
+        case "description":
+        case "blocked_reason":
+            return serializeTextField(name, value, lineEnding);
+        case "duration":
+            return `  duration ${canonicalDuration(value)}`;
+        case "estimate":
+            return serializeEstimate(value, lineEnding);
+        case "status":
+        case "priority":
+            return `  ${name} ${value}`;
+        case "tags":
+            return `  tags ${serializeTags(value)}`;
+        case "requires":
+            return serializeRequirements(value, lineEnding);
+        default:
+            throw new Error(`unsupported task field ${name}`);
+    }
+}
+function taskFields(task) {
+    const fields = new Map([["title", task.title]]);
+    if (task.description !== undefined)
+        fields.set("description", task.description);
+    if (task.duration !== undefined)
+        fields.set("duration", task.duration);
+    if (task.estimate !== undefined)
+        fields.set("estimate", task.estimate);
+    if (task.status !== undefined)
+        fields.set("status", task.status);
+    if (task.priority !== undefined)
+        fields.set("priority", task.priority);
+    if (task.requirements !== undefined)
+        fields.set("requires", task.requirements);
+    if (task.owner !== undefined)
+        fields.set("owner", task.owner);
+    if (task.tags !== undefined)
+        fields.set("tags", task.tags);
+    if (task.blockedReason !== undefined)
+        fields.set("blocked_reason", task.blockedReason);
+    if (task.source !== undefined)
+        fields.set("source", task.source);
+    return fields;
+}
+function serializeTask(mutation, lineEnding) {
+    const fields = taskFields(mutation.task);
+    return [
+        `task ${mutation.id} ${mutation.from} -> ${mutation.to}:`,
+        ...fieldOrder.flatMap((name) => {
+            if (name === "duration" && fields.has("estimate"))
+                return [];
+            if (name === "estimate" && fields.has("duration"))
+                return [];
+            return fields.has(name) ? [serializeField(name, fields.get(name), lineEnding)] : [];
+        }),
+    ].join(lineEnding);
+}
+function addTaskPlan(text, mutation) {
+    const task = mutation.task;
+    const taskError = taskDefinitionError(task);
+    if (typeof mutation.id !== "string" ||
+        typeof mutation.from !== "string" ||
+        typeof mutation.to !== "string" ||
+        taskError !== undefined) {
+        return {
+            edits: [],
+            diagnostic: mutationDiagnostic("PTMUT-301", `task.add requestが不正です${taskError === undefined ? "" : `: ${taskError}`}`),
+        };
+    }
+    const lineEnding = majorLineEnding(text);
+    return {
+        edits: [appendDeclarationEdit(text, serializeTask(mutation, lineEnding), lineEnding)],
+    };
+}
+function setRequestError(mutation) {
+    const rawSet = mutation.set;
+    const rawClear = mutation.clear;
+    const rawAddTags = mutation.addTags;
+    const rawRemoveTags = mutation.removeTags;
+    const rawUpsertRequirements = mutation.upsertRequirements;
+    const rawRemoveRequirements = mutation.removeRequirements;
+    if (rawSet !== undefined &&
+        (rawSet === null || typeof rawSet !== "object" || Array.isArray(rawSet))) {
+        return "setがobjectではありません";
+    }
+    for (const [name, value] of [
+        ["clear", rawClear],
+        ["addTags", rawAddTags],
+        ["removeTags", rawRemoveTags],
+        ["upsertRequirements", rawUpsertRequirements],
+        ["removeRequirements", rawRemoveRequirements],
+    ]) {
+        if (value !== undefined && !Array.isArray(value))
+            return `${name}がarrayではありません`;
+    }
+    const set = (rawSet ?? {});
+    const setEntries = Object.entries(set).filter(([, value]) => value !== undefined);
+    const clear = (rawClear ?? []);
+    const addTags = (rawAddTags ?? []);
+    const removeTags = (rawRemoveTags ?? []);
+    const upsertRequirements = (rawUpsertRequirements ?? []);
+    const removeRequirements = (rawRemoveRequirements ?? []);
+    if (mutation.from === undefined &&
+        mutation.to === undefined &&
+        setEntries.length === 0 &&
+        clear.length === 0 &&
+        addTags.length === 0 &&
+        removeTags.length === 0 &&
+        upsertRequirements.length === 0 &&
+        removeRequirements.length === 0) {
+        return "task.setは少なくとも1つの変更指定を必要とします";
+    }
+    if (set.duration !== undefined && set.estimate !== undefined) {
+        return "durationとestimateは同時にsetできません";
+    }
+    if (mutation.from !== undefined && typeof mutation.from !== "string") {
+        return "fromがstringではありません";
+    }
+    if (mutation.to !== undefined && typeof mutation.to !== "string") {
+        return "toがstringではありません";
+    }
+    const knownSetFields = new Set([
+        "title",
+        "description",
+        "duration",
+        "estimate",
+        "status",
+        "priority",
+        "owner",
+        "blockedReason",
+        "source",
+    ]);
+    if (Object.keys(set).some((name) => !knownSetFields.has(name))) {
+        return "setに未対応fieldが含まれています";
+    }
+    for (const name of ["title", "description", "duration", "owner", "blockedReason", "source"]) {
+        if (set[name] !== undefined && typeof set[name] !== "string") {
+            return `${name}がstringではありません`;
+        }
+    }
+    if (set.estimate !== undefined && !validEstimate(set.estimate)) {
+        return "estimateはoptimistic、mostLikely、pessimisticのstringを必要とします";
+    }
+    if (set.status !== undefined && !taskStatuses.has(set.status)) {
+        return "statusがtask statusではありません";
+    }
+    if (set.priority !== undefined && !Number.isSafeInteger(set.priority)) {
+        return "priorityがsafe integerではありません";
+    }
+    if (!Array.isArray(clear) || clear.some((name) => !clearableFields.has(name))) {
+        return "clearに未対応fieldが含まれています";
+    }
+    if (!validStringArray(addTags) || !validStringArray(removeTags)) {
+        return "addTagsとremoveTagsはstring arrayである必要があります";
+    }
+    if (!Array.isArray(upsertRequirements) ||
+        !upsertRequirements.every(validRequirement) ||
+        !validStringArray(removeRequirements)) {
+        return "requirement変更指定が不正です";
+    }
+    if (new Set(clear).size !== clear.length)
+        return "clear fieldが重複しています";
+    const clearNames = new Set(clear);
+    const setToClear = {
+        title: "title",
+        description: "description",
+        duration: "duration",
+        estimate: "estimate",
+        status: "status",
+        priority: "priority",
+        owner: "owner",
+        blockedReason: "blocked_reason",
+        source: "source",
+    };
+    for (const [name] of setEntries) {
+        if (clearNames.has(setToClear[name])) {
+            return `${setToClear[name]}をsetとclearへ同時指定できません`;
+        }
+    }
+    if (clearNames.has("tags") && (addTags.length > 0 || removeTags.length > 0)) {
+        return "clear tagsとadd/remove tagは併用できません";
+    }
+    if (clearNames.has("requires") &&
+        (upsertRequirements.length > 0 || removeRequirements.length > 0)) {
+        return "clear requiresとupsert/remove requirementは併用できません";
+    }
+    const removedTags = new Set(removeTags);
+    if (addTags.some((tag) => removedTags.has(tag))) {
+        return "同じtagをaddとremoveへ同時指定できません";
+    }
+    const removedResources = new Set(removeRequirements);
+    if (upsertRequirements.some(({ resourceId }) => removedResources.has(resourceId))) {
+        return "同じresourceをupsertとremoveへ同時指定できません";
+    }
+    const upsertIds = upsertRequirements.map(({ resourceId }) => resourceId);
+    if (new Set(upsertIds).size !== upsertIds.length) {
+        return "upsert requirementのresourceが重複しています";
+    }
+    return undefined;
+}
+function currentTags(task) {
+    const value = fieldNamed(task, "tags")?.value;
+    return Array.isArray(value)
+        ? value.filter((tag) => typeof tag === "string")
+        : [];
+}
+function currentRequirements(task) {
+    const value = fieldNamed(task, "requires")?.value;
+    return Array.isArray(value)
+        ? value.map(({ resourceId, units }) => ({ resourceId, units }))
+        : [];
+}
+function planSetTask(text, task, mutation) {
+    const error = setRequestError(mutation);
+    if (error !== undefined) {
+        return { edits: [], diagnostic: mutationDiagnostic("PTMUT-301", error, task) };
+    }
+    const lines = splitPhysicalLines(text);
+    const lineEnding = majorLineEnding(text);
+    const edits = [];
+    const deleted = new Set(mutation.clear ?? []);
+    const additions = new Map();
+    const queueAddition = (name, value) => {
+        const offset = fieldInsertionOffset(task, name, deleted, lines, fieldRank);
+        const entries = additions.get(offset) ?? [];
+        entries.push({ name, serialized: serializeField(name, value, lineEnding) });
+        additions.set(offset, entries);
+    };
+    const setScalar = (name, value, valueText) => {
+        const field = fieldNamed(task, name);
+        if (field === undefined)
+            queueAddition(name, value);
+        else
+            edits.push({
+                startOffset: field.valueSpan.start.offset,
+                endOffset: field.valueSpan.end.offset,
+                replacement: valueText,
+            });
+    };
+    const setText = (name, value) => {
+        const field = fieldNamed(task, name);
+        if (field === undefined) {
+            queueAddition(name, value);
+        }
+        else if (field.contentSpan === undefined && !value.includes("\n")) {
+            edits.push({
+                startOffset: field.valueSpan.start.offset,
+                endOffset: field.valueSpan.end.offset,
+                replacement: JSON.stringify(value),
+            });
+        }
+        else {
+            edits.push({
+                startOffset: field.span.start.offset,
+                endOffset: contentTextEndOffset(field, lines),
+                replacement: serializeTextField(name, value, lineEnding),
+            });
+        }
+    };
+    if (mutation.from !== undefined) {
+        edits.push({
+            startOffset: task.fromSpan.start.offset,
+            endOffset: task.fromSpan.end.offset,
+            replacement: mutation.from,
+        });
+    }
+    if (mutation.to !== undefined) {
+        edits.push({
+            startOffset: task.toSpan.start.offset,
+            endOffset: task.toSpan.end.offset,
+            replacement: mutation.to,
+        });
+    }
+    const set = mutation.set ?? {};
+    if (set.title !== undefined)
+        setScalar("title", set.title, JSON.stringify(set.title));
+    if (set.description !== undefined)
+        setText("description", set.description);
+    if (set.duration !== undefined) {
+        const duration = fieldNamed(task, "duration");
+        const estimate = fieldNamed(task, "estimate");
+        if (duration !== undefined) {
+            setScalar("duration", set.duration, canonicalDuration(set.duration));
+        }
+        else if (estimate !== undefined) {
+            edits.push({
+                startOffset: estimate.span.start.offset,
+                endOffset: contentTextEndOffset(estimate, lines),
+                replacement: serializeField("duration", set.duration, lineEnding),
+            });
+        }
+    }
+    if (set.estimate !== undefined) {
+        const estimate = fieldNamed(task, "estimate");
+        const duration = fieldNamed(task, "duration");
+        if (estimate !== undefined) {
+            for (const [name, value] of [
+                ["optimistic", set.estimate.optimistic],
+                ["most_likely", set.estimate.mostLikely],
+                ["pessimistic", set.estimate.pessimistic],
+            ]) {
+                const child = estimate.children.find((candidate) => candidate.name === name);
+                edits.push({
+                    startOffset: child.valueSpan.start.offset,
+                    endOffset: child.valueSpan.end.offset,
+                    replacement: canonicalDuration(value),
+                });
+            }
+        }
+        else if (duration !== undefined) {
+            edits.push({
+                startOffset: duration.span.start.offset,
+                endOffset: contentTextEndOffset(duration, lines),
+                replacement: serializeEstimate(set.estimate, lineEnding),
+            });
+        }
+    }
+    if (set.status !== undefined)
+        setScalar("status", set.status, set.status);
+    if (set.priority !== undefined)
+        setScalar("priority", set.priority, String(set.priority));
+    if (set.owner !== undefined)
+        setScalar("owner", set.owner, JSON.stringify(set.owner));
+    if (set.blockedReason !== undefined)
+        setText("blocked_reason", set.blockedReason);
+    if (set.source !== undefined)
+        setScalar("source", set.source, JSON.stringify(set.source));
+    if ((mutation.clear ?? []).includes("tags")) {
+        deleted.add("tags");
+    }
+    else if ((mutation.addTags?.length ?? 0) > 0 || (mutation.removeTags?.length ?? 0) > 0) {
+        const removed = new Set(mutation.removeTags ?? []);
+        const final = currentTags(task).filter((tag) => !removed.has(tag));
+        for (const tag of mutation.addTags ?? []) {
+            if (!final.includes(tag))
+                final.push(tag);
+        }
+        const tags = fieldNamed(task, "tags");
+        if (final.length === 0) {
+            if (tags !== undefined)
+                deleted.add("tags");
+        }
+        else if (tags === undefined) {
+            queueAddition("tags", final);
+        }
+        else {
+            edits.push({
+                startOffset: tags.valueSpan.start.offset,
+                endOffset: tags.valueSpan.end.offset,
+                replacement: serializeTags(final),
+            });
+        }
+    }
+    if ((mutation.clear ?? []).includes("requires")) {
+        deleted.add("requires");
+    }
+    else if ((mutation.upsertRequirements?.length ?? 0) > 0 ||
+        (mutation.removeRequirements?.length ?? 0) > 0) {
+        const removed = new Set(mutation.removeRequirements ?? []);
+        const current = currentRequirements(task);
+        const upserts = new Map((mutation.upsertRequirements ?? []).map((requirement) => [
+            requirement.resourceId,
+            requirement,
+        ]));
+        const final = current
+            .filter(({ resourceId }) => !removed.has(resourceId))
+            .map((requirement) => upserts.get(requirement.resourceId) ?? requirement);
+        for (const requirement of mutation.upsertRequirements ?? []) {
+            if (!current.some(({ resourceId }) => resourceId === requirement.resourceId)) {
+                final.push(requirement);
+            }
+        }
+        const requires = fieldNamed(task, "requires");
+        if (final.length === 0) {
+            if (requires !== undefined)
+                deleted.add("requires");
+        }
+        else if (requires === undefined) {
+            queueAddition("requires", final);
+        }
+        else {
+            const original = requires.value;
+            const surviving = original.filter(({ resourceId }) => !removed.has(resourceId));
+            const appended = final.filter(({ resourceId }) => !original.some((candidate) => candidate.resourceId === resourceId));
+            if (surviving.length === 0) {
+                edits.push({
+                    startOffset: requires.span.start.offset,
+                    endOffset: contentTextEndOffset(requires, lines),
+                    replacement: serializeRequirements(final, lineEnding),
+                });
+            }
+            else {
+                for (const requirement of original) {
+                    if (removed.has(requirement.resourceId)) {
+                        edits.push({
+                            startOffset: leadingCommentStart(lines, requirement.span.start.offset, 4),
+                            endOffset: lines[lineIndexAt(lines, requirement.span.end.offset)].endWithEnding,
+                            replacement: "",
+                        });
+                        continue;
+                    }
+                    const updated = upserts.get(requirement.resourceId);
+                    if (updated !== undefined) {
+                        edits.push({
+                            startOffset: requirement.unitsSpan.start.offset,
+                            endOffset: requirement.unitsSpan.end.offset,
+                            replacement: String(updated.units),
+                        });
+                    }
+                }
+                if (appended.length > 0) {
+                    const last = surviving[surviving.length - 1];
+                    const offset = lines[lineIndexAt(lines, last.span.end.offset)].endWithEnding;
+                    edits.push({
+                        startOffset: offset,
+                        endOffset: offset,
+                        replacement: insertionText(text, offset, appended.map(({ resourceId, units }) => `    ${resourceId} ${units}`), lineEnding),
+                    });
+                }
+            }
+        }
+    }
+    for (const name of deleted) {
+        const field = fieldNamed(task, name);
+        if (field !== undefined)
+            edits.push(deleteFieldEdit(field, lines));
+    }
+    for (const [offset, entries] of additions) {
+        entries.sort((left, right) => (fieldRank.get(left.name) ?? 99) - (fieldRank.get(right.name) ?? 99));
+        edits.push({
+            startOffset: offset,
+            endOffset: offset,
+            replacement: insertionText(text, offset, entries.map(({ serialized }) => serialized), lineEnding),
+        });
+    }
+    return { edits };
+}
+export function planTaskMutationEdits(text, document, mutation) {
+    const requestError = taskMutationRequestError(mutation);
+    if (requestError !== undefined) {
+        return {
+            edits: [],
+            diagnostic: mutationDiagnostic("PTMUT-301", requestError),
+        };
+    }
+    const entity = document.declarations.find(({ id }) => id === mutation.id);
+    if (mutation.kind === "task.add") {
+        if (entity !== undefined) {
+            return {
+                edits: [],
+                diagnostic: mutationDiagnostic("PTMUT-304", `entity ID ${mutation.id}はすでに使用されています`, entity),
+            };
+        }
+        return addTaskPlan(text, mutation);
+    }
+    if (entity === undefined) {
+        return {
+            edits: [],
+            diagnostic: mutationDiagnostic("PTMUT-302", `task ${mutation.id}が存在しません`),
+        };
+    }
+    if (entity.kind !== "task") {
+        return {
+            edits: [],
+            diagnostic: mutationDiagnostic("PTMUT-303", `entity ${mutation.id}はtaskではありません`, entity),
+        };
+    }
+    const lines = splitPhysicalLines(text);
+    if (mutation.kind === "task.remove") {
+        return { edits: [deleteDeclarationEdit(entity, lines)] };
+    }
+    if (mutation.kind === "task.finish") {
+        return planSetTask(text, entity, {
+            kind: "task.set",
+            id: mutation.id,
+            set: { status: "done" },
+            ...(fieldNamed(entity, "blocked_reason") === undefined
+                ? {}
+                : { clear: ["blocked_reason"] }),
+        });
+    }
+    return planSetTask(text, entity, mutation);
+}
+//# sourceMappingURL=task.js.map