herb 0.8.10-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/lib/herb/bootstrap.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# typed: ignore
+
+require "fileutils"
+
+module Herb
+  module Bootstrap
+    ROOT_PATH = File.expand_path("../..", __dir__)
+    PRISM_VENDOR_DIR = File.join(ROOT_PATH, "vendor", "prism")
+
+    PRISM_ENTRIES = [
+      "config.yml",
+      "Rakefile",
+      "src/",
+      "include/",
+      "templates/"
+    ].freeze
+
+    def self.generate_templates
+      require "pathname"
+      require "set"
+      require_relative "../../templates/template"
+
+      Dir.chdir(ROOT_PATH) do
+        Dir.glob("#{ROOT_PATH}/templates/**/*.erb").each do |template|
+          Herb::Template.render(template)
+        end
+      end
+    end
+
+    def self.git_source?
+      File.directory?(File.join(ROOT_PATH, ".git"))
+    end
+
+    def self.templates_generated?
+      File.exist?(File.join(ROOT_PATH, "ext", "herb", "nodes.c"))
+    end
+
+    def self.vendor_prism(prism_gem_path:)
+      FileUtils.mkdir_p(PRISM_VENDOR_DIR)
+
+      PRISM_ENTRIES.each do |entry|
+        source = File.join(prism_gem_path, entry)
+        next unless File.exist?(source)
+
+        puts "Vendoring '#{entry}' Prism file to #{PRISM_VENDOR_DIR}/#{entry}"
+        FileUtils.cp_r(source, PRISM_VENDOR_DIR)
+      end
+
+      generate_prism_templates unless prism_ast_header_exists?
+    end
+
+    def self.prism_vendored?
+      File.directory?(File.join(PRISM_VENDOR_DIR, "include"))
+    end
+
+    def self.prism_ast_header_exists?
+      File.exist?(File.join(PRISM_VENDOR_DIR, "include", "prism", "ast.h"))
+    end
+
+    def self.find_prism_gem_path
+      find_prism_as_bundler_sibling || find_prism_from_gem_spec
+    end
+
+    def self.generate_prism_templates
+      puts "Generating Prism template files..."
+      system("ruby", "#{PRISM_VENDOR_DIR}/templates/template.rb", exception: true)
+    end
+
+    def self.find_prism_as_bundler_sibling
+      bundler_gems_dir = File.expand_path("..", ROOT_PATH)
+      candidates = Dir.glob(File.join(bundler_gems_dir, "prism-*"))
+
+      candidates.find { |path| File.directory?(File.join(path, "src")) }
+    end
+
+    def self.find_prism_from_gem_spec
+      path = Gem::Specification.find_by_name("prism").full_gem_path
+
+      return path if File.directory?(File.join(path, "src"))
+
+      nil
+    rescue Gem::MissingSpecError
+      nil
+    end
+  end
+end

data/lib/herb/cli.rb

@@ -8,16 +8,16 @@ require "optparse"
 class Herb::CLI
   include Herb::Colors
 
-  attr_accessor :json, :silent, :no_interactive, :no_log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug
+  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check
 
   def initialize(args)
     @args = args
     @command = args[0]
-    @file = args[1]
   end
 
   def call
     options
+    @file = @args[1]
 
     if silent
       if result.failed?
@@ -61,43 +61,60 @@ class Herb::CLI
   end
 
   def file_content
-    if @file && File.exist?(@file)
+    if @file && @file != "-" && File.exist?(@file)
       File.read(@file)
-    elsif @file
+    elsif @file && @file != "-"
       puts "File doesn't exist: #{@file}"
       exit(1)
+    elsif @file == "-" || !$stdin.tty?
+      $stdin.read
     else
       puts "No file provided."
       puts
       puts "Usage:"
       puts "  bundle exec herb #{@command} [file] [options]"
