Permitindo atribuição de valores String aos modificadores

exemplos/exemplo2.foles

@@ -16,4 +16,13 @@ lmht {
     area-mascara: visualizar-caixa, completar-caixa, borda-caixa;
     atraso-transicao: 2s, 4ms;
     duracao-animacao: 10s, 35s, 230ms;
+}
+
+lmht {
+    citações: "x";
+    configuracoes-variacao-fonte: "<";
+    enfase-texto: 'foo';
+    estilo-enfase-texto: "\25B2";
+    substituir-idioma-fonte: "«" "»" "‹" "›";
+    vazamento-texto: 'xxxxx';
 }

fontes/foles.ts

@@ -101,6 +101,6 @@ export class FolEs {
 }
 
 //  const a = new FolEs(false);
-//  console.log(a.converterParaCss('../exemplos/exemplo.foles'));
+//  console.log(a.converterParaCss('../exemplos/exemplo2.foles'));
 //  console.log(a.converterParaFolEs('../exemplos/reverso/exemplo-metodos.css'));
 //  console.log(a.converterParaFolEs('../exemplos/reverso/exemplo-codigo.css'));

fontes/lexador/lexador.ts

@@ -120,11 +120,19 @@ export class Lexador implements LexadorInterface {
         literal: any = null,
         lexema: string = null
     ): void {
-        const texto: string = this.codigo[this.linha].substring(
+        let texto: string;
+        texto = this.codigo[this.linha].substring(
             this.inicioSimbolo,
             this.atual
         );
 
+        if (tipo === tiposDeSimbolos.TEXTO) {
+            texto = this.codigo[this.linha].substring(
+                this.inicioSimbolo,
+                this.atual + 1
+            );
+        }
+
         this.simbolos.push(
             new Simbolo(
                 tipo,

fontes/modificadores/citacoes.ts

@@ -9,6 +9,10 @@ export class Citacoes extends Modificador {
 
     constructor(valor: string, quantificador?: string, pragmas?: PragmasModificador) {
         super(["citacoes", "citações"], "quotes", pragmas);
+
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
 
         validarValores("citações", valor, this.valoresAceitos);
 

fontes/modificadores/configuracoes-variacao-fonte.ts

@@ -14,6 +14,10 @@ export class ConfiguracoesVariacaoFonte extends Modificador {
             pragmas
         );
 
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
+
         validarValorNumerico('configurações-variação-fonte', valor, this.valoresAceitos);
         this.valor = valor;
 

fontes/modificadores/enfase-texto.ts

@@ -24,6 +24,10 @@ export class EnfaseTexto extends Modificador {
     constructor(valor: string, quantificador?: string, pragmas?: PragmasModificador) {
         super(["enfase-texto", "ênfase-texto"], "text-emphasis", pragmas);
 
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
+
         validarValorCor('ênfase-texto', valor, this.valoresAceitos);
 
         this.valor = valor;

fontes/modificadores/estilo-enfase-texto.ts

@@ -20,19 +20,13 @@ export class EstiloEnfaseTexto extends Modificador {
     constructor(valor: string, quantificador?: string, pragmas?: PragmasModificador) {
         super(
             ["estilo-enfase-texto", "estilo-ênfase-texto"],
-            "text-emphasis-style", 
+            "text-emphasis-style",
             pragmas
         );
 
-        // OBS.: O seletor também aceita receber STRINGS, desde que essas contenham UM caractere.
-
-        // Ex.1: estilo-ênfase-texto: "x";
-        // Ex.2: estilo-ênfase-texto: "\25B2"; // ESSE CASO É PERMITIDO.
-        // Ex.3: estilo-ênfase-texto: "foo"; // ESSE CASO NÃO É PERMITIDO! 
-
-        // OBS.2: Dada a complexidade do Exemplo 2, uma simples condicional avaliando se a string
-        // possui 1 caractere não seria suficiente. A própria documentação não é muito clara sobre esse exemplo.
-        // https://developer.mozilla.org/en-US/docs/Web/CSS/text-emphasis-style 
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
 
         validarValores('estilo-ênfase-texto', valor, this.valoresAceitos);
 

fontes/modificadores/substituir-idioma-fonte.ts

@@ -9,6 +9,10 @@ export class SubstituirIdiomaFonte extends Modificador {
     constructor(valor: string, quantificador?: string, pragmas?: PragmasModificador) {
         super("substituir-idioma-fonte", "font-language-override", pragmas);
 
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
+
         validarValores('substituir-idioma-fonte', valor, this.valoresAceitos);
         this.valor = valor;
 

fontes/modificadores/vazamento-texto.ts

@@ -10,6 +10,10 @@ export class VazamentoTexto extends Modificador {
     constructor(valor: string, quantificador: string, pragmas?: PragmasModificador) {
         super("vazamento-texto", "text-overflow", pragmas);
 
+        if (valor.includes("'") || valor.includes('"')) {
+            this.valoresAceitos[valor] = valor;
+        }
+
         validarValores('vazamento-texto', valor, this.valoresAceitos);
 
         this.valor = valor;

testes/listas/valor-string.ts

@@ -0,0 +1,32 @@
+export const ValorString: Array<string> = [
+    'citações',
+    'citacoes',
+    'configurações-variação-fonte',
+    'configuracoes-variacao-fonte',
+    'ênfase-texto',
+    'enfase-texto',
+    'estilo-ênfase-texto',
+    'estilo-enfase-texto',
+    'substituir-idioma-fonte',
+    'vazamento-texto',
+];
+
+export const ValorStringAcentuado: Array<string> = [
+    'citações',
+    'configurações-variação-fonte',
+    'ênfase-texto',
+    'estilo-ênfase-texto',
+    'substituir-idioma-fonte',
+    'vazamento-texto',
+];
+
+/*
+
+VALORES STRING - Exemplos 
+    "x"
+    "<"
+    'foo'
+    "\25B2"
+    "«" "»" "‹" "›"
+    'xxxxx'
+*/

testes/modificadores/valor-string.test.ts

@@ -0,0 +1,90 @@
+import { AvaliadorSintatico } from "../../fontes/avaliador-sintatico";
+import { Importador } from "../../fontes/importador";
+import { AvaliadorSintaticoInterface, ImportadorInterface, LexadorInterface } from "../../fontes/interfaces";
+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 { ValorString, ValorStringAcentuado } from "../listas/valor-string";
+
+describe('Testando Seletores com VALORES STRING', () => {
+    describe('Testes Unitários', () => {
+        let lexador: LexadorInterface;
+        let importador: ImportadorInterface;
+        let avaliadorSintatico: AvaliadorSintaticoInterface;
+        let tradutor: Serializador;
+
+        beforeEach(() => {
+            lexador = new Lexador();
+            importador = new Importador(lexador);
+            avaliadorSintatico = new AvaliadorSintatico(importador);
+            tradutor = new Serializador();
+        });
+
+        it('Caso de sucesso - Lexador, Avaliador e Tradutor', () => {
+            for (let index = 0; index < Object.keys(ValorString).length; index += 1) {
+
+                const valoresString = [
+                    "'x'",
+                    '"«" "»" "‹" "›"',
+                    "'foo'",
+                    "'/25B2'",
+                ];
+
+                for (let valIndex = 0; valIndex < valoresString.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "corpo {",
+                        `${ValorString[index]}: ${valoresString[valIndex]};`,
+                        "}"
+                    ]);
+
+                    if (valIndex !== 1) {
+                        expect(resultadoLexador.simbolos).toHaveLength(7);
+                    } else {
+                        expect(resultadoLexador.simbolos).toHaveLength(10);
+                    }
+
+                    if (valIndex < 1) {
+                        expect(resultadoLexador.simbolos).toEqual(
+                            expect.arrayContaining([
+                                expect.objectContaining({ tipo: tiposDeSimbolos.TEXTO }),
+                            ])
+                        );
+                    } else {
+                        expect(resultadoLexador.simbolos).toEqual(
+                            expect.arrayContaining([
+                                expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                            ])
+                        );
+                    }
+
+                    // Avaliador Sintático
+                    const resultadoAvaliadorSintatico = avaliadorSintatico.analisar(resultadoLexador.simbolos);
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].nomeFoles).toContain(ValorString[index]);
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].valor).toContain(valoresString[valIndex]);
+
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    expect(resultadoTradutor).toContain(valoresString[valIndex]);
+                }
+            }
+        });
+
+        it('Caso de falha - Avaliador sintático deve retornar erro ', () => {
+            for (let index = 0; index < Object.keys(ValorStringAcentuado).length; index += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "corpo {",
+                        `${ValorStringAcentuado[index]}: x;`,
+                    "}"
+                ]);
+
+                // Avaliador Sintático não deve aceitar o valor string sem aspas
+                expect(() => {
+                    avaliadorSintatico.analisar(resultadoLexador.simbolos);
+                }).toThrowError(`Propriedade '${ValorStringAcentuado[index]}' com valor x inválido`);
+            }
+        });
+    });
+});