@garrix82/reactgenie-dsl 1.0.0

package/lib/dsl/parser.pegjs

@@ -0,0 +1,130 @@
+{
+  const DEBUGGING = false;
+  const debug = (...args) => {
+    if (DEBUGGING) {
+      console.log('DEBUG: ' + args)
+    }
+  }
+}
+
+top = s: statement sl: (SP* ';' SP* statement?)* {
+    return [s].concat(
+        sl.map((e) => {
+            return e[3];
+        }).reduce((acc, cur) => {
+            if (cur !== null) {
+                acc.push(cur);
+            }
+            return acc;
+        }, [])
+    );
+}
+
+statement = s: (value / all_symbol) SP* {
+    return s
+}
+
+all_symbol =  s:(index_symbol) l:('.' all_symbol)? {
+    if (l !== null) {
+        var last_l_parent = null;
+        l = l[1];
+        var l_parent = l;
+        while (l_parent.parent !== undefined) {
+            last_l_parent = l_parent;
+            l_parent = l_parent.parent;
+        }
+        if (last_l_parent !== null) {
+            last_l_parent.parent = {
+                type: "access",
+                parent: s,
+                access: l_parent
+            };
+        } else {
+            l = {
+                type: "access",
+                parent: s,
+                access: l_parent
+            }
+        }
+        return l;
+    } else {
+        return s;
+    }
+}
+
+index_symbol = p: (function_call / symbol ) i: ('[' int_literal ']')* {
+   var return_value = p;
+   for (var index_element of i) {
+       return_value = {
+           type: "index",
+           parent: return_value,
+           index: index_element[1]
+       };
+   }
+   return return_value;
+}
+
+function_call = func_name:symbol SP* '(' SP* pl:(parameter_list)? SP* ')' {
+    debug('function_call', func_name, pl);
+    return {
+        type: 'function_call',
+        func_name: func_name,
+        parameters: pl !== null ? pl.parameters : null
+    };
+}
+
+parameter_list = pp:parameter_pair pl:(SP* ',' SP* parameter_pair)* {
+  debug('parameter_list', pp, pl);
+  return {"parameters": pl.reduce((acc, cur) => {
+    acc.push(cur[3]);
+    return acc;
+  }, [pp])};
+}
+
+parameter_pair = sy:symbol SP* ':' SP* v:(value / accessor) {
+  return {"parameter": sy, "value": v};
+}
+
+value = 'true' {
+    return { type: "boolean", value: true };
+} / 'false' {
+    return { type: "boolean", value: false };
+} / fl: float_literal {
+    return {"type": "float", "value": fl};
+} / il: int_literal {
+    return {"type": "int", "value": il};
+} / s: all_symbol {
+    return s;
+} / '"' s: [^"]* '"' {
+    return { type: "string", value: s.join("") };
+} / '[' SP* s: array_value SP* ']' {
+    return { type: "array", value: s };
+}
+
+accessor = '.' s: all_symbol {
+    return {"type": "accessor", "field": s};
+}
+
+float_literal = s:("+" / "-")? i:[0-9]+ "." f:[0-9]+ {
+    return parseFloat((s === "-" ? "-" : "") + i.join("") + "." + f.join(""));
+}
+
+array_value = vi: value iv:(SP* ',' SP* value)* {
+    return iv.reduce((acc, cur) => {
+        acc.push(cur[3]);
+        return acc;
+    }, [vi]);
+}
+
+symbol = [a-zA-Z_][a-zA-Z0-9_]* {
+    return text();
+}
+
+int_literal = s:("+" / "-")? i:[0-9]+ {
+    return parseInt((s === "-" ? "-" : "") + i.join(""));
+}
+
+INTDIGIT = [1-9]
+SIGN = '+' / '-'
+DIGIT = [0-9]
+SP = [ \t\r\n]

package/lib/dsl-descriptor.ts

