@semacode/cli 1.5.14 → 1.5.16

package/src/php-symbols.ts

@@ -0,0 +1,462 @@
+export interface ParametroPhpExtraido {
+  nome: string;
+  obrigatorio: boolean;
+  tipoTexto?: string;
+}
+
+export interface ParametroRotaPhp {
+  nome: string;
+  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
+}
+
+export interface SimboloPhpExtraido {
+  simbolo: string;
+  retorno?: string;
+  parametros: ParametroPhpExtraido[];
+}
+
+export interface RotaPhpExtraida {
+  origem: "php";
+  metodo: string;
+  caminho: string;
+  simbolo: string;
+  parametros: ParametroRotaPhp[];
+  retorno?: string;
+}
+
+const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+const METODOS_RECURSO_LARAVEL: Array<{ metodo: string; sufixo: string; acao: string }> = [
+  { metodo: "GET", sufixo: "", acao: "index" },
+  { metodo: "POST", sufixo: "", acao: "store" },
+  { metodo: "GET", sufixo: "/{id}", acao: "show" },
+  { metodo: "PUT", sufixo: "/{id}", acao: "update" },
+  { metodo: "PATCH", sufixo: "/{id}", acao: "update" },
+  { metodo: "DELETE", sufixo: "/{id}", acao: "destroy" },
+];
+
+function removerComentariosPhp(codigo: string): string {
+  return codigo
+    .replace(/<\?(?:php)?|(\?>)/gi, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/(^|[^\:])\/\/[^\r\n]*/g, "$1")
+    .replace(/#[^\[\r\n][^\r\n]*/g, "");
+}
+
+function contarChar(texto: string, alvo: string): number {
+  return [...texto].filter((char) => char === alvo).length;
+}
+
+function normalizarNamespacePhp(valor?: string): string {
+  return (valor ?? "")
+    .replace(/^\\+|\\+$/g, "")
+    .replace(/\\/g, ".")
+    .replace(/::/g, ".")
+    .replace(/\.+/g, ".")
+    .replace(/^\.+|\.+$/g, "");
+}
+
+function normalizarSimboloPhp(valor: string): string {
+  return normalizarNamespacePhp(valor)
+    .replace(/\$\b/g, "")
+    .replace(/\.+/g, ".")
+    .replace(/^\.+|\.+$/g, "");
+}
+
+function dividirListaUsePhp(declaracao: string): string[] {
+  const partes: string[] = [];
+  let atual = "";
+  let profundidade = 0;
+  for (const caractere of declaracao) {
+    if (caractere === "," && profundidade === 0) {
+      if (atual.trim()) {
+        partes.push(atual.trim());
+      }
+      atual = "";
+      continue;
+    }
+    if (caractere === "{") {
+      profundidade += 1;
+    } else if (caractere === "}" && profundidade > 0) {
+      profundidade -= 1;
+    }
+    atual += caractere;
+  }
+  if (atual.trim()) {
+    partes.push(atual.trim());
+  }
+  return partes;
+}
+
+function registrarUsePhp(imports: Map<string, string>, item: string): void {
+  const alias = item.match(/\s+as\s+([A-Za-z_]\w*)$/i)?.[1];
+  const semAlias = item.replace(/\s+as\s+[A-Za-z_]\w*$/i, "").trim();
+  const completo = normalizarNamespacePhp(semAlias);
+  const nome = alias ?? completo.split(".").at(-1);
+  if (nome && completo) {
+    imports.set(nome, completo);
+  }
+}
+
+function extrairImportsPhp(codigo: string): Map<string, string> {
+  const imports = new Map<string, string>();
+  for (const match of codigo.matchAll(/\buse\s+(?!function\b|const\b)([^;]+);/gi)) {
+    const declaracao = match[1]!.trim();
+    const grupo = declaracao.match(/^(.+?)\\\{(.+)\}$/);
+    if (grupo) {
+      const base = grupo[1]!;
+      for (const item of dividirListaUsePhp(grupo[2]!)) {
+        registrarUsePhp(imports, `${base}\\${item}`);
+      }
+      continue;
+    }
+    for (const item of dividirListaUsePhp(declaracao)) {
+      registrarUsePhp(imports, item);
+    }
+  }
+  return imports;
+}
+
+function resolverClassePhp(classe: string, imports: Map<string, string>): string {
+  const normalizada = normalizarNamespacePhp(classe);
+  const partes = normalizada.split(".").filter(Boolean);
+  const primeiro = partes[0];
+  if (primeiro && imports.has(primeiro)) {
+    return [imports.get(primeiro), ...partes.slice(1)].filter(Boolean).join(".");
+  }
+  return normalizada;
+}
+
+function juntarSimbolo(...partes: Array<string | undefined>): string {
+  return partes.map(normalizarNamespacePhp).filter(Boolean).join(".");
+}
+
+function normalizarCaminhoPhp(caminho: string): string {
+  const semAspas = caminho.trim().replace(/^['"]|['"]$/g, "");
+  return `/${semAspas.replace(/^\/+|\/+$/g, "")}`
+    .replace(/:([A-Za-z_]\w*)/g, "{$1}")
+    .replace(/\{([A-Za-z_]\w*)\??\}/g, "{$1}")
+    .replace(/\/+/g, "/");
+}
+
+function juntarCaminho(base: string | undefined, sufixo: string | undefined): string {
+  const partes = [base, sufixo]
+    .map((parte) => parte?.trim())
+    .filter((parte): parte is string => Boolean(parte))
+    .map((parte) => parte.replace(/^\/+|\/+$/g, ""));
+  return normalizarCaminhoPhp(partes.join("/"));
+}
+
+function mapearTipoRotaPhp(tipo?: string): ParametroRotaPhp["tipoSema"] {
+  const normalizado = (tipo ?? "").replace(/^\?/, "").replace(/^\\+/, "").toLowerCase();
+  if (/^(int|integer)$/.test(normalizado)) {
+    return "Inteiro";
+  }
+  if (/^(float|double|decimal)$/.test(normalizado)) {
+    return "Decimal";
+  }
+  if (/uuid|id$/.test(normalizado)) {
+    return "Id";
+  }
+  return "Texto";
+}
+
+function dividirParametrosPhp(parametros: string): ParametroPhpExtraido[] {
+  const encontrados: ParametroPhpExtraido[] = [];
+
+  for (const parametro of parametros.split(",")) {
+    const item = parametro.trim();
+    if (!item) {
+      continue;
+    }
+    const normalizado = item
+      .replace(/#\[[^\]]+\]\s*/g, "")
+      .replace(/=.*$/, "")
+      .replace(/\b(?:public|protected|private|readonly)\s+/g, "")
+      .replace(/&/g, "")
+      .replace(/\.\.\./g, "")
+      .trim();
+    const match = normalizado.match(/^(?:(?<tipo>[?\\A-Za-z_][\\A-Za-z0-9_|.[\]?]*(?:\s*\|\s*[?\\A-Za-z_][\\A-Za-z0-9_|.[\]?]*)*)\s+)?\$(?<nome>[A-Za-z_]\w*)$/);
+    if (!match?.groups?.["nome"]) {
+      continue;
+    }
+    const tipoTexto = match.groups["tipo"]?.replace(/\s+/g, "") || undefined;
+    encontrados.push({
+      nome: match.groups["nome"],
+      ...(tipoTexto ? { tipoTexto } : {}),
+      obrigatorio: !tipoTexto?.startsWith("?"),
+    });
+  }
+
+  return encontrados;
+}
+
+function extrairParametrosRotaPhp(caminho: string, parametros: ParametroPhpExtraido[] = []): ParametroRotaPhp[] {
+  const tipos = new Map(parametros.map((parametro) => [parametro.nome, parametro.tipoTexto] as const));
+  return [...normalizarCaminhoPhp(caminho).matchAll(/\{([^}]+)\}/g)].map((match) => {
+    const nome = match[1]!;
+    return {
+      nome,
+      tipoSema: mapearTipoRotaPhp(tipos.get(nome)),
+    };
+  });
+}
+
+function extrairAtributosPhp(linhas: string[], inicio: number): { atributos: string[]; proximoIndice: number } {
+  const atributos: string[] = [];
+  let indice = inicio;
+  while (indice < linhas.length) {
+    const linha = linhas[indice]!.trim();
+    if (!linha.startsWith("#[")) {
+      break;
+    }
+    let atual = linha;
+    let saldo = contarChar(linha, "[") - contarChar(linha, "]");
+    while (saldo > 0 && indice + 1 < linhas.length) {
+      indice += 1;
+      const complemento = linhas[indice]!.trim();
+      atual += ` ${complemento}`;
+      saldo += contarChar(complemento, "[") - contarChar(complemento, "]");
+    }
+    atributos.push(atual);
+    indice += 1;
+  }
+  return { atributos, proximoIndice: indice };
+}
+
+function extrairCaminhoAtributoPhp(atributo: string): string | undefined {
+  return atributo.match(/(?:path\s*:\s*)?["']([^"']+)["']/i)?.[1];
+}
+
+function extrairMetodosAtributoPhp(atributo: string): string[] {
+  const direto = atributo.match(/#\[\s*(?:[A-Za-z_\\][A-Za-z0-9_\\]*\\)?(Get|Post|Put|Patch|Delete)\b/i)?.[1]?.toUpperCase();
+  if (direto && METODOS_HTTP.has(direto)) {
+    return [direto];
+  }
+  const encontrados = [...atributo.matchAll(/["'](GET|POST|PUT|PATCH|DELETE)["']/gi)]
+    .map((match) => match[1]!.toUpperCase())
+    .filter((metodo) => METODOS_HTTP.has(metodo));
+  return encontrados.length > 0 ? [...new Set(encontrados)] : [];
+}
+
+function registrarSimbolo(
+  simbolos: Map<string, SimboloPhpExtraido>,
+  simbolo: string,
+  parametros: string,
+  retorno?: string,
+): void {
+  const normalizado = normalizarSimboloPhp(simbolo);
+  if (!normalizado) {
+    return;
+  }
+  simbolos.set(normalizado, {
+    simbolo: normalizado,
+    retorno: retorno?.replace(/[;{].*$/, "").trim() || undefined,
+    parametros: dividirParametrosPhp(parametros),
+  });
+}
+
+function extrairSimboloHandlerPhp(handler: string, imports = new Map<string, string>()): string | undefined {
+  const arrayClass = handler.match(/\[\s*([A-Za-z_\\][A-Za-z0-9_\\]*)::class\s*,\s*["']([A-Za-z_]\w*)["']\s*\]/);
+  if (arrayClass) {
+    return normalizarSimboloPhp(`${resolverClassePhp(arrayClass[1]!, imports)}.${arrayClass[2]!}`);
+  }
+
+  const stringController = handler.match(/["']([A-Za-z_\\][A-Za-z0-9_\\]*)@([A-Za-z_]\w*)["']/);
+  if (stringController) {
+    return normalizarSimboloPhp(`${resolverClassePhp(stringController[1]!, imports)}.${stringController[2]!}`);
+  }
+
+  const invokable = handler.match(/([A-Za-z_\\][A-Za-z0-9_\\]*)::class/);
+  if (invokable) {
+    return normalizarSimboloPhp(`${resolverClassePhp(invokable[1]!, imports)}.__invoke`);
+  }
+
+  const callable = handler.match(/([A-Za-z_\\][A-Za-z0-9_\\]*)::([A-Za-z_]\w*)/);
+  if (callable) {
+    return normalizarSimboloPhp(`${resolverClassePhp(callable[1]!, imports)}.${callable[2]!}`);
+  }
+
+  return undefined;
+}
+
+function registrarRota(
+  rotas: Map<string, RotaPhpExtraida>,
+  metodo: string,
+  caminho: string,
+  simbolo: string,
+  parametros: ParametroPhpExtraido[] = [],
+  retorno?: string,
+): void {
+  const metodoNormalizado = metodo.toUpperCase();
+  if (!METODOS_HTTP.has(metodoNormalizado)) {
+    return;
+  }
+  const caminhoNormalizado = normalizarCaminhoPhp(caminho);
+  const simboloNormalizado = normalizarSimboloPhp(simbolo);
+  if (!simboloNormalizado) {
+    return;
+  }
+  rotas.set(`${metodoNormalizado}:${caminhoNormalizado}:${simboloNormalizado}`, {
+    origem: "php",
+    metodo: metodoNormalizado,
+    caminho: caminhoNormalizado,
+    simbolo: simboloNormalizado,
+    parametros: extrairParametrosRotaPhp(caminhoNormalizado, parametros),
+    retorno,
+  });
+}
+
+export function extrairSimbolosPhp(codigo: string): SimboloPhpExtraido[] {
+  const simbolos = new Map<string, SimboloPhpExtraido>();
+  const linhas = removerComentariosPhp(codigo).split(/\r?\n/);
+  const pilhaClasses: Array<{ nome: string; profundidade: number }> = [];
+  let classePendente: { nome: string; profundidade: number } | undefined;
+  let namespaceAtual = "";
+  let profundidade = 0;
+
+  for (let indice = 0; indice < linhas.length; indice += 1) {
+    const linhaOriginal = linhas[indice]!;
+    const linhaTrim = linhaOriginal.trim();
+    const namespace = linhaTrim.match(/^namespace\s+([^;{]+)[;{]/);
+    if (namespace) {
+      namespaceAtual = normalizarNamespacePhp(namespace[1]);
+    }
+
+    if (classePendente && linhaTrim.startsWith("{")) {
+      pilhaClasses.push(classePendente);
+      classePendente = undefined;
+    }
+
+    const { atributos, proximoIndice } = extrairAtributosPhp(linhas, indice);
+    if (atributos.length > 0) {
+      indice = proximoIndice;
+    }
+    const linha = (linhas[indice] ?? linhaOriginal).trim();
+
+    const classe = linha.match(/\b(?:abstract\s+|final\s+)?(?:class|trait|interface|enum)\s+([A-Za-z_]\w*)/);
+    if (classe) {
+      const entrada = { nome: classe[1]!, profundidade: profundidade + 1 };
+      if (linha.includes("{")) {
+        pilhaClasses.push(entrada);
+      } else {
+        classePendente = entrada;
+      }
+    }
+
+    const metodo = linha.match(/\b(?:public|protected|private)?\s*(?:static\s+)?function\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?::\s*([^;{]+))?/);
+    if (metodo) {
+      const classeAtual = pilhaClasses[pilhaClasses.length - 1]?.nome;
+      registrarSimbolo(
+        simbolos,
+        juntarSimbolo(namespaceAtual, classeAtual, metodo[1]),
+        metodo[2] ?? "",
+        metodo[3],
+      );
+    }
+
+    for (const closure of linha.matchAll(/\$([A-Za-z_]\w*)\s*=\s*(?:static\s+)?function\s*\(([^)]*)\)\s*(?::\s*([^;{]+))?/g)) {
+      registrarSimbolo(simbolos, juntarSimbolo(namespaceAtual, closure[1]), closure[2] ?? "", closure[3]);
+    }
+
+    profundidade += contarChar(linha, "{") - contarChar(linha, "}");
+    while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
+      pilhaClasses.pop();
+    }
+  }
+
+  return [...simbolos.values()].sort((a, b) => a.simbolo.localeCompare(b.simbolo, "pt-BR"));
+}
+
+export function extrairRotasPhp(codigo: string): RotaPhpExtraida[] {
+  const rotas = new Map<string, RotaPhpExtraida>();
+  const texto = removerComentariosPhp(codigo);
+  const imports = extrairImportsPhp(texto);
+  const linhas = texto.split(/\r?\n/);
+  const pilhaClasses: Array<{ nome: string; profundidade: number; caminhoBase?: string }> = [];
+  let classePendente: { nome: string; profundidade: number; caminhoBase?: string } | undefined;
+  let namespaceAtual = "";
+  let profundidade = 0;
+
+  for (const match of texto.matchAll(/\bRoute::(get|post|put|patch|delete)\s*\(\s*["']([^"']+)["']\s*,\s*([\s\S]*?)\)\s*;/gi)) {
+    const simbolo = extrairSimboloHandlerPhp(match[3] ?? "", imports);
+    if (simbolo) {
+      registrarRota(rotas, match[1]!, match[2]!, simbolo);
+    }
+  }
+
+  for (const match of texto.matchAll(/\$[A-Za-z_]\w*->(get|post|put|patch|delete)\s*\(\s*["']([^"']+)["']\s*,\s*([\s\S]*?)\)\s*;/gi)) {
+    const simbolo = extrairSimboloHandlerPhp(match[3] ?? "", imports);
+    if (simbolo) {
+      registrarRota(rotas, match[1]!, match[2]!, simbolo);
+    }
+  }
+
+  for (const match of texto.matchAll(/\bRoute::(?:apiResource|resource)\s*\(\s*["']([^"']+)["']\s*,\s*([A-Za-z_\\][A-Za-z0-9_\\]*)::class/gi)) {
+    const recurso = match[1]!;
+    const classe = resolverClassePhp(match[2]!, imports);
+    for (const rota of METODOS_RECURSO_LARAVEL) {
+      registrarRota(rotas, rota.metodo, juntarCaminho(recurso, rota.sufixo), `${classe}.${rota.acao}`);
+    }
+  }
+
+  for (let indice = 0; indice < linhas.length; indice += 1) {
+    const linhaOriginal = linhas[indice]!;
+    const linhaTrim = linhaOriginal.trim();
+    const namespace = linhaTrim.match(/^namespace\s+([^;{]+)[;{]/);
+    if (namespace) {
+      namespaceAtual = normalizarNamespacePhp(namespace[1]);
+    }
+
+    if (classePendente && linhaTrim.startsWith("{")) {
+      pilhaClasses.push(classePendente);
+      classePendente = undefined;
+    }
+
+    const { atributos, proximoIndice } = extrairAtributosPhp(linhas, indice);
+    if (atributos.length > 0) {
+      indice = proximoIndice;
+    }
+    const linha = (linhas[indice] ?? linhaOriginal).trim();
+    const caminhoClasse = atributos.find((atributo) => /#\[\s*(?:[A-Za-z_\\][A-Za-z0-9_\\]*\\)?Route\b/i.test(atributo))
+      ? extrairCaminhoAtributoPhp(atributos.find((atributo) => /#\[\s*(?:[A-Za-z_\\][A-Za-z0-9_\\]*\\)?Route\b/i.test(atributo))!)
+      : undefined;
+
+    const classe = linha.match(/\b(?:abstract\s+|final\s+)?(?:class|trait|interface|enum)\s+([A-Za-z_]\w*)/);
+    if (classe) {
+      const entrada = { nome: classe[1]!, profundidade: profundidade + 1, caminhoBase: caminhoClasse };
+      if (linha.includes("{")) {
+        pilhaClasses.push(entrada);
+      } else {
+        classePendente = entrada;
+      }
+    }
+
+    const metodo = linha.match(/\b(?:public|protected|private)?\s*(?:static\s+)?function\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?::\s*([^;{]+))?/);
+    if (metodo) {
+      const classeAtual = pilhaClasses[pilhaClasses.length - 1];
+      const atributosRota = atributos.filter((atributo) =>
+        /#\[\s*(?:[A-Za-z_\\][A-Za-z0-9_\\]*\\)?(?:Route|Get|Post|Put|Patch|Delete)\b/i.test(atributo));
+      for (const atributo of atributosRota) {
+        const caminho = extrairCaminhoAtributoPhp(atributo);
+        if (!caminho) {
+          continue;
+        }
+        const metodos = extrairMetodosAtributoPhp(atributo);
+        const simbolo = juntarSimbolo(namespaceAtual, classeAtual?.nome, metodo[1]);
+        for (const metodoHttp of metodos.length > 0 ? metodos : ["GET"]) {
+          registrarRota(rotas, metodoHttp, juntarCaminho(classeAtual?.caminhoBase, caminho), simbolo, dividirParametrosPhp(metodo[2] ?? ""), metodo[3]);
+        }
+      }
+    }
+
+    profundidade += contarChar(linha, "{") - contarChar(linha, "}");
+    while (pilhaClasses.length > 0 && profundidade < pilhaClasses[pilhaClasses.length - 1]!.profundidade) {
+      pilhaClasses.pop();
+    }
+  }
+
+  return [...rotas.values()].sort((a, b) =>
+    a.caminho.localeCompare(b.caminho, "pt-BR")
+    || a.metodo.localeCompare(b.metodo, "pt-BR")
+    || a.simbolo.localeCompare(b.simbolo, "pt-BR"));
+}