primate 0.0.1 → 0.3.0

package/source/server/types/Object.js

@@ -0,0 +1,12 @@
+import Instance from "./Instance.js";
+import errors from "./errors/Object.json" assert {"type": "json"};
+
+export default class extends Instance {
+  static get instance() {
+    return Object;
+  }
+
+  static get errors() {
+    return errors;
+  }
+}

package/source/server/types/Primitive.js

@@ -0,0 +1,7 @@
+import Storeable from "./Storeable.js";
+
+export default class extends Storeable {
+  static is(value) {
+    return typeof value === this.type;
+  }
+}

package/source/server/types/Storeable.js

@@ -0,0 +1,51 @@
+import {PredicateError} from "../errors.js";
+
+export default class {
+  static async verify(property, value, predicates, type) {
+    const coerced = this.coerce(value);
+    if (!await this.is(coerced, type)) {
+      throw new PredicateError(this.type_error(type));
+    }
+    await this.has(property, coerced, predicates);
+    return coerced;
+  }
+
+  static type_error() {
+    return this.errors.type;
+  }
+
+  static is() {
+    throw new Error("must be implemented");
+  }
+
+  static async has(property, value, predicates) {
+    for (const predicate of predicates) {
+      if (typeof predicate === "object") {
+        await predicate.function(property, ...predicate.params);
+      } else {
+        const [name, ...params] = predicate.split(":");
+        if (!this[name](value, ...params)) {
+          let error = this.errors[name];
+          for (let i = 0; i < params.length; i++) {
+            error = error.replace(`$${i+1}`, params[i]);
+          }
+          throw new PredicateError(error);
+        }
+      }
+    }
+  }
+
+  static coerce(value) {
+    return value;
+  }
+
+  // noop for builtin types
+  static serialize(value) {
+    return value;
+  }
+
+  // noop for builtin types
+  static deserialize(value) {
+    return value;
+  }
+}

package/source/server/types/String.js

@@ -0,0 +1,49 @@
+import Primitive from "./Primitive.js";
+import errors from "./errors/String.json" assert {"type": "json"};
+
+export default class extends Primitive {
+  static get type() {
+    return "string";
+  }
+
+  static get instance() {
+    return String;
+  }
+
+  static get errors() {
+    return errors;
+  }
+
+  static length(value, length) {
+    return value.length === Number(length);
+  }
+
+  static min(value, minimum) {
+    return value.length >= Number(minimum);
+  }
+
+  static max(value, maximum) {
+    return value.length <= Number(maximum);
+  }
+
+  static between(value, minimum, maximum) {
+    const length = value.length;
+    return length >= Number(minimum) && length <= Number(maximum);
+  }
+
+  static lowercase(value) {
+    return value === value.toLowerCase();
+  }
+
+  static uppercase(value) {
+    return value === value.toUpperCase();
+  }
+
+  static alphanumeric(value) {
+    return /^[a-z0-9]+$/iu.test(value);
+  }
+
+  static regex(value, pattern) {
+    return new RegExp(pattern, "u").test(value);
+  }
+}

package/source/server/types/errors/Array.json

@@ -0,0 +1,7 @@
+{
+  "type":  "Must be an array",
+  "length": "Must be $1 items in length",
+  "min": "Must be at least $1 items in length",
+  "max": "Must be at most $1 items in length",
+  "between": "Must be between $1 and $2 items in length"
+}

package/source/server/types/errors/Boolean.json

@@ -0,0 +1,5 @@
+{
+  "type": "Must be a boolean",
+  "true": "Must be true",
+  "false": "Must be false"
+}

package/source/server/types/errors/Date.json

@@ -0,0 +1,3 @@
+{
+  "type": "Must be a date"
+}

package/source/server/types/errors/Number.json

@@ -0,0 +1,9 @@
+{
+  "type": "Must be a number",
+  "integer": "Must be an integer",
+  "positive": "Must be a positive number",
+  "negative": "Must be a negative number",
+  "between": "Must be between $1 and $2",
+  "min": "Must be at least $1",
+  "max": "Must be at most $1"
+}

package/source/server/types/errors/Object.json

@@ -0,0 +1,3 @@
+{
+  "type":  "Must be an object"
+}

package/source/server/types/errors/String.json

@@ -0,0 +1,11 @@
+{
+  "type": "Must be a string",
+  "length": "Must be $1 characters in length",
+  "min": "Must be at least $1 characters in length",
+  "max": "Must be at most $1 characters in length",
+  "between": "Must be between $1 and $2 characters in length",
+  "lowercase": "Must be lowercase",
+  "uppercase": "Must be uppercase",
+  "alphanumeric": "Must be alphanumeric",
+  "regex": "Must adhere to the regular expression pattern '$1'"
+}

package/source/server/types.js

