@herb-tools/core 0.1.0

package/src/parse-result.ts

@@ -0,0 +1,101 @@
+import { Result } from "./result.js"
+import { DocumentNode } from "./nodes.js"
+import { HerbError } from "./error.js"
+import { HerbWarning } from "./warning.js"
+
+import type { SerializedHerbError } from "./error.js"
+import type { SerializedHerbWarning } from "./warning.js"
+import type { SerializedDocumentNode } from "./nodes.js"
+import type { Visitor } from "./visitor.js"
+
+export type SerializedParseResult = {
+  value: SerializedDocumentNode
+  source: string
+  warnings: SerializedHerbWarning[]
+  errors: SerializedHerbError[]
+}
+
+/**
+ * Represents the result of a parsing operation, extending the base `Result` class.
+ * It contains the parsed document node, source code, warnings, and errors.
+ */
+export class ParseResult extends Result {
+  /** The document node generated from the source code. */
+  readonly value: DocumentNode
+
+  /**
+   * Creates a `ParseResult` instance from a serialized result.
+   * @param result - The serialized parse result containing the value and source.
+   * @returns A new `ParseResult` instance.
+   */
+  static from(result: SerializedParseResult) {
+    return new ParseResult(
+      DocumentNode.from(result.value),
+      result.source,
+      result.warnings.map((warning) => HerbWarning.from(warning)),
+      result.errors.map((error) => HerbError.from(error)),
+    )
+  }
+
+  /**
+   * Constructs a new `ParseResult`.
+   * @param value - The document node.
+   * @param source - The source code that was parsed.
+   * @param warnings - An array of warnings encountered during parsing.
+   * @param errors - An array of errors encountered during parsing.
+   */
+  constructor(
+    value: DocumentNode,
+    source: string,
+    warnings: HerbWarning[] = [],
+    errors: HerbError[] = [],
+  ) {
+    super(source, warnings, errors)
+    this.value = value
+  }
+
+  /**
+   * Determines if the parsing failed.
+   * @returns `true` if there are errors, otherwise `false`.
+   */
+  failed(): boolean {
+    // TODO: this should probably be recursive as noted in the Ruby version
+    return this.errors.length > 0 || this.value.errors.length > 0
+  }
+
+  /**
+   * Determines if the parsing was successful.
+   * @returns `true` if there are no errors, otherwise `false`.
+   */
+  success(): boolean {
+    return !this.failed()
+  }
+
+  /**
+   * Returns a pretty-printed JSON string of the errors.
+   * @returns A string representation of the errors.
+   */
+  prettyErrors(): string {
+    return JSON.stringify([...this.errors, ...this.value.errors], null, 2)
+  }
+
+  recursiveErrors(): HerbError[] {
+    return [...this.errors, ...this.value.recursiveErrors()]
+  }
+
+  /**
+   * Returns a pretty-printed string of the parse result.
+   * @returns A string representation of the parse result.
+   */
+  inspect(): string {
+    return this.value.inspect()
+  }
+
+  /**
+   * Accepts a visitor to traverse the document node.
+   * @param visitor - The visitor instance.
+   */
+  visit(visitor: Visitor): void {
+    visitor.visit(this.value)
+  }
+}

package/src/position.ts

@@ -0,0 +1,38 @@
+export type SerializedPosition = {
+  line: number
+  column: number
+}
+
+export class Position {
+  readonly line: number
+  readonly column: number
+
+  static from(position: SerializedPosition) {
+    return new Position(position.line, position.column)
+  }
+
+  constructor(line: number, column: number) {
+    this.line = line
+    this.column = column
+  }
+
+  toHash(): SerializedPosition {
+    return { line: this.line, column: this.column }
+  }
+
+  toJSON(): SerializedPosition {
+    return this.toHash()
+  }
+
+  treeInspect(): string {
+    return `(${this.line}:${this.column})`
+  }
+
+  inspect(): string {
+    return `#<Herb::Position ${this.treeInspect()}>`
+  }
+
+  toString(): string {
+    return this.inspect()
+  }
+}

package/src/range.ts

@@ -0,0 +1,35 @@
+export type SerializedRange = [number, number]
+
+export class Range {
+  readonly start: number
+  readonly end: number
+
+  static from(range: SerializedRange) {
+    return new Range(range[0], range[1])
+  }
+
+  constructor(start: number, end: number) {
+    this.start = start
+    this.end = end
+  }
+
+  toArray(): SerializedRange {
+    return [this.start, this.end]
+  }
+
+  toJSON(): SerializedRange {
+    return this.toArray()
+  }
+
+  treeInspect(): string {
+    return `[${this.start}, ${this.end}]`
+  }
+
+  inspect(): string {
+    return `#<Herb::Range ${this.toArray()}>`
+  }
+
+  toString(): string {
+    return this.inspect()
+  }
+}

package/src/result.ts

