Code coverage in Observatory

runtime/bin/vmservice/client/lib/src/observatory/model.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.
 
 part of observatory;
 
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final String machine;
   @observable final String human;
@@ skipping 226 matching lines @@
     List<Code> inclusive = isolate.codes;
     inclusive.sort((Code a, Code b) {
       return b.inclusiveTicks - a.inclusiveTicks;
     });
     if ((inclusive.length < count) || (count == 0)) {
       return inclusive;
     }
     return inclusive.sublist(0, count);
   }
 }
+
+class ScriptLine extends Observable {
+  @observable final int line;
+  @observable int hits = -1;
+  @observable String text = '';
+  /// Do we have coverage data for this line?
+  bool get coverage => hits >= 0;
+  /// Has this line executed before?
+  bool get covered => hits > 0;

[turnidge, 2014/01/21 23:34:40]

the names "coverage" and "covered" are a bit similar and could be confusing. 
Maybe be more explicit.

[Cutch, 2014/01/22 00:50:37]

Agreed. I've gone with "executable" and "covered". Executable meaning the line
has executable code on it and covered meaning we've executed that line.

+  ScriptLine(this.line);
+}
+
+class Script extends Observable {
+  @observable String kind = null;
+  @observable Map scriptRef = toObservable({});
+  @observable Map libraryRef = toObservable({});
+  @observable final List<ScriptLine> lines =
+      toObservable(new List<ScriptLine>());
+  bool _needsSource = true;
+  bool get needsSource => _needsSource;
+  Script.fromMap(Map map) {
+    scriptRef = toObservable({
+      'id': map['id'],
+      'name': map['name'],
+      'user_name': map['user_name']
+    });
+    libraryRef = toObservable(map['library']);
+    kind = map['kind'];
+    _processSource(map['source']);
+  }
+
+  // Fetch (possibly create) the ScriptLine for [lineNumber].
+  ScriptLine _getLine(int lineNumber) {
+    assert(lineNumber != 0);
+    if (lineNumber >= lines.length) {
+      // Grow lines list.
+      lines.length = lineNumber + 1;
+    }
+    var line = lines[lineNumber];
+    if (line == null) {
+      // Create this line.
+      line = new ScriptLine(lineNumber);
+      lines[lineNumber] = line;
+    }
+    return line;
+  }
+
+  void _processSource(String source) {
+    if (source == null) {
+      return;
+    }
+    Logger.root.info('Loading source for ${scriptRef['name']}');
+    var sourceLines = source.split('\n');
+    _needsSource = sourceLines.length == 0;
+    for (var i = 0; i < sourceLines.length; i++) {
+      var line = _getLine(i + 1);
+      line.text = sourceLines[i];
+    }
+  }
+
+  void _processCoverageHits(List hits) {
+    for (var i = 0; i < hits.length; i += 2) {
+      var line = _getLine(hits[i]);
+      line.hits = hits[i + 1];
+    }
+    notifyPropertyChange(#coveredPercentage, 0.0, coveredPercentage());
+  }
+
+  /// What percentage of lines in this script have been covered?
+  double coveredPercentage() {
+    int coveredLines = 0;
+    int coverageLines = 0;
+    for (var line in lines) {
+      if (line == null) {
+        continue;
+      }
+      if (!line.coverage) {
+        continue;
+      }
+      coverageLines++;
+      if (!line.covered) {
+        continue;
+      }
+      coveredLines++;
+    }
+    if (coverageLines == 0) {
+      return 0.0;
+    }
+    return (coveredLines / coverageLines) * 100.0;
+  }
+}