Add Rubymine to list of Editors Herb Dev Tools (Add Rubymine to list of Editors Herb Dev Tools marcoroth/herb#538)
Add Rubymine to the list

inspired by

https://github.com/igorkasyanchuk/editor_opener/blob/31b09cf4f62c1b84b10e111c91ce3ce3ff450a60/lib/editor_opener/action_dispatch/trace_to_file_extractor.rb#L13

& https://github.com/marcoroth/herb/pull/486/files

Signed-off-by: Tomas Valent tomas.valent@gmail.com

Linter: Implement erb-comment-syntax linter rule (Linter: Implement erb-comment-syntax linter rule marcoroth/herb#528)
Closes: Linter Rule: CommentSyntax (ERBLint rule port) marcoroth/herb#527
Advances: erb_lint compatibility/parity marcoroth/herb#537

This PR adds the rule erb-comment-syntax. It is the same rule
implemented in
CommentSyntax
of ERB Lint.

The rule itself avoid parsing errors in the action_view erb default
parsing implementation.

Also the porting of ERB Lint rules to herb rules facilitates the
adoption of Herb as a ERB Lint replacement.

Co-authored-by: Marco Roth marco.roth@intergga.ch

C: Implement more efficient buffer resizing (C: Implement more efficient buffer resizing marcoroth/herb#539)

Problem

If the buffer is nearly full even one extra character can trigger an
expansion of the buffer. Since the buffer only grows by twice the number
of required characters per resize, in this case 2 characters, the buffer
has to be constantly resized.

Visualization

How the problem is addressed

Rather than just checking the required length, we test whether doubling
the current capacity will be enough. If it is, we expand to the doubled
capacity. If not, we double the required length itself and resize the
buffer to that size.

Performance impact

Lexing a real world html page

Before: ~88.255ms

After: ~79.208ms

Parsing showed no significant performance impact though

Parser: Fix parsing boolean attributes with track_whitespace (Parser: Fix parsing boolean attributes with track_whitespace marcoroth/herb#560)

Linter: Add test case for trailing boolean attribute in HTML element (Linter: Add test case for trailing boolean attribute in HTML element marcoroth/herb#485)
Sharing my investigation so far - I was able to reproduce the issue
reported in Linter: Unexpected token with boolean attribute + erb marcoroth/herb#471. The core parser appears to be working correctly, but
the linter errors with an unexpected token error.

Linter: fix rule generator template (Linter: fix rule generator template marcoroth/herb#563)
Fix the template for implementing new rules.

Lexer: Support lexing and parsing =%> ERB closing tag (Lexer: Support lexing and parsing =%> ERB closing tag marcoroth/herb#568)
This pull request adds support to be able to lex and parse the =%> ERB
closing tag. Since it's use is quite unknown and not well-defined we
should be able to parse is, so we can guide and advice people in the
linter to now use it, i.e using the Right Trim rule introduced in Linter: Implement erb-right-trim linter rule marcoroth/herb#556.

Co-Authored-By: Domingo Edwards dedwards@buk.cl

Linter: Implement erb-right-trim linter rule (Linter: Implement erb-right-trim linter rule marcoroth/herb#556)
Solves erb-lint: RightTrim marcoroth/herb#551

Implements the RightTrim rule from
erb-lint.

Add visitNode and visitERBNode methods to improve erb-right-trim (Add visitNode and visitERBNode methods to improve erb-right-trim marcoroth/herb#569)
This pull request introduces two new methods visitNode(node: Node) and
visitERBNode(node: ERBNode) in the JavaScript visitor that allows to
visit any node, or visit any ERB node. This is useful and allows us to
improve the erb-right-trim introduced in Linter: Implement erb-right-trim linter rule marcoroth/herb#556.

This now updates the erb-right-trim to also handle cases where the
right trimming is used when it has no effect (like on non-outputting ERB
Nodes like <%).

/cc @domingo2000

Linter Rule: Refactor erb-require-whitespace-inside-tags to use visitERBNode (Linter Rule: Refactor erb-require-whitespace-inside-tags to use visitERBNode marcoroth/herb#570)
This pull request updates the erb-require-whitespace-inside-tags
linter rule to use the new visitERBNode method in the visitor
introduced in Add visitNode and visitERBNode methods to improve erb-right-trim marcoroth/herb#569.

docs: Add References section to erb-comment-syntax linter rule
Signed-off-by: Marco Roth marco.roth@intergga.ch

C: Localize token struct members (C: Localize token struct members marcoroth/herb#529)

What it does

This PR removes the need for heap allocating the struct members of a
token (position, range, location)

How it does it

• Change the token_T members range and location to be structs,
  instead of pointers to structs
• Change location_T members start and end to be structs, instead
  of pointers to structs
• Removes functions only used to access struct members, as they were not
  consistently used anyway
• Removes init functions that do not add anything beyond providing a 1-1
  mapping of argument to struct members
• Removes copy methods as we are passing the structs by value
• Use 32bit unsigned integers for range/position/location struct
  members, effectively limiting the parseable filesize to 2^32-1 bytes
  (4gb) which for all intents and purposes (templates after all) should
  more than suffice. Saves a bit of memory without any real world
  drawbacks.

Linter: Fix --version flag for CLI (Linter: Fix --version flag for CLI marcoroth/herb#488)
Closes Linter: Running Linter CLI with --version crashes marcoroth/herb#437

Co-authored-by: Marco Roth marco.roth@intergga.ch

Formatter: Print Experimental Preview warning on stderr (Formatter: Print Experimental Preview warning on stderr marcoroth/herb#575)
This pull request updates the formatter CLI to print the ⚠️ Experimental Preview ... warning on stderr instead of stdout to
other tools can programmatically use the formatter output.

Resolves Formatter: Need a way to ignore the warnings or surpress it marcoroth/herb#574

Engine: Support Ruby Block Comments when compiling templates (Engine: Support Ruby Block Comments when compiling templates marcoroth/herb#576)
This pull request updates the Engine to detect and support the
compilation of Ruby Block
Comments
in HTML+ERB templates.

The following templates can now be compiled and evaluated:

<%
=begin %>
  This, while unusual, is a legal form of commenting.
<%
=end %>
<div>Hey there</div>

Resolves Engine: Block comments cause exceptions marcoroth/herb#562

Parser: Fix analysis of nested case/when and case/in parsing (Parser: Fix analysis of nested case/when and case/in parsing marcoroth/herb#578)
This pull request updates the parser to fix the analysis of nested
control flow structures within case/when and case/in statements.

The following kind templates now have the properly nested structure:

<% case 1 %>
<% when 1 %>
  <%= content_tag(:p) do %>
    Yep
  <% end %>
<% end %>

Resolves Parser: Case-statements containing do-end blocks cause exceptions marcoroth/herb#540

Parser: Analyze case statements with yield as ERBCaseNode (Parser: Analyze case statements with yield as ERBCaseNode marcoroth/herb#577)
This pull request updates the parser to analyze yield inside case
nodes as ERBCaseNode instead of ERBYieldNode.

The following templates:

<% case yield(:a) %>
<% when 'a' %>
  aaa
<% end %>

Gets now parsed as:

@ DocumentNode (location: (1:0)-(5:0))
└── children: (2 items)
    ├── @ ERBCaseNode (location: (1:0)-(4:9))
    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
    │   ├── tag_closing: "%>" (location: (1:18)-(1:20))
    │   ├── children: (1 item)
    │   │   └── @ HTMLTextNode (location: (1:20)-(2:0))
    │   │       └── content: "\n"
    │   │
    │   ├── conditions: (1 item)
    │   │   └── @ ERBWhenNode (location: (2:0)-(2:14))
    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
    │   │       ├── content: " when 'a' " (location: (2:2)-(2:12))
    │   │       ├── tag_closing: "%>" (location: (2:12)-(2:14))
    │   │       └── statements: (1 item)
    │   │           └── @ HTMLTextNode (location: (2:14)-(4:0))
    │   │               └── content: "\n  aaa\n"
    │   │
    │   │
    │   ├── else_clause: ∅
    │   └── end_node:
    │       └── @ ERBEndNode (location: (4:0)-(4:9))
    │           ├── tag_opening: "<%" (location: (4:0)-(4:2))
    │           ├── content: " end " (location: (4:2)-(4:7))
    │           └── tag_closing: "%>" (location: (4:7)-(4:9))
    │
    │
    └── @ HTMLTextNode (location: (4:9)-(5:0))
        └── content: "\n"

Previously it was parsed as:

@ DocumentNode (location: (1:0)-(5:0))
└── children: (6 items)
    ├── @ ERBYieldNode (location: (1:0)-(1:20))
    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
    │   └── tag_closing: "%>" (location: (1:18)-(1:20))
    │
    ├── @ HTMLTextNode (location: (1:20)-(2:0))
    │   └── content: "\n"
    │
    ├── @ ERBContentNode (location: (2:0)-(2:14))
    │   ├── tag_opening: "<%" (location: (2:0)-(2:2))
    │   ├── content: " when 'a' " (location: (2:2)-(2:12))
    │   ├── tag_closing: "%>" (location: (2:12)-(2:14))
    │   ├── parsed: true
    │   └── valid: false
    │
    ├── @ HTMLTextNode (location: (2:14)-(4:0))
    │   └── content: "\n  aaa\n"
    │
    ├── @ ERBContentNode (location: (4:0)-(4:9))
    │   ├── tag_opening: "<%" (location: (4:0)-(4:2))
    │   ├── content: " end " (location: (4:2)-(4:7))
    │   ├── tag_closing: "%>" (location: (4:7)-(4:9))
    │   ├── parsed: true
    │   └── valid: false
    │
    └── @ HTMLTextNode (location: (4:9)-(5:0))
        └── content: "\n"

Resolves Engine/Parser: Using yield inside a case statement raises ActionView::SyntaxErrorInTemplate marcoroth/herb#561

v0.7.5

Update bin/setup script

Add bin/publish_packages script

C: Also call analyze in C-CLI parse command (C: Also call analyze in C-CLI parse command marcoroth/herb#584)
This pull request updates the C-CLI to also call
herb_analyze_parse_tree in the parse command, so that the
ERBContentNodes also get analyzed in a HTML+ERB document.

AS discussed in
Parser: Introduce a new ERBEachBlockNode in the parser analysis step marcoroth/herb#406 (comment)

C: Favor explicit buffer capacity over default capacity (C: Favor explicit buffer capacity over default capacity marcoroth/herb#585)
This pull request is an alternative to C: Bump default buffer size to 4096 marcoroth/herb#579 and reworks the buffer to
not have a default capacity anymore, but instead, let the caller decide
how big the initial buffer capacity should be.

This also allows callers to request enough capacity upfront if they know
the approximate or exact buffer buffer length, which then doesn't need
any buffer capacity expansions at a later point, thus removing the need
to reallocate.

Closes C: Bump default buffer size to 4096 marcoroth/herb#579

C: Remove JSON Serialize Implementation (C: Remove JSON Serialize Implementation marcoroth/herb#586)
This pull request removes the JSON Serialize Implementation that we
haven't really made use of, so we are going to remove it for now.

If we end up needing it again, we can reference back to this pull
request and add the implementation back as it should be somewhat
straightforward to bring back.

Linter: Add test helpers to simplify linter rule tests (Linter: Add test helpers to simplify linter rule tests marcoroth/herb#587)
This pull request implements linter test helpers to reduce the verbosity
in the linter rule tests. The new createLinterTest() helper provides a
cleaner API with expectError(), expectWarning(),
expectNoOffenses(), and assertOffenses() functions.

Example:

import { SomeRule } from "../../src/rules/some-rule.js"
import { createLinterTest } from "../helpers/linter-test-helper.js"

const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(SomeRule)

describe("SomeRule", () => {
  test("no offenses", () => {
    expectNoOffenses(`<div></div>`)
  })

  test("with offenses", () => {
    expectError("Error message.")
    expectWarning("Warning message.")

    assertOffenses(`<div></div>`)
  })
})

Resolves Linter: Introduce linter test helper that make the linter tests less verbose marcoroth/herb#461

C: Split lexer/parser alloc and init into separate steps (C: Split lexer/parser alloc and init into separate steps marcoroth/herb#513)
This PR changes the way lexers and parsers are initialized.

Instead of making an allocation for the lexer/parser inside the init
function of the respective system, it allows the caller of the init
function to decide whether the lexer/parser data is going to live on the
stack or heap.

The lexer/parser lifetimes are limited to the scope of a single function
making it possible to use a stack variable.

Engine: Fix compiling case/in nodes in HTML+ERB templates (Engine: Fix compiling case/in nodes in HTML+ERB templates marcoroth/herb#596)
This pull request fixes a bug in the Herb Engine that wouldn't allow
compiling case/in nodes in HTML+ERB templates.

It's now possible to compile and render the following template:

<% case {} %>
<% in {} %>
  "matched"
<% else %>
  "not matched"
<% end %>

Resolves Engine: SyntaxError when using case/in pattern matching in Herb templates marcoroth/herb#594

Formatter: Fix punctuation splitting and content duplication issues (Formatter: Fix punctuation splitting and content duplication issues marcoroth/herb#591)
This pull request fixes a bug in the Formatter where it was incorrectly
inserting whitespace between ERB interpolations/inline elements and
adjacent punctuation.

This pull request also fixes a bug in the Formatter which was
duplicating content when formatting inline elements with long text
content.

Resolves Formatter: Duplicating content multiple times marcoroth/herb#436
Resolves Formatter: inserts whitespace around interpolations and elements marcoroth/herb#469
Resolves Formatter: duplicated lines in multilines context marcoroth/herb#564
Resolves Formatter keeps adding new text and <br> tag recursively marcoroth/herb#588
Resolves Formatter: bug where some content is duplicated marcoroth/herb#590

Formatter: Extract and refactor Format Helper Functions and Constants (Formatter: Extract and refactor Format Helper Functions and Constants marcoroth/herb#597)
This pull request reactors the FormatPrinter by extracting the
independent format helper functions to the format-helpers.ts file.

Follow up on Formatter: Fix punctuation splitting and content duplication issues marcoroth/herb#591.

Linter: Implement erb-no-case-node-children linter rule (Linter: Implement erb-no-case-node-children linter rule marcoroth/herb#598)
This pull request introduces the erb-no-case-node-children linter rule
which disallows having meaningful content between the <% case %> and
the first <% when ... %> or <% in ... %> condition.

For example, it would flag this:

<% case variable %>
  This content is outside of any when/else block!
<% when "a" %>
  A
<% when "b" %>
  B
<% end %>

Resolves Linter Rule: Don't use children for case/when and case/in nodes marcoroth/herb#595

Linter: Fix crash in html-no-underscores-in-attribute-names rule (Linter: Fix crash in html-no-underscores-in-attribute-names rule marcoroth/herb#602)
Resolves Herb linter throws js error (crash) on invalid syntax on HTMLNoUnderscoresInAttributeNamesVisitor. marcoroth/herb#601

Add stimulus-lint to .envrc

Bump Prism to v1.5.2 (Bump Prism to v1.5.2 marcoroth/herb#603)
This pull request updates Prism to
v1.5.2.

C: Remove unused html_util functions (C: Remove unused html_util functions marcoroth/herb#607)
This PR removes html_util functions that aren't used anymore.

• is_html4_void_element
• html_opening_tag_string

C: Remove unused functions from util.c (C: Remove unused functions from util.c marcoroth/herb#606)
This removes functions from util.c that aren't used in the codebase
anymore.

• is_whitespace
• count_in_string
• count_newlines
• replace_char
• string_blank
• string_present

Ruby: NTFS compliant snapshot filenames (Ruby: NTFS compliant snapshot filenames marcoroth/herb#610)
This PR changes the filenames of the snapshots used for testing to allow
checking out this project on NTFS filesystems.

RuboCop

C: Remove memory.c implementation in preparation for arena allocator (C: Remove memory.c implementation in preparation for arena allocator marcoroth/herb#611)
This PR removes the safe_malloc, safe_realloc,
nullable_safe_malloc usages from the code base and removes the
accompanying memory header/source files.

It replaces those usages with normal malloc/realloc function calls.

This is done as part of the move to an arena based memory allocation
strategy.

Formatter: Better respect and deal with whitespace and adjacent text (Formatter: Better respect and deal with whitespace and adjacent text marcoroth/herb#612)
This pull request improves the way the formatter deals with whitespace
and formatting adjacent text next to HTML element and ERB tags.

Follow up on Formatter: Fix punctuation splitting and content duplication issues marcoroth/herb#591
Partially addresses Formatter: Whitespace inserted and removed in various situations marcoroth/herb#609.

Linter: Don't lint files with parser errors (Linter: Don't lint files with parser errors marcoroth/herb#614)
This pull request updates the linter to not lint files with syntax
errors. This is to avoid false positives that might occur when trying to
lint a file that isn't properly parsed, which could also lead to a
"parser error" and "lint offense" diagnostic in the LSP.

Additionally, it updates the Linter test helpers to make sure all test
cases have valid syntax too. Since we have the no-parser-errors rule
we will still catch syntax errors, invalid syntax, and parser errors
with that rule in real applications.

Linter: Implement html-no-space-in-html-tag linter rule (Linter: Implement html-no-space-in-html-tag linter rule marcoroth/herb#559)
Implements the SpaceInHtmlTag rule from
ERBLint.

This rules avoid having whitespace in the html.

This is a Proof of concept of the implementation. I considered

1. If the parser already throws a parser error, the linter from erb-lint
   makes no sense (ej: </ div>)
2. It follows the result that the formatter would give. For example, for
   multiline, the whitespace must have 2 spaces.

Resolves erb-lint: SpaceInHtmlTag marcoroth/herb#549

Co-authored-by: Marco Roth marco.roth@intergga.ch

C: Use buffer for string operations in html_utils.c (C: Use buffer for string operations in html_utils.c marcoroth/herb#616)
This PR changes the implementation of the html_utils
html_self_closing_tag_string and html_closing_tag_string.

Instead of directly using malloc to allocate the string we instead use
the buffer, which not only performs bounds checks, but also encapsulates
any low level memory operations.

Format

C: Remove superfluous malloc from buffer_append_repeated (C: Remove superfluous malloc from buffer_append_repeated marcoroth/herb#615)
This MR removes the malloc/free combo from the buffer_append_repeated
function.

Instead it expands the buffer to the required length and sets the memory
directly using memset.

Signed-off-by: Marco Roth marco.roth@intergga.ch
Co-authored-by: Marco Roth marco.roth@intergga.ch

C: Use buffer in escape_newlines and wrap_in_string (C: Use buffer in escape_newlines and wrap_in_string marcoroth/herb#617)
This PR refactors the util functions escape_newlines and
wrap_in_string to internally use buffer instead of manually allocating
the memory and setting the null terminator.

Docs: Exclude Maintainer and Dependabot from Contributors component

C: Implement hb_string struct (C: Implement hb_string struct marcoroth/herb#618)
Implement a string datastructure representing a string with a known
limit, eliminating the need to always use null terminated strings.

This lays the groundwork for reducing the number of required allocations
during parsing.

See C: Migrate string usages to hb_string marcoroth/herb#580

Update all HTML+ERB globs to include Action View Variants (Update all HTML+ERB globs to include Action View Variants marcoroth/herb#620)
As discovered in
Revert "feat: Add Herb and ReActionView" kaigionrails/conference-app#601, we didn't
include templates that had an Action View Variant in the filename (like
index.html+mobile.erb).

This pull request now updates all file globs Herb uses to also detect
all Action View Variants.

Thanks to @nissyi-gh and @unasuke for the help! 🙏🏼

Ruby CLI: Run compile for all files in analyze command (Ruby CLI: Run compile for all files in analyze command marcoroth/herb#621)
This pull request updates the herb analyze command to also run
compile on all HTML+ERB templates found in a directory.

This should help to statically catch any template compilation errors
before actually trying to render the templates/running the application.

❯ exe/herb analyze ../conference-app/
Parsing .html.erb files in: /Users/marcoroth/Development/conference-app
Total files to process: 76

Completed processing all files.
--- SUMMARY --------------------------------------------------------------------
Total files: 76
✅ Successful (parsed & compiled): 76 (100.0%)
❌ Compilation errors: 0 (0.0%)
❌ Failed to parse: 0 (0.0%)
⚠️ Parse errors: 0 (0.0%)
⏱️  Timed out: 0 (0.0%)

⏱️ Total time: 239.54ms

Results saved to 2025-10-11_17-02-43_erb_parsing_result_conference-app.log

Linter: Support auto-fixing linter offenses using --fix (Linter: Support auto-fixing linter offenses using --fix marcoroth/herb#622)
This pull request implements a new --fix option in the Linter CLI to
autocorrect linter offenses.

This implementation is not dependent on the Herb Formatter, since it's
relying on the @herb-tools/printer architecture and using the
IdentityPrinter class. Which means the Herb Linter can autocorrect
only the offenses without touching anything else in the document other
than fixing the offense.

C: Implement rudimentary arena allocator hb_arena.c (C: Implement rudimentary arena allocator hb_arena.c marcoroth/herb#623)
This pull request implements a rudimentary arena allocator.

It provides an initial interface for performing allocations using the
function hb_arena_alloc(...).

Implementation Details

All returned pointers have an 8 byte alignment. malloc on x64
machines returns 16 byte aligned memory
ref, but from
everything I could find only 128bit integers and simd types really
require 16 bytes. Since we don't use SIMD right now, I think we can go
with 8 bytes.

We use mmap for
allocating the memory which only allocates the memory when the page is
actually written to on modern UNIX operating systems. This has the
advantage that we can reservce e.g. 512mb of memory and the OS only
really allocates the memory if we make our first write.

mmap example

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/mman.h>

#define KB(kb) (1024 * kb)
#define MB(mb) (1024 * KB(mb))

int main() {
  size_t memory_size = MB(512);
  char *memory = mmap(NULL, memory_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

  memset(memory, 0, MB(400));

  sleep(100);
}

Compile and start program

$ ./a.out &
$ vmmap $PID_SHOWN_IN_TERMINAL

...
                                 VIRTUAL   RESIDENT      DIRTY    SWAPPED ALLOCATION      BYTES DIRTY+SWAP          REGION
MALLOC ZONE                         SIZE       SIZE       SIZE       SIZE      COUNT  ALLOCATED  FRAG SIZE  % FRAG   COUNT
===========                      =======  =========  =========  =========  =========  =========  =========  ======  ======
DefaultMallocZone_0x104a5c000     524.5M     400.1M     400.1M         0K        185     512.0M         0K      0%      10

Activity Manager View

C: Make parser options a normal struct member of the parser (C: Make parser options a normal struct member of the parser marcoroth/herb#625)
This pull request changes the way we store the parser options in the parser
struct.

Instead of a heap allocation, we just use a local member.

In addition to less pointer chasing when checking the options, we also
get an explicit definition of the default parser options.

Public interfaces are unchanged by this refactoring.

Linter: Implement erb-no-extra-newline linter rule (Linter: Implement erb-no-extra-newline linter rule marcoroth/herb#557)
Implements the ExtraNewLine rule from
ERBLint.

This rules avoid having multiple extra consecutives new lines in one
file.

Resolves erb-lint: ExtraNewline marcoroth/herb#541

Co-authored-by: Marco Roth marco.roth@intergga.ch

Playground: Add Herb Linter Autofix Button (Playground: Add Herb Linter Autofix Button marcoroth/herb#627)

Linter: Fix false positive in erb-right-trim when using <%- (Linter: Fix false positive in erb-right-trim when using <%- marcoroth/herb#629)
This pull request resolves a false positive in the erb-right-trim
linter rule when using <%- opening tag with a -%> closing tag.

This is now valid:

<%- if true -%>
  Something
<%- end -%>

Closes False positive in erb-right-trim linter rule marcoroth/herb#628

Linter: Implement Autofix for erb-right-trim linter rule (Linter: Implement Autofix for erb-right-trim linter rule marcoroth/herb#630)
This pull request implements the autofix for the erb-right-trim linter
rule, so the offenses can be autocorrect when running using the --fix
mode.

C: Namespace hb_array and hb_buffer and move to src/util/ (C: Namespace hb_array and hb_buffer and move to src/util/ marcoroth/herb#626)
This pull request namespaces the array and buffer structs into
hb_array and hb_buffer and moves them into the src/util/
directory, following Prism's directory
structure.

Additonally, it moves the new hb_string struct (introduced in C: Implement hb_string struct marcoroth/herb#618) to
src/util too.

C: Remove unused functions from hb_buffer.c (C: Remove unused functions from hb_buffer.c marcoroth/herb#608)
This PR removes buffer functions that aren't used (anymore) and makes
functions required internally static.

Removed functions

• buffer_new
• buffer_increase_capacity
• buffer_expand_capacity

Made static

• buffer_resize
• buffer_has_capacity
• buffer_expand_if_needed
• buffer_append_repeated

C: Make lexer source an instance of hb_string_T (C: Make lexer source an instance of hb_string_T marcoroth/herb#632)
This PR makes the lexer source an instance of hb_string_T and adapts
all usages of the lexer source.

This is purely a refactoring and should not alter any interfaces, or
observable behavior for that matter.

Parser: Allow TOKEN_BACKSLASH in HTML Text Content (Parser: Allow TOKEN_BACKSLASH in HTML Text Content marcoroth/herb#637)
This pull request updates the parser to allow backslashes in the HTML
Text Content. Previously, a document like this failed to parse:

<p>\Asome-regexp\z</p>

With an error like:

Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_BACKSLASH`. 

Resolves Parser: Backslash in HTML Text Content leads to unexpected token error marcoroth/herb#633
Resolves Parser error on string that looks like regexp marcoroth/herb#635

Linter: Implement html-input-require-autocomplete linter rule (Linter: Implement html-input-require-autocomplete linter rule marcoroth/herb#565)
Resolves erb-lint: RequireInputAutocomplete marcoroth/herb#552

Co-authored-by: Marco Roth marco.roth@intergga.ch

Linter: Implement html-body-only-elements linter rule (Linter: Implement html-body-only-elements linter rule marcoroth/herb#470)
Add html-body-only-elements rule

This PR adds a new linter rule html-body-only-elements that enforces
certain HTML elements are only placed within the <body> tag.

What does this rule do?

This rule prevents content-bearing and interactive HTML elements from
being placed in the <head> section or outside the HTML document
structure.

Closes Linter Rule: Restrict certain elements to the <body> section marcoroth/herb#378

Co-authored-by: Marco Roth marco.roth@intergga.ch

C: Use uint32_t for length member in hb_string_T struct (C: Use uint32_t for length member in hb_string_T struct marcoroth/herb#640)
In line with the lexer/parser we are going to limit the string length to
the range of uint32_t which is sufficient to hold 4 GB large strings.

Resolves Lexer: Warning when compiling lexer.c marcoroth/herb#636

Linter: Implement html-head-only-elements linter rule (Linter: Implement html-head-only-elements linter rule marcoroth/herb#382)
Resolves Linter Rule: Restrict certain elements to the <head> section marcoroth/herb#167

Linter: Implement html-no-duplicate-meta-names linter rule (Linter: Implement html-no-duplicate-meta-names linter rule marcoroth/herb#383)
Resolves Linter Rule: Duplicate <meta> name attributes are not allowed marcoroth/herb#381

Linter Rule: Allow head-only elements on top level (Linter Rule: Allow head-only elements on top level marcoroth/herb#641)
This pull request updates the html-head-only-elements linter rule to
allow head-only elements on the top-level, like:

<meta>
<link>
<base>
<title></title>
<style></style>

This is useful, when the content of <head> element in the layout is
extracted to a partial, so that the partial itself doesn't contain the
<head> element directly. This is now allowed.

Linter: Implement Autofix for html-no-space-in-tag linter rule (Linter: Implement Autofix for html-no-space-in-tag linter rule marcoroth/herb#642)
This pull request implements the autofix function for the
html-no-space-in-tag linter rule, so that this rule can be
autocorrected when running the Herb Linter CLI using --fix.

Linter Rule: Fix false positive for yield in erb-right-trim rule (Linter Rule: Fix false positive for yield in erb-right-trim rule marcoroth/herb#644)
This pull request updates the isERBOutputNode helper in
@herb-tools/core in order to detect a <%= yield %> node as an
ERBOutputNode.

This change fixes the erb-right-trim rule to not report the following
snippet as an offense:

<%= yield -%>

Resolves Linter: Potential false positive in erb-right-trim linter rule marcoroth/herb#643

Linter Rule: Remove Trimming with -%> on non-output offense (Linter Rule: Remove Trimming with -%> on non-output offense marcoroth/herb#645)
This pull request removes the following offense from the
erb-right-trim linter rule, as it's not right and does have an effect:

Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.

It will have an effect on templates like this:

<% if true -%>
  <h1>Content</h1>
<% end -%>

C: Add hb_buffer_append_string function to hb_buffer_T (C: Add hb_buffer_append_string function to hb_buffer_T marcoroth/herb#657)
This PR adds a new function that allows adding hb_string_Ts to our
buffer implementation

Linter: Rename erb-require-trailing-newline linter rule (Linter: Rename erb-require-trailing-newline linter rule marcoroth/herb#660)
This pull request renames the erb-requires-trailing-newline linter
rule to erb-require-trailing-newline to be more in line with the other
erb-require-whitespace-inside-tags linter rule name.

Linter: Allow disabling offenses using <%# herb:disable %> (Linter: Allow disabling offenses using <%# herb:disable %> marcoroth/herb#531)
This PR makes possible to disable a rule in a erb line.

The implementation follows the Standard
way
to disable rules, in the same way that ERBLint allows to disable rules
inline.

The implementation is very similar this pull
request. The strategy
consist of

1. Use a regex to see which line skipped rules with the <%# herb:disable some-rule %> syntax
2. Partition the offenses collected by the visitor based on the rules
   that where disabled for each line.
3. Report in the reporters the number of offenses.

Here is a screenshot of how the implementation looks in the Linter CLI.

<div>
  <h1 class="<%= classes %>">
    <%= title %>
  </h1>

  <DIV>hello</DIV>
  <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
  <% %> <%# herb:disable erb-no-empty-tags %>

</div>

Future work:

• Be able to skip the skipped lines (useful when we want to find where
  are the rules skipped).
• Allow the LSP to make a code action with an autocorrect that adds the
  line skipping.
• Allow disable multiple rules in one line (this should be pretty
  straightforward in a follow up PR).
• Add another linter rule to avoid putting disable comments that not
  disable anything (like erb_lint NoUnusedDisable).

Resolves Linter Feature: Disable error for line marcoroth/herb#270

Bump Prism to v1.6.0 (Bump Prism to v1.6.0 marcoroth/herb#669)
https://github.com/ruby/prism/releases/tag/v1.6.0

C: Implement hb_string_slice function (C: Implement hb_string_slice function marcoroth/herb#661)
This PR introduces a new function that allows to get a slice of a
string.

Core: Introduce HERB_FILES_GLOB to share HTML+ERB glob (Core: Introduce HERB_FILES_GLOB to share HTML+ERB glob marcoroth/herb#672)
Resolves VS Code: Side panel doesn't accept new Action View Variants glob pattern marcoroth/herb#646
Resolves Herb: Run all Herb commands on *.rhtml files marcoroth/herb#668

C: Use Arena Allocator in hb_string_to_c_string function (C: Use Arena Allocator in hb_string_to_c_string function marcoroth/herb#674)
This PR adds the new arena allocator to the hb_string_to_c_string that
is the only hb_string function that needs to allocate memory.

C: Use hb_string_T in lexer_peek_helpers.c (C: Use hb_string_T in lexer_peek_helpers.c marcoroth/herb#656)
This PR migrates the lexer peek helper interfaces to use hb_string_T
instead of null terminated strings.

C: Inline size_t_to_string function (C: Inline size_t_to_string function marcoroth/herb#676)
This PR removes the size_t_to_string function and replaces its only
usages the function body.

Reasoning

• size_t_to_string is only used in one place
• it is rather trivial
• if we would migrate it to use the arena allocator we would need to
  pass an explicit arena allocator to the pretty print function
• Using a stack allocated char array has better cache locality

C: Use hb_string_T in herb_analyze function (C: Use hb_string_T in herb_analyze function marcoroth/herb#678)
This PR starts using the hb_string_T in the interface of
herb_analyze.

This is a side effect free refactor, that makes the switch to
hb_string_T based token values easier later on.

C: Remove unused pretty_print_analyzed_ruby (C: Remove unused pretty_print_analyzed_ruby marcoroth/herb#679)
This PR removes the unused pretty_print_analyzed_ruby function

C: Make is_newline function legible (C: Make is_newline function legible marcoroth/herb#682)
This PR is just a minor fix for a nitpick of mine. Instead of using the
ascii codes in the is_newline function, we use the characters
directly, making the function way more readable.

Lexer: Handle Memory Leak in lexer_parse_erb_content (Lexer: Handle Memory Leak in lexer_parse_erb_content marcoroth/herb#690)
As discovered by @timkaechele, this pull request fixes a memory leak in
the lexer_parse_erb_content function when returning early in the
lexer_eof case.

Co-authored-by: Tim Kächele 3810945+timkaechele@users.noreply.github.com

Parser: Handle memory leak in herb_parse (Parser: Handle memory leak in herb_parse marcoroth/herb#691)
Follow up on Lexer: Handle Memory Leak in lexer_parse_erb_content marcoroth/herb#690

bin/leaks_parse examples/incomplete_erb.invalid.html.erb

leaks Report Version: 4.0, multi-line stacks
Process 1007: 189 nodes malloced for 11 KB
Process 1007: 4 leaks for 240 total leaked bytes.

STACK OF 1 INSTANCE OF 'ROOT LEAK: <malloc in hb_array_init>':
5   dyld                                  0x1820aab98 start + 6076
4   herb                                  0x10282b800 main + 576  main.c:96
3   herb                                  0x102829250 herb_parse + 168  herb.c:40
2   herb                                  0x10282c29c herb_parser_init + 64  parser.c:39
1   herb                                  0x102831774 hb_array_init + 24  hb_array.c:12
0   libsystem_malloc.dylib                0x18227d080 _malloc_zone_malloc_instrumented_or_legacy + 152
====
    2 (176 bytes) ROOT LEAK: <malloc in hb_array_init 0x14c704130> [32]
       1 (144 bytes) <malloc in hb_array_init 0x14c704150> [144]

STACK OF 1 INSTANCE OF 'ROOT LEAK: <calloc in token_init>':
10  dyld                                  0x1820aab98 start + 6076
9   herb                                  0x10282b800 main + 576  main.c:96
8   herb                                  0x102829258 herb_parse + 176  herb.c:42
7   herb                                  0x10282c2e4 herb_parser_parse + 24  parser.c:1206
6   herb                                  0x10282c36c parser_parse_document + 124  parser.c:1196
5   herb                                  0x10282c054 parser_consume_expected + 36  parser_helpers.c:152
4   herb                                  0x10282c018 parser_consume_if_present + 64  parser_helpers.c:148
3   herb                                  0x10282bee8 parser_advance + 40  parser_helpers.c:142
2   herb                                  0x10282a3a4 lexer_next_token + 52  lexer.c:269
1   herb                                  0x10282fc5c token_init + 40  token.c:17
0   libsystem_malloc.dylib                0x18227d270 _malloc_zone_calloc_instrumented_or_legacy + 132
====
    2 (64 bytes) ROOT LEAK: <calloc in token_init 0x14c704370> [48]
       1 (16 bytes) <malloc in herb_strdup 0x14c7043a0> [16]

C: Use hb_string_T in parser_check_matching_tag function (C: Use hb_string_T in parser_check_matching_tag function marcoroth/herb#689)
This PR changes the interface and implementation of
parser_check_matching_tag to make use of the new hb_string_T struct
and accompanying functions.

C: Rename parser_free to herb_parser_deinit (C: Rename parser_free to herb_parser_deinit marcoroth/herb#692)
This PR namespaces the parser_free function and renames it to
parser_deinit.

Follow up on Parser: Handle memory leak in herb_parse marcoroth/herb#691

C: Use hb_string_T in quoted_string function (C: Use hb_string_T in quoted_string function marcoroth/herb#681)
This PR refactors the quoted_string utility to use hb_string_T as an
argument and fixes all call sites.

CI: Update trigger to run build.yml on pull requests
Signed-off-by: Marco Roth marco.roth@intergga.ch

C: Use hb_string_T in parser_is_foreign_content_tag function (C: Use hb_string_T in parser_is_foreign_content_tag function marcoroth/herb#688)
This PR adapts the interfaces of the parser_is_foreign_content_tag and
parser_get_foreign_content_type to use hb_string_T instead of a
const char*.

Herb: Upgrade to LLVM 21 and Clang 21 (Herb: Upgrade to LLVM 21 and Clang 21  marcoroth/herb#694)
This pull request upgrades the llvm and the related clang,
clang-format and clang-tidy versions from 19 to 21.

C: Migrate is_void_element to hb_string_T (C: Migrate is_void_element to hb_string_T marcoroth/herb#686)
This PR changes the interface to the is_void_element function to use
hb_string_T and adapts all call sites.

This makes the switch to hb_string_T based token values easier later
on.

C: Use hb_string_T in parser_helpers.c functions (C: Use hb_string_T in parser_helpers.c functions marcoroth/herb#696)
This PR refactors the parser_get_foreign_content_closing_tag and
parser_is_expected_closing_tag_name to use hb_string_T instead of c
strings.

Linter: Remove html-no-space-in-tag from default rules for now (Linter: Remove html-no-space-in-tag from default rules for now marcoroth/herb#697)
The html-no-space-in-tag linter rule (Linter: Implement html-no-space-in-html-tag linter rule marcoroth/herb#559 and Linter: Implement Autofix for html-no-space-in-tag linter rule marcoroth/herb#642) has quite a few
false positives and corrupts documents when using the --fix option
(see Linter: html-no-space-in-tag autofix gives wrong output marcoroth/herb#695), which is why this pull request removes the
html-no-space-in-tag rule from the default rules for now.

We can enable this rule again in the future when we improve the accuracy
of the rule.

VS Code: Only show Report Issue Code Action for Herb Diagnostics (VS Code: Only show Report Issue Code Action for Herb Diagnostics marcoroth/herb#700)
This pull request changes the VS Code Language Server client to only
show the Report Issue Code Action when the diagnostic.source
contains "Herb".

This makes it so the Code Action only shows up on diagnostics issued by
the Herb Language Server.

Resolves cssConflict does not recognize conditional logic (Diagnostic issue: cssConflict) marcoroth/herb#308
Resolves Diagnostic issue: cssConflict with multiple via colors in a gradient marcoroth/herb#699

Bump playwright from 1.55.0 to 1.55.1 in the npm_and_yarn group across 1 directory (Bump playwright from 1.55.0 to 1.55.1 in the npm_and_yarn group across 1 directory marcoroth/herb#702)
Bumps the npm_and_yarn group with 1 update in the / directory:
playwright.

Signed-off-by: dependabot[bot] support@github.com
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Bump vite from 7.1.8 to 7.1.11 in the npm_and_yarn group across 1 directory (Bump vite from 7.1.8 to 7.1.11 in the npm_and_yarn group across 1 directory marcoroth/herb#705)
Bumps the npm_and_yarn group with 1 update in the / directory:
vite.

Signed-off-by: dependabot[bot] support@github.com
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

C: Use hb_string_T in html_util.c functions (C: Use hb_string_T in html_util.c functions marcoroth/herb#703)
This PR changes all html_util functions to use hb_string_T instead
of c strings.

C: Rename hb_string_from_c_string to hb_string (C: Rename hb_string_from_c_string to hb_string marcoroth/herb#706)
This pull request renames the hb_string_from_c_string function to just
hb_string which makes it a bit easier and more natural to read.

C: Move hb_arena.c to src/util/ (C: Move hb_arena.c to src/util/ marcoroth/herb#707)
This pull request moves the hb_arena.c file into the src/utils/
folder in order to be in line with hb_array.c, hb_string.c, and
hb_buffer.c.