Repository: DesignLiquido/delegua
Pull request #588 (2024-01-21 00:20:30)

Ajustes no formatador de código de Delégua
- Dicionários;
- `para cada`;
- `tipo de`;
- `sustar`;
- Operadores lógicos;
- `leia`.


Patch:
diff --git a/fontes/formatadores/delegua.ts b/fontes/formatadores/formatador-delegua.ts
similarity index 90%
rename from fontes/formatadores/delegua.ts
rename to fontes/formatadores/formatador-delegua.ts
index 99811345..a1f6cdb1 100644
--- a/fontes/formatadores/delegua.ts
+++ b/fontes/formatadores/formatador-delegua.ts
@@ -8,12 +8,14 @@ import {
     Chamada,
     Construto,
     DefinirValor,
+    Dicionario,
     ExpressaoRegular,
     FimPara,
     FormatacaoEscrita,
     FuncaoConstruto,
     Isto,
     Literal,
+    Logico,
     Super,
     TipoDe,
     Unario,
@@ -48,7 +50,6 @@ import {
     Falhar,
 } from '../declaracoes';
 import { VisitanteComumInterface } from '../interfaces';
-import { SustarQuebra } from '../quebras';
 
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
 
@@ -247,8 +248,9 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
     }
 
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
-        throw new Error('Método não implementado.');
+    visitarDeclaracaoParaCada(declaracao: ParaCada): any {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}para cada ${declaracao.nomeVariavelIteracao} de ${declaracao.vetor.simbolo.lexema}`;
+        this.visitarExpressaoBloco(declaracao.corpo);
     }
 
     visitarDeclaracaoSe(declaracao: Se) {
@@ -483,9 +485,22 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         this.codigoFormatado += expressao.simbolo.lexema;
     }
 
-    visitarExpressaoDicionario(expressao: any) {
-        throw new Error('Método não implementado.');
+    visitarExpressaoDicionario(expressao: Dicionario) {
+        this.codigoFormatado += `{`;
+        for (let i = 0; i < expressao.chaves.length; i++) {
+            this.formatarDeclaracaoOuConstruto(expressao.chaves[i]);
+            this.codigoFormatado += `: `;
+            this.formatarDeclaracaoOuConstruto(expressao.valores[i]);
+            this.codigoFormatado += `, `;
+        }
+
+        if (expressao.chaves.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+
+        this.codigoFormatado += `}`;
     }
+
     visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): any {
         this.codigoFormatado += `||${expressao.valor}||`;
     }
@@ -503,9 +518,11 @@ export class FormatadorDelegua implements VisitanteComumInterface {
 
         this.codigoFormatado += `${this.quebraLinha}`;
     }
+
     visitarExpressaoFimPara(declaracao: FimPara) {
         throw new Error('Método não implementado.');
     }
+
     visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
         throw new Error('Método não implementado.');
     }
@@ -530,9 +547,20 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         this.codigoFormatado += `isto`;
     }
 
-    visitarExpressaoLeia(expressao: Leia): Promise<any> {
-        throw new Error('Método não implementado.');
+    visitarExpressaoLeia(expressao: Leia): any {
+        this.codigoFormatado += `leia(`;
+        for (let argumento of expressao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+            this.codigoFormatado += `, `;
+        }
+
+        if (expressao.argumentos.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+        
+        this.codigoFormatado += `)`;
     }
+
     visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -546,8 +574,21 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         this.codigoFormatado += expressao.valor;
     }
 
-    visitarExpressaoLogica(expressao: any) {
-        throw new Error('Método não implementado.');
+    visitarExpressaoLogica(expressao: Logico) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.E:
+                this.codigoFormatado += ` e `;
+                break;
+            case tiposDeSimbolos.EM:
+                this.codigoFormatado += ` em `;
+                break;
+            case tiposDeSimbolos.OU:
+                this.codigoFormatado += ` ou `;
+                break;
+        }
+        
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
     }
 
     visitarExpressaoRetornar(declaracao: Retorna): any {
@@ -566,12 +607,13 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         console.log(expressao);
     }
 
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
-        throw new Error('Método não implementado.');
+    visitarExpressaoSustar(declaracao?: Sustar): any {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}sustar${this.quebraLinha}`;
     }
 
