Make markdown error-free in strong mode.

lib/src/inline_parser.dart

 // Copyright (c) 2012, 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 markdown.src.inline_parser;
 
 import 'ast.dart';
 import 'document.dart';
 import 'util.dart';
 
@@ skipping 120 matching lines @@
   }
 
   void writeTextRange(int start, int end) {
     if (end <= start) return;
 
     var text = source.substring(start, end);
     var nodes = _stack.last.children;
 
     // If the previous node is text too, just append.
     if (nodes.length > 0 && nodes.last is Text) {
-      nodes[nodes.length - 1] = new Text('${nodes.last.text}$text');
+      var textNode = nodes.last as Text;
+      nodes[nodes.length - 1] = new Text('${textNode.text}$text');
     } else {
       nodes.add(new Text(text));
     }
   }
 
   void addNode(Node node) {
     _stack.last.children.add(node);
   }
 
   // TODO(rnystrom): Only need this because RegExp doesn't let you start
@@ skipping 33 matching lines @@
   }
 
   bool onMatch(InlineParser parser, Match match);
 }
 
 /// Matches stuff that should just be passed through as straight text.
 class TextSyntax extends InlineSyntax {
   final String substitute;
 
   TextSyntax(String pattern, {String sub})
-      : super(pattern),
-        substitute = sub;
+      : substitute = sub,
+        super(pattern);
 
   bool onMatch(InlineParser parser, Match match) {
     if (substitute == null) {
       // Just use the original matched text.
       parser.advanceBy(match[0].length);
       return false;
     }
 
     // Insert the substitution.
     parser.addNode(new Text(substitute));
@@ skipping 16 matching lines @@
   }
 }
 
 /// Matches syntax that has a pair of tags and becomes an element, like `*` for
 /// `<em>`. Allows nested tags.
 class TagSyntax extends InlineSyntax {
   final RegExp endPattern;
   final String tag;
 
   TagSyntax(String pattern, {this.tag, String end})
-      : super(pattern),
-        endPattern = new RegExp((end != null) ? end : pattern, multiLine: true);
+      : endPattern = new RegExp((end != null) ? end : pattern, multiLine: true),
+        super(pattern);
 
   bool onMatch(InlineParser parser, Match match) {
     parser._stack
         .add(new TagState(parser.pos, parser.pos + match[0].length, this));
     return true;
   }
 
   bool onMatchEnd(InlineParser parser, Match match, TagState state) {
     parser.addNode(new Element(tag, state.children));
     return true;
   }
 }
 
 /// Matches inline links like `[blah] [id]` and `[blah] (url)`.
 class LinkSyntax extends TagSyntax {
   final Resolver linkResolver;
 
-  /// Weather or not this link was resolved by a [Resolver]
-  bool resolved = false;
-
   /// The regex for the end of a link needs to handle both reference style and
   /// inline styles as well as optional titles for inline links. To make that
   /// a bit more palatable, this breaks it into pieces.
   static get linkPattern {
     var refLink = r'\s?\[([^\]]*)\]'; // "[id]" reflink id.
     var title = r'(?:[ ]*"([^"]+)"|)'; // Optional title in quotes.
     var inlineLink = '\\s?\\(([^ )]+)$title\\)'; // "(url "title")" link.
     return '\](?:($refLink|$inlineLink)|)';
 
     // The groups matched by this are:
@@ skipping 15 matching lines @@
     // this. Otherwise, it's just treated as plain text.
     if (match[1] == null) {
       if (linkResolver == null) return null;
 
       // Treat the contents as unparsed text even if they happen to match. This
       // way, we can handle things like [LINK_WITH_UNDERSCORES] as a link and
       // not get confused by the emphasis.
       var textToResolve = parser.source.substring(state.endPos, parser.pos);
 
       // See if we have a resolver that will generate a link for us.
-      resolved = true;
       return linkResolver(textToResolve);
     } else {
-      var link = getLink(parser, match, state);
-      if (link == null) return null;
-
-      var node = new Element('a', state.children);
-
-      node.attributes["href"] = escapeHtml(link.url);
-      if (link.title != null) node.attributes['title'] = escapeHtml(link.title);
-
-      return node;
+      return _createElement(parser, match, state);
     }
   }
 
+  /// Given that [match] has matched both a title and URL, creates an <a>

[nweiz, 2015/09/01 20:51:42]

Nit: `<a>`

[Bob Nystrom, 2015/09/01 21:14:57]

Done.

+  /// [Element] for it.
+  Element _createElement(InlineParser parser, Match match, TagState state) {
+    var link = getLink(parser, match, state);
+    if (link == null) return null;
+
+    var element = new Element('a', state.children);
+
+    element.attributes["href"] = escapeHtml(link.url);
+    if (link.title != null) {
+      element.attributes['title'] = escapeHtml(link.title);
+    }
+
+    return element;
+  }
+
   Link getLink(InlineParser parser, Match match, TagState state) {
     if (match[3] != null && match[3] != '') {
       // Inline link like [foo](url).
       var url = match[3];
       var title = match[4];
 
       // For whatever reason, markdown allows angle-bracketed URLs here.
       if (url.startsWith('<') && url.endsWith('>')) {
         url = url.substring(1, url.length - 1);
       }
@@ skipping 20 matching lines @@
     if (node == null) return false;
 
     parser.addNode(node);
     return true;
   }
 }
 
 /// Matches images like `![alternate text](url "optional title")` and
 /// `![alternate text][url reference]`.
 class ImageLinkSyntax extends LinkSyntax {
-  final Resolver linkResolver;
+  ImageLinkSyntax({Resolver linkResolver})
+      : super(linkResolver: linkResolver, pattern: r'!\[');
 
-  ImageLinkSyntax({this.linkResolver}) : super(pattern: r'!\[');
+  /// Creates an <a> element from the given complete [match].
+  Element _createElement(InlineParser parser, Match match, TagState state) {
+    var element = super._createElement(parser, match, state);
+    if (element == null) return null;
 
-  Node createNode(InlineParser parser, Match match, TagState state) {
-    var node = super.createNode(parser, match, state);
+    var image = new Element.withTag("img");
+    image.attributes["src"] = element.attributes["href"];
 
-    if (resolved) return node;
-    if (node == null) return null;
-
-    var imageElement = new Element.withTag("img");
-    imageElement.attributes["src"] = node.attributes["href"];
-
-    if (node.attributes.containsKey("title")) {
-      imageElement.attributes["title"] = node.attributes["title"];
+    if (element.attributes.containsKey("title")) {
+      image.attributes["title"] = element.attributes["title"];
     }
 
-    var alt = node.children.map((e) => e is! Text ? '' : e.text).join(" ");
-    if (alt != "") imageElement.attributes["alt"] = alt;
+    var alt = element.children.map((e) => e is! Text ? "" : e.text).join(" ");
+    if (alt != "") image.attributes["alt"] = alt;
 
-    node.children
+    element.children
       ..clear()
-      ..add(imageElement);
+      ..add(image);
 
-    return node;
+    return element;
   }
 }
 
 /// Matches backtick-enclosed inline code blocks.
 class CodeSyntax extends InlineSyntax {
   CodeSyntax(String pattern) : super(pattern);
 
   bool onMatch(InlineParser parser, Match match) {
     parser.addNode(new Element.text('code', escapeHtml(match[1])));
     return true;
@@ skipping 65 matching lines @@
       parser.consume(endMatch[0].length);
     } else {
       // Didn't close correctly so revert to text.
       parser.start = startPos;
       parser.advanceBy(endMatch[0].length);
     }
 
     return null;
   }
 }