@herb-tools/core 0.8.10 → 0.9.0

package/src/parse-result.ts

@@ -3,10 +3,12 @@ import { Result } from "./result.js"
 import { DocumentNode } from "./nodes.js"
 import { HerbError } from "./errors.js"
 import { HerbWarning } from "./warning.js"
+import { ParserOptions } from "./parser-options.js"
 
 import type { SerializedHerbError } from "./errors.js"
 import type { SerializedHerbWarning } from "./warning.js"
 import type { SerializedDocumentNode } from "./nodes.js"
+import type { SerializedParserOptions } from "./parser-options.js"
 
 import type { Visitor } from "./visitor.js"
 
@@ -15,6 +17,7 @@ export type SerializedParseResult = {
   source: string
   warnings: SerializedHerbWarning[]
   errors: SerializedHerbError[]
+  options: SerializedParserOptions
 }
 
 /**
@@ -25,6 +28,9 @@ export class ParseResult extends Result {
   /** The document node generated from the source code. */
   readonly value: DocumentNode
 
+  /** The parser options used during parsing. */
+  readonly options: ParserOptions
+
   /**
    * Creates a `ParseResult` instance from a serialized result.
    * @param result - The serialized parse result containing the value and source.
@@ -36,6 +42,7 @@ export class ParseResult extends Result {
       result.source,
       result.warnings.map((warning) => HerbWarning.from(warning)),
       result.errors.map((error) => HerbError.from(error)),
+      ParserOptions.from(result.options),
     )
   }
 
@@ -45,15 +52,19 @@ export class ParseResult extends Result {
    * @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.
+   * @param options - The parser options used during parsing.
    */
   constructor(
     value: DocumentNode,
     source: string,
     warnings: HerbWarning[] = [],
     errors: HerbError[] = [],
+    options: ParserOptions = new ParserOptions(),
   ) {
     super(source, warnings, errors)
     this.value = value
+    this.options = options
+    this.value.setSource(source)
   }
 
   /**

package/src/parser-options.ts

@@ -1,7 +1,61 @@
-export interface ParserOptions {
+export interface ParseOptions {
   track_whitespace?: boolean
+  analyze?: boolean
+  strict?: boolean
+  action_view_helpers?: boolean
+  prism_nodes?: boolean
+  prism_nodes_deep?: boolean
+  prism_program?: boolean
 }
 
-export const DEFAULT_PARSER_OPTIONS: ParserOptions = {
+export type SerializedParserOptions = Required<ParseOptions>
+
+export const DEFAULT_PARSER_OPTIONS: SerializedParserOptions = {
   track_whitespace: false,
+  analyze: true,
+  strict: true,
+  action_view_helpers: false,
+  prism_nodes: false,
+  prism_nodes_deep: false,
+  prism_program: false,
+}
+
+/**
+ * Represents the parser options used during parsing.
+ */
+export class ParserOptions {
+  /** Whether strict mode was enabled during parsing. */
+  readonly strict: boolean
+
+  /** Whether whitespace tracking was enabled during parsing. */
+  readonly track_whitespace: boolean
+
+  /** Whether analysis was performed during parsing. */
+  readonly analyze: boolean
+
+  /** Whether ActionView tag helper transformation was enabled during parsing. */
+  readonly action_view_helpers: boolean
+
+  /** Whether Prism node serialization was enabled during parsing. */
+  readonly prism_nodes: boolean
+
+  /** Whether deep Prism node serialization was enabled during parsing. */
+  readonly prism_nodes_deep: boolean
+
+  /** Whether the full Prism ProgramNode was serialized on the DocumentNode. */
+  readonly prism_program: boolean
+
+  static from(options: SerializedParserOptions): ParserOptions {
+    return new ParserOptions(options)
+  }
+
+  constructor(options: ParseOptions = {}) {
+    this.strict = options.strict ?? DEFAULT_PARSER_OPTIONS.strict
+    this.track_whitespace = options.track_whitespace ?? DEFAULT_PARSER_OPTIONS.track_whitespace
+    this.analyze = options.analyze ?? DEFAULT_PARSER_OPTIONS.analyze
+    this.action_view_helpers = options.action_view_helpers ?? DEFAULT_PARSER_OPTIONS.action_view_helpers
+    this.prism_nodes = options.prism_nodes ?? DEFAULT_PARSER_OPTIONS.prism_nodes
+    this.prism_nodes_deep = options.prism_nodes_deep ?? DEFAULT_PARSER_OPTIONS.prism_nodes_deep
+    this.prism_program = options.prism_program ?? DEFAULT_PARSER_OPTIONS.prism_program
+  }
 }

package/src/prism/index.ts

