perttool 0.1.0 → 0.3.0

package/dist/mutation/task.js

@@ -1,23 +1,25 @@
 import { fieldNamed } from "../model/syntax.js";
+import { GRAMMAR_1_DECLARATION_FIELD_ORDER, TARGET_GRAMMAR_2_DECLARATION_FIELD_ORDER, } from "../model/declaration-fields.js";
+import { canonicalizeExactDurationSourceToken, } from "../model/exact-duration-source.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);
+export const ACTIVE_TASK_MUTATION_PROFILE = Object.freeze({
+    fieldOrder: GRAMMAR_1_DECLARATION_FIELD_ORDER.task,
+    temporalFields: false,
+    exactDurations: false,
+});
+export const TARGET_GRAMMAR_2_TASK_MUTATION_PROFILE = Object.freeze({
+    fieldOrder: TARGET_GRAMMAR_2_DECLARATION_FIELD_ORDER.task,
+    temporalFields: true,
+    exactDurations: false,
+});
+export const TARGET_GRAMMAR_3_TASK_MUTATION_PROFILE = Object.freeze({
+    fieldOrder: TARGET_GRAMMAR_2_DECLARATION_FIELD_ORDER.task,
+    temporalFields: true,
+    exactDurations: true,
+});
 const taskStatuses = new Set(["planned", "active", "blocked", "done"]);
