Fixed writing files.

Author: fabiandev

src/bin/handlers.ts

@@ -37,6 +37,22 @@ bus.on('transform.file.done', (filePath: string) => {
   child.send({message: 'fileEnd', payload: filePath});
 });
 
+bus.on('write.start', (num: number) => {
+  child.send({message: 'writeStart', payload: num});
+});
+
+bus.on('write.end', (num: number) => {
+  child.send({message: 'writeEnd', payload: num});
+});
+
+bus.on('write.file.start', (filePath: string) => {
+  child.send({message: 'fileWriteStart', payload: filePath});
+});
+
+bus.on('transform.file.done', (filePath: string) => {
+  child.send({message: 'fileWriteEnd', payload: filePath});
+});
+
 // process.on('SIGINT', () => {
 //   child.send({message: 'term'});
 // });

src/bin/index.ts

@@ -3,25 +3,44 @@
 import './handlers';
 import * as program from 'commander';
 import transform from '../transform';
+import { Config } from '../config';
+import { CompilerResult } from '../compiler';
+import { Writer, WriterConfig, DEFAULT_CONFIG as DEFAULT_WRITER_CONFIG } from '../writer';
 import { bus } from '../bus';
 import * as status from './status';
 
 const pkg = require('../../package.json');
+const config: Config = {};
+const writerConfig: WriterConfig = DEFAULT_WRITER_CONFIG;
+let write: boolean = false;
 
-function defaultAction(env: any, options: any) {
+function defaultAction() {
   const files: string[] = program.args.filter((value) => {
     return typeof value === 'string';
   });
 
-  transform(files);
+  transform(files)
+    .then((compilerResult: CompilerResult) => {
+      if (write) {
+        const writer = new Writer(compilerResult);
+        writer.writeAll();
+      }
+    });
 }
 
 function setNoAssertConst() {
-
+  config.assertConst = true;
 }
 
 function setEncoding(encoding: string) {
+  config.encoding = encoding;
+  writerConfig.encoding = encoding;
+}
 
+function setWrite(location: string, base?: string) {
+  write = true;
+  writerConfig.writePath = location || writerConfig.writePath;
+  writerConfig.basePath = base || writerConfig.basePath;
 }
 
 program
@@ -31,10 +50,9 @@ program
   emits pretty printed TypeScript.
   --------------------------------`)
   .usage('[options] <file ...>')
-  .option('-w, --write <location> [base]', 'persist files')
+  .option('-w, --write', 'persist files', setWrite)
   .option('-e, --encoding <encoding>', 'set file encoding. defaults to utf8', setEncoding)
   .option('--no-assert-const', 'turn off const declaration checks.', setNoAssertConst)
-  .action(defaultAction)
   .on('--help', () => {
     console.log('  Examples:');
     console.log();
@@ -47,4 +65,6 @@ program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {
   program.outputHelp();
+} else {
+  defaultAction();
 }

src/bin/status.ts

@@ -68,29 +68,45 @@ status.term = () => {
 status.fileStart = (filePath: string) => {
   processed++;
   const countStr = chalk.gray(`[${processed}/${fileCount}]`);
-  spinner.text = `${countStr} Processing ${filePath}`;
+  spinner.text = `${countStr} Processing ${path.basename(filePath)}`;
 };
 
 status.fileEnd = (filePath: string) => {
   const countStr = chalk.gray(`[${processed}/${fileCount}]`);
-  spinner.succeed(`${countStr} Done processing ${filePath}`);
+  spinner.succeed(`${countStr} Done processing ${path.basename(filePath)}`);
   spinner.start();
 };
 
 status.fileFail = (filePath: string) => {
   errors++;
   const countStr = chalk.gray(`[${processed}/${fileCount}]`);
-  spinner.fail(`${countStr} Error processing ${filePath}`);
+  spinner.fail(`${countStr} Error processing ${path.basename(filePath)}`);
   spinner.start();
 };
 
 status.fileReadError = (filePath: string) => {
   errors++;
   const countStr = chalk.gray(`[${processed}/${fileCount}]`);
-  spinner.fail(`${countStr} Could not read ${filePath}`);
+  spinner.fail(`${countStr} Could not read ${path.basename(filePath)}`);
   spinner.start();
 };
 
+status.writeStart = (num: number) => {
+  spinner.text = `Writing files`;
+};
+
+status.writeEnd = (num: number) => {
+  spinner.succeed(`Wrote ${num} files`);
+};
+
+status.fileWriteStart = (filePath: string) => {
+
+};
+
+status.fileWriteEnd = (filePath: string) => {
+
+};
+
 status.error = (err: any) => {
   errors++;
 

src/compiler/Compiler.ts

@@ -1,4 +1,4 @@
-import * as fs from 'fs';
+// import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 import { Config } from '../config';
@@ -76,17 +76,15 @@ export class Compiler {
 
     return new Promise((resolve, reject) => {
 
+      filePath = path.normalize(path.join(process.cwd(), filePath));
+
       const fileName = path.basename(filePath);
 
       const source = ts.sys.readFile(filePath, this.config.encoding);
 
       if (source === undefined) {
         bus.emit('transform.file.readError', filePath);
-        return reject({
-          fileName,
-          filePath,
-          result: undefined,
-        });
+        return reject(`Error reading ${filePath}`);
       }
 
       let sourceFile = ts.createSourceFile(

src/playground/index.ts

@@ -1,17 +1,19 @@
 import * as path from 'path';
 import * as tsr from '../index';
 import { Config } from '../config';
-import { Writer, WriterConfig } from '../writer';
+// import { Writer, WriterConfig } from '../writer';
 
 const file1 = path.join(__dirname, 'test1.ts');
 const file2 = path.join(__dirname, 'test.ts');
 
-const writerConfig: WriterConfig = {
-  basePath: __dirname,
-  writePath: __dirname,
-};
+// const writerConfig: WriterConfig = {
+//   basePath: __dirname,
+//   writePath: __dirname,
+// };
 
-tsr.transform([file1, file2]).then(compilerResult => {
-  const writer = new Writer(compilerResult);
-  writer.writeAll(writerConfig);
-});
+tsr.transform([file1, file2]);
+
+// .then(compilerResult => {
+//   const writer = new Writer(compilerResult);
+//   writer.writeAll(writerConfig);
+// });