@herb-tools/rewriter 0.8.10 → 0.9.0

package/dist/types/built-ins/action-view-tag-helper-to-html.d.ts

@@ -0,0 +1,8 @@
+import { ASTRewriter } from "../ast-rewriter.js";
+import type { RewriteContext } from "../context.js";
+import type { Node } from "@herb-tools/core";
+export declare class ActionViewTagHelperToHTMLRewriter extends ASTRewriter {
+    get name(): string;
+    get description(): string;
+    rewrite<T extends Node>(node: T, _context: RewriteContext): T;
+}

package/dist/types/built-ins/html-to-action-view-tag-helper.d.ts

@@ -0,0 +1,8 @@
+import { ASTRewriter } from "../ast-rewriter.js";
+import type { RewriteContext } from "../context.js";
+import type { Node } from "@herb-tools/core";
+export declare class HTMLToActionViewTagHelperRewriter extends ASTRewriter {
+    get name(): string;
+    get description(): string;
+    rewrite<T extends Node>(node: T, _context: RewriteContext): T;
+}

package/dist/types/built-ins/index.d.ts

@@ -1,5 +1,4 @@
 import type { RewriterClass } from "../type-guards.js";
-export { TailwindClassSorterRewriter } from "./tailwind-class-sorter.js";
 /**
  * All built-in rewriters available in the package
  */
@@ -12,3 +11,6 @@ export declare function getBuiltinRewriter(name: string): RewriterClass | undefi
  * Get all built-in rewriter names
  */
 export declare function getBuiltinRewriterNames(): string[];
+export { ActionViewTagHelperToHTMLRewriter } from "./action-view-tag-helper-to-html.js";
+export { HTMLToActionViewTagHelperRewriter } from "./html-to-action-view-tag-helper.js";
+export { TailwindClassSorterRewriter } from "./tailwind-class-sorter.js";

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
 export { ASTRewriter } from "./ast-rewriter.js";
+export { ActionViewTagHelperToHTMLRewriter } from "./built-ins/action-view-tag-helper-to-html.js";
+export { HTMLToActionViewTagHelperRewriter } from "./built-ins/html-to-action-view-tag-helper.js";
 export { StringRewriter } from "./string-rewriter.js";
 export { asMutable } from "./mutable.js";
 export { isASTRewriterClass, isStringRewriterClass, isRewriterClass } from "./type-guards.js";

package/dist/types/rewriter-factories.d.ts

@@ -1,4 +1,6 @@
 import { TailwindClassSorterRewriter } from "./built-ins/tailwind-class-sorter.js";
