Initial commit

Author: neriyaco

.gitignore

@@ -0,0 +1,42 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+*.swp
+
+pids
+logs
+results
+tmp
+
+# Build
+public/css/main.css
+
+# Coverage reports
+coverage
+
+# API keys and secrets
+.env
+
+# Dependency directory
+node_modules
+bower_components
+
+# Editors
+.idea
+*.iml
+
+# OS metadata
+.DS_Store
+Thumbs.db
+
+# Ignore built ts files
+dist/**/*
+
+# ignore yarn.lock
+yarn.lock
+.lh/

.vscode/launch.json

@@ -0,0 +1,39 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Current File",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--nolazy",
+        "-r",
+        "ts-node/register/transpile-only",
+        "-r",
+        "tsconfig-paths/register"
+      ],
+      "args": ["${workspaceFolder}/${relativeFile}"],
+      "cwd": "${workspaceRoot}",
+      "internalConsoleOptions": "openOnSessionStart",
+      "skipFiles": ["<node_internals>/**", "node_modules/**"]
+    },
+    {
+      "name": "Run Simple Test",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--nolazy",
+        "-r",
+        "ts-node/register/transpile-only",
+        "-r",
+        "tsconfig-paths/register"
+      ],
+      "args": ["${workspaceFolder}/tests/simple.test.ts"],
+      "cwd": "${workspaceRoot}",
+      "internalConsoleOptions": "openOnSessionStart",
+      "skipFiles": ["<node_internals>/**", "node_modules/**"]
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "cSpell.words": [
+    "RSON"
+  ]
+}

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "rsonjs",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "repository": "https://github.com/xpodev/rsonjs",
+  "author": "Xpo Development",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.2"
+  }
+}

src/errors.ts

@@ -0,0 +1,14 @@
+export class RSONError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RSONError";
+  }
+}
+
+export class RSONParseError extends RSONError {
+  constructor(message: string) {
+    super(message);
+    this.name = "RSONParseError";
+  }
+}
+

src/globals.d.ts

@@ -0,0 +1 @@
+declare type ReplacerFunction = ((key: string, value: any) => any) | null;

src/index.ts

@@ -0,0 +1,22 @@
+import { Parser } from "./parser";
+import { StringStream } from "./stream/string";
+import { stringify as rsonStringify } from "./stringify";
+
+namespace RSON {
+  export function parse(input: string): any {
+    if (input === "") {
+      throw new SyntaxError("Unexpected end of RSON input");
+    }
+    return new Parser(new StringStream(input)).parse();
+  }
+
+  export function stringify(
+    input: any,
+    replacer?: ReplacerFunction,
+    space?: string | number
+  ): string {
+    return rsonStringify(input, replacer, space);
+  }
+}
+
+export default RSON;

src/parser/index.ts

@@ -0,0 +1 @@
+export { Parser } from "./parser";

src/parser/parser.ts

