[WIP] V3

.gitignore

@@ -2,4 +2,6 @@
 node_modules
 *.d.ts
 dist
-yarn-error.log
+yarn-error.log
+test/*/samples/_tmp
+_actual.html

package.json

@@ -15,22 +15,26 @@
     "esm": "^3.0.84",
     "rollup": "^0.67.0",
     "rollup-plugin-json": "^3.1.0",
+    "source-map-support": "^0.5.9",
     "tape-modern": "^1.1.1"
   },
   "scripts": {
     "build": "rollup -c",
     "dev": "rollup -cw",
-    "test": "node -r esm test/test.js",
+    "test": "node -r source-map-support/register -r esm test/test.js",
     "prepublishOnly": "npm test && npm run build"
   },
   "license": "LIL",
   "dependencies": {
     "estree-walker": "^0.5.2",
-    "glob": "^7.1.3",
+    "is-reference": "^1.1.0",
+    "kleur": "^2.0.2",
+    "locate-character": "^2.0.5",
     "magic-string": "^0.25.1",
     "prompts": "^1.2.0",
     "sade": "^1.4.1",
-    "svelte": "1",
-    "turbocolor": "^2.6.1"
+    "svelte": "^2.15.2",
+    "svelte-1": "npm:svelte@1",
+    "svelte-2": "npm:svelte@2"
   }
 }

rollup.config.js

@@ -5,10 +5,10 @@ export default {
 	input: ['src/index.js', 'src/cli.js'],
 	output: {
 		dir: 'dist',
-		format: 'cjs'	
+		format: 'cjs',
+		sourcemap: true
 	},
 	experimentalCodeSplitting: true,
-	experimentalDynamicImport: true,
 	external: Object.keys(pkg.dependencies),
 	plugins: [
 		json()

src/cli.js

@@ -1,9 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import sade from 'sade';
-import glob from 'glob';
 import prompts from 'prompts';
-import tc from 'turbocolor';
+import c from 'kleur';
 import * as pkg from '../package.json';
 
 const prog = sade('svelte-upgrade').version(pkg.version);
@@ -19,72 +18,162 @@ function mkdirp(dir) {
 	}
 }
 
-prog.command(`v2 <input>`)
-	.describe(`upgrade <input> file/directory to v2 syntax`)
-	.option(`-o, --output`, `Write new files, instead of overwriting input files`)
-	.option(`-f, --force`, `Don't ask before overwriting files`)
-	.example(`v2 MyComponent.html`)
-	.example(`v2 MyComponent.html -o My-Component.v2.html`)
-	.example(`v2 src`)
-	.action(async (input, opts) => {
-		try {
-			const stats = fs.statSync(input);
-
-			const upgrade = await import('./index.js');
-
-			let output = opts.output || input;
-
-			if (stats.isDirectory()) {
-				const files = glob.sync('**/*.+(html|svelte)', { cwd: input });
-				input = files.map(file => path.join(input, file));
-				output = files.map(file => path.join(output, file));
-			} else {
-				input = [input];
-				output = [output];
+const valid_extensions = new Set([
+	'.html',
+	'.htmlx',
+	'.svelte'
+]);
+
+function get_tasks(items, in_dir, out_dir, arr = []) {
+	for (const item of items) {
+		const stats = fs.statSync(item);
+
+		if (stats.isDirectory()) {
+			get_tasks(
+				fs.readdirSync(item).map(file => path.resolve(item, file)),
+				path.join(in_dir, item),
+				path.join(out_dir, item),
+				arr
+			);
+		} else {
+			if (valid_extensions.has(path.extname(item))) {
+				arr.push({
+					input: item,
+					output: item.replace(in_dir, out_dir),
+					source: fs.readFileSync(item, 'utf-8')
+				});
 			}
+		}
+	}
 
-			if (!opts.force) {
-				const existing = output.filter(file => fs.existsSync(file));
-				if (existing.length > 0) {
-					console.error(tc.cyan(`This will overwrite the following files:`));
-					console.error(tc.gray(existing.join('\n')))
-
-					const response = await prompts({
-						type: 'confirm',
-						name: 'value',
-						message: `Overwrite ${existing.length} ${existing.length === 1 ? 'file' : 'files'}?`,
-						initial: true
-					});
+	return arr;
+}
 
-					if (response.value === false) {
-						console.error(tc.cyan('Aborted'));
-						return;
-					}
+[2, 3].forEach(v => {
+	prog.command(`v${v} <input>`)
+		.describe(`upgrade <input> file/directory to v${v} syntax`)
+		.option(`-o, --output`, `Write new files, instead of overwriting input files`)
+		.option(`-f, --force`, `Don't ask before overwriting files`)
+		.example(`v${v} MyComponent.html`)
+		.example(`v${v} MyComponent.html -o My-Component.v${v}.html`)
+		.example(`v${v} src`)
+		.action(async function(_, opts) {
+			const tasks = get_tasks(
+				[_].concat(opts._).map(file => path.resolve(file)),
+				path.resolve('.'),
+				path.resolve(opts.output || '.')
+			);
+
+			if (opts.output && path.extname(opts.output)) {
+				// --output somefile.html
+				if (tasks.length > 1) {
+					console.error(c.bold.red(`--output must be a directory if more than one input is provided`));
+				} else {
+					// special case — file to file conversion
+					tasks[0].output = path.resolve(opts.output);
 				}
 			}
 
-			input.forEach((src, i) => {
-				const dest = output[i];
+			try {
+				const upgrade = v === 2
+					? await import('./v2/index.js')
+					: await import('./v3/index.js');
+
+				if (!opts.force) {
+					const existing = tasks
+						.filter(task => fs.existsSync(task.output))
+						.map(task => path.relative(process.cwd(), task.output));
+
+					if (existing.length > 0) {
+						console.error(c.cyan(`This will overwrite the following files:`));
+						console.error(c.gray(existing.join('\n')));
+
+						const response = await prompts({
+							type: 'confirm',
+							name: 'value',
+							message: `Overwrite ${existing.length} ${existing.length === 1 ? 'file' : 'files'}?`,
+							initial: true
+						});
+
+						if (response.value === false) {
+							console.error(c.cyan('Aborted'));
+							return;
+						}
+					}
+				}
 
-				try {
-					const upgraded = upgrade.upgradeTemplate(fs.readFileSync(src, 'utf-8'));
+				let unchanged_count = 0;
+
+				const manual_edits_required = [];
+				const manual_edits_suggested = [];
+				const failed = [];
+
+				tasks.forEach(({ input, output, source }) => {
+					const relative = path.relative(process.cwd(), input);
+					try {
+						const result = upgrade.upgradeTemplate(source);
+
+						const code = v === 2 ? result : result.code;
+
+						if (code.trim() === source.trim()) {
+							unchanged_count += 1;
+						} else if (result.manual_edits_required) {
+							manual_edits_required.push(relative);
+						} else if (result.manual_edits_suggested) {
+							manual_edits_suggested.push(relative);
+						}
+
+						// we still write, even if unchanged, since the output dir
+						// could be different to the input dir
+						mkdirp(path.dirname(output));
+						fs.writeFileSync(output, code);
+					} catch (error) {
+						if (error.name === 'UpgradeError') {
+							failed.push({ relative, error });
+						} else {
+							console.error(c.bold.red(`Error transforming ${relative}:`));
+							console.error(c.red(error.message));
+						}
+					}
+				});
 
-					mkdirp(path.dirname(dest));
-					fs.writeFileSync(dest, upgraded);
-				} catch (err) {
-					console.error(tc.bold.red(`Error transforming ${src}:`));
-					console.error(tc.red(err.message));
+				let message = `Wrote ${count(tasks.length)}`;
 
-					if (err.frame) {
-						console.error(err.frame);
-					}
+				if (unchanged_count > 0) {
+					message += `. ${count(unchanged_count)} required no changes`;
 				}
-			});
 
-			console.error(tc.cyan(`Wrote ${output.length} ${output.length === 1 ? 'file' : 'files'}`))
-		} catch (err) {
-			console.error(tc.red(err.message));
-		}
-	});
+				console.error(c.cyan(message));
+
+				if (failed.length > 0) {
+					console.error(c.bold.red(`\nFailed to convert ${count(failed.length)}`));
+					failed.forEach(failure => {
+						console.error(c.bold.red(`\n${failure.error.message}`));
+						console.error(failure.relative);
+
+						if (failure.error.frame) {
+							console.error(failure.error.frame);
+						}
+					});
+				}
+
+				if (manual_edits_required.length > 0) {
+					console.error(c.bold.red(`\nManual edits required for ${count(manual_edits_required.length)}`));
+					console.error(manual_edits_required.join('\n'));
+				}
+
+				if (manual_edits_suggested.length > 0) {
+					console.error(c.bold.magenta(`\nManual edits suggested for ${count(manual_edits_suggested.length)}`));
+					console.error(manual_edits_suggested.join('\n'));
+				}
+			} catch (err) {
+				console.error(c.red(err.message));
+			}
+		});
+});
+
+function count(num) {
+	return num === 1 ? `1 file` : `${num} files`;
+}
 
 prog.parse(process.argv);