Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ktfth/typescript-livro-de-bolso
Um livro breve para conceitos avançados utilizando typescript
https://github.com/ktfth/typescript-livro-de-bolso
Last synced: 8 days ago
JSON representation
Um livro breve para conceitos avançados utilizando typescript
- Host: GitHub
- URL: https://github.com/ktfth/typescript-livro-de-bolso
- Owner: ktfth
- Created: 2020-10-27T21:03:31.000Z (about 4 years ago)
- Default Branch: main
- Last Pushed: 2023-01-22T22:46:03.000Z (almost 2 years ago)
- Last Synced: 2024-08-01T22:00:12.255Z (4 months ago)
- Language: TypeScript
- Size: 132 KB
- Stars: 136
- Watchers: 3
- Forks: 3
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Funding: FUNDING.yml
Awesome Lists containing this project
README
# Typescript
## Introdução
Este livro de bolso tem como objetivo, abordar conceitos avançados sobre a
linguagem em questão. Existem diversos recursos disponíveis para você começar a
programar com Typescript, mas este em especial vai te levar um pouco alem para
quem esta desejando ter suas habilidades polidas.
Uma linguagem nasce com um propósito dado a diversos fatores e o principal é a
necessidade de expandir as coisas que você desenvolve e foi para isto que esta
linguagem foi criada. Com recursos que muitos procuravam no Javascript, porque
Typescript é Javascript com tipos e transpilado. Sua compilação produz um código
que tem total compatibilidade com especificações já existentes em diversos
motores de execução.
Não vamos abordar configurações especificar por considerar que este guia seja,
avançado ou seja você deve saber como isto funciona para dar continuidade.
Entregaremos uma experiência bastante profunda para estudo e reflexão, contando
com padrões de projeção, desenvolvimento solido e segurança de suas aplicações.
## Projetando uma aplicação
Ao começarmos a projetar uma aplicação o mais importante em todas as etapas é
você saber contar uma historia envolvendo um ator, sendo ela de pequeno, médio
ou grande porte. Esta historia pode ser contada de acordo com os fatos que se
passam no desenvolvimento de um ecosistema inteiro. Nós daremos inicio em uma
aplicação por Javascript por ser assim que o Typescript deu inicio para
finalizarmos uma aplicação simples ou avançada. Todo desenvolvimento, tem uma
linha de raciocinio dado a possibilidade de sua inferencia lógica. E não estamos
falando da inferencia que ocorre do lado da compilação da linguagem.
Saber decidir quais algoritimos utilizar e quais padrões arquiteturais você pode
investir contra a projeção é importante. Como por exemplo uma ferramenta para
busca de texto em arquivos ou fluxos de dados, devemos começar por seu teste,
sabendo o que esperar de sua interface. Lembrando que você não deve despejar
tudo para fora, você deve contar a historia passo após passo até chegar em seu
nível mais avançado sabendo o que exatamente quer pensando em casos que
contemple até mesmo iterações de uso da mesma.
Você não deve ser groceiro e implementar algo pobre quando tem a devida
oportunidade, para isto você deve práticar todos os dias, disciplinas que
entreguem maior aptidão no uso de suas ferramentas. Desenhos são formas
interessantes de se conectar com a aplicação que você vai desenvolver, mas
normalmente tomam tempo, então salvo a dada cituação nós vamos mostrar como
fazer o uso adequado de todos os recursos presentes em Javascript e Typescript
por sua vez.
### Lógica de negócio - Busca por texto
Você deve pensar no seguinte quando esta desenvolvendo uma aplicação e a
quantidade de pessoas presente no projeto conta e a fragmentação das tarefas
devem estar bem claras para você dar continuidade, estimar tempo é um tarefa
extremamente dificil então optamos sempre por estimar dado a sua complexidade.
Você deve ter isto bem claro em sua mente, então vamos a primeira tarefa.
app.js
```js
'use strict';
const assert = require('assert');
assert.ok(search('foo', 'foobar'));
```
Neste ponto eu poderia estimar que a complexidade desta tarefa é de um ponto com
o limite de oito pontos. O que devemos fazer e completar a criação do código
acima com uma implementação que cubra os requisitos da asserção. Lembrando que
temos em mente a busca de texto que pode ser muito mais do que o teste atual.
Mas precisamos iniciar a projeção e conforme evoluirmos com ela, cobriremos um
cenario maior que o atual. Executando este código nós teremos uma exceção
presente no nosso código que é o esperado.
```js
'use strict';
const assert = require('assert');
function search(term, text) {
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
```
Com este código nós temos a primeira fase do nosso código completa, então
podemos seguir executando o código e vendo que o teste passou, não vamos
permanecer com esta implementação por muito tempo, porque devemos passar de
fase o mais rápido possível. Temos uma função de busca que retorna um booleano e
agora teremos uma que retorna a quantidade de vezes que o termo aparece no texto
em inteiro.
```js
'use strict';
const assert = require('assert');
function search(term, text) {
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
assert.equal(times('baz', 'bazfoobarbaz'), 2);
```
Com isto feito podemos seguir, e devemos alcançar 3 funções principais para o
nosso programa que são:
* Search
* Times
* Match
É tudo o que precisamos para o comportamento básico de nossa aplicação.
```js
'use strict';
const assert = require('assert');
function search(term, text) {
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
function times(term, text) {
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
```
Com isto nós temos duas de nossas funções implementadas, note que todas elas
fazem o uso de RegExp para retornar o comportamento esperado por seus testes.
Perceba que padrões estão surgindo para nós tirarmos vatagem de suas repetições.
```js
'use strict';
const assert = require('assert');
function search(term, text) {
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
function times(term, text) {
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
assert.deepEqual(match('baz', 'foobarbaz'), 'foobarbaz');
```
Os pontos de complexidade foram um para cada uma das tarefas, por ser bastante
simples de cobrir os casos de uso, mas isto não significa que a tua aplicação
esta bem testada. Para garantirmos o funcionamento de uma aplicação nós devemos
ir além do esperado e cobrir casos com os devidos erros que ela deve retornar.
```js
'use strict';
const assert = require('assert');
function search(term, text) {
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
function times(term, text) {
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
function match(term, text) {
return text.match(new RegExp(term)).input;
}
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
```
Após falharmos o código passou, e temos aqui um primeiro ponto de refatoração do
código que deve ser feito apenas quando tudo esta passando. Até aqui nada de
muito complexo foi encontrado mas temos uma quantidade de código consideravel.
Tendo em vista que nossa aplicação esta completamente mapeada por onde devemos
partir para chegarmos ao objetivo de termos uma aplicação de busca completa por
texto alguns avanços foram feitos, considerando que este guia avança para mostrar
uma nova perspectiva de como construir aplicações seguras e robustas. Este é o
código atual que vai receber varias novas implemntações mas esta é a completude
do mesmo.
```js
'use strict';
const assert = require('assert');
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
function search(term, text) {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
assert.throws(() => {
search(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
assert.throws(() => {
times(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
assert.throws(() => {
match(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
class Text {
constructor(content) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
search(term) { return search(term, this.getContent()); }
times(term) { return times(term, this.getContent()); }
match(term) { return match(term, this.getContent()); }
}
let txt = new Text('foobarbaz');
assert.ok(txt instanceof Text);
assert.equal(txt.content, 'foobarbaz', 'Text content not settled');
assert.ok(txt.setContent('foobarbazbuzz') instanceof Text);
assert.equal(txt.getContent(), 'foobarbazbuzz');
assert.ok(txt.search('buzz'));
txt.setContent('fuzzbarfuzzbuzzfuzz');
assert.equal(txt.times('fuzz'), 3);
assert.equal(txt.match('buzz'), 'fuzzbarfuzzbuzzfuzz');
```
Aqui nos temos algumas verificações de entrada, implementação de uma classe de
texto para usufluirmos de funções mais polidas mesmo que seja considerado por
alguns que ela não seja uma boa abordagem, mas lembrando que estamos usando
para estudar afundo quais os pros e contras de se utilizar uma aplicação escrita
em Typescript. Temos que práticar desta forma para ter total controle e visão do
que estamos fazendo. Alguns padrões de projeção estão surgindo para termos uma
qualidade maior no reuso.
Você deve começar tudo em um mesmo lugar, mesmo que fique gigante o seu arquivo
até alcançar uma versão estavel do objetivo final, isto só vai beneficiar o seu
conhecimento do que esta acontecendo e se adaptar a diferentes tipos de
ambientes entregando maior agilidade. Dado este fato, nós podemos estimar
esta entrega por volto dos oito pontos de complexidade.
### Lógica de negócio - Construindo a interface com o sistema de arquivos
Neste ponto vamos definir dois tipos de possibilidades que são as seguintes:
* Atraveçar os arquivos em busca do termo procurado
* Entrada de dados através de uma canalização padrão
Estamos em um ponto que é importante projetar nossos recursos para cobrir mais
casos de uso que só estarão mais visiveis conforme a evolução do programa,
com isto é simples de visualizar qual o panorama final.
Nesta implementação estamos utilizando recursos do Node.js e o ideal é que
possamos contar também com uma implementação que possa ser executada utilizando
o Deno, que deixaremos para o futuro do programa quando todos os recursos
estiverem prontos para o usuário final.
```js
'use strict';
const assert = require('assert');
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
function search(term, text) {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
assert.throws(() => {
search(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
assert.throws(() => {
times(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
assert.throws(() => {
match(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
class Text {
constructor(content) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
search(term) { return search(term, this.getContent()); }
times(term) { return times(term, this.getContent()); }
match(term) { return match(term, this.getContent()); }
}
let txt = new Text('foobarbaz');
assert.ok(txt instanceof Text);
assert.equal(txt.content, 'foobarbaz', 'Text content not settled');
assert.ok(txt.setContent('foobarbazbuzz') instanceof Text);
assert.equal(txt.getContent(), 'foobarbazbuzz');
assert.ok(txt.search('buzz'));
txt.setContent('fuzzbarfuzzbuzzfuzz');
assert.equal(txt.times('fuzz'), 3);
assert.equal(txt.match('buzz'), 'fuzzbarfuzzbuzzfuzz');
const isTTY = process.stdin.isTTY;
const { Transform } = require('stream');
const args = process.argv.slice(2);
function textMatchContentTransformFactory() {
const opts = {
transform(raw, encoding, callback) {
let text = new Text(raw.toString());
if (text.search(args[0])) {
this.push(Buffer.from(text.match(args[0])));
}
callback();
}
};
return new Transform(opts);
}
if (!isTTY) {
process.stdin.pipe(textMatchContentTransformFactory()).pipe(process.stdout);
}
```
O comportamento puro da leitura de uma entrada foi completo através de uma linha
de processamento, com isto podemos estimar que esta tarefa tenha em torno de
três pontos de complexidade para verificar se o tipo de entrada não é TTY
recolher argumentos da linha de comando e depois transformar a entrada para algo
que possamos manipular com as funções presentes em nossa implementação passada e
de fato fazer o que estavamos imaginando verificando se o termo esta presente,
e depois extraindo esta entrada. Como previsto varios comportamentos podem ser
inseridos para melhorar nossa aplicação, mas isto vai ser abordado quando
portarmos nossa aplicação para Typescript ou seja o melhor esta por vir.
Não devemos ter apego com as nossas aplicações, mas toda mudança deve ser
introduzida com uma boa reflexão.
### Portabilidade - Vamos ao Typescript
Com o nosso programa funcionando de forma estavél na versão que paramos, vamos
a parte mais interessante do proceso que é executar a refatoração para o
Typescript. Nós só vamos precisar ajustar a classe que criamos mudando nome e
declarando uma variavel no escopo dela para que possamos utilizar nosso programa
mas como isto é apenas parte de nossas ações, para que possamos de fato utilizar
padrões mais sofisticados aqui esta nossas mudanças.
app.ts
```ts
'use strict';
const assert = require('assert');
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
function search(term, text) {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
assert.ok(search('foo', 'foobar'));
assert.throws(() => {
search(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
assert.equal(times('baz', 'bazfoobarbaz'), 2);
assert.throws(() => {
times(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
assert.throws(() => {
match(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
class TextContent {
content: string;
constructor(content: string) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
search(term) { return search(term, this.getContent()); }
times(term) { return times(term, this.getContent()); }
match(term) { return match(term, this.getContent()); }
}
let txt = new TextContent('foobarbaz');
assert.ok(txt instanceof TextContent);
assert.equal(txt.content, 'foobarbaz', 'TextContent content not settled');
assert.ok(txt.setContent('foobarbazbuzz') instanceof TextContent);
assert.equal(txt.getContent(), 'foobarbazbuzz');
assert.ok(txt.search('buzz'));
txt.setContent('fuzzbarfuzzbuzzfuzz');
assert.equal(txt.times('fuzz'), 3);
assert.equal(txt.match('buzz'), 'fuzzbarfuzzbuzzfuzz');
const isTTY = process.stdin.isTTY;
const { Transform } = require('stream');
const args = process.argv.slice(2);
function textMatchContentTransformFactory(filePath='') {
const opts = {
transform(raw, encoding, callback) {
let text = new TextContent(raw.toString());
if (text.search(args[0])) {
if (!!filePath) console.log(filePath);
this.push(Buffer.from(text.match(args[0])));
}
callback();
}
};
return new Transform(opts);
}
const fs = require('fs');
const path = require('path');
function traverse(dirPath, dirs=[]) {
let dir = fs.readdirSync(dirPath, {
withFileTypes: true
});
let nestedDirs = dir.filter(curr => curr.isDirectory() &&
!(curr.name.indexOf('.') === 0));
let nestedFiles = dir.filter(curr => curr.isFile() &&
!(curr.name.indexOf('.') === 0));
for (let file of nestedFiles) {
let curr = path.resolve(dirPath, file.name);
let currStream = fs.createReadStream(curr);
currStream.pipe(textMatchContentTransformFactory(curr)).pipe(process.stdout);
}
for (let entrypoint of nestedDirs) {
let curr = path.resolve(dirPath, entrypoint.name);
traverse(curr);
}
}
if (!isTTY) {
process.stdin.pipe(textMatchContentTransformFactory()).pipe(process.stdout);
} else if (isTTY) {
// traverse directories
traverse(process.cwd());
}
```
Neste ponto, devemos analisar quais as próximas refatorações importantes a serem
feitas, que podem ser as seguintes:
* Separar os testes
* Optimizar o uso de memoria e processamento de dados
* Implementar um algoritimo de busca mais eficiente
* Devolver o numero da linha que ocorre o padrão de texto que estamos buscando
* Sumarizar o texto na ocasião em especifico quando o padrão aparece
Nesta primeira refatoração nós separamos um arquivo para o programa e outro
para os testes, e este mesmo padrão se replica para novas mudanças.
app.ts
```ts
'use strict';
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
export function search(term, text): boolean {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
export function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
export function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
export class TextContent {
content: string;
constructor(content: string) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
search(term) { return search(term, this.getContent()); }
times(term) { return times(term, this.getContent()); }
match(term) { return match(term, this.getContent()); }
}
const isTTY = process.stdin.isTTY;
const { Transform } = require('stream');
const args = process.argv.slice(2);
function textMatchContentTransformFactory(filePath='') {
const opts = {
transform(raw, encoding, callback) {
let text = new TextContent(raw.toString());
if (text.search(args[0])) {
if (!!filePath) console.log(filePath);
this.push(Buffer.from(text.match(args[0])));
}
callback();
}
};
return new Transform(opts);
}
const fs = require('fs');
const path = require('path');
function traverse(dirPath, dirs=[]) {
let dir = fs.readdirSync(dirPath, {
withFileTypes: true
});
let nestedDirs = dir.filter(curr => curr.isDirectory() &&
!(curr.name.indexOf('.') === 0));
let nestedFiles = dir.filter(curr => curr.isFile() &&
!(curr.name.indexOf('.') === 0));
for (let file of nestedFiles) {
let curr = path.resolve(dirPath, file.name);
let currStream = fs.createReadStream(curr);
currStream.pipe(textMatchContentTransformFactory(curr)).pipe(process.stdout);
}
for (let entrypoint of nestedDirs) {
let curr = path.resolve(dirPath, entrypoint.name);
traverse(curr);
}
}
if (!isTTY) {
process.stdin.pipe(textMatchContentTransformFactory()).pipe(process.stdout);
} else if (isTTY && !module.parent) {
// traverse directories
traverse(process.cwd());
}
```
app.test.ts
```ts
'use strict';
const assert = require('assert');
import { search } from './app';
import { times } from './app';
import { match } from './app';
import { TextContent } from './app';
describe('Text Content Search', () => {
it('should search for a term', () => {
assert.ok(search('foo', 'foobar'));
});
it('should throws arguments exception for search', () => {
assert.throws(() => {
search(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content Times', () => {
it('should have times of a term', () => {
assert.equal(times('baz', 'bazfoobarbaz'), 2);
});
it('should throws arguments exception for times', () => {
assert.throws(() => {
times(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content Match', () => {
it('should have match of term', () => {
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
});
it('should throws arguments exception for match', () => {
assert.throws(() => {
match(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content', () => {
let txt = null;
before(() => {
txt = new TextContent('foobarbaz');
});
it('should be an instance of', () => {
assert.ok(txt instanceof TextContent);
});
it('should be an content', () => {
assert.ok(txt.content, 'foobarbaz', 'TextContent content not settled');
});
it('should be set a content', () => {
assert.ok(txt.setContent('foobarbazbuzz') instanceof TextContent);
});
it('should be get a content', () => {
assert.equal(txt.getContent(), 'foobarbazbuzz');
});
it('should be search by a term in content', () => {
assert.ok(txt.search('buzz'));
});
it('should be have times of term occured on the content', () => {
txt.setContent('fuzzbarfuzzbuzzfuzz');
assert.equal(txt.times('fuzz'), 3);
});
it('should be match by term on the content', () => {
assert.equal(txt.match('buzz'), 'fuzzbarfuzzbuzzfuzz');
});
});
```
Com as mudanças feitas podemos seguir para as próximas implementações.
A optimização foi feita através da utilização do buffer, como fonte para nossas
manipulações, com isto nós podemos analisar que foram utilizados em torno de
seis pontos de complexidade para ela ser concluida.
app.test.ts
```ts
'use strict';
const assert = require('assert');
import { search } from './app';
import { times } from './app';
import { match } from './app';
import { TextContent } from './app';
describe('Text Content Search', () => {
it('should search for a term', () => {
assert.ok(search('foo', 'foobar'));
});
it('should throws arguments exception for search', () => {
assert.throws(() => {
search(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content Times', () => {
it('should have times of a term', () => {
assert.equal(times('baz', 'bazfoobarbaz'), 2);
});
it('should throws arguments exception for times', () => {
assert.throws(() => {
times(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content Match', () => {
it('should have match of term', () => {
assert.equal(match('baz', 'foobarbaz'), 'foobarbaz');
});
it('should throws arguments exception for match', () => {
assert.throws(() => {
match(1, 10);
}, {
name: 'Error',
message: 'Each argument, must be a string'
});
});
});
describe('Text Content', () => {
let txt = null;
before(() => {
txt = new TextContent('foobarbaz');
});
it('should be an instance of', () => {
assert.ok(txt instanceof TextContent);
});
it('should be an content', () => {
assert.ok(txt.content, 'foobarbaz', 'TextContent content not settled');
});
it('should be set a content', () => {
assert.ok(txt.setContent('foobarbazbuzz') instanceof TextContent);
});
it('should be get a content', () => {
assert.equal(txt.getContent(), 'foobarbazbuzz');
});
it('should be search by a term in content', () => {
assert.ok(txt.search('buzz'));
});
it('should be have times of term occured on the content', () => {
txt.setContent('fuzzbarfuzzbuzzfuzz');
assert.equal(txt.times('fuzz'), 3);
});
it('should be match by term on the content', () => {
assert.equal(txt.match('buzz'), 'fuzzbarfuzzbuzzfuzz');
});
});
describe('Text Content processing buffer', () => {
let txtBuff = null;
before(() => {
txtBuff = new TextContent(Buffer.from('foobarbaz'));
});
it('should be an instance of', () => {
assert.ok(txtBuff instanceof TextContent);
});
it('should be an content', () => {
assert.ok(txtBuff.content, Buffer.from('foobarbaz'), 'TextContent content not settled');
});
it('should be a buffer', () => {
assert.ok(txtBuff.isBuffer(Buffer.from('bar')));
});
it('should be search by a term in content as buffer', () => {
assert.ok(txtBuff.search(Buffer.from('bar')));
});
it('should be have times of term occured on the content as buffer', () => {
txtBuff.setContent(Buffer.from('fuzzbarfuzzbuzzfuzz'));
assert.equal(txtBuff.times(Buffer.from('fuzz')), 3);
});
it('should be match by term on the content as buffer', () => {
assert.equal(txtBuff.match(Buffer.from('buzz')), 'fuzzbarfuzzbuzzfuzz');
})
});
```
app.ts
```ts
'use strict';
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
export function search(term, text): boolean {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
export function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
export function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
export class TextContent {
content: any;
constructor(content: any) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.isBuffer = this.isBuffer.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
isBuffer(value) {
return value.constructor.toString().indexOf('Buffer') > -1;
}
search(term) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
return this.getContent().indexOf(term) > -1;
}
return search(term, this.getContent());
}
times(term, t=-1, o=0) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out = o;
let curr = this.getContent().indexOf(term, t + 1);
if (curr > -1) {
out += 1;
return this.times(term, t=curr + 1, out);
}
return out;
}
return times(term, this.getContent());
}
match(term) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out = Buffer.from('');
if (this.search(term)) {
out = this.getContent();
}
return out;
}
return match(term, this.getContent());
}
}
const isTTY = process.stdin.isTTY;
const { Transform } = require('stream');
const args = process.argv.slice(2);
function textMatchContentTransformFactory(filePath='') {
const opts = {
transform(raw, encoding, callback) {
let text = new TextContent(raw);
if (!!args.length && text.search(Buffer.from(args[0]))) {
if (!!filePath) console.log(filePath);
this.push(text.match(Buffer.from(args[0])));
}
callback();
}
};
return new Transform(opts);
}
const fs = require('fs');
const path = require('path');
function traverse(dirPath, dirs=[]) {
let dir = fs.readdirSync(dirPath, {
withFileTypes: true
});
let nestedDirs = dir.filter(curr => curr.isDirectory() &&
!(curr.name.indexOf('.') === 0));
let nestedFiles = dir.filter(curr => curr.isFile() &&
!(curr.name.indexOf('.') === 0));
for (let file of nestedFiles) {
let curr = path.resolve(dirPath, file.name);
let currStream = fs.createReadStream(curr);
currStream.setMaxListeners(100000);
currStream.pipe(textMatchContentTransformFactory(curr)).pipe(process.stdout);
}
for (let entrypoint of nestedDirs) {
let curr = path.resolve(dirPath, entrypoint.name);
traverse(curr);
}
}
process.stdin.setEncoding('utf-8');
process.stdout.setMaxListeners(100000);
if (!isTTY) {
process.stdin.pipe(textMatchContentTransformFactory()).pipe(process.stdout);
} else if (isTTY && !module.parent) {
// traverse directories
traverse(process.cwd());
}
```
Estamos avançando para uma versão bastante promissora que é a seguinte.
```ts
'use strict';
function thrownArgumentException(text, term) {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
export function search(term, text): boolean {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
export function times(term, text) {
thrownArgumentException(term, text);
return text.match((new RegExp(term, 'g'))).length;
}
export function match(term, text) {
thrownArgumentException(term, text);
return text.match(new RegExp(term)).input;
}
export class TextContent {
content: any;
constructor(content: any) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.isBuffer = this.isBuffer.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
isBuffer(value) {
return value.constructor.toString().indexOf('Buffer') > -1;
}
search(term) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
return this.getContent().indexOf(term) > -1;
}
return search(term, this.getContent());
}
times(term, t=-1, o=0) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out = o;
let curr = this.getContent().indexOf(term, t + 1);
if (curr > -1) {
out += 1;
return this.times(term, t=curr + 1, out);
}
return out;
}
return times(term, this.getContent());
}
match(term) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out = {};
let lines = [];
let line = [];
for (let i = 0; i < this.getContent().length; i += 1) {
let chr = this.getContent()[i];
if (chr === Buffer.from('\n')[0]) {
lines.push(line);
line = [];
} else if (i === this.getContent().length - 1) {
line.push(chr);
lines.push(line);
line = [];
} else {
line.push(chr);
}
}
for (let i in lines) {
let curr = Buffer.from(lines[i]);
if (curr.indexOf(term) > -1) {
out[parseInt(i, 10) + 1] = curr;
}
}
return out;
}
return match(term, this.getContent());
}
}
const isTTY = process.stdin.isTTY;
const { Transform } = require('stream');
const args = process.argv.slice(2);
function textMatchContentTransformFactory(filePath='') {
const opts = {
transform(raw, encoding, callback) {
let text = new TextContent(raw);
if (!!args.length && text.search(Buffer.from(args[0]))) {
if (!!filePath) console.log(filePath);
let matches = text.match(Buffer.from(args[0]));
let lines = [];
Object.keys(matches).forEach(k => {
lines.push(`${k}:${matches[k].toString().replace((new RegExp(args[0], 'g')), '\x1b[100m' + args[0] + '\x1b[49m')}`);
});
this.push(Buffer.from(`${lines.join('\n')}\n`));
}
callback();
}
};
return new Transform(opts);
}
const fs = require('fs');
const path = require('path');
function traverse(dirPath, dirs=[]) {
let dir = fs.readdirSync(dirPath, {
withFileTypes: true
});
let nestedDirs = dir.filter(curr => curr.isDirectory() &&
!(curr.name.indexOf('.') === 0));
let nestedFiles = dir.filter(curr => curr.isFile() &&
!(curr.name.indexOf('.') === 0));
for (let file of nestedFiles) {
let curr = path.resolve(dirPath, file.name);
let currStream = fs.createReadStream(curr);
currStream.setMaxListeners(100000);
currStream.pipe(textMatchContentTransformFactory(curr)).pipe(process.stdout);
}
for (let entrypoint of nestedDirs) {
let curr = path.resolve(dirPath, entrypoint.name);
traverse(curr);
}
}
process.stdin.setEncoding('utf-8');
process.stdout.setMaxListeners(100000);
if (!isTTY) {
process.stdin.pipe(textMatchContentTransformFactory()).pipe(process.stdout);
} else if (isTTY && !module.parent) {
// traverse directories
traverse(process.cwd());
}
```
Com isto estabilizamos a nossa versão e podemos fazer o que bem entender com
ela desta forma, inclusives melhorias de como o programa funciona. Fica o
exercicio que pode ser executado por você, esta livre para vasculhar e
implementar melhorias no funcionamento do programa.
Este programa pode ser extendido de várias formas e alcançar um nível de
conhecimento mais polido e útil, para o seu dia a dia. Estamos abertos para
novas implementações até que finalizemos a obra por completo, de forma coletiva
e inteligênte.
Obrigado a você que leu e opinou sobre o livro.
## Projeção - Polindo sua ferramenta
Após utilizar a ferramenta logo vemos que existem varios modos de se fazer a
mesma coisa, mas como podemos realizar esta tarefa enquanto estamos projetando
a ferramenta? É simples, aplicaremos tecnicas que serve com o propósito de
manter uma analise constante.
### Injeção de parametros
```js
'use strict';
const assert = require('assert');
const { exec } = require('child_process');
exec('echo "foobar" | node app.js foo', (error, stdout, stderr) => {
if (error) {
console.error(`exec error: ${error}`);
return;
}
assert.equal(stdout, '1:\x1b[100m' + 'foo' + '\x1b[49mbar\n');
});
```
Anter de portarmos a nossa solução para o Deno cobriremos vários casos de uso
que a ferramenta pode ser utilizada. Com este código nos testamos uma das formas
que ele pode ser utilizada. Mas em outras baterias de testes descobrimos que o
processo aglutina quando executa o modo varredura, por isto devemos investigar
nossa implementação e decidirmos se é interessante manter este tipo de cobertura.
Neste caso utilizei algumas linhas de python que é ótimo para casos como estes
em sistemas linux e unix por ter um suporte grande a funções que não precisam de
tanto desprendimento de tempo e esforço.
```python
import os
node = 'node app.js biz'
node_output = os.popen(node).read()
assert (len(node_output) > 0)
```
Depois de testarmos o minimo do uso da linha de comando, nós vamos dar atenção
a implementação util em outros motores de execução, neste caso nós devemos
seguir o que esta sendo levantado como exceção pelo motor, neste caso o Deno.
Para esta implementação nós vamos ter que lidar com um método chamado "traverse"
que varre os diretorios e quando encontra arquivos procura pela ocorrencia de texto
e outro comportamento util é a utilização de um código que faz a busca na entrada
de texto padrão.
```typescript
'use strict';
import { existsSync } from 'https://deno.land/std/fs/mod.ts';
function thrownArgumentException(text: string, term: string): void {
if (typeof term !== 'string' || typeof text !== 'string') {
throw new Error('Each argument, must be a string');
}
}
export function search(term: string, text: string): boolean {
thrownArgumentException(term, text);
return (new RegExp(term)).test(text);
}
export function times(term: string, text: string): number {
thrownArgumentException(term, text);
let out = 0;
let matched = text.match((new RegExp(term, 'g')));
if (matched !== null) {
out = matched.length;
}
return out;
}
export function match(term: string, text: string): string {
thrownArgumentException(term, text);
let out = '';
let matched = text.match(new RegExp(term));
if (matched !== null && matched.input !== undefined) {
out = matched.input;
}
return out;
}
export class TextContent {
content: any;
constructor(content: any) {
this.content = content;
this.setContent = this.setContent.bind(this);
this.getContent = this.getContent.bind(this);
this.isBuffer = this.isBuffer.bind(this);
this.search = this.search.bind(this);
this.times = this.times.bind(this);
this.match = this.match.bind(this);
}
setContent(value: any) {
this.content = value;
return this;
}
getContent() {
return this.content;
}
isBuffer(value: Deno.Buffer) {
return value.constructor.toString().indexOf('Buffer') > -1;
}
search(term: any) {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
return this.getContent().indexOf(term) > -1;
}
return search(term, this.getContent());
}
times(term: any, t: number =-1, o: number = 0): any {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out = o;
let curr = this.getContent().indexOf(term, t + 1);
if (curr > -1) {
out += 1;
return this.times(term, t=curr + 1, out);
}
return out;
}
return times(term, this.getContent());
}
match(term: any): any {
if (this.isBuffer(term) && this.isBuffer(this.getContent())) {
let out: { [k: string]: any } = {};
let lines = [];
let line = [];
for (let i = 0; i < this.getContent().length; i += 1) {
let chr = this.getContent()[i];
if (chr === '\n'.charCodeAt(0)) {
lines.push(line);
line = [];
} else if (i === this.getContent().length - 1) {
line.push(chr);
lines.push(line);
line = [];
} else {
line.push(chr);
}
}
for (let i in lines) {
let curr = lines[i];
if (curr.indexOf(term) > -1) {
out[(parseInt(i, 10) + 1)] = curr;
}
}
return out;
}
return match(term, this.getContent());
}
}
export class Lines {}
async function traverse(dir=Deno.cwd()) {
if (Deno.cwd() !== dir) {
dir = Deno.cwd() + '/' + dir;
} if (existsSync(dir)) {
for await (const dirEntry of Deno.readDir(dir)) {
if (dirEntry.isFile) {
let decoder = new TextDecoder('utf-8');
let rawPath = Deno.cwd() + '/' + dirEntry.name;
if (existsSync(rawPath)) {
let raw = await Deno.readFile(rawPath);
let data = decoder.decode(raw);
let text = new TextContent(data.toString());
if (text.search(Deno.args[0])) {
let matches = text.match(Deno.args[0]);
let output = matches.replace((new RegExp(Deno.args[0], 'g')), '\x1b[100m' + Deno.args[0] + '\x1b[49m');
console.log(`${output}`);
}
}
} else if (dirEntry.isDirectory) {
traverse(dirEntry.name);
}
}
}
}
if (!!Deno.args.length && Deno.isatty(Deno.stdin.rid)) {
traverse();
} else if (!!Deno.args.length && !Deno.isatty(Deno.stdin.rid)) {
(async () => {
let decoder = new TextDecoder('utf-8');
let raw = await Deno.readAll(Deno.stdin);
let data = decoder.decode(raw);
let text = new TextContent(data.toString());
if (text.search(Deno.args[0])) {
let matches = text.match(Deno.args[0]);
let output = matches.replace((new RegExp(Deno.args[0], 'g')), '\x1b[100m' + Deno.args[0] + '\x1b[49m');
console.log(`${output}`);
}
})();
}
```
Com isto nós podemos verificar que a implementação contou também com uma verificação
se a entrada era do tipo "tty" para se comportar da maneira adequada. Ao executar
este código você vai encontrar o necessário para saber o que fazer após. E esta
é a nossa finalização do programa, e podemos melhorar muito mais este programa.
Neste momento podemos realizar que nossas duas versões estão maduras o suficiente
para receber modificações e também para vermos que elas tem algo em comum que tem
uma importancia muito grande. A forma com que lidamos com o texto fazendo buscas e
combinações de igualdade para obter um resultado tem similaridades e é onde podemos
visualizar que é onde o Javascript teve importancia na construção.
## Considerações finais
Creio que com isto podemos considerar que o conhecimento aqui apresentado pode
ter um reflexo positivo se incorporado da forma adequada em futuros projetos,
onde outras implementações surgiram e um novo se fara materializado. Aproveite
para práticar e construir coisas novas. Um bom exercicio que fica para o futuro
é construir uma aplicação que tira proveito de conexões em rede, e o utiliza
diversos tipos de protocolos, isto pode entregar uma visão mais ampla e minuciosa.
Agradeço a leitura e fique antenado para mais conteúdo.