Adiciona auto-indentação e configuração completa ao Pituguês (#101) (#122)

Pituguês é uma linguagem indentada por dois-pontos, como Python, mas
configuracoes/configuracao-pitugues.json declarava apenas comments,
brackets, autoClosingPairs e surroundingPairs. Sem indentationRules e
onEnterRules, pressionar Enter após 'funcao rota(requisicao, resposta):'
não indentava a linha seguinte — indentação manual a cada bloco, o dia
inteiro.

Este commit adiciona as quatro seções que faltavam, levando o Pituguês
às mesmas oito do LMHT:

- indentationRules: increaseIndentPattern ancorado às palavras-chave de
  bloco (se, senao, senao se, para, enquanto, fazer, funcao, classe,
  construtor, escolha, caso, tente, pegue, finalmente) terminadas em
  ':'. Ancorar às palavras-chave, em vez de 'linha termina em dois-
  pontos', evita indentar por dois-pontos em strings, comentários e
  dicionários literais. decreaseIndentPattern des-indenta as linhas de
  continuação (senao, senao se, caso, pegue, finalmente).
- onEnterRules: indenta a próxima linha após a abertura de um bloco.
- folding: dobra por indentação (offSide), como em Python, com marcadores
  de região por comentário.
- wordPattern: inclui letras acentuadas e sublinhado, para que
  identificadores como 'validação' e 'usuário' sejam selecionados como
  uma palavra única (duplo-clique, expandir seleção).

Como não havia testes para as configurações de linguagem, este commit
também adiciona testes/linguagens/configuracao-pitugues.test.ts (36
casos): confirma as oito seções, valida increase/decreaseIndentPattern
contra código real — incluindo os casos que NÃO devem indentar (dois-
pontos em string, comentário e dicionário) — e verifica a captura de
identificadores acentuados pelo wordPattern.

Mudança apenas em JSON de configuração e testes; nenhum código de
runtime alterado.

Fixes #101

Co-authored-by: Micael Santana <micaelparadox@gmail.com>

Author: oxbar

configuracoes/configuracao-pitugues.json

@@ -59,5 +59,27 @@
             "\\'",
             "\\'"
         ]
-    ]
-}
+    ],
+    "indentationRules": {
+        "increaseIndentPattern": "^\\s*(se|senao\\s+se|senao|para|enquanto|fazer|funcao|classe|construtor|escolha|caso|tente|pegue|finalmente)\\b.*:\\s*(#.*)?$",
+        "decreaseIndentPattern": "^\\s*(senao\\s+se|senao|caso|pegue|finalmente)\\b.*:\\s*(#.*)?$"
+    },
+    "onEnterRules": [
+        {
+            "beforeText": {
+                "pattern": "^\\s*(se|senao\\s+se|senao|para|enquanto|fazer|funcao|classe|construtor|escolha|caso|tente|pegue|finalmente)\\b.*:\\s*(#.*)?$"
+            },
+            "action": {
+                "indent": "indent"
+            }
+        }
+    ],
+    "folding": {
+        "offSide": true,
+        "markers": {
+            "start": "^\\s*#\\s*#?region\\b",
+            "end": "^\\s*#\\s*#?endregion\\b"
+        }
+    },
+    "wordPattern": "(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)"
+}

testes/linguagens/configuracao-pitugues.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from '@jest/globals';
+import * as sistemaArquivos from 'fs';
+import caminho from 'path';
+
+/**
+ * Testes de regressão para o achado A2 (issue #101):
+ * Pituguês é uma linguagem indentada por dois-pontos e precisa de
+ * indentationRules, onEnterRules, folding e wordPattern, como o LMHT
+ * já possui. Estes testes validam os padrões contra código real, para
+ * que uma regressão no JSON de configuração seja detectada.
+ */
+describe('Configuração de linguagem Pituguês', () => {
+    const configuracao = JSON.parse(
+        sistemaArquivos.readFileSync(
+            caminho.join(__dirname, '../../configuracoes/configuracao-pitugues.json'),
+            'utf-8'
+        )
+    );
+
+    it('deve declarar as oito seções de configuração, como o LMHT', () => {
+        for (const secao of [
+            'comments',
+            'brackets',
+            'autoClosingPairs',
+            'surroundingPairs',
+            'indentationRules',
+            'onEnterRules',
+            'folding',
+            'wordPattern'
+        ]) {
+            expect(configuracao[secao]).toBeDefined();
+        }
+    });
+
+    describe('increaseIndentPattern', () => {
+        const regex = new RegExp(configuracao.indentationRules.increaseIndentPattern);
+
+        it.each([
+            'funcao rota(requisicao, resposta):',
+            '    se x > 0:',
+            'para cada i em intervalo(0, 5):',
+            'enquanto verdadeiro:',
+            'senao:',
+            'senao se y < 2:',
+            'escolha chave:',
+            '    caso 1:',
+            'tente:',
+            'pegue erro:',
+            'finalmente:',
+            'classe Pessoa(Animal):',
+            '    construtor(nome):',
+            'fazer:'
+        ])('aumenta indentação após "%s"', (linha) => {
+            expect(regex.test(linha)).toBe(true);
+        });
+
+        it.each([
+            'x = 10',
+            'escreva("texto: com dois pontos")',
+            'retorna x',
+            '# comentario: com dois pontos',
+            'y = {"chave": valor}'
+        ])('não aumenta indentação em "%s"', (linha) => {
+            expect(regex.test(linha)).toBe(false);
+        });
+    });
+
+    describe('decreaseIndentPattern', () => {
+        const regex = new RegExp(configuracao.indentationRules.decreaseIndentPattern);
+
+        it.each(['senao:', 'senao se y:', 'caso 2:', 'pegue e:', 'finalmente:'])(
+            'des-indenta a linha de continuação "%s"',
+            (linha) => {
+                expect(regex.test(linha)).toBe(true);
+            }
+        );
+
+        it.each(['se x:', 'funcao f():', 'x = 10'])(
+            'não des-indenta "%s"',
+            (linha) => {
+                expect(regex.test(linha)).toBe(false);
+            }
+        );
+    });
+
+    describe('onEnterRules', () => {
+        it('deve indentar a próxima linha após abertura de bloco', () => {
+            const regra = configuracao.onEnterRules[0];
+            const regex = new RegExp(regra.beforeText.pattern);
+            expect(regex.test('funcao rota(requisicao, resposta):')).toBe(true);
+            expect(regex.test('x = 10')).toBe(false);
+            expect(regra.action.indent).toBe('indent');
+        });
+    });
+
+    describe('folding', () => {
+        it('deve usar dobra por indentação (offSide)', () => {
+            expect(configuracao.folding.offSide).toBe(true);
+        });
+    });
+
+    describe('wordPattern', () => {
+        const regex = new RegExp(configuracao.wordPattern);
+
+        it.each(['numero', 'número', 'endereço', 'validação', 'usuário', 'variavel_conta'])(
+            'captura o identificador acentuado "%s" como uma palavra única',
+            (palavra) => {
+                const resultado = regex.exec(palavra);
+                expect(resultado).not.toBeNull();
+                expect(resultado![0]).toBe(palavra);
+            }
+        );
+    });
+});