herb 0.3.0-x86-linux-gnu → 0.4.0-x86-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91f40f0b1aa8050e871a024640ac86b280e94d4e9b09cb61936f9fceb71b45c9
-  data.tar.gz: 077ee0b9e5e95850b66244f149580f5877ee8b13fc63fc56851383e864a7664c
+  metadata.gz: c26d594096c8c31de428e3e4ac60cfa041bd7aaf8dfc7ed519629a9069375b0a
+  data.tar.gz: 7fe196d58c58db1833bcd714b042ae9c2fd4419e65e6a4c987015035fd8c3941
 SHA512:
-  metadata.gz: 4bd8e3dc2c3ad81ccd43861aa3ff900c5d3f714a12e6e1fb8029601564d82b4dd758b209f60fd4ab121d5bf6835a1a0c3e023de7aafde7aa9f658223cd3c51ac
-  data.tar.gz: 832db948a9e90b7b96e25b7ab200edd371aa6321d4db5c42af96b72c0ef3b79f386eefbc75027de8c9fc79088f7c134ddca2c0ba4bd8fed23c392291cb3f1e76
+  metadata.gz: 3ef8bf7b14d9318f71c466153292bb0b447a941d57199fbafb6ad2426be5896d95d1eb7b39a999910d606dac74c97ca9ca55e40ace7d037ae740e7a27367ffe9
+  data.tar.gz: d7b82f499e55db467f480305d28c116c0a8d0937f3c0609a1bdc5cbd8c6a5a9f03f1bb070488a7c389aa3c4e5cb9be3744c72d50cfb8aca7ce64c29c5db93050

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 Marco Roth
+Copyright (c) 2024-2025 Marco Roth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.

data/README.md

@@ -1,170 +1,135 @@
 <div align="center">
-  <img alt="Herb HTML+ERB parser" height="256px" src="https://github.com/user-attachments/assets/d0714ee1-ca33-4aa4-aaa9-d632ba79d54a">
+  <img alt="Herb HTML+ERB parser" style="height: 256px" height="256px" src="https://github.com/user-attachments/assets/d0714ee1-ca33-4aa4-aaa9-d632ba79d54a">
 </div>
 
 <h2 align="center">Herb</h2>
 
-<h4 align="center">HTML + ERB (HTML Embedded Ruby)</h4>
+<h4 align="center">HTML+ERB (HTML + Embedded Ruby)</h4>
 
-<div align="center">Powerful and seamless HTML-aware ERB parsing and tooling.</div>
+<div align="center">Powerful and seamless HTML-aware ERB parsing and tooling.</div><br/>
 