-const clearableFields = new Set([
+const activeClearableFields = [
     "description",
     "status",
     "priority",
@@ -26,7 +28,10 @@ const clearableFields = new Set([
     "source",
     "tags",
     "requires",
-]);
+];
+function fieldRank(profile) {
+    return new Map(profile.fieldOrder.map((name, index) => [name, index]));
+}
 function validEstimate(value) {
     if (value === null || typeof value !== "object")
         return false;
@@ -45,15 +50,16 @@ function validRequirement(value) {
 function validStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function taskDefinitionError(value) {
+function taskDefinitionError(value, profile) {
     if (value === null || typeof value !== "object")
-        return "task definitionがobjectではありません";
+        return "task definition is not an object";
     const task = value;
     const knownFields = new Set([
         "title",
         "description",
         "duration",
         "estimate",
+        ...(profile.temporalFields ? ["notBefore", "deadline"] : []),
         "status",
         "priority",
         "requirements",
@@ -63,42 +69,48 @@ function taskDefinitionError(value) {
         "source",
     ]);
     if (Object.keys(task).some((name) => !knownFields.has(name))) {
-        return "task definitionに未対応fieldが含まれています";
+        return "task definition contains unsupported fields";
     }
     if (typeof task["title"] !== "string")
-        return "task titleがstringではありません";
+        return "task title is not a string";
     if ((task["duration"] === undefined) === (task["estimate"] === undefined)) {
-        return "durationまたはestimateのexactly oneを必要とします";
+        return "exactly one of duration or estimate is required";
     }
     if (task["duration"] !== undefined && typeof task["duration"] !== "string") {
-        return "durationがstringではありません";
+        return "duration is not a string";
     }
     if (task["estimate"] !== undefined && !validEstimate(task["estimate"])) {
-        return "estimateはoptimistic、mostLikely、pessimisticのstringを必要とします";
+        return "estimate requires optimistic, mostLikely, and pessimistic string fields";
     }
-    for (const name of ["description", "owner", "blockedReason", "source"]) {
+    for (const name of [
+        "description",
+        "owner",
+        "blockedReason",
+        "source",
+        ...(profile.temporalFields ? ["notBefore", "deadline"] : []),
+    ]) {
         if (task[name] !== undefined && typeof task[name] !== "string") {
-            return `${name}がstringではありません`;
+            return `${name} is not a string`;
         }
     }
     if (task["status"] !== undefined && !taskStatuses.has(task["status"])) {
-        return "statusがtask statusではありません";
+        return "status is not a task status";
     }
     if (task["priority"] !== undefined && !Number.isSafeInteger(task["priority"])) {
-        return "priorityがsafe integerではありません";
+        return "priority is not a safe integer";
     }
     if (task["tags"] !== undefined && !validStringArray(task["tags"])) {
-        return "tagsがstring arrayではありません";
+        return "tags are not a string array";
     }
     if (task["requirements"] !== undefined &&
         (!Array.isArray(task["requirements"]) || !task["requirements"].every(validRequirement))) {
-        return "requirementsがresourceIdとsafe integer unitsのarrayではありません";
+        return "requirements must be an array of entries with resourceId and safe integer units";
     }
     return undefined;
 }
 function taskMutationRequestError(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        return "mutation requestがobjectではありません";
+        return "mutation request is not an object";
     }
     const request = value;
     const kind = request["kind"];
@@ -106,10 +118,10 @@ function taskMutationRequestError(value) {
         kind !== "task.set" &&
         kind !== "task.remove" &&
         kind !== "task.finish") {
-        return "mutation kindが未対応です";
+        return "mutation kind is unsupported";
     }
     if (typeof request["id"] !== "string")
-        return "mutation idがstringではありません";
+        return "mutation id is not a string";
     const fieldsByKind = {
         "task.add": new Set(["kind", "id", "from", "to", "task"]),
         "task.set": new Set([
@@ -128,11 +140,14 @@ function taskMutationRequestError(value) {
         "task.finish": new Set(["kind", "id"]),
     };
     if (Object.keys(request).some((name) => !fieldsByKind[kind].has(name))) {
-        return `${kind} requestに未対応fieldが含まれています`;
+        return `${kind} request contains unsupported fields`;
     }
     return undefined;
 }
-function canonicalDuration(value) {
+function canonicalDuration(value, profile) {
+    if (profile.exactDurations) {
+        return canonicalizeExactDurationSourceToken(value)?.token ?? value;
+    }
     const match = /^(\d+)(?:\.(\d+))?([dhp])$/.exec(value);
     if (match === null)
         return value;
@@ -140,12 +155,12 @@ function canonicalDuration(value) {
     const fraction = (match[2] ?? "").replace(/0+$/, "");
     return `${whole}${fraction === "" ? "" : `.${fraction}`}${match[3]}`;
 }
-function serializeEstimate(estimate, lineEnding) {
+function serializeEstimate(estimate, lineEnding, profile) {
     return [
         "  estimate:",
-        `    optimistic ${canonicalDuration(estimate.optimistic)}`,
-        `    most_likely ${canonicalDuration(estimate.mostLikely)}`,
-        `    pessimistic ${canonicalDuration(estimate.pessimistic)}`,
+        `    optimistic ${canonicalDuration(estimate.optimistic, profile)}`,
+        `    most_likely ${canonicalDuration(estimate.mostLikely, profile)}`,
+        `    pessimistic ${canonicalDuration(estimate.pessimistic, profile)}`,
     ].join(lineEnding);
 }
 function serializeRequirements(requirements, lineEnding) {
@@ -154,7 +169,7 @@ function serializeRequirements(requirements, lineEnding) {
         ...requirements.map(({ resourceId, units }) => `    ${resourceId} ${units}`),
     ].join(lineEnding);
 }
-function serializeField(name, value, lineEnding) {
+function serializeField(name, value, lineEnding, profile) {
     switch (name) {
         case "title":
         case "owner":
@@ -164,9 +179,12 @@ function serializeField(name, value, lineEnding) {
         case "blocked_reason":
             return serializeTextField(name, value, lineEnding);
         case "duration":
-            return `  duration ${canonicalDuration(value)}`;
+            return `  duration ${canonicalDuration(value, profile)}`;
         case "estimate":
-            return serializeEstimate(value, lineEnding);
+            return serializeEstimate(value, lineEnding, profile);
+        case "not_before":
+        case "deadline":
+            return `  ${name} ${value}`;
         case "status":
         case "priority":
             return `  ${name} ${value}`;
@@ -186,6 +204,12 @@ function taskFields(task) {
         fields.set("duration", task.duration);
     if (task.estimate !== undefined)
         fields.set("estimate", task.estimate);
+    if ("notBefore" in task && task.notBefore !== undefined) {
+        fields.set("not_before", task.notBefore);
+    }
+    if ("deadline" in task && task.deadline !== undefined) {
+        fields.set("deadline", task.deadline);
+    }
     if (task.status !== undefined)
         fields.set("status", task.status);
     if (task.priority !== undefined)
@@ -202,37 +226,44 @@ function taskFields(task) {
         fields.set("source", task.source);
     return fields;
 }
-function serializeTask(mutation, lineEnding) {
+function serializeTask(mutation, lineEnding, profile) {
+    if (mutation.kind !== "task.add") {
+        throw new Error("task serializer requires task.add");
+    }
     const fields = taskFields(mutation.task);
     return [
         `task ${mutation.id} ${mutation.from} -> ${mutation.to}:`,
-        ...fieldOrder.flatMap((name) => {
+        ...profile.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)] : [];
+            return fields.has(name)
+                ? [serializeField(name, fields.get(name), lineEnding, profile)]
+                : [];
         }),
     ].join(lineEnding);
 }
-function addTaskPlan(text, mutation) {
+function addTaskPlan(text, mutation, profile) {
     const task = mutation.task;
-    const taskError = taskDefinitionError(task);
+    const taskError = taskDefinitionError(task, profile);
     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}`}`),
+            diagnostic: mutationDiagnostic("PTMUT-301", `task.add request is invalid${taskError === undefined ? "" : `: ${taskError}`}`),
         };
     }
     const lineEnding = majorLineEnding(text);
     return {
-        edits: [appendDeclarationEdit(text, serializeTask(mutation, lineEnding), lineEnding)],
+        edits: [
+            appendDeclarationEdit(text, serializeTask(mutation, lineEnding, profile), lineEnding),
+        ],
     };
 }
-function setRequestError(mutation) {
+function setRequestError(mutation, profile) {
     const rawSet = mutation.set;
     const rawClear = mutation.clear;
     const rawAddTags = mutation.addTags;
@@ -241,7 +272,7 @@ function setRequestError(mutation) {
     const rawRemoveRequirements = mutation.removeRequirements;
     if (rawSet !== undefined &&
         (rawSet === null || typeof rawSet !== "object" || Array.isArray(rawSet))) {
-        return "setがobjectではありません";
+        return "set is not an object";
     }
     for (const [name, value] of [
         ["clear", rawClear],
@@ -251,7 +282,7 @@ function setRequestError(mutation) {
         ["removeRequirements", rawRemoveRequirements],
     ]) {
         if (value !== undefined && !Array.isArray(value))
-            return `${name}がarrayではありません`;
+            return `${name} is not an array`;
     }
     const set = (rawSet ?? {});
     const setEntries = Object.entries(set).filter(([, value]) => value !== undefined);
@@ -268,22 +299,23 @@ function setRequestError(mutation) {
         removeTags.length === 0 &&
         upsertRequirements.length === 0 &&
         removeRequirements.length === 0) {
-        return "task.setは少なくとも1つの変更指定を必要とします";
+        return "task.set requires at least one change specification";
     }
     if (set.duration !== undefined && set.estimate !== undefined) {
-        return "durationとestimateは同時にsetできません";
+        return "duration and estimate cannot both be specified in set";
     }
     if (mutation.from !== undefined && typeof mutation.from !== "string") {
-        return "fromがstringではありません";
+        return "from is not a string";
     }
     if (mutation.to !== undefined && typeof mutation.to !== "string") {
-        return "toがstringではありません";
+        return "to is not a string";
     }
     const knownSetFields = new Set([
         "title",
         "description",
         "duration",
         "estimate",
+        ...(profile.temporalFields ? ["notBefore", "deadline"] : []),
         "status",
         "priority",
         "owner",
@@ -291,41 +323,57 @@ function setRequestError(mutation) {
         "source",
     ]);
     if (Object.keys(set).some((name) => !knownSetFields.has(name))) {
-        return "setに未対応fieldが含まれています";
+        return "set contains unsupported fields";
     }
-    for (const name of ["title", "description", "duration", "owner", "blockedReason", "source"]) {
-        if (set[name] !== undefined && typeof set[name] !== "string") {
-            return `${name}がstringではありません`;
+    for (const name of [
+        "title",
+        "description",
+        "duration",
+        "owner",
+        "blockedReason",
+        "source",
+        ...(profile.temporalFields ? ["notBefore", "deadline"] : []),
+    ]) {
+        if (set[name] !== undefined &&
+            typeof set[name] !== "string") {
+            return `${name} is not a string`;
         }
     }
     if (set.estimate !== undefined && !validEstimate(set.estimate)) {
-        return "estimateはoptimistic、mostLikely、pessimisticのstringを必要とします";
+        return "estimate requires optimistic, mostLikely, and pessimistic string fields";
     }
     if (set.status !== undefined && !taskStatuses.has(set.status)) {
-        return "statusがtask statusではありません";
+        return "status is not a task status";
     }
     if (set.priority !== undefined && !Number.isSafeInteger(set.priority)) {
-        return "priorityがsafe integerではありません";
+        return "priority is not a safe integer";
     }
+    const clearableFields = new Set([
+        ...activeClearableFields,
+        ...(profile.temporalFields ? ["not_before", "deadline"] : []),
+    ]);
     if (!Array.isArray(clear) || clear.some((name) => !clearableFields.has(name))) {
-        return "clearに未対応fieldが含まれています";
+        return "clear contains unsupported fields";
     }
     if (!validStringArray(addTags) || !validStringArray(removeTags)) {
-        return "addTagsとremoveTagsはstring arrayである必要があります";
+        return "addTags and removeTags must be string arrays";
     }
     if (!Array.isArray(upsertRequirements) ||
         !upsertRequirements.every(validRequirement) ||
         !validStringArray(removeRequirements)) {
-        return "requirement変更指定が不正です";
+        return "requirement change specification is invalid";
     }
     if (new Set(clear).size !== clear.length)
-        return "clear fieldが重複しています";
+        return "clear contains duplicate fields";
     const clearNames = new Set(clear);
     const setToClear = {
         title: "title",
         description: "description",
         duration: "duration",
         estimate: "estimate",
+        ...(profile.temporalFields
+            ? { notBefore: "not_before", deadline: "deadline" }
+            : {}),
         status: "status",
         priority: "priority",
         owner: "owner",
@@ -334,27 +382,27 @@ function setRequestError(mutation) {
     };
     for (const [name] of setEntries) {
         if (clearNames.has(setToClear[name])) {
-            return `${setToClear[name]}をsetとclearへ同時指定できません`;
+            return `${setToClear[name]} cannot be specified in both set and clear`;
         }
     }
     if (clearNames.has("tags") && (addTags.length > 0 || removeTags.length > 0)) {
-        return "clear tagsとadd/remove tagは併用できません";
+        return "clear tags cannot be combined with add/remove tags";
     }
     if (clearNames.has("requires") &&
         (upsertRequirements.length > 0 || removeRequirements.length > 0)) {
-        return "clear requiresとupsert/remove requirementは併用できません";
+        return "clear requires cannot be combined with upsert/remove requirements";
     }
     const removedTags = new Set(removeTags);
     if (addTags.some((tag) => removedTags.has(tag))) {
-        return "同じtagをaddとremoveへ同時指定できません";
+        return "the same tag cannot be specified in both add and remove";
     }
     const removedResources = new Set(removeRequirements);
     if (upsertRequirements.some(({ resourceId }) => removedResources.has(resourceId))) {
-        return "同じresourceをupsertとremoveへ同時指定できません";
+        return "the same resource cannot be specified in both upsert and remove";
     }
     const upsertIds = upsertRequirements.map(({ resourceId }) => resourceId);
     if (new Set(upsertIds).size !== upsertIds.length) {
-        return "upsert requirementのresourceが重複しています";
+        return "upsert requirements contain duplicate resources";
     }
     return undefined;
 }
@@ -370,8 +418,8 @@ function currentRequirements(task) {
         ? value.map(({ resourceId, units }) => ({ resourceId, units }))
         : [];
 }
-function planSetTask(text, task, mutation) {
-    const error = setRequestError(mutation);
+function planSetTask(text, task, mutation, profile) {
+    const error = setRequestError(mutation, profile);
     if (error !== undefined) {
         return { edits: [], diagnostic: mutationDiagnostic("PTMUT-301", error, task) };
     }
@@ -380,10 +428,14 @@ function planSetTask(text, task, mutation) {
     const edits = [];
     const deleted = new Set(mutation.clear ?? []);
     const additions = new Map();
+    const rank = fieldRank(profile);
     const queueAddition = (name, value) => {
-        const offset = fieldInsertionOffset(task, name, deleted, lines, fieldRank);
+        const offset = fieldInsertionOffset(task, name, deleted, lines, rank);
         const entries = additions.get(offset) ?? [];
-        entries.push({ name, serialized: serializeField(name, value, lineEnding) });
+        entries.push({
+            name,
+            serialized: serializeField(name, value, lineEnding, profile),
+        });
         additions.set(offset, entries);
     };
     const setScalar = (name, value, valueText) => {
@@ -432,6 +484,7 @@ function planSetTask(text, task, mutation) {
         });
     }
     const set = mutation.set ?? {};
+    const targetSet = set;
     if (set.title !== undefined)
         setScalar("title", set.title, JSON.stringify(set.title));
     if (set.description !== undefined)
@@ -440,13 +493,13 @@ function planSetTask(text, task, mutation) {
         const duration = fieldNamed(task, "duration");
         const estimate = fieldNamed(task, "estimate");
         if (duration !== undefined) {
-            setScalar("duration", set.duration, canonicalDuration(set.duration));
+            setScalar("duration", set.duration, canonicalDuration(set.duration, profile));
         }
         else if (estimate !== undefined) {
             edits.push({
                 startOffset: estimate.span.start.offset,
                 endOffset: contentTextEndOffset(estimate, lines),
-                replacement: serializeField("duration", set.duration, lineEnding),
+                replacement: serializeField("duration", set.duration, lineEnding, profile),
             });
         }
     }
@@ -463,7 +516,7 @@ function planSetTask(text, task, mutation) {
                 edits.push({
                     startOffset: child.valueSpan.start.offset,
                     endOffset: child.valueSpan.end.offset,
-                    replacement: canonicalDuration(value),
+                    replacement: canonicalDuration(value, profile),
                 });
             }
         }
@@ -471,10 +524,16 @@ function planSetTask(text, task, mutation) {
             edits.push({
                 startOffset: duration.span.start.offset,
                 endOffset: contentTextEndOffset(duration, lines),
-                replacement: serializeEstimate(set.estimate, lineEnding),
+                replacement: serializeEstimate(set.estimate, lineEnding, profile),
             });
         }
     }
+    if (profile.temporalFields && targetSet.notBefore !== undefined) {
+        setScalar("not_before", targetSet.notBefore, targetSet.notBefore);
+    }
+    if (profile.temporalFields && targetSet.deadline !== undefined) {
+        setScalar("deadline", targetSet.deadline, targetSet.deadline);
+    }
     if (set.status !== undefined)
         setScalar("status", set.status, set.status);
     if (set.priority !== undefined)
@@ -586,7 +645,7 @@ function planSetTask(text, task, mutation) {
             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));
+        entries.sort((left, right) => (rank.get(left.name) ?? 99) - (rank.get(right.name) ?? 99));
         edits.push({
             startOffset: offset,
             endOffset: offset,
@@ -595,7 +654,7 @@ function planSetTask(text, task, mutation) {
     }
     return { edits };
 }
-export function planTaskMutationEdits(text, document, mutation) {
+export function planTaskMutationEdits(text, document, mutation, profile = ACTIVE_TASK_MUTATION_PROFILE) {
     const requestError = taskMutationRequestError(mutation);
     if (requestError !== undefined) {
         return {
@@ -608,21 +667,21 @@ export function planTaskMutationEdits(text, document, mutation) {
         if (entity !== undefined) {
             return {
                 edits: [],
-                diagnostic: mutationDiagnostic("PTMUT-304", `entity ID ${mutation.id}はすでに使用されています`, entity),
+                diagnostic: mutationDiagnostic("PTMUT-304", `entity ID ${mutation.id} is already in use`, entity),
             };
         }
-        return addTaskPlan(text, mutation);
+        return addTaskPlan(text, mutation, profile);
     }
     if (entity === undefined) {
         return {
             edits: [],
-            diagnostic: mutationDiagnostic("PTMUT-302", `task ${mutation.id}が存在しません`),
+            diagnostic: mutationDiagnostic("PTMUT-302", `task ${mutation.id} does not exist`),
         };
     }
     if (entity.kind !== "task") {
         return {
             edits: [],
-            diagnostic: mutationDiagnostic("PTMUT-303", `entity ${mutation.id}はtaskではありません`, entity),
+            diagnostic: mutationDiagnostic("PTMUT-303", `entity ${mutation.id} is not a task`, entity),
         };
     }
     const lines = splitPhysicalLines(text);
@@ -637,8 +696,8 @@ export function planTaskMutationEdits(text, document, mutation) {
             ...(fieldNamed(entity, "blocked_reason") === undefined
                 ? {}
                 : { clear: ["blocked_reason"] }),
-        });
+        }, profile);
     }
-    return planSetTask(text, entity, mutation);
+    return planSetTask(text, entity, mutation, profile);
 }
 //# sourceMappingURL=task.js.map