@@ -0,0 +1,26 @@
+import { HerbError } from "./error.js"
+import { HerbWarning } from "./warning.js"
+
+export class Result {
+  readonly source: string
+  readonly warnings: HerbWarning[]
+  readonly errors: HerbError[]
+
+  constructor(
+    source: string,
+    warnings: HerbWarning[] = [],
+    errors: HerbError[] = [],
+  ) {
+    this.source = source
+    this.warnings = warnings || []
+    this.errors = errors || []
+  }
+
+  success(): boolean {
+    return false
+  }
+
+  failed(): boolean {
+    return true
+  }
+}

package/src/token-list.ts

@@ -0,0 +1,57 @@
+import { Token, SerializedToken } from "./token.js"
+
+export type SerializedTokenList = SerializedToken[]
+
+export class TokenList implements Iterable<Token> {
+  private list: Token[]
+
+  static from(list: SerializedTokenList) {
+    return new TokenList(
+      list.map((token: SerializedToken) => Token.from(token)),
+    )
+  }
+
+  constructor(list: Token[]) {
+    this.list = list
+  }
+
+  get length(): number {
+    return this.list.length
+  }
+
+  [Symbol.iterator](): Iterator<Token> {
+    return this.list[Symbol.iterator]()
+  }
+
+  at(index: number): Token | undefined {
+    return this.list.at(index)
+  }
+
+  forEach(
+    callback: (token: Token, index: number, array: Token[]) => void,
+  ): void {
+    this.list.forEach(callback)
+  }
+
+  map<U>(callback: (token: Token, index: number, array: Token[]) => U): U[] {
+    return this.list.map(callback)
+  }
+
+  filter(
+    predicate: (token: Token, index: number, array: Token[]) => boolean,
+  ): Token[] {
+    return this.list.filter(predicate)
+  }
+
+  __getobj__(): Token[] {
+    return this.list
+  }
+
+  inspect(): string {
+    return this.list.map((token) => token.inspect()).join("\n") + "\n"
+  }
+
+  toString(): string {
+    return this.inspect()
+  }
+}

package/src/token.ts

@@ -0,0 +1,63 @@
+import { Range, SerializedRange } from "./range.js"
+import { Location, SerializedLocation } from "./location.js"
+
+export type SerializedToken = {
+  value: string
+  range: SerializedRange
+  location: SerializedLocation
+  type: string
+}
+
+export class Token {
+  readonly value: string
+  readonly range: Range
+  readonly location: Location
+  readonly type: string
+
+  static from(token: SerializedToken) {
+    return new Token(
+      token.value,
+      Range.from(token.range),
+      Location.from(token.location),
+      token.type,
+    )
+  }
+
+  constructor(value: string, range: Range, location: Location, type: string) {
+    this.value = value
+    this.range = range
+    this.location = location
+    this.type = type
+  }
+
+  toHash(): SerializedToken {
+    return {
+      value: this.value,
+      range: this.range?.toArray(),
+      location: this.location?.toHash(),
+      type: this.type,
+    }
+  }
+
+  toJSON(): SerializedToken {
+    return this.toHash()
+  }
+
+  treeInspect(): string {
+    return `"${this.value}" ${this.location.treeInspectWithLabel()}`
+  }
+
+  valueInspect(): string {
+    return this.type === "TOKEN_EOF"
+      ? JSON.stringify("<EOF>")
+      : JSON.stringify(this.value)
+  }
+
+  inspect(): string {
+    return `#<Herb::Token type="${this.type}" value=${this.valueInspect()} range=${this.range.treeInspect()} start=${this.location.start.treeInspect()} end=${this.location.end.treeInspect()}>`
+  }
+
+  toString(): string {
+    return this.inspect()
+  }
+}

package/src/util.ts

@@ -0,0 +1,19 @@
+export function ensureString(object: any): string {
+  if (typeof object === "string") {
+    return object
+  }
+
+  throw new TypeError("Argument must be a string")
+}
+
+export function convertToUTF8(string: string) {
+  const bytes = []
+
+  for (let i = 0; i < string.length; i++) {
+    bytes.push(string.charCodeAt(i))
+  }
+
+  const decoder = new TextDecoder("utf-8")
+
+  return decoder.decode(new Uint8Array(bytes))
+}

package/src/visitor.ts

@@ -0,0 +1,14 @@
+import { Node } from "./node.js"
+
+/**
+ * Represents a visitor that can traverse nodes.
+ */
+export class Visitor {
+  /**
+   * Visits a node and performs an action.
+   * @param node - The node to visit.
+   */
+  visit(node: Node) {
+    console.log("Node", node) // TODO: implement
+  }
+}

package/src/warning.ts

@@ -0,0 +1,20 @@
+import { Location, SerializedLocation } from "./location.js"
+
+export interface SerializedHerbWarning {
+  message: string
+  location: SerializedLocation
+}
+
+export class HerbWarning {
+  message: string
+  location: Location
+
+  static from(warning: SerializedHerbWarning) {
+    return new HerbWarning(warning.message, Location.from(warning.location))
+  }
+
+  constructor(message: string, location: Location) {
+    this.message = message
+    this.location = location
+  }
+}