Don't include extra whitespace in YAML scalar spans.

pkg/yaml/lib/src/scanner.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 yaml.scanner;
 
 import 'package:collection/collection.dart';
 import 'package:string_scanner/string_scanner.dart';
 import 'package:source_span/source_span.dart';
 
@@ skipping 1066 matching lines @@
       _scanner.readChar();
       char = _scanner.peekChar();
     }
 
     // libyaml manually decodes the URL, but we don't have to do that.
     return Uri.decodeFull(_scanner.substring(start));
   }
 
   /// Scans a block scalar.
   Token _scanBlockScalar({bool literal: false}) {
+    print("scanning block scalar");

[Bob Nystrom, 2014/12/12 01:47:37]

Delete.

     var start = _scanner.state;
 
     // Eat the indicator '|' or '>'.
     _scanner.readChar();
 
     // Check for a chomping indicator.
     var chomping = _Chomping.CLIP;
     var increment = 0;
     var char = _scanner.peekChar();
     if (char == PLUS || char == HYPHEN) {
@@ skipping 52 matching lines @@
     // needed.
     var pair = _scanBlockScalarBreaks(indent);
     indent = pair.first;
     var trailingBreaks = pair.last;
 
     // Scan the block scalar contents.
     var buffer = new StringBuffer();
     var leadingBreak = '';
     var leadingBlank = false;
     var trailingBlank = false;
+    var end = _scanner.position;
     while (_scanner.column == indent && !_scanner.isDone) {
       // Check for a document indicator. libyaml doesn't do this, but the spec
       // mandates it. See example 9.5:
       // http://yaml.org/spec/1.2/spec.html#id2801606.
       if (_isDocumentIndicator) break;
 
       // We are at the beginning of a non-empty line.
 
       // Is there trailing whitespace?
       trailingBlank = _isBlank;
@@ skipping 12 matching lines @@
       buffer.write(trailingBreaks);
 
       // Is there leading whitespace?
       leadingBlank = _isBlank;
 
       var startPosition = _scanner.position;
       while (!_isBreakOrEnd) {
         _scanner.readChar();
       }
       buffer.write(_scanner.substring(startPosition));
+      end = _scanner.position;
 
       // libyaml always reads a line here, but this breaks on block scalars at
       // the end of the document that end without newlines. See example 8.1:
       // http://yaml.org/spec/1.2/spec.html#id2793888.
       if (!_scanner.isDone) leadingBreak = _readLine();
 
       // Eat the following indentation and spaces.
       var pair = _scanBlockScalarBreaks(indent);
       indent = pair.first;
       trailingBreaks = pair.last;
     }
 
     // Chomp the tail.
     if (chomping != _Chomping.STRIP) buffer.write(leadingBreak);
     if (chomping == _Chomping.KEEP) buffer.write(trailingBreaks);
 
-    return new ScalarToken(_scanner.spanFrom(start), buffer.toString(),
+    return new ScalarToken(_scanner.spanFrom(start, end), buffer.toString(),
         literal ? ScalarStyle.LITERAL : ScalarStyle.FOLDED);
   }
 
   /// Scans indentation spaces and line breaks for a block scalar.
   ///
   /// Determines the intendation level if needed. Returns the new indentation
   /// level and the text of the line breaks.
   Pair<int, String> _scanBlockScalarBreaks(int indent) {
     var maxIndent = 0;
     var breaks = new StringBuffer();
@@ skipping 205 matching lines @@
     // Eat the right quote.
     _scanner.readChar();
 
     return new ScalarToken(_scanner.spanFrom(start), buffer.toString(),
         singleQuote ? ScalarStyle.SINGLE_QUOTED : ScalarStyle.DOUBLE_QUOTED);
   }
 
   /// Scans a plain scalar.
   Token _scanPlainScalar() {
     var start = _scanner.state;
+    var end = _scanner.state;
     var buffer = new StringBuffer();
     var leadingBreak = '';
     var trailingBreaks = '';
     var whitespace = new StringBuffer();
     var indent = _indent + 1;
 
     while (true) {
       // Check for a document indicator.
       if (_isDocumentIndicator) break;
 
@@ skipping 16 matching lines @@
         }
       }
 
       // libyaml's notion of valid identifiers differs substantially from YAML
       // 1.2's. We use [_isPlainChar] instead of libyaml's character here.
       var startPosition = _scanner.position;
       while (_isPlainChar) {
         _scanner.readChar();
       }
       buffer.write(_scanner.substring(startPosition));
+      end = _scanner.state;
 
       // Is it the end?
       if (!_isBlank && !_isBreak) break;
 
       while (_isBlank || _isBreak) {
         if (_isBlank) {
           // Check for a tab character messing up the intendation.
           if (leadingBreak.isNotEmpty && _scanner.column < indent &&
               _scanner.peekChar() == TAB) {
             _scanner.error("Expected a space but found a tab.", length: 1);
@@ skipping 15 matching lines @@
         }
       }
 
       // Check the indentation level.
       if (_inBlockContext && _scanner.column < indent) break;
     }
 
     // Allow a simple key after a plain scalar with leading blanks.
     if (leadingBreak.isNotEmpty) _simpleKeyAllowed = true;
 
-    return new ScalarToken(_scanner.spanFrom(start), buffer.toString(),
+    return new ScalarToken(_scanner.spanFrom(start, end), buffer.toString(),
         ScalarStyle.PLAIN);
   }
 
   /// Moves past the current line break, if there is one.
   void _skipLine() {
     var char = _scanner.peekChar();
     if (char != CR && char != LF) return;
     _scanner.readChar();
     if (char == CR && _scanner.peekChar() == LF) _scanner.readChar();
   }
@@ skipping 139 matching lines @@
 
   /// All trailing whitespace is preserved.
   static const KEEP = const _Chomping("KEEP");
 
   final String name;
 
   const _Chomping(this.name);
 
   String toString() => name;
 }