@@ -0,0 +1,44 @@
+import { deserialize } from "@ruby/prism/src/deserialize.js"
+import type { ParseResult as PrismParseResult } from "@ruby/prism/src/deserialize.js"
+
+export * as PrismNodes from "@ruby/prism/src/nodes.js"
+
+export { Visitor as PrismVisitor, BasicVisitor as PrismBasicVisitor } from "@ruby/prism/src/visitor.js"
+
+export type PrismNode = any
+export type PrismLocation = { startOffset: number; length: number }
+export type { PrismParseResult }
+
+export { inspectPrismNode, inspectPrismSerialized } from "./inspect.js"
+
+/**
+ * Deserialize a Prism parse result from the raw bytes produced by pm_serialize().
+ *
+ * @param bytes - The serialized bytes (from prism_serialized field on ERB nodes)
+ * @param source - The original source string that was parsed
+ * @returns The deserialized Prism ParseResult containing the AST
+ */
+export function deserializePrismParseResult(bytes: Uint8Array, source: string): PrismParseResult {
+  const sourceBytes = new TextEncoder().encode(source)
+
+  return deserialize(sourceBytes, bytes)
+}
+
+/**
+ * Deserialize a Prism node from the raw bytes produced by pm_serialize().
+ * pm_serialize() serializes a single node subtree, so the ParseResult's
+ * value is the Prism node directly (not wrapped in ProgramNode).
+ *
+ * @param bytes - The serialized bytes (from prism_serialized field on ERB nodes)
+ * @param source - The original source string that was parsed
+ * @returns The Prism node, or null if deserialization fails
+ */
+export function deserializePrismNode(bytes: Uint8Array, source: string): PrismNode | null {
+  try {
+    const result = deserializePrismParseResult(bytes, source)
+
+    return result.value ?? null
+  } catch {
+    return null
+  }
+}

package/src/prism/inspect.ts

@@ -0,0 +1,118 @@
+import { deserializePrismNode } from "./index.js"
+
+import type { PrismLocation } from "./index.js"
+import type { PrismNode } from "./index.js"
+
+function offsetToLineColumn(source: string, offset: number): string {
+  let line = 1
+  let column = 0
+
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++
+      column = 0
+    } else {
+      column++
+    }
+  }
+
+  return `${line}:${column}`
+}
+
+function formatLocation(location: PrismLocation, source: string): string {
+  const start = offsetToLineColumn(source, location.startOffset)
+  const end = offsetToLineColumn(source, location.startOffset + location.length)
+
+  return `(${start})-(${end})`
+}
+
+function isPrismNode(value: any): boolean {
+  return value && typeof value === "object" && typeof value.toJSON === "function" && value.location
+}
+
+export function inspectPrismNode(node: PrismNode, source: string, prefix: string = ""): string {
+  if (!node) return "∅\n"
+
+  const nodeName = typeof node.toJSON === "function" ? node.toJSON().type : node.constructor.name
+  let output = ""
+
+  output += `@ ${nodeName}`
+
+  if (node.location) {
+    output += ` (location: ${formatLocation(node.location, source)})`
+  }
+
+  output += "\n"
+
+  const fields = getNodeFields(node)
+
+  fields.forEach((field, index) => {
+    const isLastField = index === fields.length - 1
+    const symbol = isLastField ? "└── " : "├── "
+    const childPrefix = prefix + (isLastField ? "    " : "│   ")
+    const value = node[field]
+
+    if (value === null || value === undefined) {
+      output += `${prefix}${symbol}${field}: ∅\n`
+    } else if (typeof value === "string") {
+      output += `${prefix}${symbol}${field}: ${JSON.stringify(value)}\n`
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      output += `${prefix}${symbol}${field}: ${value}\n`
+    } else if (Array.isArray(value)) {
+      output += `${prefix}${symbol}${field}: `
+
+      if (value.length === 0) {
+        output += "[]\n"
+      } else {
+        output += `(${value.length} item${value.length === 1 ? "" : "s"})\n`
+
+        value.forEach((item: any, i: number) => {
+          const isLastItem = i === value.length - 1
+          const itemSymbol = isLastItem ? "└── " : "├── "
+          const itemPrefix = childPrefix + (isLastItem ? "    " : "│   ")
+
+          if (isPrismNode(item)) {
+            output += `${childPrefix}${itemSymbol}${inspectPrismNode(item, source, itemPrefix).trimStart()}`
+          } else {
+            output += `${childPrefix}${itemSymbol}${item}\n`
+          }
+        })
+      }
+    } else if (isPrismNode(value)) {
+      output += `${prefix}${symbol}${field}:\n`
+      output += `${childPrefix}└── ${inspectPrismNode(value, source, childPrefix + "    ").trimStart()}`
+    } else if (typeof value === "object" && value.startOffset !== undefined) {
+      output += `${prefix}${symbol}${field}: (location: ${formatLocation(value, source)})\n`
+    } else if (typeof value === "object" && "value" in value && "encoding" in value) {
+      output += `${prefix}${symbol}${field}: ${JSON.stringify(value.value)}\n`
+    } else {
+      output += `${prefix}${symbol}${field}: ${String(value)}\n`
+    }
+  })
+
+  return output
+}
+
+function getNodeFields(node: PrismNode): string[] {
+  const skip = new Set(["nodeID", "location", "flags"])
+  const fields: string[] = []
+
+  for (const key of Object.keys(node)) {
+    if (!skip.has(key)) {
+      fields.push(key)
+    }
+  }
+
+  return fields
+}
+
+export function inspectPrismSerialized(bytes: Uint8Array, source: string, prefix: string = ""): string {
+  try {
+    const node = deserializePrismNode(bytes, source)
+    if (!node) return "∅"
+
+    return "\n" + prefix + "└── " + inspectPrismNode(node, source, prefix + "    ").trimStart().trimEnd()
+  } catch {
+    return `(${bytes.length} bytes, deserialize error)`
+  }
+}

