Era pra ser só a lógica de geração de rotas "selecionar um", mas...

infraestrutura/resposta.ts

@@ -1,8 +1,9 @@
 import { Simbolo } from '@designliquido/delegua/fontes/lexador';
 import { DefinirValor, FuncaoConstruto, Isto, Literal, Variavel } from '@designliquido/delegua/fontes/construtos';
-import { Expressao, Retorna } from '@designliquido/delegua/fontes/declaracoes';
+import { Expressao, PropriedadeClasse, Retorna } from '@designliquido/delegua/fontes/declaracoes';
 import { DeleguaClasse, DeleguaFuncao } from '@designliquido/delegua/fontes/estruturas';
 import { ParametroInterface } from '@designliquido/delegua/fontes/interfaces';
+
 import { GeradorExpressoes } from './utilidades/gerador-expressoes';
 
 /**
@@ -13,53 +14,65 @@
 export class Resposta extends DeleguaClasse {
     constructor() {
         const metodos = {};
+        const propriedades = [
+            new PropriedadeClasse(
+                new Simbolo('IDENTIFICADOR', 'mensagem', null, -1, -1),
+                'texto'
+            ),
+            new PropriedadeClasse(
+                new Simbolo('IDENTIFICADOR', 'statusHttp', null, -1, -1),
+                'numero'
+            ),
+            new PropriedadeClasse(
+                new Simbolo('IDENTIFICADOR', 'valores', null, -1, -1),
+                'dicionário'
+            ),
+            new PropriedadeClasse(
+                new Simbolo('IDENTIFICADOR', 'visao', null, -1, -1),
+                'texto'
+            )
+        ];
+
+        // Há duas formas de construção de métodos apenas usando
+        // estruturas de alto nível: declarando cada uma manualmente, 
+        // ou usando o gerador de expressões.
+        // O exemplo abaixo utiliza o gerador de expressões.
+        // Seria o equivalente à seguinte implementação em Delégua:
 
-        // Todo @Italo: Verificar se isso é melhor para instrumentar métodos.
-        /*  const geradorExpressoes = new GeradorExpressoes();
-            metodos['enviar'] = geradorExpressoes.gerarMetodo('enviar', 
-            geradorExpressoes.gerarDeclaracao(
-                [geradorExpressoes.gerarParametro('mensagem', 'numero')],
+        // classe Resposta {
+        //     // Outros método e propriedades aqui
+        //     enviar(mensagem: texto) {
+        //         isto.mensagem = mensagem
+        //         retorna isto
+        //     }
+        // }
+
+        const geradorExpressoes = new GeradorExpressoes();
+        metodos['enviar'] = geradorExpressoes.gerarMetodo('enviar', 
+            geradorExpressoes.gerarConstrutoFuncao(
+                [geradorExpressoes.gerarParametro('mensagem', 'texto')],
                 [
                     geradorExpressoes.gerarAtribuicaoValorEmPropriedadeClasse(
                         'mensagem', 
                         geradorExpressoes.gerarReferenciaVariavel('mensagem')
                     ),
                     geradorExpressoes.gerarRetornoDeFuncao('isto')
                 ]
             )
-        ); */
-
-        metodos['enviar'] = new DeleguaFuncao(
-            'enviar',
-            new FuncaoConstruto(
-                -1,
-                -1,
-                [
-                    {
-                        abrangencia: 'padrao',
-                        tipo: 'numero',
-                        nome: new Simbolo('IDENTIFICADOR', 'mensagem', null, -1, -1)
-                    } as ParametroInterface
-                ],
-                [
-                    new Expressao(
-                        new DefinirValor(
-                            -1,
-                            -1,
-                            new Isto(-1, -1, new Simbolo('ISTO', 'isto', null, -1, -1)),
-                            new Simbolo('IDENTIFICADOR', 'mensagem', null, -1, -1),
-                            new Variavel(-1, new Simbolo('IDENTIFICADOR', 'mensagem', null, -1, -1))
-                        )
-                    ),
-                    new Retorna(
-                        new Simbolo('IDENTIFICADOR', 'qualquerCoisa', null, -1, -1),
-                        new Variavel(-1, new Simbolo('IDENTIFICADOR', 'isto', null, -1, -1))
-                    )
-                ]
-            ),
-            null,
-            false
         );
