[Issue #59] Atribuição Abreviada / Múltiplos Valores

exemplos/exemplo2.foles

@@ -1,15 +1,5 @@
 lmht {
-    tempo-transicao: curva-cúbica(0.42, 0.0, 1.0, 1.0);
-    cor-destaque: rgb(100, 200, 300);
+    opacidade: 80%;
+    recuo: 10px 10px 15px 20px;
+    altura: 50%;
 }
-
-.classe {
-    tempo-transicao: passos(3, final);
-    tamanho-colunas-em-grade: minmax(200px, auto);
-    altura-máxima: encaixar-conteúdo(5cm);
-    altura: limitar(1px, 2vw, 2.5rem);
-
-    .outra-classe {
-        tamanho-fonte: 24px;
-    }
-}

exemplos/exemplo3.foles

@@ -1,6 +1,7 @@
 lmht {
     linhas-superiores: 2;
     altura: 30px;
+    largura: herdar;
     colunas: 2;
     opacidade: 0.5;
     indice-z: 5;

fontes/avaliador-sintatico/avaliador-sintatico.ts

@@ -994,15 +994,33 @@
         return textoUrl;
     }
 
-    valorModificador(): any {
-        const valorModificador = this.avancarEDevolverAnterior();
+    valoresModificador(): Array<any> {
+        const modificadores = [];
 
-        switch (valorModificador.tipo) {
-            case tiposDeSimbolos.METODO:
-                return this.resolverMetodo(valorModificador.lexema);
-            default:
-                return valorModificador;
+        while (this.simbolos[this.atual].hasOwnProperty('tipo') && this.simbolos[this.atual].tipo !== tiposDeSimbolos.PONTO_E_VIRGULA) {
+            const valorModificador = this.avancarEDevolverAnterior();
+
+            switch (valorModificador.tipo) {
+                case tiposDeSimbolos.METODO:
+                    const metodo = this.resolverMetodo(valorModificador.lexema);
+                    modificadores.push(metodo);
+                default:
+                    const modificador = valorModificador;
+                    modificadores.push(modificador);
+            }
         }
+
+        return modificadores;
+
+        // IMPLEMENTAÇÃO ANTERIOR
+        // const valorModificador = this.avancarEDevolverAnterior();
+
+        // switch (valorModificador.tipo) {
+        //     case tiposDeSimbolos.METODO:
+        //         return this.resolverMetodo(valorModificador.lexema);
+        //     default:
+        //         return valorModificador;
+        // }
     }
 
     private tratarValorNumerico(modificador: Simbolo): Boolean {
@@ -1152,40 +1170,82 @@
             "Esperado ':' após nome do modificador."
         );
 
-        const valorModificador = this.valorModificador();
-        let quantificador;
+        const valoresModificador: Array<any> = this.valoresModificador();
+        let quantificador: any;
+        let quantificadores: Array<any> = [];
+
+        for (const [index, valorModificador] of valoresModificador.entries()) {
+            if (valorModificador.hasOwnProperty('tipo') && valorModificador.tipo === tiposDeSimbolos.NUMERO) {
+
+                const tratarValorNumerico = this.tratarValorNumerico(valorModificador);
+
+                if (tratarValorNumerico) {
+                    quantificador = valoresModificador[index + 1];
+                    quantificadores.push(valoresModificador[index + 1]);
+                    valoresModificador.splice(index + 1, 1);
+                }
+            }
+
+            if (valorModificador.hasOwnProperty('tipo') && valorModificador.tipo === tiposDeSimbolos.METODO) {
+                valoresModificador.splice(index, 1);
+            }
+        }
+
         // TODO: Pensar num teste melhor pra isso.
         /*if (!(valorModificador instanceof Metodo)) {
             quantificador = this.avancarEDevolverAnterior();
         }*/
 
-        if (valorModificador.hasOwnProperty('tipo') && valorModificador.tipo === tiposDeSimbolos.NUMERO) {
-            const tratarValorNumerico = this.tratarValorNumerico(modificador);
-
-            if (tratarValorNumerico) {
-                quantificador = this.avancarEDevolverAnterior();
-            }
+        if (valoresModificador.length === 0) {
+            const proximoSimbolo = this.avancarEDevolverAnterior();
+            valoresModificador.push(proximoSimbolo);
         }
-
         this.consumir(
             tiposDeSimbolos.PONTO_E_VIRGULA,
             `Esperado ';' após declaração de valor de modificador '${modificador.lexema}'.`
         );
 
-        const classeModificadora = new SeletorModificador(
-            modificador.lexema,
-            valorModificador.hasOwnProperty('lexema') ? valorModificador.lexema : valorModificador,
-            quantificador && quantificador.hasOwnProperty('lexema') ?
-                quantificador.lexema :
-                quantificador,
-            {
-                linha: modificador.linha,
-                colunaInicial: modificador.colunaInicial,
-                colunaFinal: modificador.colunaFinal
+        if (valoresModificador.length === 1) {
+            const classeModificadora = new SeletorModificador(
+                modificador.lexema,
+                valoresModificador[0].hasOwnProperty('lexema') ? valoresModificador[0].lexema : valoresModificador[0],
+                quantificador && quantificador.hasOwnProperty('lexema') ?
+                    quantificador.lexema :
+                    quantificador,
+                {
+                    linha: modificador.linha,
+                    colunaInicial: modificador.colunaInicial,
+                    colunaFinal: modificador.colunaFinal
+                }
+            );
+
+            return classeModificadora as Modificador;
+        } else {
+            let atribuicaoAbreviada: string = '';
+            for (let i = 0; i < valoresModificador.length; i += 1) {
+                if (i > 0) {
+                    atribuicaoAbreviada += ' ';
+                    atribuicaoAbreviada += `${valoresModificador[i].lexema}${quantificadores[i].lexema}`;
+                } else {
+                    atribuicaoAbreviada += `${valoresModificador[i].lexema}${quantificadores[i].lexema}`;
+                }
             }
-        );
 
-        return classeModificadora as Modificador;
+            const classeModificadora = new SeletorModificador(
+                modificador.lexema,
+                atribuicaoAbreviada,
+                quantificador && quantificador.hasOwnProperty('lexema') ?
+                    quantificador.lexema :
+                    quantificador,
+                {
+                    linha: modificador.linha,
+                    colunaInicial: modificador.colunaInicial,
+                    colunaFinal: modificador.colunaFinal
+                }
+            );
+
+            return classeModificadora as Modificador;
+        }
     }
 
     resolverModificadoresEDeclaracoesAninhadas(): { modificadores: Modificador[], declaracoesAninhadas: Declaracao[] } {

fontes/serializadores/serializador.ts

@@ -51,7 +51,14 @@
             };\n`;
         }
 
-        // Caso 4: É um valor genérico, cuja tradução está na lista 'valoresGerais'.
+        // Caso 4: Atribuição Abreviada | Múltiplos valores
+        if (modificador.valor.includes(' ')) {
+            return `${" ".repeat(indentacao)}${modificador.propriedadeCss}: ${
+                modificador.valor
+            };\n`;
+        }
+
+        // Caso 5: É um valor genérico, cuja tradução está na lista 'valoresGerais'.
         const valorTraduzido = valoresGerais[modificador.valor];
         return `${" ".repeat(indentacao)}${
             modificador.propriedadeCss

testes/listas/valor-numerico.ts

@@ -24,6 +24,26 @@ export const ValorNumerico: Array<string> = [
     'coluna-em-grade',    
 ];
 
+export const ValorNumericoApenas: Array<string> = [
+    'linhas-superiores',
+    'repetir-animacao',
+    'repetir-animação',
+    'contar-coluna',
+    'flex-crescimento',
+    'flex-reduzir',
+    'ajustar-tamanho-fonte',
+    'espessura-fonte',
+    'fim-coluna-em-grade',
+    'inicio-coluna-em-grade',
+    'início-coluna-em-grade',
+    'fim-linha-em-grade',
+    'inicio-linha-em-grade',
+    'início-linha-em-grade',
+    'ordenar',
+    'linhas-inferiores',
+];
+
+
 // A lista abaixo inclui modificadores que aceitam tanto somente valores numéricos 
 // quanto valores numéricos c/ quantificador.
 export const ValorNumericoComQuantificador = [

testes/modificadores/valor-numerico.test.ts

@@ -5,7 +5,7 @@ import { Lexador } from "../../fontes/lexador";
 import { SeletorModificador } from "../../fontes/modificadores/superclasse";
 import tiposDeSimbolos from "../../fontes/tipos-de-simbolos/foles";
 import { Serializador } from "../../fontes/serializadores";
-import { ValorNumerico, ValorNumericoComQuantificador } from "../listas/valor-numerico";
+import { ValorNumerico, ValorNumericoApenas, ValorNumericoComQuantificador } from "../listas/valor-numerico";
 
 describe('Testando Seletores que recebem VALOR NUMÉRICO sem quantificador', () => {
   describe('Testes Unitários', () => {
@@ -58,12 +58,12 @@ describe('Testando Seletores que recebem VALOR NUMÉRICO sem quantificador', ()
     });
 
     it('Casos de Falha - Lexador, Avaliador e Tradutor', () => {
-      for (let index = 0; index < Object.keys(ValorNumerico).length; index += 1) {
+      for (let index = 0; index < Object.keys(ValorNumericoApenas).length; index += 1) {
 
         // Lexador - valor numérico não informado
         const resultadoLexador = lexador.mapear([
           "lmht {",
-          `${ValorNumerico[index]}: ;`,
+          `${ValorNumericoApenas[index]}: ;`,
           "}"
         ]);
 
@@ -76,14 +76,24 @@ describe('Testando Seletores que recebem VALOR NUMÉRICO sem quantificador', ()
         // Tentando passar um quantificador para os modificadores (o que não deve ser permitido)
         const novoLexador = lexador.mapear([
           "lmht {",
-          `${ValorNumerico[index]}: 15px;`,
+          `${ValorNumericoApenas[index]}: 15px;`,
           "}"
         ]);
 
         // Avaliador Sintático - Erro esperado como retorno
-        expect(() => {
-          avaliador.analisar(novoLexador.simbolos);
-        }).toThrow(`Esperado ';' após declaração de valor de modificador '${ValorNumerico[index]}'.`);
+        const regex = /[~çáéíóúÁÉÍÓÚ]/;
+
+        if (!regex.test(ValorNumericoApenas[index]) && regex.test(ValorNumericoApenas[index + 1])){
+          expect(() => {
+            avaliador.analisar(novoLexador.simbolos);
+          }).toThrow(`A propriedade ${ValorNumericoApenas[index + 1]} aceita somente valores numéricos. O quantificador px é inválido para esta operação.`);
+        } else {
+          expect(() => {
+            avaliador.analisar(novoLexador.simbolos);
+          }).toThrow(`A propriedade ${ValorNumericoApenas[index]} aceita somente valores numéricos. O quantificador px é inválido para esta operação.`);
+        }
+
+        // A propriedade linhas-superiores aceita somente valores numéricos. O quantificador px é inválido para esta operação.
 
 
         // Tradutor - Não deve traduzir devido ao erro do Avaliador Sintático
@@ -217,7 +227,7 @@ describe('Testando Seletores que recebem VALOR NUMÉRICO com ou sem quantificado
         // Avaliador Sintático - Erro esperado como retorno
         expect(() => {
           avaliador.analisar(novoLexador.simbolos);
-        }).toThrow(`Esperado ';' após declaração de valor de modificador '${seletorIncorreto}'.`);
+        }).toThrow(`O seletor '${seletorIncorreto}' não existe.`);
 
         // // Tradutor - Não deve traduzir devido ao erro do Avaliador Sintático
         expect(() => {