DevTools: [Documentation] Update parser for WikiText

Source/devtools/front_end/documentation/JSArticle.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  */
 WebInspector.JSArticle = function()
 {
     /** @type {string} */
     this.pageTitle;
     /** @type {string} */
     this.standardizationStatus;
     /** @type {?WebInspector.WikiParser.Block} */
     this.summary;
     /** @type {!Array.<!WebInspector.JSArticle.Parameter>} */
     this.parameters = [];
     /** @type {?WebInspector.JSArticle.Method} */
     this.methods;
     /** @type {?WebInspector.WikiParser.Block} */
     this.remarks;
     /** @type {!Array.<!WebInspector.JSArticle.Example>} */
     this.examples = [];
 }
 
 /**
  * @constructor
- * @param {string} name
- * @param {string} dataType
- * @param {string} optional
+ * @param {?WebInspector.WikiParser.Block} name
+ * @param {?WebInspector.WikiParser.Block} dataType
+ * @param {?WebInspector.WikiParser.Block} optional
  * @param {?WebInspector.WikiParser.Block} description
  */
 WebInspector.JSArticle.Parameter = function(name, dataType, optional, description)
 {
-    this.name = name;
-    this.dataType = dataType;
-    this.optional = optional.toUpperCase() === "YES";
+    this.name = WebInspector.JSArticle.textContent(name);
+    this.dataType = WebInspector.JSArticle.textContent(dataType);
+    this.optional = WebInspector.JSArticle.textContent(optional) ? WebInspector.JSArticle.textContent(optional).toUpperCase() === "YES" : false;

[apavlov, 2014/09/10 14:09:23]

This is computing the text content twice in a row. Please pre-compute to avoid
the overhead.

[iliia, 2014/09/11 09:26:30]

Done.

     this.description = description;
 }
 
 /**
  * @constructor
- * @param {string} language
- * @param {string} code
- * @param {string} liveUrl
+ * @param {?WebInspector.WikiParser.Block} language
+ * @param {!WebInspector.WikiParser.Block} code
+ * @param {?WebInspector.WikiParser.Block} liveUrl
  * @param {?WebInspector.WikiParser.Block} description
  */
 WebInspector.JSArticle.Example = function(language, code, liveUrl, description)
 {
-    this.language = language;
-    this.code = code;
-    this.liveUrl = liveUrl;
+    this.language = WebInspector.JSArticle.textContent(language);
+    this.code = WebInspector.JSArticle.textContent(code);
+    this.liveUrl = WebInspector.JSArticle.textContent(liveUrl);
     this.description = description;
 }
 
 /**
  * @constructor
- * @param {string} returnValueName
- * @param {string} returnValueDescription
+ * @param {?WebInspector.WikiParser.Block} returnValueName
+ * @param {?WebInspector.WikiParser.Block} returnValueDescription
  */
 WebInspector.JSArticle.Method = function(returnValueName, returnValueDescription)
 {
-    this.returnValueName = returnValueName;
-    this.returnValueDescription = returnValueDescription;
+    this.returnValueName = WebInspector.JSArticle.textContent(returnValueName);
+    this.returnValueDescription = WebInspector.JSArticle.textContent(returnValueDescription);
 }
 
 /**
+ * @param {?WebInspector.WikiParser.Block} block
+ * @return {null|string}

[apavlov, 2014/09/10 14:09:23]

{?string}

[iliia, 2014/09/11 09:26:30]

Done.

+ */
+WebInspector.JSArticle.textContent = function(block)
+{
+    if (block && Array.isArray(block.children()) && block.children().length > 0

[apavlov, 2014/09/10 14:09:23]

Let's introduce WI.WikiParser.Block.prototype.hasChildren():

return !!this._children && !!this._children.length;

[iliia, 2014/09/11 09:26:30]

Done.

+        && Array.isArray(block.children()[0].children()) && block.children()[0].children().length > 0)
+        return block.children()[0].children()[0].text();

[apavlov, 2014/09/10 14:09:23]

Is this the universally correct way to compute the block text content?

[iliia, 2014/09/11 09:26:30]

Yes, earlier there was only one simple string. But now due to parser's changes
it's one simple string inside blocks.
On 2014/09/10 14:09:23, apavlov (OOO until Sept.19) wrote:

+    return null;
+}
+
+/**
  * @param {string} wikiMarkupText
  * @return {!WebInspector.JSArticle}
  */
 WebInspector.JSArticle.parse = function(wikiMarkupText)
 {
-    /**
-     * @param {string} string
-     * @param {string} debugInfo
-     * @return {?WebInspector.WikiParser.Block}
-     */
-    function parseString(string, debugInfo)
-    {
-        var result = wikiParser.parseString(string);
-        if (!result)
-            console.error("Can't parse " + debugInfo);
-        return result;
-    }
-
     var wikiParser = new WebInspector.WikiParser(wikiMarkupText);
     var wikiDocument = wikiParser.document();
-
     var article = new WebInspector.JSArticle();
     article.pageTitle = wikiDocument["Page_Title"];
     if (typeof article.pageTitle !== "string")
         delete article.pageTitle;
     article.standardizationStatus = wikiDocument["Standardization_Status"];
     if (article.standardizationStatus !== "string")
         delete article.standardizationStatus;
     var apiObjectMethod = wikiDocument["API_Object_Method"];
     if (apiObjectMethod) {
         var returnValueName = apiObjectMethod["Javascript_data_type"];
         var returnValue = apiObjectMethod["Return_value_description"];
         if (returnValueName && returnValue)
             article.methods = new WebInspector.JSArticle.Method(returnValueName, returnValue);
     }
 
-    var remarks = wikiDocument["Remarks_Section"] ? wikiDocument["Remarks_Section"]["Remarks"] : null;
-    if (remarks)
-        article.remarks = parseString(remarks, "remarks");
-
-    var summary = wikiDocument["Summary_Section"];
-    if (summary)
-        article.summary = parseString(summary, "summary");
+    article.remarks = wikiDocument["Remarks_Section"] ? wikiDocument["Remarks_Section"]["Remarks"] : null;
+    article.summary = wikiDocument["Summary_Section"];
 
     var examples = wikiDocument["Examples_Section"] ? wikiDocument["Examples_Section"]["Examples"] : [];
     if (!Array.isArray(examples) && typeof examples !== "undefined")
         examples = [examples];
 
     for (var i = 0; i < examples.length; ++i) {
-        var language = examples[i]["Single Example"]["Language"];
-        var code = examples[i]["Single Example"]["Code"];
-        var liveUrl = examples[i]["Single Example"]["LiveURL"];
-        var description = parseString(examples[i]["Single Example"]["Description"], "example description");
+        var language = examples[i].values["Language"];
+        var code = examples[i].values["Code"];
+        var liveUrl = examples[i].values["LiveURL"];
+        var description = examples[i].values["Description"];
         article.examples.push(new WebInspector.JSArticle.Example(language, code, liveUrl, description));
     }
 
     var parameters = apiObjectMethod ? apiObjectMethod["Parameters"] : [];
     if (!Array.isArray(parameters) && typeof parameters !== "undefined")
         parameters = [parameters];
 
     for (var i = 0; i < parameters.length; ++i) {
-        var name = parameters[i]["Method Parameter"]["Name"];
-        var dataType = parameters[i]["Method Parameter"]["Data type"];
-        var optional = parameters[i]["Method Parameter"]["Optional"];
-        var description = parseString(parameters[i]["Method Parameter"]["Description"], "method description");
+        var name = parameters[i].values["Name"];
+        var dataType = parameters[i].values["Data type"];
+        var optional = parameters[i].values["Optional"];
+        var description = parameters[i].values["Description"];
         article.parameters.push(new WebInspector.JSArticle.Parameter(name, dataType, optional, description));
     }
 
     return article;
 }