+      puts
+      puts "You can also pipe content via stdin:"
+      puts "  echo \"<div>Hello</div>\" | bundle exec herb #{@command}"
+      puts "  cat file.html.erb | bundle exec herb #{@command}"
+      puts "  bundle exec herb #{@command} -"
       exit(1)
     end
   end
 
   def help(exit_code = 0)
     message = <<~HELP
-      ▗▖ ▗▖▗▄▄▄▖▗▄▄▖ ▗▄▄▖
-      ▐▌ ▐▌▐▌   ▐▌ ▐▌▐▌ ▐▌
-      ▐▛▀▜▌▐▛▀▀▘▐▛▀▚▖▐▛▀▚▖
-      ▐▌ ▐▌▐▙▄▄▖▐▌ ▐▌▐▙▄▞▘
-
-      Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.
+      Herb 🌿 Powerful and seamless HTML-aware ERB toolchain.
 
       Usage:
         bundle exec herb [command] [options]
 
       Commands:
-        bundle exec herb lex [file]         Lex a file.
-        bundle exec herb parse [file]       Parse a file.
-        bundle exec herb compile [file]     Compile ERB template to Ruby code.
-        bundle exec herb render [file]      Compile and render ERB template to final output.
-        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 prism [file]       Extract Ruby from a file and parse the Ruby source with Prism.
-        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.
+        bundle exec herb lex [file]           Lex a file.
+        bundle exec herb parse [file]         Parse a file.
+        bundle exec herb compile [file]       Compile ERB template to Ruby code.
+        bundle exec herb render [file]        Compile and render ERB template to final output.
+        bundle exec herb analyze [path]       Analyze a project by passing a directory to the root of the project
+        bundle exec herb report [file]        Generate a Markdown bug report for a file
+        bundle exec herb config [path]        Show configuration and file patterns for a 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.
+
+        bundle exec herb lint [patterns]      Lint templates (delegates to @herb-tools/linter)
+        bundle exec herb format [patterns]    Format templates (delegates to @herb-tools/formatter)
+        bundle exec herb highlight [file]     Syntax highlight templates (delegates to @herb-tools/highlighter)
+        bundle exec herb print [file]         Print AST (delegates to @herb-tools/printer)
+        bundle exec herb lsp                  Start the language server (delegates to @herb-tools/language-server)
+
+      stdin:
+        Commands that accept [file] also accept input via stdin:
+          echo "<div>Hello</div>" | bundle exec herb lex
+          cat file.html.erb | bundle exec herb parse
+
+        Use `-` to explicitly read from stdin:
+          bundle exec herb compile -
 
       Options:
         #{option_parser.to_s.strip.gsub(/^    /, "  ")}
@@ -112,21 +129,44 @@ class Herb::CLI
   def result
     @result ||= case @command
                 when "analyze"
-                  project = Herb::Project.new(directory)
-                  project.no_interactive = no_interactive
-                  project.no_log_file = no_log_file
+                  path = @file || "."
+
+                  if path != "-" && File.file?(path)
+                    project = Herb::Project.new(File.dirname(path))
+                    project.file_paths = [File.expand_path(path)]
+                  else
+                    unless File.directory?(path)
+                      puts "Not a file or directory: '#{path}'."
+                      exit(1)
+                    end
+
+                    project = Herb::Project.new(path)
+                  end
+
+                  project.no_log_file = log_file ? false : true
                   project.no_timing = no_timing
                   project.silent = silent
-                  has_issues = project.parse!
+                  project.verbose = verbose || ci?
+                  project.isolate = isolate
+                  project.validate_ruby = true
+                  project.arena_stats = arena_stats
+                  project.leak_check = leak_check
+                  has_issues = project.analyze!
                   exit(has_issues ? 1 : 0)
+                when "report"
+                  generate_report
+                  exit(0)
+                when "config"
+                  show_config
+                  exit(0)
                 when "parse"
-                  Herb.parse(file_content)
+                  Herb.parse(file_content, strict: strict.nil? || strict, analyze: analyze.nil? || analyze, track_whitespace: track_whitespace || false, arena_stats: arena_stats)
                 when "compile"
                   compile_template
                 when "render"
                   render_template
                 when "lex"
