@designliquido/delegua 0.0.1 → 0.0.2

package/.github/workflows/principal.yml

@@ -0,0 +1,20 @@
+name: Commit e PR - Principal
+
+on:
+  pull_request:
+    branches: [ principal ]
+
+jobs:
+  teste_desenvolvimento:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2-beta
+      with:
+        node-version: '16'
+
+    - name: Testes da Linguagem
+      run: | 
+        sudo chmod +x ./bin/delegua
+        sudo npm run testes

package/.release-it.json

@@ -0,0 +1,8 @@
+{
+  "git": {
+    "commitMessage": "Lançamento da versão v${version}"
+  },
+  "github": {
+    "release": true
+  }
+}

package/.vscode/launch.json

@@ -12,7 +12,7 @@
                 "<node_internals>/**"
             ],
             "console": "integratedTerminal",
-            "program": "${workspaceFolder}\\index.js"
+            "program": "${workspaceFolder}\\indice.js"
         },
         {
             "type": "node",
@@ -23,7 +23,7 @@
             ],
             "args": ["${workspaceFolder}\\tests\\tests.egua"],
             "console": "integratedTerminal",
-            "program": "${workspaceFolder}\\index.js"
+            "program": "${workspaceFolder}\\indice.js"
         }
     ]
 }

package/README.md

@@ -1,7 +1,5 @@
 <br>
 <p align="center">
-  <img src="./web/assets/egua.png" alt="egua" width="auto" height="80px">
-
   <h3 align="center">Linguagem Delégua</h3>
 
   <p align="center">
@@ -17,9 +15,9 @@
 
 ## Introdução
 
-Delégua é uma variação da linguagem Égua, usada para fins educacionais e comerciais pela Design Líquido.
+Delégua é uma variação da linguagem Égua, usada para fins educacionais e comerciais pela Design Líquido. A variação começou na versão 1.2.0 de Égua.
 