package/src/util.ts

@@ -5,15 +5,3 @@ export function ensureString(object: any): string {
 
   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

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.10/templates/javascript/packages/core/src/visitor.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/core/src/visitor.ts.erb
 
 import {
   Node,
@@ -7,11 +7,18 @@ import {
   DocumentNode,
   LiteralNode,
   HTMLOpenTagNode,
+  HTMLConditionalOpenTagNode,
   HTMLCloseTagNode,
+  HTMLOmittedCloseTagNode,
+  HTMLVirtualCloseTagNode,
   HTMLElementNode,
+  HTMLConditionalElementNode,
   HTMLAttributeValueNode,
   HTMLAttributeNameNode,
   HTMLAttributeNode,
+  RubyLiteralNode,
+  RubyHTMLAttributesSplatNode,
+  ERBOpenTagNode,
   HTMLTextNode,
   HTMLCommentNode,
   HTMLDoctypeNode,
@@ -48,11 +55,18 @@ export interface IVisitor {
   visitDocumentNode(node: DocumentNode): void
   visitLiteralNode(node: LiteralNode): void
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void
+  visitHTMLConditionalOpenTagNode(node: HTMLConditionalOpenTagNode): void
   visitHTMLCloseTagNode(node: HTMLCloseTagNode): void
+  visitHTMLOmittedCloseTagNode(node: HTMLOmittedCloseTagNode): void
+  visitHTMLVirtualCloseTagNode(node: HTMLVirtualCloseTagNode): void
   visitHTMLElementNode(node: HTMLElementNode): void
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void
   visitHTMLAttributeValueNode(node: HTMLAttributeValueNode): void
   visitHTMLAttributeNameNode(node: HTMLAttributeNameNode): void
   visitHTMLAttributeNode(node: HTMLAttributeNode): void
+  visitRubyLiteralNode(node: RubyLiteralNode): void
+  visitRubyHTMLAttributesSplatNode(node: RubyHTMLAttributesSplatNode): void
+  visitERBOpenTagNode(node: ERBOpenTagNode): void
   visitHTMLTextNode(node: HTMLTextNode): void
   visitHTMLCommentNode(node: HTMLCommentNode): void
   visitHTMLDoctypeNode(node: HTMLDoctypeNode): void
@@ -118,16 +132,36 @@ export class Visitor implements IVisitor {
     this.visitChildNodes(node)
   }
 
+  visitHTMLConditionalOpenTagNode(node: HTMLConditionalOpenTagNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
   visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
     this.visitNode(node)
     this.visitChildNodes(node)
   }
 
+  visitHTMLOmittedCloseTagNode(node: HTMLOmittedCloseTagNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLVirtualCloseTagNode(node: HTMLVirtualCloseTagNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
   visitHTMLElementNode(node: HTMLElementNode): void {
     this.visitNode(node)
     this.visitChildNodes(node)
   }
 
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
   visitHTMLAttributeValueNode(node: HTMLAttributeValueNode): void {
     this.visitNode(node)
     this.visitChildNodes(node)
@@ -143,6 +177,22 @@ export class Visitor implements IVisitor {
     this.visitChildNodes(node)
   }
 
+  visitRubyLiteralNode(node: RubyLiteralNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitRubyHTMLAttributesSplatNode(node: RubyHTMLAttributesSplatNode): void {
+    this.visitNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitERBOpenTagNode(node: ERBOpenTagNode): void {
+    this.visitNode(node)
+    this.visitERBNode(node)
+    this.visitChildNodes(node)
+  }
+
   visitHTMLTextNode(node: HTMLTextNode): void {
     this.visitNode(node)
     this.visitChildNodes(node)