Add API to provide a selection range, and return the updated selection after formatting.

test/formatter_test.dart

 // Copyright (c) 2014, the Dart 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 file.
 
 library dart_style.test.formatter_test;
 
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
 import 'package:unittest/compact_vm_config.dart';
 import 'package:unittest/unittest.dart';
 
 import 'package:dart_style/dart_style.dart';
 
 void main() {
   // Tidy up the unittest output.
   filterStacks = true;
   formatStacks = true;
   useCompactVMConfiguration();
 
   testDirectory("comments");
   testDirectory("regression");
+  testDirectory("selections");
   testDirectory("splitting");
   testDirectory("whitespace");
 
   test("throws a FormatterException on failed parse", () {
     var formatter = new DartFormatter();
     expect(() => formatter.format('wat?!'),
        throwsA(new isInstanceOf<FormatterException>()));
   });
 
   test("FormatterException describes parse errors", () {
     try {
       new DartFormatter().format("""
 
       var a = some error;
 
       var b = another one;
       """, uri: "my_file.dart");
 
       fail("Should throw.");
     } on FormatterException catch (err) {
       var message = err.message();
       expect(message, contains("my_file.dart"));
       expect(message, contains("line 2"));
       expect(message, contains("line 4"));
     }
   });
 
+  group('SourceCode', () {
+    test('throws on negative start', () {
+      expect(() {
+        new SourceCode("12345;", selectionStart: -1, selectionLength: 0);
+      }, throwsArgumentError);
+    });
+
+    test('throws on out of bounds start', () {
+      expect(() {
+        new SourceCode("12345;", selectionStart: 7, selectionLength: 0);
+      }, throwsArgumentError);
+    });
+
+    test('throws on negative length', () {
+      expect(() {
+        new SourceCode("12345;", selectionStart: 1, selectionLength: -1);
+      }, throwsArgumentError);
+    });
+
+    test('throws on out of bounds length', () {
+      expect(() {
+        new SourceCode("12345;", selectionStart: 2, selectionLength: 5);
+      }, throwsArgumentError);
+    });
+
+    test('throws is start is null and length is not', () {
+      expect(() {
+        new SourceCode("12345;", selectionStart: 0);
+      }, throwsArgumentError);
+    });
+
+    test('throws is length is null and start is not', () {
+      expect(() {
+        new SourceCode("12345;", selectionLength: 1);
+      }, throwsArgumentError);
+    });
+  });
+
   test("adds newline to unit", () {
     expect(new DartFormatter().format("var x = 1;"),
         equals("var x = 1;\n"));
   });
 
   test("adds newline to unit after trailing comment", () {
     expect(new DartFormatter().format("library foo; //zamm"),
         equals("library foo; //zamm\n"));
   });
 
@@ skipping 82 matching lines @@
         while (!lines[i].startsWith("<<<")) {
           input += lines[i++] + "\n";
         }
 
         var expectedOutput = "";
         while (++i < lines.length && !lines[i].startsWith(">>>")) {
           expectedOutput += lines[i] + "\n";
         }
 
         test(description, () {
+          var isCompilationUnit = p.extension(entry.path) == ".unit";
+
+          var inputCode = _extractSelection(input,
+              isCompilationUnit: isCompilationUnit);
+
+          var expected = _extractSelection(expectedOutput,
+              isCompilationUnit: isCompilationUnit);
+
           var formatter = new DartFormatter(
               pageWidth: pageWidth, indent: leadingIndent);
 
-          var result;
-          if (p.extension(entry.path) == ".stmt") {
-            result = formatter.formatStatement(input) + "\n";
-          } else {
-            result = formatter.format(input);
-          }
+          var actual = formatter.formatSource(inputCode);
 
-          expect(result, equals(expectedOutput));
+          // The test files always put a newline at the end of the expectation.
+          // Statements from the formatter (correctly) don't have that, so add
+          // one to line up with the expected result.
+          var actualText = actual.text;
+          if (!isCompilationUnit) actualText += "\n";
+
+          expect(actualText, equals(expected.text));
+          expect(actual.selectionStart, equals(expected.selectionStart));
+          expect(actual.selectionLength, equals(expected.selectionLength));
         });
       }
     });
   }
 }
+
+/// Given a source string that contains ‹ and › to indicate a selection, returns
+/// a [SourceCode] with the text (with the selection markers removed) and the
+/// correct selection range.
+SourceCode _extractSelection(String source, {bool isCompilationUnit: false}) {
+  var start = source.indexOf("‹");
+  source = source.replaceAll("‹", "");
+
+  var end = source.indexOf("›");
+  source = source.replaceAll("›", "");
+
+  // If the selection end is after a trailing newline, there will be an extra
+  // newline *after* the "›", so remove it.
+  if (end != -1 && source.endsWith("\n\n")) {
+    source = source.substring(0, source.length - 1);
+  }
+
+  return new SourceCode(source,
+      isCompilationUnit: isCompilationUnit,
+      selectionStart: start == -1 ? null : start,
+      selectionLength: end == -1 ? null : end - start);
+}