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

data/lib/herb/configuration.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Herb
+  class Configuration
+    CONFIG_FILENAMES = [".herb.yml"].freeze
+
+    PROJECT_INDICATORS = [
+      ".git",
+      ".herb",
+      ".herb.yml",
+      "Gemfile",
+      "package.json",
+      "Rakefile",
+      "README.md",
+      "*.gemspec",
+      "config/application.rb"
+    ].freeze
+
+    DEFAULTS_PATH = File.expand_path("defaults.yml", __dir__ || __FILE__).freeze
+    DEFAULTS = YAML.safe_load_file(DEFAULTS_PATH).freeze
+
+    attr_reader :config, :config_path, :project_root
+
+    def initialize(project_path = nil)
+      @start_path = project_path ? Pathname.new(project_path) : Pathname.pwd
+      @config_path, @project_root = find_config_file
+      @config = load_config
+    end
+
+    def [](key)
+      @config[key.to_s]
+    end
+
+    def dig(*keys)
+      @config.dig(*keys.map(&:to_s))
+    end
+
+    def version
+      @config["version"]
+    end
+
+    def files
+      @config["files"] || {}
+    end
+
+    def file_include_patterns
+      files["include"] || DEFAULTS.dig("files", "include") || []
+    end
+
+    def file_exclude_patterns
+      files["exclude"] || DEFAULTS.dig("files", "exclude") || []
+    end
+
+    def linter
+      @config["linter"] || {}
+    end
+
+    def engine
+      @config["engine"] || {}
+    end
+
+    def enabled_validators(overrides = {})
+      config = dig("engine", "validators") || {}
+
+      {
+        security: config.fetch("security", true),
+        nesting: config.fetch("nesting", true),
+        accessibility: config.fetch("accessibility", true),
+      }.merge(
+        overrides.to_h { |key, value| [key.to_sym, !!value] }
+      )
+    end
+
+    def formatter
+      @config["formatter"] || {}
+    end
+
+    def include_patterns_for(tool)
+      tool_config = send(tool.to_s)
+      file_include_patterns + (tool_config["include"] || [])
+    end
+
+    def exclude_patterns_for(tool)
+      tool_config = send(tool.to_s)
+      file_exclude_patterns + (tool_config["exclude"] || [])
+    end
+
+    def linter_include_patterns
+      include_patterns_for(:linter)
+    end
+
+    def linter_exclude_patterns
+      exclude_patterns_for(:linter)
+    end
+
+    def formatter_include_patterns
+      include_patterns_for(:formatter)
+    end
+
+    def formatter_exclude_patterns
+      exclude_patterns_for(:formatter)
+    end
+
+    def enabled_for_path?(path, tool)
+      tool_config = send(tool.to_s)
+      tool_include = tool_config["include"] || []
+      tool_exclude = tool_config["exclude"] || []
+
+      if tool_include.any? && path_included?(path, tool_include)
+        return !path_excluded?(path, tool_exclude)
+      end
+
+      exclude_patterns = exclude_patterns_for(tool)
+
+      !path_excluded?(path, exclude_patterns)
+    end
+
+    def linter_enabled_for_path?(path)
+      enabled_for_path?(path, :linter)
+    end
+
+    def formatter_enabled_for_path?(path)
+      enabled_for_path?(path, :formatter)
+    end
+
+    def path_excluded?(path, patterns)
+      patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME) }
+    end
+
+    def path_included?(path, patterns)
+      patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME) }
+    end
+
+    def find_files(search_path = nil)
+      search_path ||= @project_root || @start_path
+      expanded_path = File.expand_path(search_path.to_s)
+
+      all_files = file_include_patterns.flat_map do |pattern|
+        Dir[File.join(expanded_path, pattern)]
+      end.uniq
+
+      all_files.reject do |file|
+        relative = file.sub("#{expanded_path}/", "")
+        path_excluded?(relative, file_exclude_patterns)
+      end.sort
+    end
+
+    def find_files_for_tool(tool, search_path = nil)
+      search_path ||= @project_root || @start_path
+      expanded_path = File.expand_path(search_path.to_s)
+
+      include_patterns = include_patterns_for(tool)
+      exclude_patterns = exclude_patterns_for(tool)
+
+      all_files = include_patterns.flat_map do |pattern|
+        Dir[File.join(expanded_path, pattern)]
+      end.uniq
+
+      all_files.reject do |file|
+        relative = file.sub("#{expanded_path}/", "")
+        path_excluded?(relative, exclude_patterns)
+      end.sort
+    end
+
+    def find_files_for_linter(search_path = nil)
+      find_files_for_tool(:linter, search_path)
+    end
+
+    def find_files_for_formatter(search_path = nil)
+      find_files_for_tool(:formatter, search_path)
+    end
+
+    class << self
+      def load(project_path = nil)
+        new(project_path)
+      end
+
+      def default
+        @default ||= new
+      end
+
+      def default_file_patterns
+        DEFAULTS.dig("files", "include") || []
+      end
+
+      def default_exclude_patterns
+        DEFAULTS.dig("files", "exclude") || []
+      end
+    end
+
+    private
+
+    def find_config_file
+      search_path = @start_path
+      search_path = search_path.parent if search_path.file?
+
+      while search_path.to_s != "/"
+        CONFIG_FILENAMES.each do |filename|
+          config_file = search_path / filename
+          return [config_file, search_path] if config_file.exist?
+        end
+
+        return [nil, search_path] if project_root?(search_path)
+
+        search_path = search_path.parent
+      end
+
+      [nil, @start_path]
+    end
+
+    def project_root?(path)
+      PROJECT_INDICATORS.any? do |indicator|
+        if indicator.include?("*")
+          Dir.glob(path / indicator).any?
+        else
+          (path / indicator).exist?
+        end
+      end
+    end
+
+    def load_config
+      return deep_merge(DEFAULTS, {}) unless @config_path&.exist?
+
+      begin
+        user_config = YAML.safe_load_file(@config_path, permitted_classes: [Symbol]) || {}
+        deep_merge(DEFAULTS, user_config)
+      rescue Psych::SyntaxError => e
+        warn "Warning: Invalid YAML in #{@config_path}: #{e.message}"
+        deep_merge(DEFAULTS, {})
+      end
+    end
+
+    def deep_merge(base, override, additive_keys: ["include", "exclude"])
+      base.merge(override) do |key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val, additive_keys: additive_keys)
+        elsif old_val.is_a?(Array) && new_val.is_a?(Array) && additive_keys.include?(key)
+          old_val + new_val
+        else
+          new_val
+        end
+      end
+    end
+  end
+end

data/lib/herb/defaults.yml

@@ -0,0 +1,32 @@
+files:
+  include:
+    - "**/*.herb"
+    - "**/*.html.erb"
+    - "**/*.html.herb"
+    - "**/*.html"
+    - "**/*.html+*.erb"
+    - "**/*.rhtml"
+    - "**/*.turbo_stream.erb"
+
+  exclude:
+    - "coverage/**/*"
+    - "log/**/*"
+    - "node_modules/**/*"
+    - "storage/**/*"
+    - "tmp/**/*"
+    - "vendor/**/*"
+
+engine:
+  validators:
+    security: true
+    nesting: true
+    accessibility: true
+
+linter:
+  enabled: true
+  rules: {}
+
+formatter:
+  enabled: false
+  indentWidth: 2
+  maxLineLength: 80

data/lib/herb/engine/compiler.rb

@@ -22,7 +22,7 @@ module Herb
       def generate_output
         optimized_tokens = optimize_tokens(@tokens)
 
-        optimized_tokens.each do |type, value, context|
+        optimized_tokens.each do |type, value, context, escaped|
           case type
           when :text
             @engine.send(:add_text, value)
@@ -48,6 +48,8 @@ module Herb
           when :expr_block_escaped
             indicator = @escape ? "=" : "=="
             @engine.send(:add_expression_block, indicator, value)
+          when :expr_block_end
+            @engine.send(:add_expression_block_end, value, escaped: escaped)
           end
         end
       end
@@ -71,7 +73,27 @@ module Herb
         visit_all(node.body)
         visit(node.close_tag)
 
-        pop_context if %w[script style].include?(tag_name)
+        pop_context if ["script", "style"].include?(tag_name)
+
+        @element_stack.pop if tag_name
+      end
+
+      def visit_html_conditional_element_node(node)
+        tag_name = node.tag_name&.value&.downcase
+
+        @element_stack.push(tag_name) if tag_name
+
+        if tag_name == "script"
+          push_context(:script_content)
+        elsif tag_name == "style"
+          push_context(:style_content)
+        end
+
+        visit(node.open_conditional)
+        visit_all(node.body)
+        visit(node.close_conditional)
+
+        pop_context if ["script", "style"].include?(tag_name)
 
         @element_stack.pop if tag_name
       end
@@ -125,6 +147,10 @@ module Herb
         add_text(node.tag_closing&.value)
       end
 
+      def visit_html_omitted_close_tag_node(node)
+        # no-op
+      end
+
       def visit_html_text_node(node)
         add_text(node.content)
       end
@@ -168,7 +194,9 @@ module Herb
       end
 
       def visit_erb_control_node(node, &_block)
-        apply_trim(node, node.content.value.strip)
+        if node.content
+          apply_trim(node, node.content.value.strip)
+        end
 
         yield if block_given?
       end
@@ -257,7 +285,7 @@ module Herb
                      end
 
           visit_all(node.body)
-          visit(node.end_node)
+          visit_erb_block_end_node(node.end_node, escaped: should_escape)
         else
           visit_erb_control_node(node) do
             visit_all(node.body)
@@ -266,6 +294,24 @@ module Herb
         end
       end
 
+      def visit_erb_block_end_node(node, escaped: false)
+        has_left_trim = node.tag_opening.value.start_with?("<%-")
+
+        remove_trailing_whitespace_from_last_token! if has_left_trim
+
+        code = node.content.value.strip
+
+        if at_line_start?
+          lspace = extract_and_remove_lspace!
+          rspace = " \n"
+
+          @tokens << [:expr_block_end, "#{lspace}#{code}#{rspace}", current_context, escaped]
+          @trim_next_whitespace = true
+        else
+          @tokens << [:expr_block_end, code, current_context, escaped]
+        end
+      end
+
       def visit_erb_control_with_parts(node, *parts)
         visit_erb_control_node(node) do
           parts.each do |part|
@@ -320,13 +366,22 @@ module Herb
       def process_erb_tag(node, skip_comment_check: false)
         opening = node.tag_opening.value
 
-        return if !skip_comment_check && erb_comment?(opening)
+        if !skip_comment_check && erb_comment?(opening)
+          has_left_trim = opening.start_with?("<%-")
+          remove_trailing_whitespace_from_last_token! if has_left_trim
+
+          if at_line_start?
+            extract_and_remove_lspace!
+            @trim_next_whitespace = true
+          end
+          return
+        end
         return if erb_graphql?(opening)
 
         code = node.content.value.strip
 
         if erb_output?(opening)
-          process_erb_output(opening, code)
+          process_erb_output(node, opening, code)
         else
           apply_trim(node, code)
         end
@@ -370,7 +425,7 @@ module Herb
         current_text = ""
         current_context = nil
 
-        compacted.each do |type, value, context|
+        compacted.each do |type, value, context, escaped|
           if type == :text
             current_text += value
             current_context ||= context
@@ -382,7 +437,7 @@ module Herb
               current_context = nil
             end
 
-            optimized << [type, value, context]
+            optimized << [type, value, context, escaped]
           end
         end
 
@@ -441,9 +496,11 @@ module Herb
         search_index >= 0 ? tokens[search_index] : nil
       end
 
-      def process_erb_output(opening, code)
+      def process_erb_output(node, opening, code)
+        has_right_trim = node.tag_closing&.value == "-%>"
         should_escape = should_escape_output?(opening)
         add_expression_with_escaping(code, should_escape)
+        @trim_next_whitespace = true if has_right_trim
       end
 
       def should_escape_output?(opening)
@@ -464,10 +521,20 @@ module Herb
           @tokens.last[0] != :text ||
           @tokens.last[1].empty? ||
           @tokens.last[1].end_with?("\n") ||
-          @tokens.last[1] =~ /\A[ \t]+\z/ ||
+          (@tokens.last[1] =~ /\A[ \t]+\z/ && preceding_token_ends_with_newline?) ||
           @tokens.last[1] =~ /\n[ \t]+\z/
       end
 
+      def preceding_token_ends_with_newline?
+        return true unless @tokens.length >= 2
+
+        preceding = @tokens[-2]
+        return false if [:expr, :expr_escaped, :expr_block, :expr_block_escaped, :expr_block_end].include?(preceding[0])
+        return true unless preceding[0] == :text
+
+        preceding[1].end_with?("\n")
+      end
+
       def extract_lspace
         return "" unless @tokens.last && @tokens.last[0] == :text
 
@@ -501,7 +568,7 @@ module Herb
 
         if at_line_start?
           lspace = extract_and_remove_lspace!
-          rspace = " \n"
+          rspace = Herb::Engine.heredoc?(code) ? "\n" : " \n"
 
           @tokens << [:code, "#{lspace}#{code}#{rspace}", current_context]
           @trim_next_whitespace = true

data/lib/herb/engine/debug_visitor.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: false
 
 module Herb
   class Engine
@@ -31,6 +32,7 @@ module Herb
         @in_html_comment = false
         @in_html_doctype = false
         @erb_nodes_to_wrap = [] #: Array[Herb::AST::ERBContentNode]
+        @top_level_elements = [] #: Array[Herb::AST::HTMLElementNode]
       end
 
       def visit_document_node(node)
@@ -149,8 +151,6 @@ module Herb
       end
 
       def find_top_level_elements(document_node)
-        @top_level_elements = [] #: Array[Herb::AST::HTMLElementNode]
-
         document_node.children.each do |child|
           @top_level_elements << child if child.is_a?(Herb::AST::HTMLElementNode)
         end
@@ -339,7 +339,9 @@ module Herb
         excluded_tags = ["script", "style", "head", "textarea", "pre", "svg", "math"]
         return true if excluded_tags.any? { |tag| @element_stack.include?(tag) }
 
-        return true if @erb_block_stack.any? { |node| javascript_tag?(node.content.value.strip) }
+        if @erb_block_stack.any? { |node| javascript_tag?(node.content.value.strip) || include_debug_disable_comment?(node.content.value.strip) }
+          return true
+        end
 
         false
       end
@@ -390,6 +392,14 @@ module Herb
 
         false
       end
+
+      def include_debug_disable_comment?(code)
+        cleaned_code = code.strip.gsub(/\s+/, " ")
+
+        return true if cleaned_code.match?(/#\s*herb:debug\sdisable\s*$/)
+
+        false
+      end
     end
   end
 end

data/lib/herb/engine/error_formatter.rb

@@ -214,12 +214,9 @@ module Herb
           output << "  Details: #{error.error_message}\n"
           output << "  Suggestion: Check your Ruby syntax inside the ERB tag\n"
 
-        when Herb::Errors::QuotesMismatchError
-          if error.opening_quote && error.closing_quote
-            output << "  Opening quote: #{error.opening_quote.value}\n"
-            output << "  Closing quote: #{error.closing_quote.value}\n"
-            output << "  Suggestion: Use matching quotes for attribute values\n"
-          end
+        when Herb::Errors::MissingAttributeValueError
+          output << "  Attribute: #{error.attribute_name}\n"
+          output << "  Suggestion: Add a value after the equals sign or remove the equals sign\n"
         end
 
         output
@@ -229,7 +226,8 @@ module Herb
         case error
         when Herb::Errors::MissingClosingTagError,
              Herb::Errors::TagNamesMismatchError,
-             Herb::Errors::UnclosedElementError
+             Herb::Errors::UnclosedElementError,
+             Herb::Errors::MissingAttributeValueError
           true
         else
           false
@@ -244,6 +242,8 @@ module Herb
           "← Tag mismatch"
         when Herb::Errors::UnclosedElementError
           "← Unclosed element"
+        when Herb::Errors::MissingAttributeValueError
+          "← Missing attribute value"
         else
           ""
         end
@@ -419,8 +419,12 @@ module Herb
           end
         when Herb::Errors::RubyParseError
           "Check your Ruby syntax inside the ERB tag"
-        when Herb::Errors::QuotesMismatchError
-          "Use matching quotes for attribute values"
+        when Herb::Errors::MissingAttributeValueError
+          if error.attribute_name
+            "Add a value after the equals sign for '#{error.attribute_name}' or remove the equals sign"
+          else
+            "Add a value after the equals sign or remove the equals sign"
+          end
         end
       end
     end

data/lib/herb/engine/parser_error_overlay.rb

@@ -9,12 +9,12 @@ module Herb
         Herb::Errors::UnexpectedTokenError,
         Herb::Errors::UnexpectedError,
         Herb::Errors::RubyParseError,
-        Herb::Errors::QuotesMismatchError,
         Herb::Errors::TagNamesMismatchError,
         Herb::Errors::VoidElementClosingTagError,
         Herb::Errors::UnclosedElementError,
         Herb::Errors::MissingClosingTagError,
-        Herb::Errors::MissingOpeningTagError
+        Herb::Errors::MissingOpeningTagError,
+        Herb::Errors::MissingAttributeValueError
       ].freeze
 
       def initialize(source, errors, filename: nil)
@@ -729,8 +729,12 @@ module Herb
           end
         when Herb::Errors::RubyParseError
           "Fix Ruby syntax: Check your Ruby syntax inside the ERB tag"
-        when Herb::Errors::QuotesMismatchError
-          "Fix quote mismatch: Use matching quotes for attribute values"
+        when Herb::Errors::MissingAttributeValueError
+          if error.respond_to?(:attribute_name) && error.attribute_name
+            "Add attribute value: Add a value after the equals sign for '#{error.attribute_name}' or remove the equals sign"
+          else
+            "Add attribute value: Add a value after the equals sign or remove the equals sign"
+          end
         else
           message = error.respond_to?(:message) ? error.message : error.to_s
           "Fix error: #{message}"
@@ -747,10 +751,10 @@ module Herb
           "← Unclosed element"
         when Herb::Errors::VoidElementClosingTagError
           "← Void element cannot be closed"
-        when Herb::Errors::QuotesMismatchError
-          "← Quote mismatch"
         when Herb::Errors::RubyParseError
           "← Ruby syntax error"
+        when Herb::Errors::MissingAttributeValueError
+          "← Missing attribute value"
         end
       end
 

data/lib/herb/engine/validator.rb

@@ -3,14 +3,19 @@
 module Herb
   class Engine
     class Validator < Herb::Visitor
-      attr_reader :diagnostics
+      attr_reader :diagnostics, :enabled
 
-      def initialize
-        super
+      def initialize(enabled: true)
+        super()
 
+        @enabled = enabled
         @diagnostics = []
       end
 
+      def enabled?
+        @enabled
+      end
+
       def validate(node)
         visit(node)
       end

data/lib/herb/engine/validators/nesting_validator.rb

@@ -31,7 +31,7 @@ module Herb
         end
 
         def validate_no_block_elements_in_paragraph(node)
-          block_elements = %w[div section article header footer nav aside p h1 h2 h3 h4 h5 h6 ul ol dl table form]
+          block_elements = ["div", "section", "article", "header", "footer", "nav", "aside", "p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "dl", "table", "form"]
 
           node.body.each do |child|
             next unless child.is_a?(Herb::AST::HTMLElementNode)
@@ -58,7 +58,7 @@ module Herb
         end
 
         def validate_no_interactive_in_button(node)
-          interactive_elements = %w[a button input select textarea]
+          interactive_elements = ["a", "button", "input", "select", "textarea"]
 
           node.body.each do |child|
             next unless child.is_a?(Herb::AST::HTMLElementNode)