Included the code on the readme

Removed unusued code

Author: ktfth

README.md

@@ -1256,3 +1256,170 @@ 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.
+Vamos para a parte de analise e refatoração.

main.ts

@@ -151,64 +151,3 @@ if (!!Deno.args.length && Deno.isatty(Deno.stdin.rid)) {
     }
   })();
 }
-
-// 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(new Deno.Buffer(args[0]))) {
-//         if (!!filePath) console.log(filePath);
-//         let matches = text.match(new Deno.Buffer(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(new Deno.Buffer(`${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());
-// }