-Por ora, Delégua tem retrocompatibilidade com a linguagem Égua. Em outras palavras, todo programa escrito em Égua funciona em Delégua, mas Delégua tem capacidades a mais, conforme mencionado em documentação.
+Delégua tem retrocompatibilidade com a linguagem Égua e usa a mesma extensão de arquivo (`.egua`). Em outras palavras, todo programa escrito em Égua funciona em Delégua, mas Delégua tem capacidades a mais, [conforme mencionado em documentação](https://github.com/DesignLiquido/delegua/wiki).
 
 ## Características
 
@@ -52,8 +50,9 @@ Para finalizar a execução do interpretador LAIR Delégua, use o atalho <key>Ct
 
 ## Documentação
 
-- Para acessar nossa documentação, visite o [site de documentação](https://egua.tech/docs).
+- Para acessar a documentação da linguagem Égua, visite https://egua.tech/docs.
+- [Delégua é documentada na Wiki deste GitHub](https://github.com/DesignLiquido/delegua/wiki). 
 
-## Contruibuições
+## Contribuições
 
 * Para contribuições, por favor, leia o nosso [Guia de Contribuição](.github/CONTRIBUTING.md) antes de submeter uma Pull Request.

package/bin/delegua

@@ -1,3 +1,3 @@
 #! /usr/bin/env node
 
-require('../index.js');
+require('../indice.js');

package/bin/delegua.cmd

@@ -0,0 +1 @@
+node indice.js %*

package/indice.js

@@ -0,0 +1,14 @@
+const Delegua = require("./src/delegua.js").Delegua;
+
+const principal = function() {
+    const argumentos = process.argv;
+
+    const delegua = new Delegua();
+    if (argumentos.length === 2) {
+        delegua.runPrompt();
+    } else {
+        delegua.runfile(argumentos[2]);
+    }
+};
+
+principal();

package/package.json

@@ -1,37 +1,46 @@
-{
-  "name": "@designliquido/delegua",
-  "version": "0.0.1",
-  "description": "Linguagem de programação simples e moderna usando português",
-  "main": "index.js",
-  "scripts": {
-    "npm-publish": "npm publish --access public",
-    "testes": "./bin/delegua testes/testes.egua",
-    "testes-unitarios": "jest",
-    "production": "npm run npm-publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DesignLiquido/delegua.git"
-  },
-  "bin": {
-    "delegua": "./bin/delegua"
-  },
-  "keywords": [
-    "egua",
-    "delegua"
-  ],
-  "author": "Leonel Sanches da Silva",
-  "contributors": [
-    "Leonel Sanches da Silva <leonel@designliquido.com.br> (https://www.linkedin.com/in/leonelsanchesdasilva/)"
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/DesignLiquido/delegua/issues"
-  },
-  "homepage": "https://github.com/DesignLiquido/delegua#readme",
-  "devDependencies": {
-    "@babel/preset-env": "^7.12.1",
-    "jest": "^26.6.1"
-  },
-  "dependencies": {}
-}
+{
+  "name": "@designliquido/delegua",
+  "version": "0.0.2",
+  "description": "Linguagem de programação simples e moderna usando português",
+  "main": "indice.js",
+  "scripts": {
+    "npm-publish": "npm publish --access public",
+    "testes": "./bin/delegua testes/testes.egua",
+    "testes-unitarios": "jest",
+    "production": "npm run npm-publish",
+    "release": "release-it"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DesignLiquido/delegua.git"
+  },
+  "bin": {
+    "delegua": "./bin/delegua"
+  },
+  "keywords": [
+    "egua",
+    "delegua"
+  ],
+  "author": "Leonel Sanches da Silva",
+  "contributors": [
+    {
+      "name": "Leonel Sanches da Silva",
+      "url": "https://www.linkedin.com/in/leonelsanchesdasilva/"
+    },
+    {
+      "name": "Samuel Renan Gonçalves Vaz",
+      "url": "https://www.linkedin.com/in/samuel-renan-gon%C3%A7alves-vaz-b6b83a103/"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/DesignLiquido/delegua/issues"
+  },
+  "homepage": "https://github.com/DesignLiquido/delegua#readme",
+  "devDependencies": {
+    "@babel/preset-env": "^7.12.1",
+    "jest": "^26.6.1",
+    "release-it": "^14.11.8"
+  },
+  "dependencies": {}
+}

package/src/ambiente.js

@@ -0,0 +1,53 @@
+const ErroEmTempoDeExecucao = require("./erro.js").ErroEmTempoDeExecucao;
+
+module.exports = class Ambiente {
+    constructor(enclosing) {
+        this.enclosing = enclosing || null;
+        this.valores = {};
+    }
+
+    definirVariavel(nomeVariavel, valor) {
+        this.valores[nomeVariavel] = valor;
+    }
+
+    atribuirVariavelEm(distancia, nome, valor) {
+        this.ancestor(distancia).valores[nome.lexeme] = valor;
+    }
+
+    atribuirVariavel(nome, valor) {
+        if (this.valores[nome.lexeme] !== undefined) {
+            this.valores[nome.lexeme] = valor;
+            return;
+        }
+
+        if (this.enclosing != null) {
+            this.enclosing.atribuirVariavel(nome, valor);
+            return;
+        }
+
+        throw new ErroEmTempoDeExecucao(nome, "Variável não definida '" + nome.lexeme + "'.");
+    }
+
+    ancestor(distancia) {
+        let ambiente = this;
+        for (let i = 0; i < distancia; i++) {
+            ambiente = ambiente.enclosing;
+        }
+
+        return ambiente;
+    }
+
+    obterVariavelEm(distancia, nome) {
+        return this.ancestor(distancia).valores[nome];
+    }
+
+    obterVariavel(simbolo) {
+        if (this.valores[simbolo.lexeme] !== undefined) {
+            return this.valores[simbolo.lexeme];
+        }
+
+        if (this.enclosing !== null) return this.enclosing.obterVariavel(simbolo);
+
+        throw new ErroEmTempoDeExecucao(simbolo, "Variável não definida '" + simbolo.lexeme + "'.");
+    }
+};

package/src/{egua.js → delegua.js}

@@ -1,13 +1,13 @@
 const Lexer = require("./lexer.js");
 const Parser = require("./parser.js");
 const Resolver = require("./resolver.js");
-const Interpreter = require("./interpreter.js");
-const tokenTypes = require("./tokenTypes.js");
+const Interpretador = require("./interpretador.js");
+const tiposDeSimbolos = require("./tiposDeSimbolos.js");
 const fs = require("fs");
-const path = require("path");
+const caminho = require("path");
 const readline = require("readline");
 
-module.exports.Egua = class Egua {
+module.exports.Delegua = class Delegua {
     constructor(nomeArquivo) {
         this.nomeArquivo = nomeArquivo;
 
@@ -16,12 +16,12 @@ module.exports.Egua = class Egua {
     }
 
     runPrompt() {
-        const interpreter = new Interpreter(this, process.cwd(), undefined);
-        console.log("Console da Linguagem Delégua v1.1.15");
+        const interpretador = new Interpretador(this, process.cwd(), undefined);
+        console.log("Console da Linguagem Delégua v0.0.1");
         const leiaLinha = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
-            prompt: "\negua> "
+            prompt: "\ndelegua> "
         });
 
         leiaLinha.prompt();
@@ -30,14 +30,14 @@ module.exports.Egua = class Egua {
             this.teveErro = false;
             this.teveErroEmTempoDeExecucao = false;
 
-            this.run(linha, interpreter);
+            this.run(linha, interpretador);
             leiaLinha.prompt();
         });
     }
 
     runfile(nomeArquivo) {
-        this.nomeArquivo = path.basename(nomeArquivo);
-        const interpretador = new Interpreter(this, process.cwd());
+        this.nomeArquivo = caminho.basename(nomeArquivo);
+        const interpretador = new Interpretador(this, process.cwd());
 
         const dadosDoArquivo = fs.readFileSync(nomeArquivo).toString();
         this.run(dadosDoArquivo, interpretador);
@@ -46,8 +46,8 @@ module.exports.Egua = class Egua {
         if (this.teveErroEmTempoDeExecucao) process.exit(70);
     }
 
-    run(code, interpretador) {
-        const lexer = new Lexer(code, this);
+    run(codigo, interpretador) {
+        const lexer = new Lexer(codigo, this);
         const simbolos = lexer.scan();
 
         if (this.teveErro === true) return;
@@ -74,8 +74,8 @@ module.exports.Egua = class Egua {
         this.teveErro = true;
     }
 
-    error(simbolo, mensagemDeErro) {
-        if (simbolo.type === tokenTypes.EOF) {
+    erro(simbolo, mensagemDeErro) {
+        if (simbolo.tipo === tiposDeSimbolos.EOF) {
             this.reportar(simbolo.line, " no final", mensagemDeErro);
         } else {
             this.reportar(simbolo.line, ` no '${simbolo.lexeme}'`, mensagemDeErro);
@@ -86,16 +86,16 @@ module.exports.Egua = class Egua {
         this.reportar(linha, ` no '${caractere}'`, mensagem);
     }
 
-    runtimeError(erro) {
-        const linha = erro.token.line;
-        if (erro.token && linha) {
+    erroEmTempoDeExecucao(erro) {
+        const linha = erro.simbolo.linha;
+        if (erro.simbolo && linha) {
             if (this.nomeArquivo)
                 console.error(
-                    `Erro: [Arquivo: ${this.nomeArquivo}] [Linha: ${erro.token.line}] ${erro.message}`
+                    `Erro: [Arquivo: ${this.nomeArquivo}] [Linha: ${erro.simbolo.linha}] ${erro.mensagem}`
                 );
-            else console.error(`Erro: [Linha: ${erro.token.line}] ${erro.message}`);
+            else console.error(`Erro: [Linha: ${erro.simbolo.linha}] ${erro.mensagem}`);
         } else {
-            console.error(`Erro: ${erro.message}`);
+            console.error(`Erro: ${erro.mensagem}`);
         }
         this.teveErroEmTempoDeExecucao = true;
     }

package/src/erro.js

@@ -0,0 +1,18 @@
+module.exports.ErroEmTempoDeExecucao = class ErroEmTempoDeExecucao extends Error {
+  constructor(simbolo, mensagem) {
+    super(mensagem);
+    this.simbolo = simbolo;
+    this.mensagem = mensagem;
+  }
+};
+
+module.exports.ContinueException = class ContinueException extends Error { };
+
+module.exports.BreakException = class BreakException extends Error { };
+
+module.exports.ReturnException = class ReturnException extends Error {
+  constructor(valor) {
+    super(valor);
+    this.valor = valor;
+  }
+};

package/src/estruturas/callable.js

@@ -0,0 +1,5 @@
+module.exports = class Callable {
+    aridade() {
+        return this.valorAridade;
+    }
+};

package/src/estruturas/classe.js

@@ -0,0 +1,43 @@
+const Callable = require("./callable.js");
+const DeleguaInstancia = require("./instancia.js");
+
+module.exports = class DeleguaClasse extends Callable {
+    constructor(nome, superClasse, metodos) {
+        super();
+        this.nome = nome;
+        this.superClasse = superClasse;
+        this.metodos = metodos;
+    }
+
+    encontrarMetodo(nome) {
+        if (this.metodos.hasOwnProperty(nome)) {
+            return this.metodos[nome];
+        }
+
+        if (this.superClasse !== null) {
+            return this.superClasse.encontrarMetodo(nome);
+        }
+
+        return undefined;
+    }
+
+    toString() {
+        return `<classe ${this.nome}>`;
+    }
+
+    aridade() {
+        let inicializador = this.encontrarMetodo("construtor");
+        return inicializador ? inicializador.aridade() : 0;
+    }
+
+    call(interpretador, argumentos) {
+        let instancia = new DeleguaInstancia(this);
+
+        let inicializador = this.encontrarMetodo("construtor");
+        if (inicializador) {
+            inicializador.bind(instancia).call(interpretador, argumentos);
+        }
+
+        return instancia;
+    }
+};

package/src/estruturas/funcao.js

@@ -0,0 +1,62 @@
+const Callable = require("./callable.js");
+const Ambiente = require("../ambiente.js");
+const ReturnExpection = require("../erro.js").ReturnException;
+
+module.exports = class DeleguaFuncao extends Callable {
+    constructor(nome, declaracao, closure, eInicializador = false) {
+        super();
+        this.nome = nome;
+        this.declaracao = declaracao;
+        this.closure = closure;
+        this.eInicializador = eInicializador;
+    }
+
+    aridade() {
+        return this.declaracao.parametros.length;
+    }
+
+    toString() {
+        if (this.nome === null) return "<função>";
+        return `<função ${this.nome}>`;
+    }
+
+    call(interpretador, argumentos) {
+        let ambiente = new Ambiente(this.closure);
+        let parametros = this.declaracao.parametros;
+        for (let i = 0; i < parametros.length; i++) {
+            const param = parametros[i];
+
+            const nome = param["nome"].lexeme;
+            let valor = argumentos[i];
+            if (argumentos[i] === null) {
+                valor = param["padrao"] ? param["padrao"].valor : null;
+            }
+            ambiente.definirVariavel(nome, valor);
+        }
+
+        try {
+            interpretador.executeBlock(this.declaracao.corpo, ambiente);
+        } catch (erro) {
+            if (erro instanceof ReturnExpection) {
+                if (this.eInicializador) return this.closure.obterVariavelEm(0, "isto");
+                return erro.valor;
+            } else {
+                throw erro;
+            }
+        }
+
+        if (this.eInicializador) return this.closure.obterVariavelEm(0, "isto");
+        return null;
+    }
+
+    bind(instancia) {
+        let ambiente = new Ambiente(this.closure);
+        ambiente.definirVariavel("isto", instancia);
+        return new DeleguaFuncao(
+            this.nome,
+            this.declaracao,
+            ambiente,
+            this.eInicializador
+        );
+    }
+};

package/src/estruturas/funcaoPadrao.js

@@ -0,0 +1,18 @@
+const Callable = require("./callable.js");
+
+module.exports = class FuncaoPadrao extends Callable {
+    constructor(valorAridade, funcao) {
+        super();
+        this.valorAridade = valorAridade;
+        this.funcao = funcao;
+    }
+
+    chamar(interpretador, argumentos, simbolo) {
+        this.simbolo = simbolo;
+        return this.funcao.apply(this, argumentos);
+    }
+
+    toString() {
+        return "<função>";
+    }
+};

package/src/estruturas/instancia.js

@@ -0,0 +1,27 @@
+const ErroEmTempoDeExecucao = require("../erro.js").ErroEmTempoDeExecucao;
+
+module.exports = class DeleguaInstancia {
+    constructor(criarClasse) {
+        this.criarClasse = criarClasse;
+        this.campos = {};
+    }
+
+    get(nome) {
+        if (this.campos.hasOwnProperty(nome.lexeme)) {
+            return this.campos[nome.lexeme];
+        }
+
+        let metodo = this.criarClasse.encontrarMetodo(nome.lexeme);
+        if (metodo) return metodo.bind(this);
+
+        throw new ErroEmTempoDeExecucao(nome, "Método indefinido não recuperado.");
+    }
+
+    set(nome, valor) {
+        this.campos[nome.lexeme] = valor;
+    }
+
+    toString() {
+        return "<Objeto " + this.criarClasse.nome + ">";
+    }
+};

package/src/estruturas/modulo.js

@@ -0,0 +1,9 @@
+module.exports = class DeleguaModulo {
+    constructor(nome) {
+        if (nome !== undefined) this.nome = nome;
+    }
+
+    toString() {
+        return this.nome ? `<modulo ${this.nome}>` : "<modulo>";
+    }
+};