+import { ActionViewTagHelperToHTMLRewriter } from "./built-ins/action-view-tag-helper-to-html.js";
+import { HTMLToActionViewTagHelperRewriter } from "./built-ins/html-to-action-view-tag-helper.js";
 export interface TailwindClassSorterOptions {
     /**
      * Base directory for resolving Tailwind configuration
@@ -26,3 +28,5 @@ export interface TailwindClassSorterOptions {
  * @returns A configured and initialized TailwindClassSorterRewriter instance
  */
 export declare function tailwindClassSorter(options?: TailwindClassSorterOptions): Promise<TailwindClassSorterRewriter>;
+export declare function actionViewTagHelperToHTML(): ActionViewTagHelperToHTMLRewriter;
+export declare function htmlToActionViewTagHelper(): HTMLToActionViewTagHelperRewriter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/rewriter",
-  "version": "0.8.10",
+  "version": "0.9.0",
   "description": "Rewriter system for transforming HTML+ERB AST nodes and formatted strings",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -38,12 +38,12 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.8.10",
-    "@herb-tools/tailwind-class-sorter": "0.8.10",
+    "@herb-tools/core": "0.9.0",
+    "@herb-tools/tailwind-class-sorter": "0.9.0",
     "tinyglobby": "^0.2.15"
   },
   "devDependencies": {
-    "@herb-tools/printer": "0.8.10"
+    "@herb-tools/printer": "0.9.0"
   },
   "files": [
     "package.json",

package/src/built-ins/action-view-tag-helper-to-html.ts

@@ -0,0 +1,179 @@
+import { Visitor, Location, HTMLOpenTagNode, HTMLCloseTagNode, HTMLElementNode, HTMLAttributeValueNode, WhitespaceNode, ERBContentNode } from "@herb-tools/core"
+import { isHTMLAttributeNode, isERBOpenTagNode, isRubyLiteralNode, isRubyHTMLAttributesSplatNode, createSyntheticToken } from "@herb-tools/core"
+
+import { ASTRewriter } from "../ast-rewriter.js"
+import { asMutable } from "../mutable.js"
+
+import type { RewriteContext } from "../context.js"
+import type { Node } from "@herb-tools/core"
+
+function createWhitespaceNode(): WhitespaceNode {
+  return new WhitespaceNode({
+    type: "AST_WHITESPACE_NODE",
+    location: Location.zero,
+    errors: [],
+    value: createSyntheticToken(" "),
+  })
+}
+
+class ActionViewTagHelperToHTMLVisitor extends Visitor {
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (!node.element_source) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    const openTag = node.open_tag
+
+    if (!isERBOpenTagNode(openTag)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    const tagName = openTag.tag_name
+
+    if (!tagName) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    const htmlChildren: Node[] = []
+
+    for (const child of openTag.children) {
+      if (isRubyHTMLAttributesSplatNode(child)) {
+        htmlChildren.push(createWhitespaceNode())
+
+        htmlChildren.push(new ERBContentNode({
+          type: "AST_ERB_CONTENT_NODE",
+          location: Location.zero,
+          errors: [],
+          tag_opening: createSyntheticToken("<%="),
+          content: createSyntheticToken(` ${child.content} `),
+          tag_closing: createSyntheticToken("%>"),
+          parsed: false,
+          valid: true,
+          prism_node: null,
+        }))
+
+        continue
+      }
+
+      htmlChildren.push(createWhitespaceNode())
+
+      if (isHTMLAttributeNode(child)) {
+        if (child.equals && child.equals.value !== "=") {
+          asMutable(child).equals = createSyntheticToken("=")
+        }
+
+        if (child.value) {
+          this.transformAttributeValue(child.value)
+        }
+
+        htmlChildren.push(child)
+      }
+    }
+
+    const htmlOpenTag = new HTMLOpenTagNode({
+      type: "AST_HTML_OPEN_TAG_NODE",
+      location: openTag.location,
+      errors: [],
+      tag_opening: createSyntheticToken("<"),
+      tag_name: createSyntheticToken(tagName.value),
+      tag_closing: createSyntheticToken(node.is_void ? " />" : ">"),
+      children: htmlChildren,
+      is_void: node.is_void,
+    })
+
+    asMutable(node).open_tag = htmlOpenTag
+
+    if (node.is_void) {
+      asMutable(node).close_tag = null
+    } else if (node.close_tag) {
+      const htmlCloseTag = new HTMLCloseTagNode({
+        type: "AST_HTML_CLOSE_TAG_NODE",
+        location: node.close_tag.location,
+        errors: [],
+        tag_opening: createSyntheticToken("</"),
+        tag_name: createSyntheticToken(tagName.value),
+        children: [],
+        tag_closing: createSyntheticToken(">"),
+      })
+
+      asMutable(node).close_tag = htmlCloseTag
+    }
+
+    asMutable(node).element_source = "HTML"
+
+    if (node.body) {
+      asMutable(node).body = node.body.map(child => {
+        if (isRubyLiteralNode(child)) {
+          return new ERBContentNode({
+            type: "AST_ERB_CONTENT_NODE",
+            location: child.location,
+            errors: [],
+            tag_opening: createSyntheticToken("<%="),
+            content: createSyntheticToken(` ${child.content} `),
+            tag_closing: createSyntheticToken("%>"),
+            parsed: false,
+            valid: true,
+            prism_node: null
+          })
+        }
+
+        this.visit(child)
+        return child
+      })
+    }
+  }
+
+  private transformAttributeValue(value: HTMLAttributeValueNode): void {
+    const mutableValue = asMutable(value)
+    const hasRubyLiteral = value.children.some(child => isRubyLiteralNode(child))
+
+    if (hasRubyLiteral) {
+      const newChildren: Node[] = value.children.map(child => {
+        if (isRubyLiteralNode(child)) {
+          return new ERBContentNode({
+            type: "AST_ERB_CONTENT_NODE",
+            location: child.location,
+            errors: [],
+            tag_opening: createSyntheticToken("<%="),
+            content: createSyntheticToken(` ${child.content} `),
+            tag_closing: createSyntheticToken("%>"),
+            parsed: false,
+            valid: true,
+            prism_node: null,
+          })
+        }
+
+        return child
+      })
+
+      mutableValue.children = newChildren
+
+      if (!value.quoted) {
+        mutableValue.quoted = true
+        mutableValue.open_quote = createSyntheticToken('"')
+        mutableValue.close_quote = createSyntheticToken('"')
+      }
+    }
+  }
+}
+
+export class ActionViewTagHelperToHTMLRewriter extends ASTRewriter {
+  get name(): string {
+    return "action-view-tag-helper-to-html"
+  }
+
+  get description(): string {
+    return "Converts ActionView tag helpers (tag.*, content_tag, link_to, turbo_frame_tag) to raw HTML elements"
+  }
+
+  rewrite<T extends Node>(node: T, _context: RewriteContext): T {
+    const visitor = new ActionViewTagHelperToHTMLVisitor()
+
+    visitor.visit(node)
+
+    return node
+  }
+}

package/src/built-ins/html-to-action-view-tag-helper.ts

@@ -0,0 +1,268 @@
+import { Visitor, Location, ERBOpenTagNode, ERBEndNode, HTMLElementNode, HTMLVirtualCloseTagNode, createSyntheticToken } from "@herb-tools/core"
+import { getStaticAttributeName, isLiteralNode, isHTMLOpenTagNode, isHTMLTextNode, isHTMLAttributeNode, isERBContentNode, isWhitespaceNode } from "@herb-tools/core"
+
+import { ASTRewriter } from "../ast-rewriter.js"
+import { asMutable } from "../mutable.js"
+
+import type { RewriteContext } from "../context.js"
+import type { Node, HTMLAttributeValueNode } from "@herb-tools/core"
+
+function serializeAttributeValue(value: HTMLAttributeValueNode): string {
+  const hasERB = value.children.some(child => isERBContentNode(child))
+
+  if (hasERB && value.children.length === 1 && isERBContentNode(value.children[0])) {
+    return value.children[0].content?.value?.trim() ?? '""'
+  }
+
+  const parts: string[] = []
+
+  for (const child of value.children) {
+    if (isLiteralNode(child)) {
+      parts.push(child.content)
+    } else if (isERBContentNode(child)) {
+      parts.push(`#{${child.content?.value?.trim() ?? ""}}`)
+    }
+  }
+
+  return `"${parts.join("")}"`
+}
+
+function dashToUnderscore(string: string): string {
+  return string.replace(/-/g, "_")
+}
+
+interface SerializedAttributes {
+  attributes: string
+  href: string | null
+  id: string | null
+}
+
+function serializeAttributes(children: Node[], options: { extractHref?: boolean, extractId?: boolean } = {}): SerializedAttributes {
+  const regular: string[] = []
+  const prefixed: Map<string, string[]> = new Map()
+
+  let href: string | null = null
+  let id: string | null = null
+
+  for (const child of children) {
+    if (!isHTMLAttributeNode(child)) continue
+
+    const name = getStaticAttributeName(child.name!)
+    if (!name) continue
+
+    const value = child.value ? serializeAttributeValue(child.value) : "true"
+
+    if (options.extractHref && name === "href") {
+      href = value
+      continue
+    }
+
+    if (options.extractId && name === "id") {
+      id = value
+      continue
+    }
+
+    const dataMatch = name.match(/^(data|aria)-(.+)$/)
+
+    if (dataMatch) {
+      const [, prefix, rest] = dataMatch
+
+      if (!prefixed.has(prefix)) {
+        prefixed.set(prefix, [])
+      }
+
+      prefixed.get(prefix)!.push(`${dashToUnderscore(rest)}: ${value}`)
+    } else {
+      regular.push(`${name}: ${value}`)
+    }
+  }
+
+  const parts = [...regular]
+
+  for (const [prefix, entries] of prefixed) {
+    parts.push(`${prefix}: { ${entries.join(", ")} }`)
+  }
+
+  return { attributes: parts.join(", "), href, id }
+}
+
+function isTextOnlyBody(body: Node[]): boolean {
+  if (body.length !== 1 || !isHTMLTextNode(body[0])) return false
+
+  return !body[0].content.includes("\n")
+}
+
+class HTMLToActionViewTagHelperVisitor extends Visitor {
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const openTag = node.open_tag
+
+    if (!isHTMLOpenTagNode(openTag)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    const tagName = openTag.tag_name
+
+    if (!tagName) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    if (node.body) {
+      for (const child of node.body) {
+        this.visit(child)
+      }
+    }
+
+    const isAnchor = tagName.value === "a"
+    const isTurboFrame = tagName.value === "turbo-frame"
+    const attributes = openTag.children.filter(child => !isWhitespaceNode(child))
+    const { attributes: attributesString, href, id } = serializeAttributes(attributes, { extractHref: isAnchor, extractId: isTurboFrame })
+    const hasBody = node.body && node.body.length > 0 && !node.is_void
+    const isInlineContent = hasBody && isTextOnlyBody(node.body)
+
+    let content: string
+    let elementSource: string
+
+    if (isAnchor) {
+      content = this.buildLinkToContent(node, attributesString, href, isInlineContent)
+      elementSource = "ActionView::Helpers::UrlHelper#link_to"
+    } else if (isTurboFrame) {
+      content = this.buildTurboFrameTagContent(node, attributesString, id, isInlineContent)
+      elementSource = "Turbo::FramesHelper#turbo_frame_tag"
+    } else {
+      content = this.buildTagContent(tagName.value, node, attributesString, isInlineContent)
+      elementSource = "ActionView::Helpers::TagHelper#tag"
+    }
+
+    const erbOpenTag = new ERBOpenTagNode({
+      type: "AST_ERB_OPEN_TAG_NODE",
+      location: openTag.location,
+      errors: [],
+      tag_opening: createSyntheticToken("<%="),
+      content: createSyntheticToken(content),
+      tag_closing: createSyntheticToken("%>"),
+      tag_name: createSyntheticToken(tagName.value),
+      children: [],
+    })
+
+    asMutable(node).open_tag = erbOpenTag
+    asMutable(node).element_source = elementSource
+
+    const isInlineForm = isInlineContent || (isTurboFrame && !hasBody)
+
+    if (node.is_void) {
+      asMutable(node).close_tag = null
+    } else if (isInlineForm) {
+      asMutable(node).body = []
+
+      const virtualClose = new HTMLVirtualCloseTagNode({
+        type: "AST_HTML_VIRTUAL_CLOSE_TAG_NODE",
+        location: Location.zero,
+        errors: [],
+        tag_name: createSyntheticToken(tagName.value),
+      })
+
+      asMutable(node).close_tag = virtualClose
+    } else if (node.close_tag) {
+      const erbEnd = new ERBEndNode({
+        type: "AST_ERB_END_NODE",
+        location: node.close_tag.location,
+        errors: [],
+        tag_opening: createSyntheticToken("<%"),
+        content: createSyntheticToken(" end "),
+        tag_closing: createSyntheticToken("%>"),
+      })
+
+      asMutable(node).close_tag = erbEnd
+    }
+  }
+
+  private buildTagContent(tag: string, node: HTMLElementNode, attributes: string, isInlineContent: boolean): string {
+    const methodName = dashToUnderscore(tag)
+
+    if (node.is_void) {
+      return attributes
+        ? ` tag.${methodName} ${attributes} `
+        : ` tag.${methodName} `
+    }
+
+    if (isInlineContent && isHTMLTextNode(node.body[0])) {
+      const textContent = node.body[0].content
+
+      return attributes
+        ? ` tag.${methodName} "${textContent}", ${attributes} `
+        : ` tag.${methodName} "${textContent}" `
+    }
+
+    return attributes
+      ? ` tag.${methodName} ${attributes} do `
+      : ` tag.${methodName} do `
+  }
+
+  private buildTurboFrameTagContent(node: HTMLElementNode, attributes: string, id: string | null, isInlineContent: boolean): string {
+    const args: string[] = []
+
+    if (id) {
+      args.push(id)
+    }
+
+    if (isInlineContent && isHTMLTextNode(node.body[0])) {
+      args.push(`"${node.body[0].content}"`)
+    }
+
+    if (attributes) {
+      args.push(attributes)
+    }
+
+    const argString = args.join(", ")
+
+    if (isInlineContent || !node.body || node.body.length === 0) {
+      return argString ? ` turbo_frame_tag ${argString} ` : ` turbo_frame_tag `
+    }
+
+    return argString ? ` turbo_frame_tag ${argString} do ` : ` turbo_frame_tag do `
+  }
+
+  private buildLinkToContent(node: HTMLElementNode, attribute: string, href: string | null, isInlineContent: boolean): string {
+    const args: string[] = []
+
+    if (isInlineContent && isHTMLTextNode(node.body[0])) {
+      args.push(`"${node.body[0].content}"`)
+    }
+
+    if (href) {
+      args.push(href)
+    }
+
+    if (attribute) {
+      args.push(attribute)
+    }
+
+    const argString = args.join(", ")
+
+    if (isInlineContent) {
+      return argString ? ` link_to ${argString} ` : ` link_to `
+    }
+
+    return argString ? ` link_to ${argString} do ` : ` link_to do `
+  }
+}
+
+export class HTMLToActionViewTagHelperRewriter extends ASTRewriter {
+  get name(): string {
+    return "html-to-action-view-tag-helper"
+  }
+
+  get description(): string {
+    return "Converts raw HTML elements to ActionView tag helpers (tag.*, turbo_frame_tag)"
+  }
+
+  rewrite<T extends Node>(node: T, _context: RewriteContext): T {
+    const visitor = new HTMLToActionViewTagHelperVisitor()
+
+    visitor.visit(node)
+
+    return node
+  }
+}

package/src/built-ins/index.ts

@@ -1,12 +1,15 @@
-import type { RewriterClass } from "../type-guards.js"
-
-export { TailwindClassSorterRewriter } from "./tailwind-class-sorter.js"
+import { ActionViewTagHelperToHTMLRewriter } from "./action-view-tag-helper-to-html.js"
+import { HTMLToActionViewTagHelperRewriter } from "./html-to-action-view-tag-helper.js"
 import { TailwindClassSorterRewriter } from "./tailwind-class-sorter.js"
 
+import type { RewriterClass } from "../type-guards.js"
+
 /**
  * All built-in rewriters available in the package
  */
 export const builtinRewriters: RewriterClass[] = [
+  ActionViewTagHelperToHTMLRewriter,
+  HTMLToActionViewTagHelperRewriter,
   TailwindClassSorterRewriter
 ]
 
@@ -31,3 +34,7 @@ export function getBuiltinRewriterNames(): string[] {
     return instance.name
   })
 }
+
+export { ActionViewTagHelperToHTMLRewriter } from "./action-view-tag-helper-to-html.js"
+export { HTMLToActionViewTagHelperRewriter } from "./html-to-action-view-tag-helper.js"
+export { TailwindClassSorterRewriter } from "./tailwind-class-sorter.js"