@@ -0,0 +1,241 @@
+import { ExampleParse } from "./nl";
+
+let constructorInCreateObject = false;
+
+export class GenieObject {
+  static __genieObjectType: string;
+  constructor({}) {
+    if (!constructorInCreateObject) {
+      console.error(
+        "Constructor not called in CreateObject\nAll GenieObject should be created using CreateObject"
+      );
+    }
+  }
+
+  /**
+   * This function is called after the object is created, and called before function calls and property access.
+   */
+  update(): void | Promise<void> {
+    return
+  }
+
+  /**
+   * This function is called object's property is updated.
+   */
+  sync(): void | Promise<void> {
+    return
+  }
+
+  // placeholder, should be replaced by GenieClass decorator
+  static _createObject<T extends typeof GenieObject>(
+    this: T,
+    ...args: any[]
+  ): InstanceType<T> {
+    throw new Error(
+      "Not implemented. Did you forget to decorate the class with @GenieClass?"
+    );
+  }
+
+  static CreateObject<T extends typeof GenieObject>(
+    this: T,
+    ...args: any[]
+  ): InstanceType<T> {
+    constructorInCreateObject = true;
+    let returnValue = this._createObject(...args);
+    constructorInCreateObject = false;
+    return returnValue;
+  }
+
+  // placeholder, other code that should run after initGenie
+  static setup() {}
+
+  description(): {} {
+    return this;
+  }
+
+  static Examples: ExampleParse[] = [];
+
+  static ClassDescriptor: ClassDescriptor<GenieObject>;
+
+  public __deleted = false;
+
+  __getState(): {} {
+    return {};
+  }
+}
+
+/**
+ * DataClass are objects that controls the interactions.
+ *
+ * DataClass will be automatically indexed by ReactGenie.
+ */
+export class DataClass extends GenieObject {
+  static genieKey: string;
+  static __genieObjectType: string = "DataClass";
+
+  constructor({}) {
+    super({});
+  }
+
+  // noinspection JSUnusedGlobalSymbols
+  _getConstructorParams(): any {
+    const name = this.constructor.prototype.genieKey;
+    return {
+      [name]: this[name],
+    };
+  }
+
+  // placeholder, should be replaced by GenieClass decorator
+  static GetObject<T extends typeof DataClass>(
+    this: T,
+    ...args: any[]
+  ): InstanceType<T> {
+    throw new Error(
+      "Not implemented. Did you forget to decorate the class with @GenieClass?"
+    );
+  }
+
+  static All<T extends typeof DataClass>(
+    this: T,
+    ...args: any[]
+  ): InstanceType<T>[] | Promise<InstanceType<T>[]> {
+    throw new Error(
+      "Not implemented. Did you forget to decorate the class with @GenieClass?"
+    );
+  }
+
+  static DeleteObject<T extends typeof DataClass>(
+    this: T,
+    ...args: any[]
+  ): InstanceType<T> {
+    throw new Error(
+      "Not implemented. Did you forget to decorate the class with @GenieClass?"
+    );
+  }
+}
+
+export type HelperClassGetter = () => {};
+export type HelperClassSetter = (value: {}) => void;
+export type HelperClassGetterSetter = [HelperClassGetter, HelperClassSetter];
+
+/**
+ * Helper class are for storing complex data types in DataClass.
+ */
+export class HelperClass extends GenieObject {
+  localStore: {} = null;
+  localStoreGetterSetter: HelperClassGetterSetter = null;
+  static __genieObjectType: string = "HelperClass";
+
+  constructor(value: { __genieObjectType: {} } | {}) {
+    super(value);
+    if (value && value.hasOwnProperty("__genieObjectType")) {
+      this.localStore = value;
+    }
+  }
+}
+
+export class ParamDescriptor {
+  // noinspection JSUnusedGlobalSymbols
+  constructor(
+    public name: string,
+    public type: string,
+    public required: boolean = true,
+    public defaultValue: any = null
+  ) {}
+  description(): string {
+    return (
+      `${this.name}: ${this.type}` + (this.required ? "" : "?") +
+      (this.defaultValue ? ` = \`${this.defaultValue}\`` : "")
+    );
+  }
+}
+
+export class FuncDescriptor {
+  constructor(
+    public func_name: string,
+    public parameters: ParamDescriptor[],
+    public returnType: string,
+    public isStatic: boolean = false,
+    public comment: string = ""
+  ) {}
+  description(): string {
+    return (
+      (this.comment !== "" ? `// ${this.comment}\n\t` : "") +
+      (this.isStatic ? `static ` : "") +
+      `${this.returnType} ${this.func_name}(${this.parameters
+        .map((p) => p.description())
+        .join(", ")});`
+    );
+  }
+
+  isSame(another: FuncDescriptor) {
+    return (
+      this.func_name === another.func_name &&
+      this.returnType === another.returnType &&
+      this.isStatic === another.isStatic &&
+      this.parameters.length === another.parameters.length &&
+      this.parameters.every(
+        (p, i) =>
+          p.name === another.parameters[i].name &&
+          p.type === another.parameters[i].type
+      )
+    );
+  }
+}
+
+export class FieldDescriptor {
+  constructor(
+    public field: string,
+    public fieldType: string,
+    public isStatic: boolean = false,
+    public comment: string = ""
+  ) {}
+
+  description(): string {
+    return (
+      (this.comment !== "" ? `// ${this.comment}\n\t` : "") +
+      (this.isStatic ? `static ` : "") +
+      `${this.fieldType} ${this.field};`
+    );
+  }
+
+  isSame(another: FieldDescriptor) {
+    return (
+      this.field === another.field &&
+      this.fieldType === another.fieldType &&
+      this.isStatic === another.isStatic
+    );
+  }
+}
+
+export class ClassDescriptor<T extends GenieObject> {
+  public functions: Set<FuncDescriptor>;
+  public fields: Set<FieldDescriptor>;
+
+  constructor(
+    public className: string,
+    functions: FuncDescriptor[],
+    fields: FieldDescriptor[],
+    public classConstructor: { new (...any): T },
+    public comment: string = ""
+  ) {
+    this.functions = new Set(functions);
+    this.fields = new Set(fields);
+  }
+
+  description(): string {
+    return (
+      (this.comment !== "" ? `// ${this.comment}\n` : "") +
+      `class ${this.className} {\n` +
+      Array.from(this.fields)
+        .map((f) => "\t" + f.description())
+        .join("\n") +
+      "\n" +
+      Array.from(this.functions)
+        .map((f) => "\t" + f.description())
+        .join("\n") +
+      "\n" +
+      `}`
+    );
+  }
+}

package/lib/index.ts

@@ -0,0 +1,5 @@
+export * from "./dsl-descriptor";
+export * from "./dsl";
+export * from "./decorators";
+export * from "./nl";
+export * from "./nl-interpreter";