@herb-tools/core 0.5.0 → 0.6.0

package/src/ast-utils.ts

@@ -0,0 +1,191 @@
+import {
+  LiteralNode,
+  ERBIfNode,
+  ERBUnlessNode,
+  ERBBlockNode,
+  ERBCaseNode,
+  ERBCaseMatchNode,
+  ERBWhileNode,
+  ERBForNode,
+  ERBBeginNode,
+  HTMLElementNode,
+  HTMLOpenTagNode,
+  HTMLCloseTagNode,
+  HTMLCommentNode
+} from "./nodes.js"
+
+import {
+  isNode,
+  isAnyOf,
+  isLiteralNode,
+  isERBNode,
+  isERBContentNode,
+  areAllOfType,
+  filterLiteralNodes
+} from "./node-type-guards.js"
+
+import { Node, ERBContentNode, HTMLAttributeNameNode } from "./nodes.js"
+
+/**
+ * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
+ */
+export function isERBOutputNode(node: Node): node is ERBContentNode {
+  return isNode(node, ERBContentNode) && ["<%=", "<%=="].includes((node as ERBContentNode).tag_opening?.value!)
+}
+
+/**
+ * Checks if a node is a non-output ERB node (control flow: <% %>)
+ */
+export function isERBControlFlowNode(node: Node): node is ERBContentNode {
+  return isAnyOf(node, ERBIfNode, ERBUnlessNode, ERBBlockNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBForNode, ERBBeginNode)
+}
+
+/**
+ * Checks if an array of nodes contains any ERB content nodes
+ */
+export function hasERBContent(nodes: Node[]): boolean {
+  return nodes.some(isERBContentNode)
+}
+
+/**
+ * Checks if an array of nodes contains any ERB output nodes (dynamic content)
+ */
+export function hasERBOutput(nodes: Node[]): boolean {
+  return nodes.some(isERBOutputNode)
+}
+
+
+/**
+ * Extracts a static string from an array of literal nodes
+ * Returns null if any node is not a literal node
+ */
+export function getStaticStringFromNodes(nodes: Node[]): string | null {
+  if (!areAllOfType(nodes, LiteralNode)) {
+    return null
+  }
+
+  return nodes.map(node => node.content).join("")
+}
+
+/**
+ * Extracts static content from nodes, including mixed literal/ERB content
+ * Returns the concatenated literal content, or null if no literal nodes exist
+ */
+export function getStaticContentFromNodes(nodes: Node[]): string | null {
+  const literalNodes = filterLiteralNodes(nodes)
+
+  if (literalNodes.length === 0) {
+    return null
+  }
+
+  return literalNodes.map(node => node.content).join("")
+}
+
+/**
+ * Checks if nodes contain any literal content (for static validation)
+ */
+export function hasStaticContent(nodes: Node[]): boolean {
+  return nodes.some(isLiteralNode)
+}
+
+/**
+ * Checks if nodes are effectively static (only literals and non-output ERB)
+ * Non-output ERB like <% if %> doesn't affect static validation
+ */
+export function isEffectivelyStatic(nodes: Node[]): boolean {
+  return !hasERBOutput(nodes)
+}
+
+/**
+ * Gets static-validatable content from nodes (ignores control ERB, includes literals)
+ * Returns concatenated literal content for validation, or null if contains output ERB
+ */
+export function getValidatableStaticContent(nodes: Node[]): string | null {
+  if (hasERBOutput(nodes)) {
+    return null
+  }
+
+  return filterLiteralNodes(nodes).map(node => node.content).join("")
+}
+
+/**
+ * Extracts a combined string from nodes, including ERB content
+ * For ERB nodes, includes the full tag syntax (e.g., "<%= foo %>")
+ * This is useful for debugging or displaying the full attribute name
+ */
+export function getCombinedStringFromNodes(nodes: Node[]): string {
+  return nodes.map(node => {
+    if (isLiteralNode(node)) {
+      return node.content
+    } else if (isERBContentNode(node)) {
+      const opening = node.tag_opening?.value || ""
+      const content = node.content?.value || ""
+      const closing = node.tag_closing?.value || ""
+
+      return `${opening}${content}${closing}`
+    } else {
+      // For other node types, return a placeholder or empty string
+      return `[${node.type}]`
+    }
+  }).join("")
+}
+
+/**
+ * Checks if an HTML attribute name node has a static (literal-only) name
+ */
+export function hasStaticAttributeName(attributeNameNode: HTMLAttributeNameNode): boolean {
+  if (!attributeNameNode.children) {
+    return false
+  }
+
+  return areAllOfType(attributeNameNode.children, LiteralNode)
+}
+
+/**
+ * Checks if an HTML attribute name node has dynamic content (contains ERB)
+ */
+export function hasDynamicAttributeName(attributeNameNode: HTMLAttributeNameNode): boolean {
+  if (!attributeNameNode.children) {
+    return false
+  }
+
+  return hasERBContent(attributeNameNode.children)
+}
+
+/**
+ * Gets the static string value of an HTML attribute name node
+ * Returns null if the attribute name contains dynamic content (ERB)
+ */
+export function getStaticAttributeName(attributeNameNode: HTMLAttributeNameNode): string | null {
+  if (!attributeNameNode.children) {
+    return null
+  }
+
+  return getStaticStringFromNodes(attributeNameNode.children)
+}
+
+/**
+ * Gets the combined string representation of an HTML attribute name node
+ * This includes both static and dynamic content, useful for debugging
+ */
+export function getCombinedAttributeName(attributeNameNode: HTMLAttributeNameNode): string {
+  if (!attributeNameNode.children) {
+    return ""
+  }
+
+  return getCombinedStringFromNodes(attributeNameNode.children)
+}
+
+/**
+ * Gets the tag name of an HTML element node
+ */
+export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): string {
+  return node.tag_name?.value ?? ""
+}
+
+/**
+ * Check if a node is a comment (HTML comment or ERB comment)
+ */
+export function isCommentNode(node: Node): boolean {
+  return isNode(node, HTMLCommentNode) || (isERBNode(node) && !isERBControlFlowNode(node))
+}

