Rename fletch -> dartino

tests/dartino_compiler/run.dart

 // Copyright (c) 2015, the Dartino project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
-library fletchc.test.run;
+library dartino_compiler.test.run;
 
 import 'dart:async';
 
 import 'dart:io';
 
 import 'dart:io' as io;
 
-import 'package:fletchc/src/hub/session_manager.dart';
+import 'package:dartino_compiler/src/hub/session_manager.dart';
 
-import 'package:fletchc/src/worker/developer.dart';
+import 'package:dartino_compiler/src/worker/developer.dart';
 
-import 'package:fletchc/src/worker/developer.dart' as developer;
+import 'package:dartino_compiler/src/worker/developer.dart' as developer;
 
-import 'package:fletchc/src/verbs/infrastructure.dart' show fileUri;
+import 'package:dartino_compiler/src/verbs/infrastructure.dart' show fileUri;
 
-import 'package:fletchc/src/device_type.dart' show
+import 'package:dartino_compiler/src/device_type.dart' show
     DeviceType,
     parseDeviceType;
 
 const String userVmAddress = const String.fromEnvironment("attachToVm");
 
 const String exportTo = const String.fromEnvironment("snapshot");
 
 const String userPackages = const String.fromEnvironment("packages");
 
 const String userAgentAddress = const String.fromEnvironment("agent");
 
-const String fletchSettingsFile =
-    const String.fromEnvironment("test.fletch_settings_file_name");
+const String dartinoSettingsFile =
+    const String.fromEnvironment("test.dartino_settings_file_name");
 
 /// Enables printing of Compiler/VM protocol commands after each compilation.
 const bool printCommands = const bool.fromEnvironment("printCommands");
 
-/// Enables pretty printing the Fletch system (the compilation result) after
+/// Enables pretty printing the Dartino system (the compilation result) after
 /// each compilation.
 const bool printSystem = const bool.fromEnvironment("printSystem");
 
-class FletchRunner {
+class DartinoRunner {
   Future<Null> attach(SessionState state) async {
     if (userVmAddress == null) {
       await startAndAttachDirectly(state, Uri.base);
     } else {
       Address address = parseAddress(userVmAddress);
       await attachToVm(address.host, address.port, state);
     }
   }
 
   Future<Settings> computeSettings() async {
-    if (fletchSettingsFile != null) {
-      return await readSettings(fileUri(fletchSettingsFile, Uri.base));
+    if (dartinoSettingsFile != null) {
+      return await readSettings(fileUri(dartinoSettingsFile, Uri.base));
     }
     Address agentAddress =
         userAgentAddress == null ? null : parseAddress(userAgentAddress);
     return new Settings(
         fileUri(userPackages == null ? ".packages" : userPackages, Uri.base),
         ["--verbose"],
         <String, String>{
           "foo": "1",
           "bar": "baz",
         },
@@ skipping 28 matching lines @@
       }
       await attach(state);
       state.stdoutSink.attachCommandSender(stdout.add);
       state.stderrSink.attachCommandSender(stderr.add);
 
       if (exportTo != null) {
         await developer.export(state, fileUri(exportTo, Uri.base));
       } else {
         await developer.run(state);
       }
-      if (state.fletchVm != null) {
-        int exitCode = await state.fletchVm.exitCode;
-        print("$script: Fletch VM exit code: $exitCode");
+      if (state.dartinoVm != null) {
+        int exitCode = await state.dartinoVm.exitCode;
+        print("$script: Dartino VM exit code: $exitCode");
         if (exitCode != expectedExitCode) {
           return exitCode;
         }
       }
     }
     print(state.getLog());
     return 0;
   }
 }
 
 main(List<String> arguments) async {
-  io.exitCode = await new FletchRunner().run(arguments);
+  io.exitCode = await new DartinoRunner().run(arguments);
 }
 
 void checkExitCode(int expected, int actual) {
   if (expected != actual) {
     throw "Unexpected exit code: $expected != $actual";
   }
 }
 
 Future<Null> test() async {
   checkExitCode(
-      0, await new FletchRunner().run(
+      0, await new DartinoRunner().run(
           <String>['tests/language/application_test.dart']));
 }
 
 Future<Null> testIncrementalDebugInfo() async {
   checkExitCode(
-      0, await new FletchRunner().run(
-          <String>['tests/fletchc/test_incremental_debug_info.dart',
-                   'tests/fletchc/test_incremental_debug_info.dart'],
+      0, await new DartinoRunner().run(
+          <String>['tests/dartino_compiler/test_incremental_debug_info.dart',
+                   'tests/dartino_compiler/test_incremental_debug_info.dart'],
           expectedExitCode: 255));
 }
 
-// TODO(ahe): Move this method into FletchRunner and use computeSettings.
+// TODO(ahe): Move this method into DartinoRunner and use computeSettings.
 Future<Null> export(
     String script, String snapshot, {bool binaryProgramInfo: false,
         Map<String, String> constants: const <String, String> {}}) async {
   Settings settings;
-  if (fletchSettingsFile == null) {
+  if (dartinoSettingsFile == null) {
     settings = new Settings(
         fileUri(".packages", Uri.base),
         <String>[],
         constants,
         null,
         null,
         IncrementalMode.none);
   } else {
-    settings = await readSettings(fileUri(fletchSettingsFile, Uri.base));
+    settings = await readSettings(fileUri(dartinoSettingsFile, Uri.base));
   }
   SessionState state = createSessionState("test", settings);
   await compile(fileUri(script, Uri.base), state, Uri.base);
   await startAndAttachDirectly(state, Uri.base);
   state.stdoutSink.attachCommandSender(stdout.add);
   state.stderrSink.attachCommandSender(stderr.add);
   await developer.export(
       state, fileUri(snapshot, Uri.base), binaryProgramInfo: binaryProgramInfo);
 }