@semacode/cli 1.5.16 → 1.5.17

package/src/php-symbols.ts

@@ -1,462 +0,0 @@
-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"));
-}