convert Parser class to set of function for better compression

packages/bbob-parser/lib/parse.js

@@ -1,8 +1,243 @@
-const Parser = require('./Parser');
+const {
+  convertTokenToText,
+  getTagName,
+  getTokenColumn,
+  getTokenLine,
+  getTokenValue,
+  isAttrNameToken,
+  isAttrValueToken,
+  isTagStart,
+  isTagToken,
+  isTextToken,
+  isTagEnd,
+} = require('./Token');
 
-module.exports = function parse(input, options) {
-  const parser = new Parser(input, options);
-  const ast = parser.parse();
+const Tokenizer = require('./Tokenizer');
+const TagNode = require('./TagNode');
 
-  return ast;
+/**
+ * @private
+ * @type {Array}
+ */
+let nodes;
+/**
+ * @private
+ * @type {Array}
+ */
+let nestedNodes;
+/**
+ * @private
+ * @type {Array}
+ */
+let tagNodes;
+/**
+ * @private
+ * @type {Array}
+ */
+let tagNodesAttrName;
+
+let options = {};
+let tokenizer = null;
+let tokens = null;
+
+/**
+ *
+ * @param tag
+ * @param attrs
+ * @param content
+ */
+const newTagNode = (tag, attrs = {}, content = []) => new TagNode(tag, attrs, content);
+
+const createTokenizer = (input, onToken) => new Tokenizer(input, { onToken });
+
+/**
+ * @private
+ * @param token
+ * @return {*}
+ */
+const isTagNested = token => tokenizer.isTokenNested(token);
+
+/**
+ * @private
+ * @return {TagNode}
+ */
+const getTagNode = () => (tagNodes.length ? tagNodes[tagNodes.length - 1] : null);
+
+/**
+ * @private
+ * @return {Array}
+ */
+const createTagNode = token => tagNodes.push(newTagNode(getTokenValue(token)));
+/**
+ * @private
+ * @return {Array}
+ */
+const createTagNodeAttrName = token => tagNodesAttrName.push(getTokenValue(token));
+
+/**
+ * @private
+ * @return {Array}
+ */
+const getTagNodeAttrName = () =>
+  (tagNodesAttrName.length ? tagNodesAttrName[tagNodesAttrName.length - 1] : getTagNode().tag);
+
+/**
+ * @private
+ * @return {Array}
+ */
+const clearTagNodeAttrName = () => {
+  if (tagNodesAttrName.length) {
+    tagNodesAttrName.pop();
+  }
 };
+
+/**
+ * @private
+ * @return {Array}
+ */
+const clearTagNode = () => {
+  if (tagNodes.length) {
+    tagNodes.pop();
+
+    clearTagNodeAttrName();
+  }
+};
+
+/**
+ * @private
+ * @return {Array}
+ */
+const getNodes = () => {
+  if (nestedNodes.length) {
+    const nestedNode = nestedNodes[nestedNodes.length - 1];
+    return nestedNode.content;
+  }
+
+  return nodes;
+};
+
+/**
+ * @private
+ * @param tag
+ */
+const appendNode = (tag) => {
+  getNodes().push(tag);
+};
+
+/**
+ * @private
+ * @param value
+ * @return {boolean}
+ */
+const isAllowedTag = (value) => {
+  if (options.onlyAllowTags && options.onlyAllowTags.length) {
+    return options.onlyAllowTags.indexOf(value) >= 0;
+  }
+
+  return true;
+};
+/**
+ * @private
+ * @param token
+ */
+const handleTagStart = (token) => {
+  if (isTagStart(token)) {
+    createTagNode(token);
+
+    if (isTagNested(token)) {
+      nestedNodes.push(getTagNode());
+    } else {
+      appendNode(getTagNode());
+      clearTagNode();
+    }
+  }
+};
+
+/**
+ * @private
+ * @param token
+ */
+const handleTagEnd = (token) => {
+  if (isTagEnd(token)) {
+    clearTagNode();
+
+    const lastNestedNode = nestedNodes.pop();
+
+    if (lastNestedNode) {
+      appendNode(lastNestedNode);
+    } else {
+      // eslint-disable-next-line no-console
+      console.warn(`Inconsistent tag '${getTokenValue(token)}' on line ${getTokenLine(token)} and column ${getTokenColumn(token)}`);
+    }
+  }
+};
+
+/**
+ * @private
+ * @param token
+ */
+const handleTagToken = (token) => {
+  if (isTagToken(token)) {
+    if (isAllowedTag(getTagName(token))) {
+      // [tag]
+      handleTagStart(token);
+
+      // [/tag]
+      handleTagEnd(token);
+    } else {
+      appendNode(convertTokenToText(token));
+    }
+  }
+};
+
+/**
+ * @private
+ * @param token
+ */
+const handleTagNode = (token) => {
+  const tagNode = getTagNode();
+
+  if (tagNode) {
+    if (isAttrNameToken(token)) {
+      createTagNodeAttrName(token);
+      tagNode.attr(getTagNodeAttrName(), null);
+    } else if (isAttrValueToken(token)) {
+      tagNode.attr(getTagNodeAttrName(), getTokenValue(token));
+      clearTagNodeAttrName();
+    } else if (isTextToken(token)) {
+      tagNode.append(getTokenValue(token));
+    }
+  } else if (isTextToken(token)) {
+    appendNode(getTokenValue(token));
+  }
+};
+
+/**
+ * @private
+ * @param token
+ */
+const parseToken = (token) => {
+  handleTagToken(token);
+  handleTagNode(token);
+};
+
+/**
+ * @public
+ * @return {Array}
+ */
+const parse = (input, opts = {}) => {
+  tokenizer = createTokenizer(input, parseToken);
+  options = opts;
+
+  nodes = [];
+  nestedNodes = [];
+  tagNodes = [];
+  tagNodesAttrName = [];
+
+  tokens = tokenizer.tokenize();
+
+  return nodes;
+};
+
+module.exports = parse;
+module.exports.createTagNode = createTagNode;