@@ -0,0 +1,166 @@
+import { Token, Tokenizer, TokenType } from "src/tokenizer";
+import { IStream } from "src/stream/stream";
+import { TokenStream } from "./token-stream";
+import { RSONParseError } from "src/errors";
+
+class LateReference {
+  constructor(
+    public readonly obj: Record<string, any> | Array<any>,
+    public readonly key: number | string,
+    public readonly name: string
+  ) {}
+}
+
+export class Parser {
+  private tokenizer: Tokenizer;
+  private tokenStream!: TokenStream;
+  private readonly objectReferences: Record<string, any> = {};
+  private readonly lateReferences: Array<LateReference> = [];
+  constructor(stream: IStream) {
+    this.tokenizer = new Tokenizer(stream);
+  }
+
+  public parse() {
+    this.tokenStream = new TokenStream(this.tokenizer.tokenize());
+    const obj = this.parseValue();
+    this.eat(TokenType.EOF);
+    this.lateReferences.forEach((ref) => {
+      if (ref.name in this.objectReferences) {
+        if (Array.isArray(ref.obj)) {
+          ref.obj.splice(ref.key as number, 1, this.objectReferences[ref.name]);
+        } else {
+          ref.obj[ref.key as string] = this.objectReferences[ref.name];
+        }
+      } else {
+        throw new RSONParseError(
+          `Object reference '${ref.name}' not found in object references`
+        );
+      }
+    });
+    return obj;
+  }
+
+  private parseValue() {
+    const token = this.tokenStream.current();
+    let value: any;
+    switch (token.type) {
+      case TokenType.LeftCurlyBracket:
+        value = this.parseObject();
+        break;
+      case TokenType.LeftSquareBracket:
+        value = this.parseArray();
+        break;
+      case TokenType.String:
+        value = this.tokenStream.next().value;
+        break;
+      case TokenType.Number:
+        value = Number(this.tokenStream.next().value);
+        break;
+      case TokenType.True:
+        this.eat(TokenType.True);
+        value = true;
+        break;
+      case TokenType.False:
+        this.eat(TokenType.False);
+        value = false;
+        break;
+      case TokenType.Null:
+        this.eat(TokenType.Null);
+        value = null;
+        break;
+      default:
+        throw new RSONParseError(
+          `Unexpected token ${token.value} at position ${token.startPosition}`
+        );
+    }
+
+    if (this.tokenStream.hasNext()) {
+      if (
+        this.tokenStream.current().type === TokenType.ObjectReferenceDefinition
+      ) {
+        const objectReferenceName = this.tokenStream.next().value;
+        if (objectReferenceName in this.objectReferences) {
+          throw new RSONParseError(
+            `Object reference '${objectReferenceName}' already exists`
+          );
+        }
+
+        this.objectReferences[objectReferenceName] = value;
+      }
+    }
+
+    return value;
+  }
+
+  private parseObject() {
+    this.eat(TokenType.LeftCurlyBracket);
+    const obj: Record<string, any> = {};
+    while (this.tokenStream.current().type !== TokenType.RightCurlyBracket) {
+      const key = this.tokenStream.next().value;
+      this.eat(TokenType.Colon);
+
+      if (this.tokenStream.current().type === TokenType.ObjectReference) {
+        const ref = this.parseReference();
+        if (ref instanceof Token) {
+          this.lateReferences.push(
+            new LateReference(obj, key, ref.value)
+          );
+        } else {
+          obj[key] = ref;
+        }
+      } else {
+        obj[key] = this.parseValue();
+      }
+      this.maybeEat(TokenType.Comma);
+    }
+    this.eat(TokenType.RightCurlyBracket);
+    return obj;
+  }
+
+  private parseArray() {
+    this.eat(TokenType.LeftSquareBracket);
+    const arr: any[] = [];
+    while (this.tokenStream.current().type !== TokenType.RightSquareBracket) {
+      if (this.tokenStream.current().type === TokenType.ObjectReference) {
+        const ref = this.parseReference();
+        if (ref instanceof Token) {
+          this.lateReferences.push(
+            new LateReference(arr, arr.length, ref.value)
+          );
+        } else {
+          arr.push(ref);
+        }
+      } else {
+        arr.push(this.parseValue());
+      }
+      this.maybeEat(TokenType.Comma);
+    }
+    this.eat(TokenType.RightSquareBracket);
+    return arr;
+  }
+
+  private parseReference() {
+    const referenceToken = this.tokenStream.next();
+    if (referenceToken.value in this.objectReferences) {
+      return this.objectReferences[referenceToken.value];
+    } else {
+      return referenceToken;
+    }
+  }
+
+  private maybeEat(tokenType: TokenType) {
+    if (this.tokenStream.current().type === tokenType) {
+      this.eat(tokenType);
+    }
+  }
+
+  private eat(tokenType: TokenType) {
+    const token = this.tokenStream.current();
+    if (token.type !== tokenType) {
+      throw new RSONParseError(
+        `Unexpected token ${token.value} at position ${token.startPosition}`
+      );
+    }
+    return this.tokenStream.next();
+  }
+}

src/parser/token-stream.ts

@@ -0,0 +1,22 @@
+import { Token } from "src/tokenizer";
+
+export class TokenStream {
+  private tokens: Token[];
+  private position = 0;
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens;
+  }
+
+  current() {
+    return this.tokens[this.position];
+  }
+
+  next() {
+    return this.tokens[this.position++];
+  }
+
+  hasNext() {
+    return this.position < this.tokens.length;
+  }
+}