@@ -0,0 +1,7 @@
+export {default as ArrayType} from "./types/Array.js";
+export {default as BooleanType} from "./types/Boolean.js";
+export {default as DateType} from "./types/Date.js";
+export {default as NumberType} from "./types/Number.js";
+export {default as ObjectType} from "./types/Object.js";
+export {default as StringType} from "./types/String.js";
+export {default as FileType} from "./types/File.js";

package/source/server/utils/extend_object.js

@@ -0,0 +1,10 @@
+const extend_object = (base = {}, extension = {}) =>
+  Object.keys(extension).reduce((result, property) => {
+    const value = extension[property];
+    result[property] = value?.constructor === Object
+      ? extend_object(base[property], value)
+      : value;
+    return result;
+  }, base);
+
+export default extend_object;

package/source/server/view/Parser.js

@@ -0,0 +1,122 @@
+import TreeNode from "./TreeNode.js";
+
+const OPEN_TAG = "open_tag";
+const CLOSE_TAG = "close_tag";
+const OPEN_AND_CLOSE_TAG = "open_and_close_tag";
+const last_index = -1;
+
+export default class Parser {
+  constructor(html) {
+    this.html = html;
+    this.result = [];
+    this.index = 0;
+    this.buffer = "";
+    this.balance = 0;
+    this.reading_tag = false;
+    this.node = new TreeNode();
+    this.tree = this.node;
+  }
+
+  at(index) {
+    return this.html[index];
+  }
+
+  get previous() {
+    return this.at(this.index+last_index);
+  }
+
+  get current() {
+    return this.at(this.index);
+  }
+
+  get next() {
+    return this.at(this.index+1);
+  }
+
+  remove_whitespace() {
+    this.html = this.html.replace(/[\n\t\r]/gu, "");
+  }
+
+  open_tag() {
+    this.node = new TreeNode(this.node, this.buffer);
+  }
+
+  close_tag() {
+    if (this.node.parent !== undefined) {
+      this.node = this.node.parent;
+    }
+  }
+
+  open_and_close_tag() {
+    this.open_tag();
+    this.close_tag();
+  }
+
+  // currently inside tag
+  process_reading_tag() {
+    if (this.current === ">") {
+      // mark as outside tag
+      this.reading_tag = false;
+      // if the previous character is '/', it's an open and close tag
+      if (this.previous === "/") {
+        this.tag = OPEN_AND_CLOSE_TAG;
+        this.balance--;
+        this.buffer = this.buffer.slice(0, last_index);
+      }
+
+      // execute the function associated with this kind of tag
+      this[this.tag]();
+      // empty buffer
+      this.buffer = "";
+    } else {
+      this.buffer += this.current;
+    }
+  }
+
+  // currently outside of a tag
+  process_not_reading_tag() {
+    // encountered '<'
+    if (this.current === "<") {
+      // mark as inside tag
+      this.reading_tag = true;
+      if (this.next === "/") {
+        // next character is slash, this is a close tag
+        this.tag = CLOSE_TAG;
+        this.balance--;
+      } else {
+        // this is an open tag (or open-and-close)
+        this.tag = OPEN_TAG;
+        this.balance++;
+      }
+    }
+  }
+
+  read() {
+    if (this.reading_tag) {
+      this.process_reading_tag();
+    } else {
+      this.process_not_reading_tag();
+    }
+    this.index++;
+
+    return this.current !== undefined;
+  }
+
+  return_checked() {
+    if (this.balance !== 0) {
+      throw Error(`unbalanced DOM tree: ${this.balance}`);
+    }
+    return this.tree;
+  }
+
+  // TODO: ignore comments in the analysed html
+  parse() {
+    this.remove_whitespace();
+    do {} while (this.read());
+    return this.return_checked();
+  }
+
+  static parse(html) {
+    return new Parser(html).parse();
+  }
+}

package/source/server/view/TreeNode.js

