@alu0101127163/constant-folding v3.0.2

constant-folding

El objetivo que cumple este módulo es realizar la transformación de plegado de constantes sobre un fichero de entrada input.js dejando la salida en un fichero de salida output.js.

El plegado constante es el proceso de reconocer y evaluar expresiones constantes en tiempo de compilación en lugar de calcularlas en tiempo de ejecución. Los términos en expresiones constantes suelen ser literales simples, como el literal entero 2, pero también pueden ser variables cuyos valores se conocen en tiempo de compilación.

Installation

Para poder instalarlo hay que tener en cuenta de que se trata un paquete publicado en npmjs.

Previamente ha de tener instalado la herramienta npm; para poder aplicar este módulo dentro del proyecto ha de escribir en su package.json la dependencia "@alu0101127163/constant-folding": "*", y la instalamos con npm i. Así tendremos tanto el ejecutable como el objeto si lo quiere usar dentro de s código.

Usage as executable:

Para poder porveer un ejecutable debemos de añadir al package.json la siguiente línea:

  "bin": {
    "cf": "bin/constant-folding-cli.js"
  }

Con esto estamos exportando un ejecutable llamado cf el cuál ejecutará el programa constant-folding-cli-js contenido en la carpeta /bin. Para poder usar este ejecutable debemos de instalar el módulo @alu0101127163/constant-folding globalmente npm install -g @alu0101127163/constant-folding, y así ya podremos poder usar libremente el módulo desde línea de comandos.

Usage from code:

Si queremos usarlo en el código de nuestro proyecto simplemente debemos de añadirlo en la cabecera del fichero y crear un objeto que contenga dicho módulo.

const constantFolding = require('constant-folding');
//call the function

The documentation of the function.

Examples

Examples as executable

Por ejemplo, para comprobar que la herramienta commander funciona correctamente, ejecutamos el ejecutable con la opción --help.

~/src/PL/constant-folding-module-oscar-hernandez-diaz-alu0101127163 (master) $ cf --help
Usage: cf [options] <filename>

Constant Folding javascript code

Arguments:
  filename                 file with the original code

Options:
  -V, --version            output the version number
  -o, --output <filename>  output file (default: "output.js")
  -h, --help               display help for command

Ahora si queremos hacer uso de esta debemos pasarle un <filename> que contendrá el código que queremos que le haga un plegado de constantes y le pasamos la opción -o para que nos vuelque la salida en un fichero aparte, por default lo escribe en output.js.

~/src/PL/constant-folding-module-oscar-hernandez-diaz-alu0101127163 (master) $ cf input.js 
File read succesfully
Output written succesfully in output.js

o

~/src/PL/constant-folding-module-oscar-hernandez-diaz-alu0101127163 (master) $ cf input.js -o output.js 
File read succesfully
Output written succesfully in output.js

Examples from code

Para poder usarlo en el código, como nombre antes hay que añadir primero el módulo:

const constantFolding = require("@alu0101127163/constant-folding");

Ahora podemos usar este objeto pasandole por parámetro un código js y nos devolvera con un plegado de constantes; con este códido ya plegado podemos trabajar con el todo lo que queramos

Author

Óscar Hernández Díaz.

alu0101127163@ull.edu.es

Tests

Para los test usamos la herramienta chai, para eso creamos un script test.js que contenga lo siguiente.

const constantFolding = require('../src/constant-folding');
const should = require('chai').should();  

const Checks = [
  //{ text: "[a, b, c].concat([d, e], f, g, [h]);", result: "[ a, b, c, d, e, f, g, h];"},
  { text: "[a, b, c].join();", result: "'a,b,c';" },
  { text: "[a, b, c].join('@');", result: "'a@b@c';" },
  { text: "[1, 2, 3].length;", result: "3;" },
  { text: "[1, 2, 3][2-1];", result: "2;" },
  { text: "[1, 2, 3].shift();", result: "1;" },
  { text: "[a, b, c].pop();", result: "'c';"},
  { text: "'abc'[0];", result : "'a';"},
  { text: "'abc'.charAt();", result: "'a';"},
  { text: "'abc'.charAt(1);", result: "'b';"},
  { text: "'abc'.length;", result: "3;"},
  { text: "'a,b,c'.split(',');", result: "a,b,c;"},
  { text: "(100 + 23).toString();", result: "'123';" },
];

describe('constantFolding tests', () => {
  for (let c of Checks) {
    it(`Test ${c.text} = ${c.result}`, () => {
      constantFolding(c.text).should.equal(c.result);
    });
  }
});

Lo que nos hará para cada código que tenemos en el objeto Checks se lo pasará a nuestro programa y comprobará si la salida que nos ha dado es la misma que esperabamos y nos quedaría tal que así:

~/src/PL/constant-folding-module-oscar-hernandez-diaz-alu0101127163 (master) $ npm run test

> @alu0101127163/constant-folding@3.0.1 test
> mocha



  constantFolding tests
    ✔ Test [a, b, c].join(); = 'a,b,c';
    ✔ Test [a, b, c].join('@'); = 'a@b@c';
    ✔ Test [1, 2, 3].length; = 3;
    ✔ Test [1, 2, 3][2-1]; = 2;
    ✔ Test [1, 2, 3].shift(); = 1;
    ✔ Test [a, b, c].pop(); = 'c';
    ✔ Test 'abc'[0]; = 'a';
    ✔ Test 'abc'.charAt(); = 'a';
    ✔ Test 'abc'.charAt(1); = 'b';
    ✔ Test 'abc'.length; = 3;
    ✔ Test 'a,b,c'.split(','); = a,b,c;
    ✔ Test (100 + 23).toString(); = '123';


  12 passing (32ms)