-                  Herb.lex(file_content)
+                  Herb.lex(file_content, arena_stats: arena_stats)
                 when "ruby"
                   puts Herb.extract_ruby(file_content)
                   exit(0)
@@ -134,7 +174,12 @@ class Herb::CLI
                   puts Herb.extract_html(file_content)
                   exit(0)
                 when "playground"
-                  require "lz_string"
+                  require "bundler/inline"
+
+                  gemfile do
+                    source "https://rubygems.org"
+                    gem "lz_string"
+                  end
 
                   hash = LZString::UriSafe.compress(file_content)
                   local_url = "http://localhost:5173"
@@ -152,6 +197,16 @@ class Herb::CLI
                     system(%(open "#{url}##{hash}"))
                     exit(0)
                   end
+                when "lint"
+                  run_node_tool("herb-lint", "@herb-tools/linter")
+                when "format"
+                  run_node_tool("herb-format", "@herb-tools/formatter")
+                when "print"
+                  run_node_tool("herb-print", "@herb-tools/printer")
+                when "highlight"
+                  run_node_tool("herb-highlight", "@herb-tools/highlighter")
+                when "lsp"
+                  run_node_tool("herb-language-server", "@herb-tools/language-server")
                 when "help"
                   help
                 when "version"
@@ -187,12 +242,16 @@ class Herb::CLI
         self.silent = true
       end
 
-      parser.on("-n", "--non-interactive", "Disable interactive output (progress bars, terminal clearing)") do
-        self.no_interactive = true
+      parser.on("--verbose", "Show detailed per-file progress (default in CI)") do
+        self.verbose = true
+      end
+
+      parser.on("--isolate", "Fork each file into its own process for crash isolation (slower)") do
+        self.isolate = true
       end
 
-      parser.on("--no-log-file", "Disable log file generation") do
-        self.no_log_file = true
+      parser.on("--log-file", "Enable log file generation") do
+        self.log_file = true
       end
 
       parser.on("--no-timing", "Disable timing output") do
@@ -218,15 +277,100 @@ class Herb::CLI
       parser.on("--debug", "Enable debug mode with ERB expression wrapping (for compile command)") do
         self.debug = true
       end
+
+      parser.on("--strict", "Enable strict mode - report errors for omitted closing tags (for parse/compile/render commands) (default: true)") do
+        self.strict = true
+      end
+
+      parser.on("--no-strict", "Disable strict mode (for parse/compile/render commands)") do
+        self.strict = false
+      end
+
+      parser.on("--analyze", "Enable analyze mode (for parse command) (default: true)") do
+        self.analyze = true
+      end
+
+      parser.on("--no-analyze", "Disable analyze mode (for parse command)") do
+        self.analyze = false
+      end
+
+      parser.on("--track-whitespace", "Enable whitespace tracking (for parse command) (default: false)") do
+        self.track_whitespace = true
+      end
+
+      parser.on("--tool TOOL", "Show config for specific tool: linter, formatter (for config command)") do |t|
+        self.tool = t.to_sym
+      end
+
+      parser.on("--arena-stats", "Print arena memory statistics (for lex/parse/analyze commands)") do
+        self.arena_stats = true
+      end
+
+      parser.on("--leak-check", "Check for memory leaks in lex/parse/extract operations (for analyze command)") do
+        self.leak_check = true
+      end
     end
   end
 
   def options
+    return if ["lint", "format", "print", "highlight", "lsp"].include?(@command)
+
     option_parser.parse!(@args)
   end
 
   private
 
+  def ci?
+    ENV["CI"] == "true" || ENV.key?("GITHUB_ACTIONS") || ENV.key?("BUILDKITE") || ENV.key?("JENKINS_URL") || ENV.key?("CIRCLECI") || ENV.key?("TRAVIS")
+  end
+
+  def find_node_binary(name)
+    local_bin = File.join(Dir.pwd, "node_modules", ".bin", name)
+    return local_bin if File.executable?(local_bin)
+
+    path_result = `which #{name} 2>/dev/null`.strip
+    return path_result unless path_result.empty?
+
+    nil
+  end
+
+  def node_available?
+    system("which node > /dev/null 2>&1")
+  end
+
+  def run_node_tool(binary_name, package_name)
+    unless node_available?
+      warn "Error: Node.js is required to run 'herb #{@command}'."
+      warn ""
+      warn "Install the tool:"
+      warn "  npm install #{package_name}"
+      warn "  yarn add #{package_name}"
+      warn "  pnpm add #{package_name}"
+      warn "  bun add #{package_name}"
+      warn ""
+      warn "Or install Node.js from https://nodejs.org"
+      exit 1
+    end
+
+    remaining_args = @args[1..]
+    binary = find_node_binary(binary_name)
+    node_version = `node --version 2>/dev/null`.strip
+
+    command_parts = if binary
+                      [binary, *remaining_args]
+                    else
+                      ["npx", package_name, *remaining_args]
+                    end
+
+    escaped_command = command_parts.map { |arg| arg.include?(" ") ? "\"#{arg}\"" : arg }.join(" ")
+
+    warn "Node.js: #{node_version}"
+    warn "Running: #{escaped_command}"
+    warn ""
+
+    exec(*command_parts)
+  end
+
   def print_error_summary(errors)
     puts
     puts white("#{bold(red("Errors"))} #{dimmed("(#{errors.size} total)")}")
@@ -254,6 +398,35 @@ class Herb::CLI
     end
   end
 
+  def generate_report
+    unless @file
+      puts "Usage: herb report <file>"
+      exit(1)
+    end
+
+    unless File.file?(@file)
+      puts "File not found: #{@file}"
+      exit(1)
+    end
+
+    project = Herb::Project.new(File.dirname(@file))
+    project.file_paths = [File.expand_path(@file)]
+    project.no_log_file = true
+    project.no_timing = true
+    project.silent = true
+    project.validate_ruby = true
+
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      project.analyze!
+    ensure
+      $stdout = original_stdout
+    end
+
+    project.print_file_report(@file)
+  end
+
   def compile_template
     require_relative "engine"
 
@@ -262,12 +435,14 @@ class Herb::CLI
       options[:filename] = @file if @file
       options[:escape] = no_escape ? false : true
       options[:freeze] = true if freeze
+      options[:strict] = strict.nil? || strict
 
       if debug
         options[:debug] = true
         options[:debug_filename] = @file if @file
       end
 
+      options[:validate_ruby] = true
       engine = Herb::Engine.new(file_content, options)
 
       if json
@@ -276,6 +451,7 @@ class Herb::CLI
           source: engine.src,
           filename: engine.filename,
           bufvar: engine.bufvar,
+          strict: options[:strict],
         }
 
         puts result.to_json
@@ -286,6 +462,24 @@ class Herb::CLI
       end
 
       exit(0)
+    rescue Herb::Engine::InvalidRubyError => e
+      if json
+        result = {
+          success: false,
+          error: e.message,
+          source: e.compiled_source,
+          filename: @file,
+        }
+        puts result.to_json
+      elsif silent
+        puts "Failed"
+      else
+        puts e.compiled_source if e.compiled_source
+        puts
+        puts e.message
+      end
+
+      exit(1)
     rescue Herb::Engine::CompilationError => e
       if json
         result = {
@@ -328,6 +522,7 @@ class Herb::CLI
       options[:filename] = @file if @file
       options[:escape] = no_escape ? false : true
       options[:freeze] = true if freeze
+      options[:strict] = strict.nil? || strict
 
       if debug
         options[:debug] = true
@@ -344,6 +539,7 @@ class Herb::CLI
           success: true,
           output: rendered_output,
           filename: engine.filename,
+          strict: options[:strict],
         }
 
         puts result.to_json
@@ -388,6 +584,120 @@ class Herb::CLI
     end
   end
 
+  def show_config
+    path = @file || "."
+    config = Herb::Configuration.load(path)
+
+    if tool
+      show_tool_config(config, path)
+    else
+      show_general_config(config, path)
+    end
+  end
+
+  def show_general_config(config, path)
+    puts bold("Herb Configuration")
+    puts
+    puts "#{bold("Project root:")} #{config.project_root || "(not found)"}"
+    puts "#{bold("Config file:")}  #{config.config_path || "(using defaults)"}"
+    puts
+
+    puts bold("Include patterns:")
+    config.file_include_patterns.each { |p| puts "  #{green("+")} #{p}" }
+    puts
+
+    puts bold("Exclude patterns:")
+    config.file_exclude_patterns.each { |p| puts "  #{red("-")} #{p}" }
+    puts
+
+    all_matched = find_all_matching_files(path, config.file_include_patterns)
+    included_files = config.find_files(path)
+    excluded_files = all_matched - included_files
+
+    puts bold("Files (#{included_files.size} included, #{excluded_files.size} excluded):")
+    puts
+
+    show_file_lists(included_files, excluded_files, path, config.file_exclude_patterns)
+
+    puts
+    puts dimmed("Tip: Use --tool linter or --tool formatter to see tool-specific configuration")
+  end
+
+  def show_tool_config(config, path)
+    unless [:linter, :formatter].include?(tool)
+      puts red("Unknown tool: #{tool}")
+      puts "Valid tools: linter, formatter"
+      exit(1)
+    end
+
+    tool_config = config.send(tool)
+    include_patterns = config.include_patterns_for(tool)
+    exclude_patterns = config.exclude_patterns_for(tool)
+
+    puts bold("Herb Configuration for #{tool.to_s.capitalize}")
+    puts
+    puts "#{bold("Project root:")} #{config.project_root || "(not found)"}"
+    puts "#{bold("Config file:")}  #{config.config_path || "(using defaults)"}"
+    puts
+
+    if tool_config["enabled"] == false
+      puts yellow("⚠ #{tool.to_s.capitalize} is disabled in configuration")
+      puts
+    end
+
+    puts bold("Include patterns (files + #{tool}):")
+    include_patterns.each { |p| puts "  #{green("+")} #{p}" }
+    puts
+
+    puts bold("Exclude patterns (files + #{tool}):")
+    exclude_patterns.each { |p| puts "  #{red("-")} #{p}" }
+    puts
+
+    all_matched = find_all_matching_files(path, include_patterns)
+    included_files = config.find_files_for_tool(tool, path)
+    excluded_files = all_matched - included_files
+
+    puts bold("Files for #{tool} (#{included_files.size} included, #{excluded_files.size} excluded):")
+    puts
+
+    show_file_lists(included_files, excluded_files, path, exclude_patterns)
+  end
+
+  def show_file_lists(included_files, excluded_files, path, exclude_patterns)
+    expanded_path = File.expand_path(path)
+
+    if included_files.any?
+      puts "  #{bold(green("Included:"))}"
+      included_files.each do |f|
+        relative = f.sub("#{expanded_path}/", "")
+        puts "    #{green("✓")} #{relative}"
+      end
+      puts
+    end
+
+    return unless excluded_files.any?
+
+    puts "  #{bold(red("Excluded:"))}"
+    excluded_files.each do |f|
+      relative = f.sub("#{expanded_path}/", "")
+      reason = find_exclude_reason(relative, exclude_patterns)
+      puts "    #{red("✗")} #{relative} #{dimmed("(#{reason})")}"
+    end
+  end
+
+  def find_all_matching_files(path, include_patterns)
+    expanded_path = File.expand_path(path)
+    include_patterns.flat_map do |pattern|
+      Dir[File.join(expanded_path, pattern)]
+    end.uniq
+  end
+
+  def find_exclude_reason(relative_path, exclude_patterns)
+    exclude_patterns.find do |pattern|
+      File.fnmatch?(pattern, relative_path, File::FNM_PATHNAME)
+    end || "excluded"
+  end
+
   def print_version
     puts Herb.version
     exit(0)