android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/android/resources.js

@@ -0,0 +1,398 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, join, relative, sep } from "node:path";
+import { hardFailure } from "../diagnostics.js";
+import { combinedProductFlavorSourceSetName } from "../project/gradle-model.js";
+import { elementText, parseXml } from "./xml-parser.js";
+const XML_RESOURCE_TYPES = new Set(["layout", "xml", "navigation", "menu"]);
+const DENSITIES = new Set([
+  "ldpi",
+  "mdpi",
+  "tvdpi",
+  "hdpi",
+  "xhdpi",
+  "xxhdpi",
+  "xxxhdpi",
+  "anydpi",
+  "nodpi",
+]);
+function relativePath(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+function location(root, path, anchor, startLine, endLine, sourceKind) {
+  return {
+    sourceKind,
+    path: relativePath(root, path),
+    anchor,
+    range: { startLine, endLine },
+  };
+}
+function parseLocale(parts, index) {
+  const part = parts[index] ?? "";
+  if (/^[a-z]{2,3}$/u.test(part)) {
+    const region = /^r([A-Z]{2}|\d{3})$/u.exec(parts[index + 1] ?? "");
+    return {
+      locale: region ? `${part}-${region[1]}` : part,
+      consumed: region ? 2 : 1,
+      unsupported: false,
+    };
+  }
+  if (part.startsWith("b+")) {
+    const segments = part.slice(2).split("+");
+    const language = segments[0];
+    const region = segments.find((segment) =>
+      /^([A-Z]{2}|\d{3})$/u.test(segment),
+    );
+    const hasScript = segments.some((segment) =>
+      /^[A-Z][a-z]{3}$/u.test(segment),
+    );
+    return {
+      locale:
+        language && !hasScript
+          ? `${language}${region ? `-${region}` : ""}`
+          : undefined,
+      consumed: 1,
+      unsupported: !language || hasScript,
+    };
+  }
+  return { consumed: 0, unsupported: false };
+}
+function parseQualifiers(directory, resourceType) {
+  const suffix = directory.slice(resourceType.length).replace(/^-/, "");
+  const parts = suffix.length === 0 ? [] : suffix.split("-");
+  const result = { raw: suffix || "default", unsupported: false };
+  for (let index = 0; index < parts.length;) {
+    const locale = parseLocale(parts, index);
+    if (locale.consumed > 0) {
+      if (result.locale || locale.unsupported) result.unsupported = true;
+      else result.locale = locale.locale;
+      index += locale.consumed;
+      continue;
+    }
+    const part = parts[index];
+    if (part === "port" || part === "land") {
+      result.orientation = part === "port" ? "portrait" : "landscape";
+    } else if (part === "night" || part === "notnight") {
+      result.uiMode = part;
+    } else if (/^sw\d+dp$/u.test(part)) {
+      result.smallestWidthDp = Number(part.slice(2, -2));
+    } else if (/^v\d+$/u.test(part)) {
+      result.apiLevel = Number(part.slice(1));
+    } else if (DENSITIES.has(part) || /^\d+dpi$/u.test(part)) {
+      result.density = part;
+    } else {
+      result.unsupported = true;
+    }
+    index += 1;
+  }
+  return result;
+}
+function sourceSetPriority(selected, sourceSet) {
+  const flavors = selected.variant.productFlavors.map((flavor) => flavor.name);
+  if (sourceSet.name === "main") return 0;
+  const flavorIndex = flavors.indexOf(sourceSet.name);
+  if (flavorIndex >= 0) return 20 + flavorIndex;
+  if (
+    flavors.length > 1 &&
+    sourceSet.name === combinedProductFlavorSourceSetName(selected.variant)
+  )
+    return 50;
+  if (sourceSet.name === selected.variant.buildType) return 70;
+  if (sourceSet.name === selected.variant.name) return 90;
+  return 10;
+}
+function modulePriority(selected, module) {
+  if (module.gradlePath === selected.applicationModule.gradlePath)
+    return 10_000;
+  const index = selected.reachableModules.findIndex(
+    (candidate) => candidate.gradlePath === module.gradlePath,
+  );
+  return Math.max(0, index);
+}
+function valueOf(element) {
+  if (
+    element.name === "array" ||
+    element.name === "string-array" ||
+    element.name === "integer-array"
+  ) {
+    return element.children
+      .filter((child) => child.name === "item")
+      .map((child) => elementText(child));
+  }
+  if (element.name === "plurals") {
+    return Object.fromEntries(
+      element.children
+        .filter((child) => child.name === "item")
+        .map((child) => [
+          child.attributes.quantity ?? "other",
+          elementText(child),
+        ]),
+    );
+  }
+  return elementText(element);
+}
+function collectValues(selected, path, qualifiers, overlay) {
+  const source = readFileSync(path, "utf8");
+  const root = parseXml(source);
+  if (root.name !== "resources") return [];
+  return root.children.flatMap((element) => {
+    const declaredType =
+      element.name === "item" ? element.attributes.type : element.name;
+    // Android exposes all three XML collection declarations through R.array.
+    const resourceType =
+      declaredType === "array" ||
+      declaredType === "string-array" ||
+      declaredType === "integer-array"
+        ? "array"
+        : declaredType;
+    const name = element.attributes.name;
+    if (!resourceType || !name) return [];
+    const key = `${resourceType}/${name}`;
+    return [
+      {
+        key,
+        resourceType,
+        name,
+        value: valueOf(element),
+        qualifiers,
+        overlay,
+        path,
+        evidence: location(
+          selected.model.projectRoot,
+          path,
+          `@${key}`,
+          element.startLine,
+          element.endLine,
+          "resource",
+        ),
+      },
+    ];
+  });
+}
+function walkResourceDirectories(selected) {
+  const values = [];
+  const xml = [];
+  for (const module of selected.reachableModules) {
+    const sourceSets = selected.activeSourceSets.get(module.gradlePath) ?? [];
+    for (const sourceSet of sourceSets) {
+      const overlay =
+        modulePriority(selected, module) * 100 +
+        sourceSetPriority(selected, sourceSet);
+      for (const resRoot of sourceSet.res) {
+        if (!existsSync(resRoot) || !statSync(resRoot).isDirectory()) continue;
+        const directories = readdirSync(resRoot, { withFileTypes: true })
+          .filter((entry) => entry.isDirectory())
+          .sort((left, right) => left.name.localeCompare(right.name, "en"));
+        for (const directory of directories) {
+          const resourceType = directory.name.split("-")[0];
+          if (
+            resourceType !== "values" &&
+            !XML_RESOURCE_TYPES.has(resourceType)
+          )
+            continue;
+          const qualifiers = parseQualifiers(directory.name, resourceType);
+          const files = readdirSync(join(resRoot, directory.name), {
+            withFileTypes: true,
+          })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".xml"))
+            .sort((left, right) => left.name.localeCompare(right.name, "en"));
+          for (const file of files) {
+            const path = join(resRoot, directory.name, file.name);
+            if (resourceType === "values") {
+              values.push(
+                ...collectValues(selected, path, qualifiers, overlay),
+              );
+              continue;
+            }
+            const type = resourceType;
+            const name = basename(file.name, ".xml");
+            const source = readFileSync(path, "utf8");
+            const root = parseXml(source);
+            xml.push({
+              key: `${type}/${name}`,
+              resourceType: type,
+              name,
+              qualifiers,
+              overlay,
+              path,
+              evidence: location(
+                selected.model.projectRoot,
+                path,
+                `@${type}/${name}`,
+                root.startLine,
+                root.endLine,
+                "xml",
+              ),
+            });
+          }
+        }
+      }
+    }
+  }
+  return { values, xml };
+}
+function localeScore(candidate, requested) {
+  if (!candidate) return 0;
+  const normalizedCandidate = candidate.replace("_", "-").toLowerCase();
+  const normalizedRequested = requested.replace("_", "-").toLowerCase();
+  if (normalizedCandidate === normalizedRequested) return 2;
+  if (
+    !normalizedCandidate.includes("-") &&
+    normalizedRequested.split("-")[0] === normalizedCandidate
+  )
+    return 1;
+  return -1;
+}
+function densityScore(candidate, requested) {
+  if (!candidate) return 0;
+  if (candidate === requested) return 4;
+  if (candidate === "anydpi") return 3;
+  if (candidate === "nodpi") return 2;
+  return requested ? 1 : -1;
+}
+function matchScore(qualifiers, configuration) {
+  if (qualifiers.unsupported) return undefined;
+  const locale = localeScore(qualifiers.locale, configuration.locale);
+  if (locale < 0) return undefined;
+  if (
+    qualifiers.orientation &&
+    qualifiers.orientation !== configuration.orientation
+  )
+    return undefined;
+  if (qualifiers.uiMode && qualifiers.uiMode !== configuration.uiMode) {
+    return undefined;
+  }
+  const smallestWidth = qualifiers.smallestWidthDp ?? 0;
+  if (
+    qualifiers.smallestWidthDp !== undefined &&
+    (configuration.smallestWidthDp === undefined ||
+      qualifiers.smallestWidthDp > configuration.smallestWidthDp)
+  )
+    return undefined;
+  const apiLevel = qualifiers.apiLevel ?? 0;
+  if (
+    qualifiers.apiLevel !== undefined &&
+    (configuration.apiLevel === undefined ||
+      qualifiers.apiLevel > configuration.apiLevel)
+  )
+    return undefined;
+  const density = densityScore(qualifiers.density, configuration.density);
+  if (density < 0) return undefined;
+  return [
+    locale,
+    smallestWidth,
+    qualifiers.orientation ? 1 : 0,
+    qualifiers.uiMode ? 1 : 0,
+    density,
+    apiLevel,
+  ];
+}
+function compareScore(left, right) {
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function selectCandidates(candidates, configuration) {
+  const overlays = new Map();
+  for (const candidate of candidates) {
+    const key = `${candidate.key}\0${candidate.qualifiers.raw}`;
+    const existing = overlays.get(key);
+    if (
+      !existing ||
+      candidate.overlay > existing.overlay ||
+      (candidate.overlay === existing.overlay &&
+        candidate.path.localeCompare(existing.path, "en") > 0)
+    )
+      overlays.set(key, candidate);
+  }
+  const selected = new Map();
+  for (const candidate of overlays.values()) {
+    const score = matchScore(candidate.qualifiers, configuration);
+    if (!score) continue;
+    const existing = selected.get(candidate.key);
+    if (
+      !existing ||
+      compareScore(score, existing.score) > 0 ||
+      (compareScore(score, existing.score) === 0 &&
+        candidate.qualifiers.raw.localeCompare(
+          existing.candidate.qualifiers.raw,
+          "en",
+        ) < 0)
+    )
+      selected.set(candidate.key, { candidate, score });
+  }
+  return [...selected.values()]
+    .map(({ candidate }) => candidate)
+    .sort((left, right) => left.key.localeCompare(right.key, "en"));
+}
+export function selectAndroidResources(selected, configuration) {
+  let collected;
+  try {
+    collected = walkResourceDirectories(selected);
+  } catch (error) {
+    throw hardFailure(
+      "ANDROID_RESOURCE_PARSE_FAILED",
+      "resources",
+      `Could not parse Android resources: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  const selectedValues = selectCandidates(collected.values, configuration);
+  const selectedXml = selectCandidates(collected.xml, configuration);
+  const values = selectedValues.map((candidate) => ({
+    resourceType: candidate.resourceType,
+    name: candidate.name,
+    configuration: candidate.qualifiers.raw,
+    value: candidate.value,
+    evidence: candidate.evidence,
+  }));
+  const resources = selectedXml.map((candidate) => ({
+    resourceType: candidate.resourceType,
+    name: candidate.name,
+    configuration: candidate.qualifiers.raw,
+    path: relativePath(selected.model.projectRoot, candidate.path),
+    evidence: candidate.evidence,
+  }));
+  const byKey = new Map(
+    values.map((value) => [`${value.resourceType}/${value.name}`, value.value]),
+  );
+  const resolve = (raw, seen) => {
+    const reference = /^@(?:\+)?([^:/]+)\/([^/]+)$/u.exec(raw);
+    if (!reference || reference[1] === "android") {
+      return raw.startsWith("@") ? undefined : raw;
+    }
+    const key = `${reference[1]}/${reference[2]}`;
+    if (seen.has(key)) return undefined;
+    const value = byKey.get(key);
+    if (value === undefined) return undefined;
+    const nextSeen = new Set([...seen, key]);
+    if (typeof value === "string") {
+      return value.startsWith("@") ? resolve(value, nextSeen) : value;
+    }
+    if (Array.isArray(value)) {
+      const resolvedItems = value.map((item) =>
+        typeof item === "string" && item.startsWith("@")
+          ? resolve(item, nextSeen)
+          : item,
+      );
+      return resolvedItems.some((item) => item === undefined)
+        ? undefined
+        : resolvedItems;
+    }
+    return value;
+  };
+  return {
+    values,
+    resources,
+    resolveAttribute(raw) {
+      const resolved = resolve(raw, new Set());
+      return {
+        raw,
+        ...(typeof resolved === "string" ? { resolved } : {}),
+        ...(resolved !== undefined && typeof resolved !== "string"
+          ? { resolvedValue: resolved }
+          : {}),
+      };
+    },
+  };
+}

package/skills/a2h-app-req-gen/scripts/reqgen/src/android/types.js

@@ -0,0 +1 @@
+export const ANDROID_XML_CONTRACT_VERSION = "1.0.0";