+
+        // O exemplo abaixo gera um método `status` declarando manualmente
+        // todas as estruturas de alto nível de Delégua.
+        // Seria o equivalente à seguinte implementação:
+
+        // classe Resposta {
+        //     // Outros método e propriedades aqui
+        //     status(statusHttp: numero) {
+        //         isto.statusHttp = statusHttp
+        //         retorna isto
+        //     }
+        // }
+
         metodos['status'] = new DeleguaFuncao(
             'status',
             new FuncaoConstruto(
@@ -91,7 +104,66 @@
             null,
             false
         );
-        metodos['lmht'] = new DeleguaFuncao(
+
+        // O exemplo abaixo gera um método `lmht` utilizando o gerador de expressões.
+        // Seria o equivalente à seguinte implementação:
+
+        // classe Resposta {
+        //     visao: texto
+        //     valores: dicionário
+        // 
+        //     lmht(*visaoEValores) {
+        //         se visaoEValores.tamanho() > 1 {
+        //             isto.visao = visaoEValores[0]
+        //             isto.valores = visaoEValores[1]
+        //         } senão {
+        //             isto.valores = visaoEValores[0]
+        //         }
+        // 
+        //         retorna isto
+        //     }
+        // }
+
+        metodos['lmht'] = geradorExpressoes.gerarMetodo('lmht', 
+            geradorExpressoes.gerarConstrutoFuncao(
+                [geradorExpressoes.gerarParametro('visaoEValores', 'vetor', 'multiplo')],
+                [
+                    geradorExpressoes.gerarAtribuicaoValorEmPropriedadeClasse(
+                        'lmht', 
+                        geradorExpressoes.gerarLiteral(true)
+                    ),
+                    geradorExpressoes.gerarDeclaracaoSe(
+                        geradorExpressoes.gerarConstrutoBinario(
+                            geradorExpressoes.gerarChamada(
+                                geradorExpressoes.gerarAcessoMetodoOuPropriedade(
+                                    geradorExpressoes.gerarReferenciaVariavel('visaoEValores'),
+                                    'tamanho'
+                                )
+                            ),
+                            geradorExpressoes.gerarOperadorComparacao('maior'),
+                            geradorExpressoes.gerarLiteral(1)
+                        ), 
+                        geradorExpressoes.gerarBlocoEscopo([ // Se
+                            geradorExpressoes.gerarAtribuicaoValorEmPropriedadeClasse(
+                                'visao', 
+                                geradorExpressoes.gerarAcessoIndiceVariavel('visaoEValores', 0)
+                            ),
+                            geradorExpressoes.gerarAtribuicaoValorEmPropriedadeClasse(
+                                'valores', 
+                                geradorExpressoes.gerarAcessoIndiceVariavel('visaoEValores', 1)
+                            )
+                        ]),
+                        geradorExpressoes.gerarBlocoEscopo([ // Senão
+                            geradorExpressoes.gerarAtribuicaoValorEmPropriedadeClasse(
+                                'valores', 
+                                geradorExpressoes.gerarAcessoIndiceVariavel('visaoEValores', 0)
+                            ),
+                        ])
+                    ),
+                    geradorExpressoes.gerarRetornoDeFuncao('isto')
+                ])
+            );
+        /* metodos['lmht'] = new DeleguaFuncao(
             'lmht',
             new FuncaoConstruto(
                 -1,
@@ -130,7 +202,12 @@
             ),
             null,
             false
+        ); */
+        super(
+            new Simbolo('IDENTIFICADOR', 'Resposta', null, -1, -1), 
+            null, 
+            metodos, 
+            propriedades
         );
-        super(new Simbolo('IDENTIFICADOR', 'Resposta', null, -1, -1), null, metodos);
     }
 }

infraestrutura/utilidades/gerador-expressoes.ts

@@ -1,8 +1,8 @@
 import { DeleguaFuncao } from '@designliquido/delegua/fontes/estruturas';
-import { DefinirValor, FuncaoConstruto, Isto, Construto, Variavel } from '@designliquido/delegua/fontes/construtos';
-import { ParametroInterface } from '@designliquido/delegua/fontes/interfaces';
+import { DefinirValor, FuncaoConstruto, Isto, Construto, Variavel, Binario, Literal, Chamada, AcessoMetodoOuPropriedade, AcessoIndiceVariavel } from '@designliquido/delegua/fontes/construtos';
+import { ParametroInterface, SimboloInterface } from '@designliquido/delegua/fontes/interfaces';
 import { Simbolo } from '@designliquido/delegua/fontes/lexador';
