HTMLFileContent and component for extracting IDL fragments

config/files.js

@@ -90,6 +90,10 @@
     `lib${sep}org${sep}chromium${sep}webidl${sep}ast${sep}Stringifier.js`,
     `lib${sep}org${sep}chromium${sep}webidl${sep}ast${sep}Float.js`,
 
+    // HTML File Content and Extractor
+    `lib${sep}org${sep}chromium${sep}webidl${sep}HTMLFileContents.js`,
+    `lib${sep}org${sep}chromium${sep}webidl${sep}IDLFragmentExtractor.js`,
+
     // Web IDL parsers
     `lib${sep}org${sep}chromium${sep}webidl${sep}BaseParser.js`,
     `lib${sep}org${sep}chromium${sep}webidl${sep}Parser.js`,

lib/org/chromium/webidl/HTMLFileContents.js

@@ -0,0 +1,36 @@
+// Copyright 2017 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.
+'use strict';
+
+foam.CLASS({
+  package: 'org.chromium.webidl',
+  name: 'HTMLFileContents',
+
+  documentation: 'An HTML file that stores the raw content of the response.',
+
+  ids: ['url', 'timestamp'],
+
+  properties: [
+    {
+      class: 'String',
+      name: 'url',
+      required: true,
+    },
+    {
+      class: 'Date',
+      name: 'timestamp',
+      required: true,
+    },
+    {
+      class: 'String',
+      name: 'contents',
+    },
+    {
+      class: 'Array',
+      of: 'String',
+      documentation: 'Any array of files referencing the URL of this file.',
+      name: 'references',
+    },
+  ],
+});

lib/org/chromium/webidl/IDLFileContents.js

@@ -12,7 +12,6 @@ foam.CLASS({
   requires: [
     'foam.core.Property',
     'foam.net.HTTPrequest',
-    'org.chromium.webidl.IDLFileBase',
   ],
 
   properties: [

lib/org/chromium/webidl/IDLFragmentExtractor.js

@@ -0,0 +1,116 @@
+// Copyright 2017 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.
+'use strict';
+
+foam.CLASS({
+  package: 'org.chromium.webidl',
+  name: 'IDLFragmentExtractor',
+  documentation: 'Extracts IDL Fragments from HTML files.',
+  requires: [
+    'foam.parsers.html.HTMLLexer',
+    'foam.parsers.html.TagType',
+  ],
+
+  properties: [
+    {
+      name: 'file',
+      of: 'org.chromium.webidl.HTMLFileContent',
+      postSet: function(_, file) {
+        this.idlFragments = this.extract();
+      },
+    },
+    {
+      name: 'idlFragments',
+      // description: 'all idlFragments found in the parsed HTML file',
+    },
+  ],
+
+  methods: [
+    function extract() {
+      var lexer = this.HTMLLexer.create();
+      var OPEN = this.TagType.OPEN.name;
+      var CLOSE = this.TagType.CLOSE.name;
+      var extractAttr = function(node, attrName) {
+        var retVal = [];
+        node.attributes.forEach(function(attr) {
+          if (attr.name === attrName) {
+            retVal = retVal.concat(attr.value.split(' '));
+          }
+        });
+        return retVal;
+      };
+
+      var results = lexer.parseString(this.file.contents).value;
+      if (!results) throw new Error("IDL Parse was not successful.");
+
+      var idlFragments = [];
+      var tagStack = [];            // Used for tag matching.
+      var excludeStack = [];        // Used for tracking excluded (example/note) tags.
+      var tagMatching = true;       // Set whe not inside a pre tag of interest.
+      var content = '';             // Used to group together related content.
+      for (var i = 0; i < results.length; i++) {
+        var item = results[i];
+        var isTag = lexer.Tag.isInstance(item);
+
+        // FUTURE: Handle nested pre tags.
+        // As of this writing, there has not been any IDL fragments
+        // that has been found within nested pre tags.
+        if (!tagMatching) {
+          // Ignoring all tags. Only extracting text content within pre tags.
+          if (isTag) {
+            if (item.nodeName === 'pre') {
+              tagMatching = true;
+              tagStack.pop();
+              idlFragments.push(lexer.lib.unescapeString(content));
+              content = '';
+            }
+          } else {
+            // item is text fragments, so we append it.
+            content += item;
+          }
+        } else if (isTag) {
+          // Encountered a tag and we are tag matching.
+          // Perform appropriate action based on class attribute and tagType.
+          var top = tagStack[tagStack.length - 1];
+          var classes = extractAttr(item, 'class');
+          var isIDL = classes && classes.includes('idl');
+          var isExcluded = function(cls) {
+            return cls && (cls.includes('example') || cls.includes('note'));
+          };
+
+          if (item.type.name === OPEN) {
+            if (isExcluded(classes)) {
+              // Entering the body of an excluded tag.
+              excludeStack.push(item);
+            } else if (excludeStack.length === 0
+                && item.nodeName === 'pre' && isIDL) {
+              // Found a <pre class="idl.*">.
+              // Ignore tags and only extract text now.
+              tagMatching = false;
+            }
+            tagStack.push(item);
+          } else if (top && item.type.name === CLOSE
+              && top.nodeName === item.nodeName) {
+            // Item is a close tag matching the tag at the top of the stack.
+            // Aliasing for readability.
+            var openTag = top;
+            var closeTag = item;
+
+            var openTagCls = extractAttr(openTag, 'class');
+            var excludeStackTop = excludeStack[excludeStack.length - 1];
+            if (isExcluded(openTagCls) &&
+                closeTag.nodeName === excludeStackTop.nodeName) {
+              excludeStack.pop();
+            }
+            tagStack.pop();
+          } else {
+            // Mismatched close tags and OPEN_CLOSE tags are ignored.
+          }
+        }
+      }
+      return idlFragments;
+    },
+  ],
+});
+

test/node/parsing/Console/2

@@ -0,0 +1,25 @@
+[Exposed=(Window,Worker,Worklet)]
+namespace console { // but see namespace object requirements below
+  // Logging
+  void assert(optional boolean condition = false, any... data);
+  void clear();
+  void count(optional DOMString label = "default");
+  void debug(any... data);
+  void error(any... data);
+  void info(any... data);
+  void log(any... data);
+  void table(any tabularData, optional sequence<DOMString> properties);
+  void trace(any... data);
+  void warn(any... data);
+  void dir(any item, optional object? options);
+  void dirxml(any... data);
+
+  // Grouping
+  void group(any... data);
+  void groupCollapsed(any... data);
+  void groupEnd();
+
+  // Timing
+  void time(optional DOMString label = "default");
+  void timeEnd(optional DOMString label = "default");
+};

test/node/parsing/Console/3

@@ -0,0 +1,25 @@
+[Exposed=(Window,Worker,Worklet)]
+namespace console { // but see namespace object requirements below
+  // Logging
+  void assert(optional boolean condition = false, any... data);
+  void clear();
+  void count(optional DOMString label = "default");
+  void debug(any... data);
+  void error(any... data);
+  void info(any... data);
+  void log(any... data);
+  void table(any tabularData, optional sequence<DOMString> properties);
+  void trace(any... data);
+  void warn(any... data);
+  void dir(any item, optional object? options);
+  void dirxml(any... data);
+
+  // Grouping
+  void group(any... data);
+  void groupCollapsed(any... data);
+  void groupEnd();
+
+  // Timing
+  void time(optional DOMString label = "default");
+  void timeEnd(optional DOMString label = "default");
+};