@@ -0,0 +1,195 @@
+const data_regex = /\${([^}]*)}/g;
+
+export default class TreeNode {
+  constructor(parent, content) {
+    this.children = [];
+    this.content = content;
+    if (parent !== undefined) {
+      this.parent = parent;
+      this.parent.attach(this);
+    }
+  }
+
+  attach(child) {
+    this.children.push(child);
+    child.parent = this;
+  }
+
+  // splices the child at the position i and hoists its children to i...
+  splice(i) {
+    if (this.children[i] !== undefined) {
+      const children = this.children[i].children;
+      for (const child of children) {
+        child.parent = this;
+      }
+      this.children.splice(i, 1, ...children);
+    }
+  }
+
+  filter(predicate) {
+    for (let i = this.children.length-1; i >= 0; i--) {
+      this.children[i].filter(predicate);
+      predicate(this.children[i].content) && this.splice(i);
+    }
+    return this;
+  }
+
+  each(operation) {
+    if (this.content !== undefined) {
+      operation(this);
+    }
+    for (let i = 0; i < this.children.length; i++) {
+      this.children[i].each(operation);
+    }
+    return this;
+  }
+
+  transform() {
+    const tree = [];
+    let flatten = [];
+
+    this.filter(content => !content.includes("data-"))
+      .each(node => {
+        const data_tags = node.content.split("data-");
+        data_tags.shift();
+        node.content = data_tags
+          .filter(part => part.includes("="))
+          .map(part => {
+            const index = part.indexOf("=");
+            const key = part.slice(0, index);
+            const right = part.slice(index+1);
+            return {key, "value": right.slice(1, right.indexOf("\"", 1))};
+          });
+      })
+      // transform template strings
+      .each(node => {
+        for (let i = 0; i < node.content.length; i++) {
+          const part = node.content[i];
+          const key = part.key;
+          const matches = [...part.value.matchAll(data_regex)];
+          if (matches.length > 0) {
+            for (const match of matches) {
+              // add new entries to node.content
+              node.content.push({key, "value": match[1]});
+            }
+            // remove this entry
+            node.content.splice(i, 1);
+            i--;
+          }
+        }
+      })
+      // unfold scopes
+      .each(node => {
+        for (let i = 0; i < node.content.length; i++) {
+          const part = node.content[i];
+          // memove scope and rework subtree
+          if (part.key === "scope") {
+            const scope = part.value;
+            for (let j = 0; j < node.children.length; j++) {
+              let recurse = true;
+              node.children[j].each(scopeable => {
+                // skip descending into children of data-scope
+                if (!recurse) {
+                  return;
+                }
+                let found_scope = false;
+                scopeable.content.forEach(content => {
+                  if (content.key === "scope") {
+                    found_scope = true;
+                  }
+                  content.value = `${scope}.${content.value}`;
+                });
+                recurse = !found_scope;
+              });
+            }
+            node.content.splice(i, 1);
+          }
+        }
+      })
+      .each(node => {
+        flatten = flatten.concat(node.content.map(content => content.value));
+      });
+
+    const error = key => { throw new Error(
+      `\`${key}\` appears as both value and object key`); };
+    const put = (tree, part) => {
+      if (!part.includes(".")) {
+        if (!tree.includes(part)) {
+          tree.push(part);
+        }
+        for (const node of tree) {
+          if (typeof node === "object") {
+            if (node[part] !== undefined) {
+              error(part);
+            }
+          }
+        }
+      } else {
+        const index = part.indexOf(".");
+        const left = part.slice(0, index);
+        const right = part.slice(index+1);
+        if (tree.includes(left)) {
+          error(left);
+        }
+        let found_node = undefined;
+        for (const node of tree) {
+          if (typeof node === "object") {
+            if (node[left] !== undefined) {
+              found_node = node[left];
+              break;
+            }
+          }
+        }
+        if (found_node === undefined) {
+          found_node = [];
+          tree.push({[left]: found_node});
+        }
+        put(found_node, right);
+      }
+    };
+    flatten.forEach(part => put(tree, part));
+    return tree;
+  }
+
+  flatten() {
+    const object = {};
+    if (this.children.length === 0) {
+      return this.content.key;
+    }
+    const key = this.content ? this.content.key : "root";
+    object[key] = [];
+    for (const child of this.children) {
+      if (child !== undefined) {
+        const interim = child.flatten();
+        if (interim instanceof Array) {
+          object[key] = object[key].concat(interim);
+        } else {
+          object[key].push(interim);
+        }
+        const strings = [];
+        const objects = {};
+        object[key] = object[key].filter(value => {
+          if (typeof value === "string") {
+            if (strings.includes(value)) {
+              return false;
+            }
+            strings.push(value);
+            return true;
+          } else {
+            const key = Object.keys(value)[0];
+            value = value[key];
+            // merge with it
+            if (objects[key] !== undefined) {
+              objects[key].push(...value);
+              return false;
+            } else {
+              objects[key] = value;
+              return true;
+            }
+          }
+        });
+      }
+    }
+    return object;
+  }
+}

package/source/server/view/View.js

@@ -0,0 +1,30 @@
+import Parser from "./Parser.js";
+import {InternalServerError} from "../errors.js";
+
+const $content = "${content}";
+
+export default class View {
+  constructor(path, content, layouts) {
+    this.path = path;
+    this.content = content;
+    this.layouts = layouts;
+  }
+
+  elements(layout) {
+    try {
+      return Parser.parse(layout === undefined
+        ? this.content
+        : this.file(layout)).transform();
+    } catch (error) {
+      throw new InternalServerError(`${this.path} ${error.message}`);
+    }
+  }
+
+  layout(layout) {
+    return this.layouts[layout] ?? $content;
+  }
+
+  file(layout = "default") {
+    return this.layout(layout).replace($content, this.content);
+  }
+}