-import { Expressao, Retorna, Declaracao } from '@designliquido/delegua/fontes/declaracoes';
+import { Expressao, Retorna, Declaracao, Se, Bloco } from '@designliquido/delegua/fontes/declaracoes';
 
 /**
  * O gerador de expressões é uma classe facilitadora para a criação de
@@ -11,20 +11,77 @@
  */
 export class GeradorExpressoes {
 
+    gerarAcessoIndiceVariavel(variavel: string, indice: number): AcessoIndiceVariavel {
+        return new AcessoIndiceVariavel(
+            -1, 
+            new Variavel(
+                -1, 
+                new Simbolo('IDENTIFICADOR', variavel, null, -1, -1)
+            ), 
+            new Literal(-1, -1, indice), 
+            new Simbolo('COLCHETE_DIREITO', ']', null, -1, -1)
+        );
+    }
+
+    gerarAcessoMetodoOuPropriedade(objeto: Variavel, metodoOuPropriedade: string): AcessoMetodoOuPropriedade {
+        return new AcessoMetodoOuPropriedade(
+            -1, 
+            objeto,
+            new Simbolo('IDENTIFICADOR', metodoOuPropriedade, null, -1, -1)
+        );
+    }
+
+    gerarBlocoEscopo(declaracoes: Declaracao[]): Bloco {
+        return new Bloco(-1, -1, declaracoes);
+    }
+
+    gerarChamada(entidadeChamada: AcessoMetodoOuPropriedade, argumentos: any[] = []): Chamada {
+        return new Chamada(-1, entidadeChamada, null, argumentos);
+    }
+
+    gerarConstrutoBinario(ladoEsquerdo: Construto, operador: SimboloInterface, ladoDireito: Construto) {
+        return new Binario(-1, ladoEsquerdo, operador, ladoDireito);
+    }
+
+    gerarConstrutoFuncao(parametros: ParametroInterface[], corpo: Declaracao[]): FuncaoConstruto {
+        return new FuncaoConstruto(-1, -1, parametros, corpo);
+    }
+
+    gerarDeclaracaoSe(condicao: Construto, caminhoEntao: Declaracao, caminhoSenao?: Declaracao) {
+        return new Se(condicao, caminhoEntao, [], caminhoSenao);
+    }
+
+    gerarLiteral(valor: any) {
+        return new Literal(-1, -1, valor);
+    }
+
     gerarMetodo(nomeMetodo: string, declaracao: FuncaoConstruto): DeleguaFuncao {
         return new DeleguaFuncao(nomeMetodo, declaracao, null, false);
     }
 
-    gerarDeclaracao(parametros: ParametroInterface[], corpo: Declaracao[]): FuncaoConstruto {
-        return new FuncaoConstruto(-1, -1, parametros, corpo);
+    gerarOperadorComparacao(tipo: 'maior' | 'menor' | 'maiorOuIgual' | 'menorOuIgual' | 'igual' | 'diferente'): SimboloInterface {
+        switch (tipo) {
+            case 'maior':
+                return new Simbolo('MAIOR', '>', null, -1, -1);
+            case 'menor':
+                return new Simbolo('MENOR', '<', null, -1, -1);
+            case 'maiorOuIgual':
+                return new Simbolo('MAIOR_IGUAL', '>=', null, -1, -1);
+            case 'menorOuIgual':
+                return new Simbolo('MENOR_IGUAL', '<=', null, -1, -1);
+            case 'igual':
+                return new Simbolo('IGUAL_IGUAL', '==', null, -1, -1);
+            case 'diferente':
+                return new Simbolo('DIFERENTE', '!=', null, -1, -1);
+        }
     }
 
-    gerarParametro(nome: string, tipo: string): ParametroInterface {
+    gerarParametro(nome: string, tipo: string, abrangencia: 'padrao' | 'multiplo' = 'padrao'): ParametroInterface {
         return {
-            abrangencia: 'padrao',
+            abrangencia: abrangencia,
             tipo: tipo,
             nome: new Simbolo('IDENTIFICADOR', nome, null, -1, -1)
         } as ParametroInterface;
     }
 
     gerarReferenciaVariavel(nomeVariavel: string) {

interface-linha-comando/gerar/gerador-rotas.ts

@@ -64,7 +64,7 @@ export class GeradorRotas {
      * @returns O caminho do arquivo de rotas no sistema de arquivos.
      */
     private criarNovasRotasComId(declaracaoModelo: Classe, diretorioRotas: string): string {
-        const conteudoSelecionarUm = `liquido.rotaGet(funcao(requisicao, resposta) {\n    resposta.enviar(requisicao.params.id)\n})\n\n`;
+        const conteudoSelecionarUm = this.criarRotaSelecionarUm(declaracaoModelo);
         const conteudoAtualizar = `liquido.rotaPut(funcao(requisicao, resposta) {\n    resposta.lmht({ "titulo": "Liquido" })\n})\n\n`;
         const conteudoExcluir = `liquido.rotaDelete(funcao(requisicao, resposta) {\n    resposta.lmht({ "titulo": "Liquido" })\n})\n\n`;
         const conteudoRotas = `${conteudoSelecionarUm}${conteudoAtualizar}${conteudoExcluir}`;
@@ -95,4 +95,21 @@ export class GeradorRotas {
             `${" ".repeat(this.indentacao)}})\n` +
             `})\n\n`;
     }
+
+    private criarRotaSelecionarUm(declaracaoModelo: Classe) {
+        // Isso aqui não vai ficar assim. 
+        // É preciso montar as partes de dados antes.
+        const dadosTestes = [];
+        for (const propriedade of declaracaoModelo.propriedades) {
+            dadosTestes.push(`"${propriedade.nome.lexema}": "Teste"`);
+        }
+
+        return `liquido.rotaGet(funcao(requisicao, resposta) {\n` +
+            `${" ".repeat(this.indentacao)}resposta.lmht("detalhes", {\n` +
+            `${" ".repeat(this.indentacao * 2)}${dadosTestes.reduce(
+                (acumulador, elemento) => acumulador + ', ' + elemento
+            )}\n` +
+            `${" ".repeat(this.indentacao)}})\n` +
+            `})\n\n`;
+    }
 }

interface-linha-comando/gerar/gerador-visoes.ts

@@ -31,7 +31,7 @@ export class GeradorVisoes {
                 break;
             case 'selecionarUm':
                 caminhoVisao = caminho.join(diretorioVisoes, 'detalhes.lmht');
-                corpo = '    <corpo>Teste</corpo>\n';
+                corpo = `${" ".repeat(this.indentacao)}<corpo>\n${this.corpoDetalhes(declaracaoModelo)}\n${" ".repeat(this.indentacao)}</corpo>\n`;
                 break;
             case 'adicionar':
                 caminhoVisao = caminho.join(diretorioVisoes, 'adicionar.lmht');
@@ -94,4 +94,27 @@ export class GeradorVisoes {
 
         return `${" ".repeat(this.indentacao * 2)}<tabela>\n${cabecaTabela}\n${corpoTabela}\n${" ".repeat(this.indentacao * 2)}</tabela>`;
     }
+
+    /**
+     * Função que gera o corpo de `detalhes.lmht` de cada visão gerada por linha de comando.
+     * @param {Classe} declaracaoModelo A declaração do modelo de dados, com suas propriedades e definições.
+     * @returns {string} Um trecho em LMHT com a estrutura do corpo da página.
+     */
+    private corpoDetalhes(declaracaoModelo: Classe): string {
+        const titulo = `${" ".repeat(this.indentacao * 2)}<titulo1>Detalhes de ${declaracaoModelo.simbolo.lexema}</titulo1>\n`;
+
+        const listaPropriedades: string[] = [];
+        for (const propriedade of declaracaoModelo.propriedades) {
+            listaPropriedades.push(" ".repeat(this.indentacao * 3) + `<divisão>${propriedade.nome.lexema}</divisão>`);
+            listaPropriedades.push(" ".repeat(this.indentacao * 3) + `<divisão>{{${propriedade.nome.lexema}}}</divisão>`);
+        }
+
+        const relacaoPropriedades = `${" ".repeat(this.indentacao * 2)}<lista-definições>\n` + 
+            listaPropriedades.reduce(
+                (acumulador, elemento) => acumulador + '\n' + elemento
+            ) +
+            `\n${" ".repeat(this.indentacao * 2)}</lista-definições>\n`;
+
+        return `${titulo}${relacaoPropriedades}`;
+    }
 }

liquido.ts

@@ -335,9 +335,19 @@
             statusHttp = valor.propriedades.statusHttp;
         }
 
         try {
             if (valor.propriedades.lmht) {
-                const resultadoFormatacaoLmht = await this.formatadorLmht.formatar(caminhoRota, valor.propriedades.valores);
+                let visao: string = caminhoRota;
+                // Verifica se foi definida uma preferência de visão.
+                // Se não foi, usa o sufixo da rota como visão correspondente.
+                // Por exemplo, `/rotas/inicial.delegua` tem como visão correspondente `/visoes/inicial.lmht`.
+                if (valor.propriedades.visao) {
+                    const partesRota = caminhoRota.split('/');
+                    partesRota.pop();
+                    visao = partesRota.join('/') + '/' + valor.propriedades.visao;
+                }
+
+                const resultadoFormatacaoLmht = await this.formatadorLmht.formatar(visao, valor.propriedades.valores);
                 return {
                     corpoRetorno: resultadoFormatacaoLmht,
                     statusHttp: statusHttp

package.json

@@ -39,7 +39,7 @@
         "swagger": "tsoa spec"
     },
     "dependencies": {
-        "@designliquido/delegua-node": "^0.29.1",
+        "@designliquido/delegua-node": "^0.29.2",
         "@designliquido/flexoes": "^0.1.0",
         "@designliquido/foles": "^0.6.1",
         "@designliquido/lincones-sqlite": "^0.0.2",

rotas/blog/inicial.delegua

@@ -1,3 +1,3 @@
 liquido.rotaGet(funcao(requisicao, resposta) {
     resposta.lmht({ "titulo": "Blog" })
-})
+})