-    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
-        throw new Error('Método não implementado.');
+    visitarExpressaoTipoDe(expressao: TipoDe): any {
+        this.codigoFormatado += `tipo de `;
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
     }
 
     visitarExpressaoUnaria(expressao: Unario) {
@@ -650,6 +692,9 @@ export class FormatadorDelegua implements VisitanteComumInterface {
             case 'DefinirValor':
                 this.visitarExpressaoDefinirValor(declaracaoOuConstruto as DefinirValor);
                 break;
+            case 'Dicionario':
+                this.visitarExpressaoDicionario(declaracaoOuConstruto as Dicionario);
+                break;
             case 'Escolha':
                 this.visitarDeclaracaoEscolha(declaracaoOuConstruto as Escolha);
                 break;
@@ -683,12 +728,21 @@ export class FormatadorDelegua implements VisitanteComumInterface {
             case 'Isto':
                 this.visitarExpressaoIsto(declaracaoOuConstruto as Isto);
                 break;
+            case 'Leia':
+                this.visitarExpressaoLeia(declaracaoOuConstruto as Leia);
+                break;
             case 'Literal':
                 this.visitarExpressaoLiteral(declaracaoOuConstruto as Literal);
                 break;
+            case 'Logico':
+                this.visitarExpressaoLogica(declaracaoOuConstruto as Logico);
+                break;
             case 'Para':
                 this.visitarDeclaracaoPara(declaracaoOuConstruto as Para);
                 break;
+            case 'ParaCada':
+                this.visitarDeclaracaoParaCada(declaracaoOuConstruto as ParaCada);
+                break;
             case 'Retorna':
                 this.visitarExpressaoRetornar(declaracaoOuConstruto as Retorna);
                 break;
@@ -698,9 +752,15 @@ export class FormatadorDelegua implements VisitanteComumInterface {
             case 'Super':
                 this.visitarExpressaoSuper(declaracaoOuConstruto as Super);
                 break;
+            case 'Sustar':
+                this.visitarExpressaoSustar(declaracaoOuConstruto as Sustar);
+                break;
             case 'Tente':
                 this.visitarDeclaracaoTente(declaracaoOuConstruto as Tente);
                 break;
+            case 'TipoDe':
+                this.visitarExpressaoTipoDe(declaracaoOuConstruto as TipoDe);
+                break;
             case 'Unario':
                 this.visitarExpressaoUnaria(declaracaoOuConstruto as Unario);
                 break;
diff --git a/fontes/formatadores/index.ts b/fontes/formatadores/index.ts
index f5235213..f04435eb 100644
--- a/fontes/formatadores/index.ts
+++ b/fontes/formatadores/index.ts
@@ -1,1 +1,1 @@
-export * from './delegua';
+export * from './formatador-delegua';


Test patch:
diff --git a/testes/formatadores/formatador-delegua.test.ts b/testes/formatadores/formatador-delegua.test.ts
index 249a7180..ac71ad1d 100644
--- a/testes/formatadores/formatador-delegua.test.ts
+++ b/testes/formatadores/formatador-delegua.test.ts
@@ -50,6 +50,19 @@ describe('Formatadores > Delégua', () => {
         expect(linhasResultado).toHaveLength(13);
     });
 
+    it('Dicionários', () => {
+        const resultadoLexador = lexador.mapear([
+            `var dicionario = {  'a':1, 'b'  : 2    }`,
+        ], -1);
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        // console.log(resultado);
+        expect(linhasResultado).toHaveLength(2);
+    });
+
     it('Escolha', () => {
         const resultadoLexador = lexador.mapear([
             "escolha (2) { caso 1: escreva('correspondente à opção 1'); caso 2: caso 3: escreva('correspondente à opção 2 e 3'); padrao: escreva('Sem opção correspondente'); }",
@@ -65,7 +78,7 @@ describe('Formatadores > Delégua', () => {
 
     it('Enquanto', () => {
         const resultadoLexador = lexador.mapear(
-            ["var a = 1 enquanto a < 10 { a += 1}"], 
+            ["var a = 1 enquanto a < 10 { a += 1 se a > 8 {sustar  }}"], 
             -1
         );
 
@@ -74,7 +87,23 @@ describe('Formatadores > Delégua', () => {
         const linhasResultado = resultado.split(sistemaOperacional.EOL);
         
         // console.log(resultado);
-        expect(linhasResultado).toHaveLength(5);
+        expect(linhasResultado).toHaveLength(8);
+    });
+
+    it('Expressões Regulares', () => {
+        const resultadoLexador = lexador.mapear(
+            [
+                "var str = \"olá mundo, olá universo\" var novaStr = str.substituir(||/olá/g||, \"oi\") escreva(novaStr);",
+            ], 
+            -1
+        );
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        // console.log(resultado);
+        expect(linhasResultado).toHaveLength(4);
     });
 
     it('Fazer', () => {
@@ -145,11 +174,9 @@ describe('Formatadores > Delégua', () => {
         expect(linhasResultado).toHaveLength(4);
     });
 
-    it('Expressões Regulares', () => {
+    it('leia() e escreva()', () => {
         const resultadoLexador = lexador.mapear(
-            [
-                "var str = \"olá mundo, olá universo\" var novaStr = str.substituir(||/olá/g||, \"oi\") escreva(novaStr);",
-            ], 
+            [`var a=leia( "Escreva alguma coisa"   ) escreva( a )`], 
             -1
         );
 
@@ -157,7 +184,21 @@ describe('Formatadores > Delégua', () => {
         const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
         const linhasResultado = resultado.split(sistemaOperacional.EOL);
         
-        // console.log(resultado);
+        console.log(resultado);
+        expect(linhasResultado).toHaveLength(3);
+    });
+
+    it('Operadores lógicos', () => {
+        const resultadoLexador = lexador.mapear(
+            [`var a=falso var b=verdadeiro escreva( a    ou b)`], 
+            -1
+        );
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        console.log(resultado);
         expect(linhasResultado).toHaveLength(4);
     });
 
@@ -175,6 +216,20 @@ describe('Formatadores > Delégua', () => {
         expect(linhasResultado).toHaveLength(7);
     });
 
+    it('Para cada', () => {
+        const resultadoLexador = lexador.mapear(
+            ["var a = [1, 2,3] para cada  elemento   de  a    {  escreva( a  ) }"], 
+            -1
+        );
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        // console.log(resultado);
+        expect(linhasResultado).toHaveLength(5);
+    });
+
     it('Se', () => {
         const resultadoLexador = lexador.mapear(
             ["se a == 1 { escreva(a) } senao {escreva(a + 1)} "], 
@@ -203,6 +258,20 @@ describe('Formatadores > Delégua', () => {
         expect(linhasResultado).toHaveLength(8);
     });
 
+    it('Tipo de', () => {
+        const resultadoLexador = lexador.mapear(
+            [`var a   = "Teste" escreva( tipo     de a      )`],
+            -1
+        );
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        console.log(resultado);
+        expect(linhasResultado).toHaveLength(3);
+    });
+
     it('Variaveis', () => {
         const resultadoLexador = lexador.mapear(
             ["var a=1 fixo c = 2"], 
diff --git a/testes/visualg/analisador-semantico.test.ts b/testes/visualg/analisador-semantico.test.ts
index 57130268..b534a6a8 100644
--- a/testes/visualg/analisador-semantico.test.ts
+++ b/testes/visualg/analisador-semantico.test.ts
@@ -16,7 +16,7 @@ describe('Analisador sêmantico (Visualg)', () => {
 
 
         describe('Cenários de falha', () => {
-            it('Variável indefinida, não declarada(escreva)', () => {
+            it('Variável indefinida, não declarada (escreva)', () => {
                 const retornoLexador = lexador.mapear([
                     'algoritmo "Declaração de variável"',
                     'var',
@@ -30,7 +30,7 @@ describe('Analisador sêmantico (Visualg)', () => {
                 expect(retornoAnalisadorSemantico.diagnosticos).toHaveLength(1);
             });
 
-            it('Variável indefinida, não declarada(atribuição)', () => {
+            it('Variável indefinida, não declarada (atribuição)', () => {
                 const retornoLexador = lexador.mapear([
                     'algoritmo "Atribuição de valor"',
                     'var',