1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
import chalk from "chalk";
import FileTransform from "./FileTransform";
import Logger from "../utils/logger";
import type { UtilityArgs } from "../types";
import type {
FileResult,
ModifyFileArgs,
AbortTransformArgs,
TransformerResults,
} from "./types";
class Runner {
transform: string;
rootPath: string;
dry: boolean;
print: boolean;
modifications: Record<string, FileTransform> = {};
logger: Logger;
constructor(options: UtilityArgs) {
this.transform = options.transformer;
this.rootPath = options.rootPath;
this.dry = options.dry;
this.print = options.print;
this.logger = new Logger(options);
}
abortTransform(args: AbortTransformArgs): TransformerResults {
this.logger.error(args.reason);
return {
fatalError: new Error(args.reason),
changes: args.changes || {},
};
}
// add a file to be transformed
modifyFile(args: ModifyFileArgs): void {
this.modifications[args.filePath] = new FileTransform({
rootPath: this.rootPath,
...args,
});
}
// execute all transforms and track results for reporting
finish(): TransformerResults {
const results: TransformerResults = { changes: {} };
// perform all actions and track results
Object.keys(this.modifications).forEach((filePath) => {
const mod = this.modifications[filePath];
const result: FileResult = {
action: "unchanged",
additions: mod.additions(),
deletions: mod.deletions(),
};
if (mod.hasChanges()) {
if (this.dry) {
result.action = "skipped";
this.logger.skipped(chalk.dim(mod.fileName()));
} else {
try {
mod.write();
result.action = "modified";
this.logger.modified(chalk.bold(mod.fileName()));
} catch (err) {
let message = "Unknown error";
if (err instanceof Error) {
message = err.message;
}
result.error = new Error(message);
result.action = "error";
this.logger.error(mod.fileName(), message);
}
}
if (this.print) {
mod.log({ diff: true });
}
} else {
this.logger.unchanged(chalk.dim(mod.fileName()));
}
results.changes[mod.fileName()] = result;
});
const encounteredError = Object.keys(results.changes).some((fileName) => {
return results.changes[fileName].action === "error";
});
if (encounteredError) {
return this.abortTransform({
reason: "Encountered an error while transforming files",
changes: results.changes,
});
}
return results;
}
static logResults(results: TransformerResults): void {
const changedFiles = Object.keys(results.changes);
console.log();
if (changedFiles.length > 0) {
console.log(chalk.bold(`Results:`));
const table: Record<
string,
{
action: FileResult["action"];
additions: FileResult["additions"];
deletions: FileResult["deletions"];
error?: string;
}
> = {};
changedFiles.forEach((fileName) => {
const fileChanges = results.changes[fileName];
table[fileName] = {
action: fileChanges.action,
additions: fileChanges.additions,
deletions: fileChanges.deletions,
error: fileChanges.error?.message || "None",
};
});
console.table(table);
console.log();
}
}
}
export default Runner;
|