| library pub.executable; |
| import 'dart:async'; |
| import 'dart:io'; |
| import 'package:barback/barback.dart'; |
| import 'package:path/path.dart' as p; |
| import 'package:stack_trace/stack_trace.dart'; |
| import 'barback/asset_environment.dart'; |
| import 'entrypoint.dart'; |
| import 'exit_codes.dart' as exit_codes; |
| import 'io.dart'; |
| import 'log.dart' as log; |
| import 'utils.dart'; |
| Future<int> runExecutable(Entrypoint entrypoint, String package, |
| String executable, Iterable<String> args, {bool isGlobal: false, |
| BarbackMode mode}) { |
| final completer0 = new Completer(); |
| scheduleMicrotask(() { |
| try { |
| join0() { |
| join1() { |
| join2() { |
| join3() { |
| var localSnapshotPath = |
| p.join(".pub", "bin", package, "${executable}.dart.snapshot"); |
| join4() { |
| var rootDir = "bin"; |
| var parts = p.split(executable); |
| join5() { |
| var assetPath = "${p.url.joinAll(p.split(executable))}.dart"; |
| var id = new AssetId(package, assetPath); |
| AssetEnvironment.create( |
| entrypoint, |
| mode, |
| useDart2JS: false, |
| entrypoints: [id]).then((x0) { |
| try { |
| var environment = x0; |
| environment.barback.errors.listen(((error) { |
| log.error(log.red("Build error:\n$error")); |
| })); |
| var server; |
| join6() { |
| completer0.complete( |
| environment.barback.getAssetById(id).then(((_) { |
| final completer0 = new Completer(); |
| scheduleMicrotask(() { |
| try { |
| var vmArgs = []; |
| vmArgs.add("--checked"); |
| var relativePath = |
| p.url.relative(assetPath, from: p.url.joinAll(p.split(server.rootDirectory))); |
| vmArgs.add( |
| server.url.resolve(relativePath).toString()); |
| vmArgs.addAll(args); |
| Process.start( |
| Platform.executable, |
| vmArgs).then((x0) { |
| try { |
| var process = x0; |
| process.stderr.listen(stderr.add); |
| process.stdout.listen(stdout.add); |
| stdin.listen(process.stdin.add); |
| completer0.complete(process.exitCode); |
| } catch (e0) { |
| completer0.completeError(e0); |
| } |
| }, onError: (e1) { |
| completer0.completeError(e1); |
| }); |
| } catch (e2) { |
| completer0.completeError(e2); |
| } |
| }); |
| return completer0.future; |
| })).catchError(((error, stackTrace) { |
| if (error is! AssetNotFoundException) throw error; |
| var message = |
| "Could not find ${log.bold(executable + ".dart")}"; |
| if (package != entrypoint.root.name) { |
| message += |
| " in package ${log.bold(server.package)}"; |
| } |
| log.error("$message."); |
| log.fine(new Chain.forTrace(stackTrace)); |
| return exit_codes.NO_INPUT; |
| }))); |
| } |
| if (package == entrypoint.root.name) { |
| environment.serveDirectory(rootDir).then((x1) { |
| try { |
| server = x1; |
| join6(); |
| } catch (e1) { |
| completer0.completeError(e1); |
| } |
| }, onError: (e2) { |
| completer0.completeError(e2); |
| }); |
| } else { |
| environment.servePackageBinDirectory( |
| package).then((x2) { |
| try { |
| server = x2; |
| join6(); |
| } catch (e3) { |
| completer0.completeError(e3); |
| } |
| }, onError: (e4) { |
| completer0.completeError(e4); |
| }); |
| } |
| } catch (e0) { |
| completer0.completeError(e0); |
| } |
| }, onError: (e5) { |
| completer0.completeError(e5); |
| }); |
| } |
| if (parts.length > 1) { |
| assert(!isGlobal && package == entrypoint.root.name); |
| rootDir = parts.first; |
| join5(); |
| } else { |
| executable = p.join("bin", executable); |
| join5(); |
| } |
| } |
| if (!isGlobal && |
| fileExists(localSnapshotPath) && |
| mode == BarbackMode.RELEASE) { |
| completer0.complete( |
| _runCachedExecutable(entrypoint, localSnapshotPath, args)); |
| } else { |
| join4(); |
| } |
| } |
| if (p.extension(executable) == ".dart") { |
| executable = p.withoutExtension(executable); |
| join3(); |
| } else { |
| join3(); |
| } |
| } |
| if (log.verbosity == log.Verbosity.NORMAL) { |
| log.verbosity = log.Verbosity.WARNING; |
| join2(); |
| } else { |
| join2(); |
| } |
| } |
| if (entrypoint.root.name != package && |
| !entrypoint.root.immediateDependencies.any(((dep) => dep.name == package))) { |
| entrypoint.loadPackageGraph().then((x3) { |
| try { |
| var graph = x3; |
| join7() { |
| join1(); |
| } |
| if (graph.packages.containsKey(package)) { |
| dataError( |
| 'Package "${package}" is not an immediate dependency.\n' |
| 'Cannot run executables in transitive dependencies.'); |
| join7(); |
| } else { |
| dataError( |
| 'Could not find package "${package}". Did you forget to add a ' 'dependency?'); |
| join7(); |
| } |
| } catch (e6) { |
| completer0.completeError(e6); |
| } |
| }, onError: (e7) { |
| completer0.completeError(e7); |
| }); |
| } else { |
| join1(); |
| } |
| } |
| if (mode == null) { |
| mode = BarbackMode.RELEASE; |
| join0(); |
| } else { |
| join0(); |
| } |
| } catch (e8) { |
| completer0.completeError(e8); |
| } |
| }); |
| return completer0.future; |
| } |
| Future<int> runSnapshot(String path, Iterable<String> args, {recompile(), |
| bool checked: false}) { |
| final completer0 = new Completer(); |
| scheduleMicrotask(() { |
| try { |
| var vmArgs = [path]..addAll(args); |
| join0() { |
| var stdin1; |
| var stdin2; |
| join1() { |
| runProcess(input) { |
| final completer0 = new Completer(); |
| scheduleMicrotask(() { |
| try { |
| Process.start(Platform.executable, vmArgs).then((x0) { |
| try { |
| var process = x0; |
| process.stderr.listen(stderr.add); |
| process.stdout.listen(stdout.add); |
| input.listen(process.stdin.add); |
| completer0.complete(process.exitCode); |
| } catch (e0) { |
| completer0.completeError(e0); |
| } |
| }, onError: (e1) { |
| completer0.completeError(e1); |
| }); |
| } catch (e2) { |
| completer0.completeError(e2); |
| } |
| }); |
| return completer0.future; |
| } |
| runProcess(stdin1).then((x0) { |
| try { |
| var exitCode = x0; |
| join2() { |
| recompile().then((x1) { |
| try { |
| x1; |
| completer0.complete(runProcess(stdin2)); |
| } catch (e1) { |
| completer0.completeError(e1); |
| } |
| }, onError: (e2) { |
| completer0.completeError(e2); |
| }); |
| } |
| if (recompile == null || exitCode != 255) { |
| completer0.complete(exitCode); |
| } else { |
| join2(); |
| } |
| } catch (e0) { |
| completer0.completeError(e0); |
| } |
| }, onError: (e3) { |
| completer0.completeError(e3); |
| }); |
| } |
| if (recompile == null) { |
| stdin1 = stdin; |
| join1(); |
| } else { |
| var pair = tee(stdin); |
| stdin1 = pair.first; |
| stdin2 = pair.last; |
| join1(); |
| } |
| } |
| if (checked) { |
| vmArgs.insert(0, "--checked"); |
| join0(); |
| } else { |
| join0(); |
| } |
| } catch (e4) { |
| completer0.completeError(e4); |
| } |
| }); |
| return completer0.future; |
| } |
| Future<int> _runCachedExecutable(Entrypoint entrypoint, String snapshotPath, |
| List<String> args) { |
| return runSnapshot(snapshotPath, args, checked: true, recompile: () { |
| log.fine("Precompiled executable is out of date."); |
| return entrypoint.precompileExecutables(); |
| }); |
| } |