package/src/backend.ts

@@ -1,11 +1,12 @@
 import type { SerializedParseResult } from "./parse-result.js"
 import type { SerializedLexResult } from "./lex-result.js"
+import type { ParserOptions } from "./parser-options.js"
 
 interface LibHerbBackendFunctions {
   lex: (source: string) => SerializedLexResult
   lexFile: (path: string) => SerializedLexResult
 
-  parse: (source: string) => SerializedParseResult
+  parse: (source: string, options?: ParserOptions) => SerializedParseResult
   parseFile: (path: string) => SerializedParseResult
 
   extractRuby: (source: string) => string

package/src/errors.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.5.0/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/errors.ts.erb
 
 import { Location, SerializedLocation } from "./location.js"
 import { Token, SerializedToken } from "./token.js"

package/src/herb-backend.ts

@@ -3,8 +3,10 @@ import packageJSON from "../package.json" with { type: "json" }
 import { ensureString } from "./util.js"
 import { LexResult } from "./lex-result.js"
 import { ParseResult } from "./parse-result.js"
+import { DEFAULT_PARSER_OPTIONS } from "./parser-options.js"
 
 import type { LibHerbBackend, BackendPromise } from "./backend.js"
+import type { ParserOptions } from "./parser-options.js"
 
 /**
  * The main Herb parser interface, providing methods to lex and parse input.
@@ -64,13 +66,16 @@ export abstract class HerbBackend {
   /**
    * Parses the given source string into a `ParseResult`.
    * @param source - The source code to parse.
+   * @param options - Optional parsing options.
    * @returns A `ParseResult` instance.
    * @throws Error if the backend is not loaded.
    */
-  parse(source: string): ParseResult {
+  parse(source: string, options?: ParserOptions): ParseResult {
     this.ensureBackend()
 
-    return ParseResult.from(this.backend.parse(ensureString(source)))
+    const mergedOptions = { ...DEFAULT_PARSER_OPTIONS, ...options }
+
+    return ParseResult.from(this.backend.parse(ensureString(source), mergedOptions))
   }
 
   /**

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./ast-utils.js"
 export * from "./backend.js"
 export * from "./diagnostic.js"
 export * from "./errors.js"
@@ -5,7 +6,9 @@ export * from "./herb-backend.js"
 export * from "./lex-result.js"
 export * from "./location.js"
 export * from "./nodes.js"
+export * from "./node-type-guards.js"
 export * from "./parse-result.js"
+export * from "./parser-options.js"
 export * from "./position.js"
 export * from "./range.js"
 export * from "./result.js"