-## Contributing
-
-This project builds the Herb program and its associated unit tests using a Makefile for automation. The Makefile provides several useful commands for compiling, running tests, and cleaning the project.
-
-### Requirements
-
-- [**Check**](https://libcheck.github.io/check/): For unit testing.
-- [**Clang 19**](https://clang.llvm.org): The compiler used to build this project.
-- [**Clang Format 19**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
-- [**Clang Tidy 19**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
-- [**Prism Ruby Parser v1.4.0**](https://github.com/ruby/prism/releases/tag/v1.4.0): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
-- [**Ruby**](https://www.ruby-lang.org/en/): We need Ruby as a dependency for `bundler`.
-- [**Bundler**](https://bundler.io): We are using `bundler` to build [`prism`](https://github.com/ruby/prism) from source so we can build `herb` against it.
-- [**Emscripten**](https://emscripten.org): For the WebAssembly build of `libherb` so it can be used in the browser using the [`@herb-tools/browser`](https://github.com/marcoroth/herb/blob/main/javascript/packages/browser) package.
-- [**Doxygen**](https://www.doxygen.nl): For building the C-Reference documentation pages.
+<p align="center">
+  <a href="https://rubygems.org/gems/herb"><img alt="Gem Version" src="https://img.shields.io/gem/v/herb"></a>
+  <a href="https://herb-tools.dev"><img alt="Documentation" src="https://img.shields.io/badge/documentation-available-green"></a>
+  <a href="https://herb-tools.dev/playground"><img alt="playground" src="https://img.shields.io/badge/playground-Try_it_in_the_browser!-green"></a>
+  <a href="https://github.com/marcoroth/herb/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/github/license/marcoroth/herb"></a>
+  <a href="https://github.com/marcoroth/herb/issues"><img alt="Issues" src="https://img.shields.io/github/issues/marcoroth/herb"></a>
+</p>
 
-##### For Linux
+<br/><br/><br/>
 
-```bash
-xargs sudo apt-get install < Aptfile
-```
-or:
+## What is Herb?
 
-```bash
-sudo apt-get install check clang-19 clang-tidy-19 clang-format-19 emscripten doxygen
-```
+**Herb** is an ecosystem of developer tooling built specifically around **HTML+ERB** (`.html.erb`) files. It is designed to simplify and enhance the experience of working with HTML+ERB templates through precise, accurate tooling.
 
-##### For macOS (using Homebrew)
+At the core of Herb is the **Herb Parser**, a fast, portable, and HTML-aware ERB parser written in C. The parser generates a detailed, accurate syntax tree that serves as the foundation for reliable code analysis, transformations, and developer tooling.
 
-```bash
-brew bundle
-```
-or:
+The Herb ecosystem includes **developer tools** (CLI, language server, formatter, linter), **language bindings** (for Ruby, Node.js, and the Browser using WebAssembly), and **utility libraries** (language service, highlighter, minifier, printer). All these components leverage the Herb Parser's syntax tree to provide consistent, accurate, and helpful tooling experiences.
 
-```bash
-brew install check llvm@19 emscripten doxygen
-```
+## What Herb Can Do for You
 
-### Building
+Herb provides a complete ecosystem of HTML+ERB tooling, designed to simplify and enhance your daily workflow. Built on the **Herb Parser**, it offers multiple tools that integrate seamlessly into editors, developer environments, and CI pipelines:
 
-#### Clone the Repo
+- **Herb Language Server** ([available now](https://herb-tools.dev/projects/language-server)):
+  Rich integration for editors like VS Code, Zed, Neovim, and more. It provides diagnostics and real-time feedback to keep your templates error-free.
 
-Clone the Git Repository:
+- **Herb Formatter** ([coming soon](https://herb-tools.dev/projects/formatter)):
+  Automatic, consistent formatting for HTML+ERB files, reducing manual styling and enforcing a standard across projects.
 
-```
-git clone https://github.com/marcoroth/herb && cd herb/
-```
+- **Herb Linter** ([coming soon](https://herb-tools.dev/projects/linter)):  
+  Static analysis for your HTML+ERB templates to enforce best practices and quickly identify common mistakes.
 
-#### Build Herb
+You can use Herb programmatically in **Ruby**, as well as in **JavaScript** via Node.js, WebAssembly, or directly in browsers.
 
-We can now compile all source files in `src/` and generate the `herb` executable.
+For a complete overview of all available tools, libraries, and integrations, visit the [**Projects page**](https://herb-tools.dev/projects) on our documentation site.
 
-```bash
-make all
-```
+## Motiviation
 
-> [!NOTE]
-For any consecutive builds you can just run `make`/`make all`.
+HTML+ERB templates never really had good, accurate, and reliable tooling. While developer tooling for Ruby code improved significantly in the last few years (especially with the introduction of the new Prism parser), HTML+ERB files remained underserved, lacking fundamental support like syntax checking, auto-formatting, linting, and structural understanding.
 
-### Run
+At the same time, with the rise of tools like [Hotwire](https://hotwired.dev), [Stimulus](https://stimulus.hotwired.dev), [Turbo](https://turbo.hotwired.dev), [HTMX](https://htmx.org), [Unploy](https://unpoly.com), and [Alpine.js](https://alpinejs.dev), advanced HTML templating became increasingly relevant (again). Developers expect modern, reliable, and precise tooling, especially given the robust ecosystem available to JavaScript frameworks and libraries.
 
-The `herb` executable exposes a few commands for interacting with `.html.erb` files:
+Herb was built to close this tooling gap, providing proper tooling for HTML+ERB that matches what modern developers expect in the age of language servers, LLMs, and AI-driven workflows.
 
-```
-❯ ./herb
-./herb [command] [options]
+## Command-Line Usage
 
-Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.
+Install the Herb gem via RubyGems:
 
-./herb lex [file]      -  Lex a file
-./herb lex_json [file] -  Lex a file and return the result as json.
-./herb parse [file]    -  Parse a file
-./herb ruby [file]     -  Extract Ruby from a file
-./herb html [file]     -  Extract HTML from a file
-./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism
+```sh
+gem install herb
 ```
 
-Running the executable shows a pretty-printed output for the respective command and the time it took to execute:
+Basic usage to analyze all HTML+ERB files in your project:
 
+```sh
+herb analyze .
 ```
-❯ ./herb lex examples/simple_erb.html.erb
-
-#<Herb::Token type="TOKEN_ERB_START" value="<%" range=[0, 2] start=(1:0) end=(1:2)>
-#<Herb::Token type="TOKEN_ERB_CONTENT" value=" title " range=[2, 9] start=(1:2) end=(1:9)>
-#<Herb::Token type="TOKEN_ERB_END" value="%>" range=[9, 11] start=(1:9) end=(1:11)>
-#<Herb::Token type="TOKEN_NEWLINE" value="\n" range=[11, 12] start=(1:0) end=(2:1)>
-#<Herb::Token type="TOKEN_EOF" value="" range=[12, 12] start=(2:1) end=(2:1)>
 
-Finished lexing in:
-
-        12 µs
-     0.012 ms
-  0.000012  s
+This will give you an overview of how the Herb Parser sees your project:
 ```
+--- SUMMARY --------------------------------------------------------------------
+Total files: 145
+✅ Successful: 143 (98.6%)
+❌ Failed: 0 (0.0%)
+⚠️ Parse errors: 2 (1.4%)
+⏱️ Timed out: 0 (0.0%)
 
-### Building the Ruby extension
-
-We use `rake` and `rake-compiler` to compile the Ruby extension. Running rake will generate the needed templates, run make, build the needed artifacts, and run the Ruby tests.
+Files with parse errors:
+  - app/views/contributions/index.html.erb
+  - index.html.erb
 
-```bash
-rake
+Results saved to 2025-06-29_12-16-23_erb_parsing_result_rubyevents.log
 ```
 
-If `rake` was successful you can use `bundle console` to interact with `Herb`:
+Herb also comes with other useful commands:
 
-```bash
-bundle console
-```
-
-```
-irb(main):001> Herb.parse("<div></div>")
-
-# => #<Herb::ParseResult:0x0000000 ... >
-```
-
-### Test
-
-Builds the test suite from files in `test/` and creates the `run_herb_tests` executable to run the tests:
-
-#### For the C Tests
-
-```bash
-make test && ./run_herb_tests
 ```
+Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.
 
-#### For the Ruby Tests
+Usage:
+  bundle exec herb [command] [options]
 
-```bash
-rake test
+Commands:
+  bundle exec herb lex [file]         Lex a file.
+  bundle exec herb parse [file]       Parse a file.
+  bundle exec herb analyze [path]     Analyze a project by passing a directory to the root of the project
+  bundle exec herb ruby [file]        Extract Ruby from a file.
+  bundle exec herb html [file]        Extract HTML from a file.
+  bundle exec herb playground [file]  Open the content of the source file in the playground
+  bundle exec herb version            Prints the versions of the Herb gem and the libherb library.
 ```
 
-### Clean
+For detailed information, like how you can use Herb progamatiacally in Ruby and JavaScript, visit the [documentation site](https://herb-tools.dev/bindings/ruby/reference).
 
-Removes the `herb`, `run_herb_tests`, `prism` installation, and all `.o` files.
 
-```bash
-make clean
-```
+## Background and Talk
 
-### Local Integration Testing
+**Herb** was first introduced at [**RubyKaigi 2025**](https://rubykaigi.org/2025/presentations/marcoroth.html) in April 2025 with the talk [*Empowering Developers with HTML-Aware ERB Tooling*](https://www.rubyevents.org/talks/empowering-developers-with-html-aware-erb-tooling-rubykaigi-2025).
 
-The `bin/integration` script allows for quick local iteration. On every run it cleans the directory, builds the source from scratch and runs all checks, including the C-Tests, Ruby Tests, Linters, and examples in succession.
+## Contributing
 
-```bash
-bin/integration
-```
+Bug reports and pull requests are welcome on [GitHub](https://github.com/marcoroth/herb). Please see the [CONTRIBUTING.md](https://github.com/marcoroth/herb/blob/main/CONTRIBUTING.md) document for guidelines on how to set up Herb for local development and how to contribute to **Herb**.
 
-The integration was successful if you see:
+## Prior Art & Inspiration
 
-```
-❯ bin/integration
+While Herb brings a fresh approach to HTML+ERB tooling, it builds upon and learns from several existing tools and approaches in the ecosystem:
 
-[...]
+- [**Tree-sitter**](https://tree-sitter.github.io/tree-sitter/)
+- [**tree-sitter-embedded-template**](https://github.com/tree-sitter/tree-sitter-embedded-template)
+- [**Prism Ruby Parser**](https://github.com/ruby/prism)
+- [**Ruby LSP**](https://github.com/Shopify/ruby-lsp)
+- [**better-html**](https://github.com/Shopify/better-html)
+- [**erb_lint**](https://github.com/Shopify/erb_lint)
+- [**erb-formatter**](https://github.com/nebulab/erb-formatter)
+- [**erb-formatter-vscode**](https://github.com/nebulab/erb-formatter-vscode)
+- [**deface**](https://github.com/spree/deface)
+- [**html_press**](https://github.com/stereobooster/html_press)
+- [**htmlbeautifier**](https://github.com/threedaymonk/htmlbeautifier)
+- [**vscode-erb-beautify**](https://github.com/aliariff/vscode-erb-beautify)
+- [**vscode-erb-linter**](https://github.com/manuelpuyol/vscode-erb-linter)
 
-Integration successful!
-```
+Herb differentiates itself by being HTML-aware from the ground up, providing a unified parsing approach that understands both HTML and ERB as first-class citizens, rather than treating one as embedded within the other.
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE.txt) file for details.
+This project is available as open source under the terms of the [MIT License](https://github.com/marcoroth/herb/blob/main/LICENSE.txt).

data/ext/herb/nodes.c

@@ -415,7 +415,7 @@ static VALUE rb_erb_content_node_from_c_struct(AST_ERB_CONTENT_NODE_T* erb_conte
   VALUE erb_content_node_tag_opening = rb_token_from_c_struct(erb_content_node->tag_opening);
   VALUE erb_content_node_content = rb_token_from_c_struct(erb_content_node->content);
   VALUE erb_content_node_tag_closing = rb_token_from_c_struct(erb_content_node->tag_closing);
-  /* #<Herb::Template::AnalyzedRubyField:0x00007ffffed61860 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007ffffed61888 @name="analyzed_ruby", @options={kind: nil}> */
   VALUE erb_content_node_analyzed_ruby = Qnil;
   VALUE erb_content_node_parsed = (erb_content_node->parsed) ? Qtrue : Qfalse;
   VALUE erb_content_node_valid = (erb_content_node->valid) ? Qtrue : Qfalse;

data/lib/herb/ast/node.rb

@@ -51,7 +51,7 @@ module Herb
         output = +""
 
         if array.any?
-          output += "(#{array.count} #{array.count == 1 ? item_name : "#{item_name}s"})"
+          output += "(#{array.count} #{array.one? ? item_name : "#{item_name}s"})"
           output += "\n"
 
           items = array.map { |item|
@@ -92,6 +92,11 @@ module Herb
       def compact_child_nodes
         child_nodes.compact
       end
+
+      #: () -> Array[Herb::Errors::Error]
+      def recursive_errors
+        errors + compact_child_nodes.flat_map(&:recursive_errors)
+      end
     end
   end
 end

data/lib/herb/cli.rb

@@ -6,7 +6,7 @@
 require "optparse"
 
 class Herb::CLI
-  attr_accessor :json, :silent
+  attr_accessor :json, :silent, :no_interactive, :no_log_file, :no_timing
 
   def initialize(args)
     @args = args
@@ -106,7 +106,11 @@ class Herb::CLI
   def result
     @result ||= case @command
                 when "analyze"
-                  Herb::Project.new(directory).parse!
+                  project = Herb::Project.new(directory)
+                  project.no_interactive = no_interactive
+                  project.no_log_file = no_log_file
+                  project.no_timing = no_timing
+                  project.parse!
                   exit(0)
                 when "parse"
                   Herb.parse(file_content)
@@ -162,6 +166,18 @@ class Herb::CLI
       parser.on("-s", "--silent", "Log no result to stdout") do
         self.silent = true
       end
+
+      parser.on("-n", "--non-interactive", "Disable interactive output (progress bars, terminal clearing)") do
+        self.no_interactive = true
+      end
+
+      parser.on("--no-log-file", "Disable log file generation") do
+        self.no_log_file = true
+      end
+
+      parser.on("--no-timing", "Disable timing output") do
+        self.no_timing = true
+      end
     end
   end
 

data/lib/herb/parse_result.rb

@@ -12,9 +12,14 @@ module Herb
       super(source, warnings, errors)
     end
 
+    #: () -> Array[Herb::Errors::Error]
+    def errors
+      super + value.recursive_errors
+    end
+
     #: () -> bool
     def failed?
-      errors.any? || value.errors.any? # TODO: this should probably be recursive
+      errors.any?
     end
 
     #: () -> bool
@@ -24,7 +29,7 @@ module Herb
 
     #: () -> String
     def pretty_errors
-      JSON.pretty_generate(errors + value.errors)
+      JSON.pretty_generate(errors)
     end
 
     #: (Visitor) -> void

data/lib/herb/project.rb

@@ -8,10 +8,17 @@ require "timeout"
 require "tempfile"
 require "pathname"
 require "English"
+require "stringio"
 
 module Herb
   class Project
-    attr_accessor :project_path, :output_file
+    attr_accessor :project_path, :output_file, :no_interactive, :no_log_file, :no_timing
+
+    def interactive?
+      return false if no_interactive
+
+      !IO.console.nil?
+    end
 
     def initialize(project_path, output_file: nil)
       @project_path = Pathname.new(
@@ -39,7 +46,15 @@ module Herb
     end
 
     def parse!
-      File.open(output_file, "w") do |log|
+      start_time = Time.now unless no_timing
+
+      log = if no_log_file
+              StringIO.new
+            else
+              File.open(output_file, "w")
+            end
+
+      begin
         log.puts heading("METADATA")
         log.puts "Herb Version: #{Herb.version}"
         log.puts "Reported at: #{Time.now.strftime("%Y-%m-%dT%H:%M:%S")}\n\n"
@@ -54,10 +69,10 @@ module Herb
           message = "No .html.erb files found using #{full_path_glob}"
           log.puts message
           puts message
-          next
+          return
         end
 
-        print "\e[H\e[2J"
+        print "\e[H\e[2J" if interactive?
 
         successful_files = []
         failed_files = []
@@ -77,37 +92,43 @@ module Herb
           lines_to_clear += 3 if total_timeout.positive?
           lines_to_clear += 3 if total_errors.positive?
 
-          lines_to_clear.times { print "\e[1A\e[K" } if index.positive?
+          lines_to_clear.times { print "\e[1A\e[K" } if index.positive? && interactive?
 
-          puts "Parsing .html.erb files in: #{project_path}"
-          puts "Total files to process: #{files.count}\n"
+          if interactive?
+            puts "Parsing .html.erb files in: #{project_path}"
+            puts "Total files to process: #{files.count}\n"
 
-          relative_path = file_path.sub("#{project_path}/", "")
+            relative_path = file_path.sub("#{project_path}/", "")
 
-          puts
-          puts progress_bar(index + 1, files.count)
-          puts
-          puts "Processing [#{index + 1}/#{files.count}]: #{relative_path}"
-
-          if failed_files.any?
             puts
-            puts "Files that failed:"
-            failed_files.each { |file| puts "  - #{file}" }
+            puts progress_bar(index + 1, files.count)
             puts
+          else
+            relative_path = file_path.sub("#{project_path}/", "")
           end
+          puts "Processing [#{index + 1}/#{files.count}]: #{relative_path}"
 
-          if timeout_files.any?
-            puts
-            puts "Files that timed out:"
-            timeout_files.each { |file| puts "  - #{file}" }
-            puts
-          end
+          if interactive?
+            if failed_files.any?
+              puts
+              puts "Files that failed:"
+              failed_files.each { |file| puts "  - #{file}" }
+              puts
+            end
 
-          if error_files.any?
-            puts
-            puts "Files with parse errors:"
-            error_files.each { |file| puts "  - #{file}" }
-            puts
+            if timeout_files.any?
+              puts
+              puts "Files that timed out:"
+              timeout_files.each { |file| puts "  - #{file}" }
+              puts
+            end
+
+            if error_files.any?
+              puts
+              puts "Files with parse errors:"
+              error_files.each { |file| puts "  - #{file}" }
+              puts
+            end
           end
 
           begin
@@ -214,10 +235,13 @@ module Herb
           end
         end
 
-        print "\e[1A\e[K"
-        puts "Completed processing all files."
-
-        print "\e[H\e[2J"
+        if interactive?
+          print "\e[1A\e[K"
+          puts "Completed processing all files."
+          print "\e[H\e[2J"
+        else
+          puts "Completed processing all files."
+        end
 
         log.puts ""
 
@@ -333,13 +357,23 @@ module Herb
           end
         end
 
-        puts "\nResults saved to #{output_file}"
+        unless no_timing
+          end_time = Time.now
+          duration = end_time - start_time
+          timing_message = "\n⏱️ Total time: #{format_duration(duration)}"
+          log.puts timing_message
+          puts timing_message
+        end
+
+        puts "\nResults saved to #{output_file}" unless no_log_file
+      ensure
+        log.close unless no_log_file
       end
     end
 
     private
 
-    def progress_bar(current, total, width = IO.console.winsize[1] - "[] 100% (#{total}/#{total})".length)
+    def progress_bar(current, total, width = (IO.console&.winsize&.[](1) || 80) - "[] 100% (#{total}/#{total})".length)
       progress = current.to_f / total
       completed_length = (progress * width).to_i
       completed = "█" * completed_length
@@ -366,5 +400,17 @@ module Herb
 
       prefix + ("-" * (80 - prefix.length))
     end
+
+    def format_duration(seconds)
+      if seconds < 1
+        "#{(seconds * 1000).round(2)}ms"
+      elsif seconds < 60
+        "#{seconds.round(2)}s"
+      else
+        minutes = (seconds / 60).to_i
+        remaining_seconds = seconds % 60
+        "#{minutes}m #{remaining_seconds.round(2)}s"
+      end
+    end
   end
 end

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/sig/herb/ast/node.rbs

@@ -43,6 +43,9 @@ module Herb
 
       # : () -> Array[Herb::AST::Node]
       def compact_child_nodes: () -> Array[Herb::AST::Node]
+
+      # : () -> Array[Herb::Errors::Error]
+      def recursive_errors: () -> Array[Herb::Errors::Error]
     end
   end
 end

data/sig/herb/parse_result.rbs

@@ -7,6 +7,9 @@ module Herb
     # : (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error]) -> void
     def initialize: (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error]) -> void
 
+    # : () -> Array[Herb::Errors::Error]
+    def errors: () -> Array[Herb::Errors::Error]
+
     # : () -> bool
     def failed?: () -> bool
 

data/src/analyze.c

@@ -49,13 +49,20 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
   if (node->type == AST_ERB_CONTENT_NODE) {
     AST_ERB_CONTENT_NODE_T* erb_content_node = (AST_ERB_CONTENT_NODE_T*) node;
 
-    analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
+    const char* opening = erb_content_node->tag_opening->value;
+    if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0) {
+      analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
 
-    if (false) { pretty_print_analyed_ruby(analyzed, erb_content_node->content->value); }
+      if (false) { pretty_print_analyed_ruby(analyzed, erb_content_node->content->value); }
 
-    erb_content_node->parsed = true;
-    erb_content_node->valid = analyzed->valid;
-    erb_content_node->analyzed_ruby = analyzed;
+      erb_content_node->parsed = true;
+      erb_content_node->valid = analyzed->valid;
+      erb_content_node->analyzed_ruby = analyzed;
+    } else {
+      erb_content_node->parsed = false;
+      erb_content_node->valid = true;
+      erb_content_node->analyzed_ruby = NULL;
+    }
   }
 
   herb_visit_child_nodes(node, analyze_erb_content, data);
@@ -64,12 +71,20 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 }
 
 static size_t process_block_children(
-  AST_NODE_T* node, array_T* array, size_t index, array_T* children_array, analyze_ruby_context_T* context,
+  AST_NODE_T* node,
+  array_T* array,
+  size_t index,
+  array_T* children_array,
+  analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
 static size_t process_subsequent_block(
-  AST_NODE_T* node, array_T* array, size_t index, AST_NODE_T** subsequent_out, analyze_ruby_context_T* context,
+  AST_NODE_T* node,
+  array_T* array,
+  size_t index,
+  AST_NODE_T** subsequent_out,
+  analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
@@ -132,7 +147,10 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 }
 
 static AST_NODE_T* create_control_node(
-  AST_ERB_CONTENT_NODE_T* erb_node, array_T* children, AST_NODE_T* subsequent, AST_ERB_END_NODE_T* end_node,
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  array_T* children,
+  AST_NODE_T* subsequent,
+  AST_ERB_END_NODE_T* end_node,
   control_type_t control_type
 ) {
   array_T* errors = array_init(8);
@@ -362,7 +380,11 @@ static AST_NODE_T* create_control_node(
 }
 
 static size_t process_control_structure(
-  AST_NODE_T* node, array_T* array, size_t index, array_T* output_array, analyze_ruby_context_T* context,
+  AST_NODE_T* node,
+  array_T* array,
+  size_t index,
+  array_T* output_array,
+  analyze_ruby_context_T* context,
   control_type_t initial_type
 ) {
   AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
@@ -858,7 +880,11 @@ static size_t process_control_structure(
 }
 
 static size_t process_subsequent_block(
-  AST_NODE_T* node, array_T* array, size_t index, AST_NODE_T** subsequent_out, analyze_ruby_context_T* context,
+  AST_NODE_T* node,
+  array_T* array,
+  size_t index,
+  AST_NODE_T** subsequent_out,
+  analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
   AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
@@ -922,7 +948,11 @@ static size_t process_subsequent_block(
 }
 
 static size_t process_block_children(
-  AST_NODE_T* node, array_T* array, size_t index, array_T* children_array, analyze_ruby_context_T* context,
+  AST_NODE_T* node,
+  array_T* array,
+  size_t index,
+  array_T* children_array,
+  analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
   while (index < array_size(array)) {

data/src/analyze_helpers.c

@@ -89,12 +89,17 @@ bool search_if_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
   if (node->type == PM_IF_NODE) {
-    analyzed->has_if_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_if_nodes, analyzed);
+    const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+
+    // Handle ternary
+    if (if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL) {
+      analyzed->has_if_node = true;
+      return true;
+    }
   }
 
+  pm_visit_child_nodes(node, search_if_nodes, analyzed);
+
   return false;
 }
 

data/src/extract.c

@@ -20,7 +20,9 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+        if (strcmp(token->value, "<%#") == 0 || strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+          skip_erb_content = true;
+        }
 
         buffer_append_whitespace(output, range_length(token->range));
         break;
@@ -67,7 +69,9 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+        if (strcmp(token->value, "<%#") == 0 || strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+          skip_erb_content = true;
+        }
 
         buffer_append_whitespace(output, range_length(token->range));
         break;

data/src/include/parser_helpers.h

@@ -16,7 +16,10 @@ void parser_append_unexpected_error(parser_T* parser, const char* description, c
 void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
 
 void parser_append_literal_node_from_buffer(
-  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+  const parser_T* parser,
+  buffer_T* buffer,
+  array_T* children,
+  position_T* start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
@@ -26,7 +29,9 @@ token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
 token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
-  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+  AST_HTML_OPEN_TAG_NODE_T* open_tag,
+  array_T* body,
+  array_T* errors
 );
 void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 

data/src/include/pretty_print.h

@@ -13,37 +13,77 @@ void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffe
 void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
 
 void pretty_print_position_property(
-  position_T* position, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  position_T* position,
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_location(location_T* location, buffer_T* buffer);
 
 void pretty_print_property(
-  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  const char* name,
+  const char* value,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
-  size_t value, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  size_t value,
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_string_property(
-  const char* string, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  const char* string,
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
-  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  const char* name,
+  const char* value,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
-  const char* name, bool value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  const char* name,
+  bool value,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_token_property(
-  token_T* token, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  token_T* token,
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+  const char* name,
+  array_T* array,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  buffer_T* buffer
 );
 
 void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);

data/src/include/prism_helpers.h

@@ -10,7 +10,10 @@
 const char* pm_error_level_to_string(pm_error_level_t level);
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
-  const pm_diagnostic_t* error, const AST_NODE_T* node, const char* source, pm_parser_t* parser
+  const pm_diagnostic_t* error,
+  const AST_NODE_T* node,
+  const char* source,
+  pm_parser_t* parser
 );
 
 position_T* position_from_source_with_offset(const char* source, size_t offset);

data/src/include/token_struct.h

@@ -20,7 +20,7 @@ typedef enum {
   TOKEN_HTML_COMMENT_START, // <!--
   TOKEN_HTML_COMMENT_END,   // -->
 
-  TOKEN_ERB_START,   // <%, <%=, <%#, <%-, <%==, <%%
+  TOKEN_ERB_START,   // <%, <%=, <%%=, <%#, <%-, <%==, <%%
   TOKEN_ERB_CONTENT, // Ruby Code
   TOKEN_ERB_END,     // %>, -%>, %%>
 

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.3.0"
+#define HERB_VERSION "0.4.0"
 
 #endif

data/src/lexer.c

@@ -163,7 +163,7 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  const char* erb_patterns[] = { "<%==", "<%=", "<%#", "<%-", "<%%", "<%" };
+  const char* erb_patterns[] = { "<%==", "<%%=", "<%=", "<%#", "<%-", "<%%", "<%" };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -184,7 +184,16 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
     }
 
     buffer_append_char(&buffer, lexer->current_character);
-    lexer_advance(lexer);
+
+    if (is_newline(lexer->current_character)) {
+      lexer->current_line++;
+      lexer->current_column = 0;
+    } else {
+      lexer->current_column++;
+    }
+
+    lexer->current_position++;
+    lexer->current_character = lexer->source[lexer->current_position];
   }
 
   lexer->state = STATE_ERB_CLOSE;

data/src/parser.c

@@ -197,13 +197,19 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value(
-  parser_T* parser, array_T* children, array_T* errors
+  parser_T* parser,
+  array_T* children,
+  array_T* errors
 ) {
   buffer_T buffer = buffer_new();
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
   position_T* start = position_copy(parser->current_token->location->start);
 
-  while (token_is_none_of(parser, TOKEN_QUOTE, TOKEN_EOF)) {
+  while (!token_is(parser, TOKEN_EOF)
+         && !(
+           token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
+           && strcmp(parser->current_token->value, opening_quote->value) == 0
+         )) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
@@ -472,7 +478,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
 // TODO: this should probably be AST_HTML_ELEMENT_NODE_T with a AST_HTML_SELF_CLOSING_TAG_NODE_T
 static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
-  const parser_T* parser, AST_HTML_OPEN_TAG_NODE_T* open_tag
+  const parser_T* parser,
+  AST_HTML_OPEN_TAG_NODE_T* open_tag
 ) {
   return ast_html_element_node_init(
     open_tag,
@@ -487,7 +494,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
 }
 
 static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
-  parser_T* parser, AST_HTML_OPEN_TAG_NODE_T* open_tag
+  parser_T* parser,
+  AST_HTML_OPEN_TAG_NODE_T* open_tag
 ) {
   array_T* errors = array_init(8);
   array_T* body = array_init(8);
@@ -618,6 +626,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_IDENTIFIER,
           TOKEN_NEWLINE,
           TOKEN_PERCENT,
+          TOKEN_QUOTE,
           TOKEN_SEMICOLON,
           TOKEN_SLASH,
           TOKEN_UNDERSCORE,

data/src/parser_helpers.c

@@ -80,7 +80,10 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
 }
 
 void parser_append_literal_node_from_buffer(
-  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+  const parser_T* parser,
+  buffer_T* buffer,
+  array_T* children,
+  position_T* start
 ) {
   if (buffer_length(buffer) == 0) { return; }
 
@@ -115,7 +118,9 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
 }
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
-  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+  AST_HTML_OPEN_TAG_NODE_T* open_tag,
+  array_T* body,
+  array_T* errors
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
@@ -137,7 +142,9 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 }
 
 void parser_handle_mismatched_tags(
-  const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  array_T* errors
 ) {
   if (array_size(parser->open_tags_stack) > 0) {
     token_T* expected_tag = array_last(parser->open_tags_stack);

data/src/pretty_print.c

@@ -25,7 +25,11 @@ void pretty_print_newline(const size_t indent, const size_t relative_indent, buf
 }
 
 void pretty_print_label(
-  const char* name, const size_t indent, const size_t relative_indent, const bool last_property, buffer_T* buffer
+  const char* name,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
+  buffer_T* buffer
 ) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
@@ -41,7 +45,11 @@ void pretty_print_label(
 }
 
 void pretty_print_quoted_property(
-  const char* name, const char* value, const size_t indent, const size_t relative_indent, const bool last_property,
+  const char* name,
+  const char* value,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   char* quoted = quoted_string(value);
@@ -50,14 +58,22 @@ void pretty_print_quoted_property(
 }
 
 void pretty_print_boolean_property(
-  const char* name, bool value, const size_t indent, const size_t relative_indent, const bool last_property,
+  const char* name,
+  bool value,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   pretty_print_property(name, value ? "true" : "false", indent, relative_indent, last_property, buffer);
 }
 
 void pretty_print_property(
-  const char* name, const char* value, const size_t indent, const size_t relative_indent, const bool last_property,
+  const char* name,
+  const char* value,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
@@ -66,7 +82,11 @@ void pretty_print_property(
 }
 
 void pretty_print_size_t_property(
-  size_t value, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  size_t value,
+  const char* name,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
@@ -77,7 +97,11 @@ void pretty_print_size_t_property(
 }
 
 void pretty_print_array(
-  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  const char* name,
+  array_T* array,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   if (array == NULL) {
@@ -122,7 +146,11 @@ void pretty_print_array(
 }
 
 void pretty_print_errors(
-  AST_NODE_T* node, const size_t indent, const size_t relative_indent, const bool last_property, buffer_T* buffer
+  AST_NODE_T* node,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
+  buffer_T* buffer
 ) {
   if (node->errors != NULL && array_size(node->errors) > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
@@ -146,7 +174,11 @@ void pretty_print_location(location_T* location, buffer_T* buffer) {
 }
 
 void pretty_print_position_property(
-  position_T* position, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  position_T* position,
+  const char* name,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
@@ -173,7 +205,11 @@ void pretty_print_position_property(
 }
 
 void pretty_print_token_property(
-  token_T* token, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  token_T* token,
+  const char* name,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
@@ -193,7 +229,11 @@ void pretty_print_token_property(
 }
 
 void pretty_print_string_property(
-  const char* string, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  const char* string,
+  const char* name,
+  const size_t indent,
+  const size_t relative_indent,
+  const bool last_property,
   buffer_T* buffer
 ) {
   const char* value = "∅";

data/src/prism_helpers.c

@@ -32,7 +32,10 @@ position_T* position_from_source_with_offset(const char* source, size_t offset)
 }
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
-  const pm_diagnostic_t* error, const AST_NODE_T* node, const char* source, pm_parser_t* parser
+  const pm_diagnostic_t* error,
+  const AST_NODE_T* node,
+  const char* source,
+  pm_parser_t* parser
 ) {
   size_t start_offset = (size_t) (error->location.start - parser->start);
   size_t end_offset = (size_t) (error->location.end - parser->start);

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: x86-linux-gnu
 authors:
 - Marco Roth
 bindir: exe
 cert_chain: []
-date: 2025-06-21 00:00:00.000000000 Z
+date: 2025-07-10 00:00:00.000000000 Z
 dependencies: []
 description: Powerful and seamless HTML-aware ERB parsing and tooling.
 email: