android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/validation/req-text.js

@@ -0,0 +1,195 @@
+function resolvedText(value, fallback) {
+  return value.status === "resolved" ? value.value : fallback;
+}
+export function areaDescriptionMustMarkPending(area) {
+  const featureUnresolvedRefs = new Set(
+    area.features.flatMap((feature) => feature.unresolvedRefs),
+  );
+  const deterministicallyRenderedAreaRefs = new Set();
+  if (area.displayName.status === "unresolved") {
+    deterministicallyRenderedAreaRefs.add(area.displayName.unresolvedRef);
+  }
+  if (area.canonicalPath.status === "unresolved") {
+    deterministicallyRenderedAreaRefs.add(area.canonicalPath.unresolvedRef);
+  }
+  return area.unresolvedRefs.some(
+    (ref) =>
+      !featureUnresolvedRefs.has(ref) &&
+      !deterministicallyRenderedAreaRefs.has(ref),
+  );
+}
+export function featureDescriptionMustMarkPending(feature) {
+  const renderedNameRef =
+    feature.displayName.status === "unresolved"
+      ? feature.displayName.unresolvedRef
+      : undefined;
+  return feature.unresolvedRefs.some((ref) => ref !== renderedNameRef);
+}
+function validateAreaBlock(area, block, blockPath) {
+  const issues = [];
+  const areaName = resolvedText(area.displayName, "Area 名称待确认");
+  const accessLine = block.find((line) => line.startsWith("访问路径："));
+  const descriptionLine = block.find((line) => line.startsWith("区域说明："));
+  if (!accessLine) {
+    issues.push({
+      code: "REQ_ACCESS_PATH_MISSING",
+      path: blockPath,
+      message: `Area ${areaName} is missing 访问路径`,
+    });
+  } else if (accessLine.slice("访问路径：".length).trim().length === 0) {
+    issues.push({
+      code: "REQ_ACCESS_PATH_EMPTY",
+      path: blockPath,
+      message: `Area ${areaName} has an empty 访问路径`,
+    });
+  } else if (!accessLine.includes(areaName)) {
+    issues.push({
+      code: "REQ_ACCESS_PATH_TARGET_MISSING",
+      path: blockPath,
+      message: `访问路径 does not name its target Area: ${areaName}`,
+    });
+  }
+  if (!descriptionLine) {
+    issues.push({
+      code: "REQ_DESCRIPTION_MISSING",
+      path: blockPath,
+      message: `Area ${areaName} is missing 区域说明`,
+    });
+  } else if (descriptionLine.slice("区域说明：".length).trim().length === 0) {
+    issues.push({
+      code: "REQ_DESCRIPTION_EMPTY",
+      path: blockPath,
+      message: `Area ${areaName} has an empty 区域说明`,
+    });
+  }
+  const preconditionLine = block.find((line) => line.startsWith("前置条件："));
+  if (area.preconditions.length > 0 && !preconditionLine) {
+    issues.push({
+      code: "REQ_PRECONDITION_MISSING",
+      path: blockPath,
+      message: `Area ${areaName} has structured preconditions but no 前置条件 line`,
+    });
+  } else if (
+    area.preconditions.length > 0 &&
+    preconditionLine &&
+    preconditionLine.slice("前置条件：".length).trim().length === 0
+  ) {
+    issues.push({
+      code: "REQ_PRECONDITION_EMPTY",
+      path: blockPath,
+      message: `Area ${areaName} has an empty 前置条件 line`,
+    });
+  }
+  const descriptionIndex = block.findIndex((line) =>
+    line.startsWith("区域说明："),
+  );
+  const firstFeatureIndex = block.findIndex((line) =>
+    /^[^：\n]+--.+$/u.test(line),
+  );
+  if (
+    descriptionIndex >= 0 &&
+    firstFeatureIndex >= 0 &&
+    descriptionIndex > firstFeatureIndex
+  ) {
+    issues.push({
+      code: "REQ_BLOCK_ORDER",
+      path: blockPath,
+      message: "区域说明 must appear before feature entries",
+    });
+  }
+  if (
+    areaDescriptionMustMarkPending(area) &&
+    descriptionLine?.includes("待确认") !== true
+  ) {
+    issues.push({
+      code: "REQ_AREA_UNRESOLVED_MARKER_MISSING",
+      path: blockPath,
+      message: `Area ${areaName} has unresolved facts but no local 待确认 marker`,
+    });
+  }
+  let featureSearchIndex = Math.max(0, firstFeatureIndex);
+  for (const feature of area.features) {
+    const featureName = resolvedText(feature.displayName, "控件名称待确认");
+    const heading = `${areaName}页面 - ${featureName}`;
+    const relativeHeadingIndex = block
+      .slice(featureSearchIndex)
+      .findIndex((line) => line === heading);
+    const headingIndex =
+      relativeHeadingIndex < 0 ? -1 : featureSearchIndex + relativeHeadingIndex;
+    if (headingIndex < 0) {
+      issues.push({
+        code: "REQ_FEATURE_MISSING",
+        path: blockPath,
+        message: `Missing feature heading: ${heading}`,
+      });
+      continue;
+    }
+    featureSearchIndex = headingIndex + 1;
+    const nextHeadingOffset = block
+      .slice(headingIndex + 1)
+      .findIndex((line) => /^[^：\n]+页面 - .+$/u.test(line));
+    const featureBlock = block.slice(
+      headingIndex + 1,
+      nextHeadingOffset < 0
+        ? block.length
+        : headingIndex + 1 + nextHeadingOffset,
+    );
+    const followingLine = featureBlock.find((line) => line.trim().length > 0);
+    if (
+      !followingLine ||
+      followingLine.startsWith("访问路径：") ||
+      /^[^：\n]+页面 - .+$/u.test(followingLine)
+    ) {
+      issues.push({
+        code: "REQ_FEATURE_DESCRIPTION_MISSING",
+        path: `${blockPath}/${featureName}`,
+        message: `Feature ${heading} needs a following description line`,
+      });
+    }
+    if (
+      featureDescriptionMustMarkPending(feature) &&
+      !featureBlock.some((line) => line.includes("待确认"))
+    ) {
+      issues.push({
+        code: "REQ_FEATURE_UNRESOLVED_MARKER_MISSING",
+        path: `${blockPath}/${featureName}`,
+        message: `Feature ${heading} has unresolved behavior but no local 待确认 marker`,
+      });
+    }
+  }
+  return issues;
+}
+export function validateReqText(text, reqModel) {
+  const lines = text
+    .replace(/\r\n?/gu, "\n")
+    .normalize("NFC")
+    .split("\n")
+    .map((line) => line.trimEnd());
+  const starts = lines
+    .map((line, index) => (line.startsWith("访问路径：") ? index : -1))
+    .filter((index) => index >= 0);
+  const issues = [];
+  if (starts.length !== reqModel.areas.length) {
+    issues.push({
+      code: "REQ_AREA_BLOCK_COUNT",
+      path: "/",
+      message: `Expected ${reqModel.areas.length} Area blocks, found ${starts.length}`,
+    });
+  }
+  const count = Math.min(starts.length, reqModel.areas.length);
+  for (let index = 0; index < count; index += 1) {
+    const start = starts[index];
+    const end = starts[index + 1] ?? lines.length;
+    issues.push(
+      ...validateAreaBlock(
+        reqModel.areas[index],
+        lines.slice(start, end),
+        `/areas/${index}`,
+      ),
+    );
+  }
+  return {
+    ok: issues.length === 0,
+    issues,
+  };
+}