herb 0.6.1-x86-linux-musl → 0.7.0-x86-linux-musl

data/lib/herb/engine.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "pathname"
+
+require_relative "engine/debug_visitor"
+require_relative "engine/compiler"
+require_relative "engine/error_formatter"
+require_relative "engine/validation_errors"
+require_relative "engine/parser_error_overlay"
+require_relative "engine/validation_error_overlay"
+require_relative "engine/validators/security_validator"
+require_relative "engine/validators/nesting_validator"
+require_relative "engine/validators/accessibility_validator"
+
+module Herb
+  class Engine
+    attr_reader :src, :filename, :project_path, :relative_file_path, :bufvar, :debug, :content_for_head,
+                :validation_error_template
+
+    ESCAPE_TABLE = {
+      "&" => "&",
+      "<" => "&lt;",
+      ">" => "&gt;",
+      '"' => "&quot;",
+      "'" => "&#39;",
+    }.freeze
+
+    class CompilationError < StandardError
+    end
+
+    def initialize(input, properties = {})
+      @filename = properties[:filename] ? ::Pathname.new(properties[:filename]) : nil
+      @project_path = ::Pathname.new(properties[:project_path] || Dir.pwd)
+
+      if @filename
+        absolute_filename = @filename.absolute? ? @filename : @project_path + @filename
+        @relative_file_path = absolute_filename.relative_path_from(@project_path).to_s
+      else
+        @relative_file_path = "unknown"
+      end
+
+      @bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
+      @escape = properties.fetch(:escape) { properties.fetch(:escape_html, false) }
+      @escapefunc = properties[:escapefunc]
+      @src = properties[:src] || String.new
+      @chain_appends = properties[:chain_appends]
+      @buffer_on_stack = false
+      @debug = properties.fetch(:debug, false)
+      @content_for_head = properties[:content_for_head]
+      @validation_error_template = nil
+      @validation_mode = properties.fetch(:validation_mode, :raise)
+
+      unless [:raise, :overlay, :none].include?(@validation_mode)
+        raise ArgumentError,
+              "validation_mode must be one of :raise, :overlay, or :none, got #{@validation_mode.inspect}"
+      end
+
+      @escapefunc ||= if @escape
+                        "__herb.h"
+                      else
+                        "::Herb::Engine.h"
+                      end
+
+      @freeze = properties[:freeze]
+      @freeze_template_literals = properties.fetch(:freeze_template_literals, true)
+      @text_end = @freeze_template_literals ? "'.freeze" : "'"
+
+      bufval = properties[:bufval] || "::String.new"
+      preamble = properties[:preamble] || "#{@bufvar} = #{bufval};"
+      postamble = properties[:postamble] || "#{@bufvar}.to_s\n"
+
+      @src << "# frozen_string_literal: true\n" if @freeze
+
+      if properties[:ensure]
+        @src << "begin; __original_outvar = #{@bufvar}"
+        @src << if /\A@[^@]/ =~ @bufvar
+                  "; "
+                else
+                  " if defined?(#{@bufvar}); "
+                end
+      end
+
+      @src << "__herb = ::Herb::Engine; " if @escape && @escapefunc == "__herb.h"
+
+      @src << preamble
+      @src << "\n" unless preamble.end_with?("\n")
+
+      parse_result = ::Herb.parse(input)
+      ast = parse_result.value
+      parser_errors = parse_result.errors
+
+      if parser_errors.any?
+        case @validation_mode
+        when :raise
+          handle_parser_errors(parser_errors, input, ast)
+          return
+        when :overlay
+          add_parser_error_overlay(parser_errors, input)
+        when :none
+          # Skip both errors and compilation, but still need minimal Ruby code
+        end
+      else
+        validation_errors = run_validation(ast) unless @validation_mode == :none
+        all_errors = parser_errors + (validation_errors || [])
+
+        handle_validation_errors(all_errors, input) if @validation_mode == :raise && all_errors.any?
+
+        add_validation_overlay(validation_errors, input) if @validation_mode == :overlay && validation_errors&.any?
+
+        if @debug
+          debug_visitor = DebugVisitor.new(self)
+          ast.accept(debug_visitor)
+        end
+
+        compiler = Compiler.new(self, properties)
+        ast.accept(compiler)
+
+        compiler.generate_output
+      end
+
+      if @validation_error_template
+        escaped_html = @validation_error_template.gsub("'", "\\\\'")
+        @src << " #{@bufvar} << ('#{escaped_html}'.html_safe).to_s;"
+      end
+
+      @src << "\n" unless @src.end_with?("\n")
+      send(:add_postamble, postamble)
+
+      @src << "; ensure\n  #{@bufvar} = __original_outvar\nend\n" if properties[:ensure]
+
+      @src.freeze
+      freeze
+    end
+
+    def self.h(value)
+      value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)
+    end
+
+    def self.attr(value)
+      value.to_s
+           .gsub("&", "&amp;")
+           .gsub('"', "&quot;")
+           .gsub("'", "&#39;")
+           .gsub("<", "&lt;")
+           .gsub(">", "&gt;")
+           .gsub("\n", "&#10;")
+           .gsub("\r", "&#13;")
+           .gsub("\t", "&#9;")
+    end
+
+    def self.js(value)
+      value.to_s.gsub(/[\\'"<>&\n\r\t\f\b]/) do |char|
+        case char
+        when "\n" then "\\n"
+        when "\r" then "\\r"
+        when "\t" then "\\t"
+        when "\f" then "\\f"
+        when "\b" then "\\b"
+        else
+          "\\x#{char.ord.to_s(16).rjust(2, "0")}"
+        end
+      end
+    end
+
+    def self.css(value)
+      value.to_s.gsub(/[^\w-]/) do |char|
+        "\\#{char.ord.to_s(16).rjust(6, "0")}"
+      end
+    end
+
+    protected
+
+    def add_text(text)
+      return if text.empty?
+
+      text = text.gsub(/['\\]/, '\\\\\&')
+
+      with_buffer { @src << " << '" << text << @text_end }
+    end
+
+    def add_code(code)
+      terminate_expression
+
+      @src << " " << code
+      @src << ";" unless code[-1] == "\n"
+      @buffer_on_stack = false
+    end
+
+    def add_expression(indicator, code)
+      if (indicator == "=") ^ @escape
+        add_expression_result(code)
+      else
+        add_expression_result_escaped(code)
+      end
+    end
+
+    def add_expression_result(code)
+      with_buffer { @src << " << (" << code << ").to_s" }
+    end
+
+    def add_expression_result_escaped(code)
+      with_buffer { @src << " << " << @escapefunc << "((" << code << "))" }
+    end
+
+    def add_expression_block(indicator, code)
+      if (indicator == "=") ^ @escape
+        add_expression_block_result(code)
+      else
+        add_expression_block_result_escaped(code)
+      end
+    end
+
+    def add_expression_block_result(code)
+      with_buffer { @src << " << " << code }
+    end
+
+    def add_expression_block_result_escaped(code)
+      with_buffer { @src << " << " << @escapefunc << "(" << code << ")" }
+    end
+
+    def add_postamble(postamble)
+      terminate_expression
+      @src << postamble
+    end
+
+    def with_buffer(&_block)
+      if @chain_appends
+        @src << "; " << @bufvar unless @buffer_on_stack
+        yield
+        @buffer_on_stack = true
+      else
+        @src << " " << @bufvar
+        yield
+        @src << ";"
+      end
+    end
+
+    def terminate_expression
+      @src << "; " if @chain_appends && @buffer_on_stack
+    end
+
+    private
+
+    def run_validation(ast)
+      validators = [
+        Validators::SecurityValidator.new,
+        Validators::NestingValidator.new,
+        Validators::AccessibilityValidator.new
+      ]
+
+      errors = [] #: Array[untyped]
+
+      validators.each do |validator|
+        ast.accept(validator)
+        errors.concat(validator.errors)
+      end
+
+      errors
+    end
+
+    def handle_parser_errors(parser_errors, input, _ast)
+      case @validation_mode
+      when :raise
+        formatter = ErrorFormatter.new(input, parser_errors, filename: @filename)
+        message = formatter.format_all
+
+        raise CompilationError, "\n#{message}"
+      when :overlay
+        add_parser_error_overlay(parser_errors, input)
+        @src << "\n" unless @src.end_with?("\n")
+        send(:add_postamble, "#{@bufvar}.to_s\n")
+      when :none
+        @src << "\n" unless @src.end_with?("\n")
+        send(:add_postamble, "#{@bufvar}.to_s\n")
+      end
+    end
+
+    def handle_validation_errors(errors, input)
+      return unless errors.any?
+
+      security_error = errors.find { |error|
+        error.is_a?(Hash) && error[:source] == "SecurityValidator"
+      }
+
+      if security_error
+        line = security_error[:location]&.start&.line
+        column = security_error[:location]&.start&.column
+        suggestion = security_error[:suggestion]
+
+        raise SecurityError.new(
+          security_error[:message],
+          line: line,
+          column: column,
+          filename: @filename,
+          suggestion: suggestion
+        )
+      end
+
+      formatter = ErrorFormatter.new(input, errors, filename: @filename)
+      message = formatter.format_all
+      raise CompilationError, "\n#{message}"
+    end
+
+    def add_validation_overlay(errors, input = nil)
+      return unless errors.any?
+
+      templates = errors.map { |error|
+        location = error[:location]
+        line = location&.start&.line || 0
+        column = location&.start&.column || 0
+
+        source = input || @src
+        overlay_generator = ValidationErrorOverlay.new(source, error, filename: @relative_file_path)
+        html_fragment = overlay_generator.generate_fragment
+
+        escaped_message = escape_attr(error[:message])
+        escaped_suggestion = error[:suggestion] ? escape_attr(error[:suggestion]) : ""
+
+        <<~TEMPLATE
+          <template
+            data-herb-validation-error
+            data-severity="#{error[:severity]}"
+            data-source="#{error[:source]}"
+            data-code="#{error[:code]}"
+            data-line="#{line}"
+            data-column="#{column}"
+            data-filename="#{escape_attr(@relative_file_path)}"
+            data-message="#{escaped_message}"
+            #{"data-suggestion=\"#{escaped_suggestion}\"" if error[:suggestion]}
+            data-timestamp="#{Time.now.iso8601}"
+          >#{html_fragment}</template>
+        TEMPLATE
+      }.join
+
+      @validation_error_template = templates
+    end
+
+    def escape_attr(text)
+      text.to_s
+          .gsub("&", "&amp;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&#39;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\n", "&#10;")
+          .gsub("\r", "&#13;")
+          .gsub("\t", "&#9;")
+    end
+
+    def add_parser_error_overlay(parser_errors, input)
+      return unless parser_errors.any?
+
+      overlay_generator = ParserErrorOverlay.new(
+        input,
+        parser_errors,
+        filename: @relative_file_path
+      )
+
+      error_html = overlay_generator.generate_html
+      escaped_html = error_html.gsub("'", "\\'")
+      @validation_error_template = "<template data-herb-parser-error>#{escaped_html}</template>"
+    end
+  end
+end

data/lib/herb/project.rb

@@ -12,7 +12,7 @@ require "stringio"
 
 module Herb
   class Project
-    attr_accessor :project_path, :output_file, :no_interactive, :no_log_file, :no_timing
+    attr_accessor :project_path, :output_file, :no_interactive, :no_log_file, :no_timing, :silent
 
     def interactive?
       return false if no_interactive
@@ -106,7 +106,7 @@ module Herb
           else
             relative_path = file_path.sub("#{project_path}/", "")
           end
-          puts "Processing [#{index + 1}/#{files.count}]: #{relative_path}"
+          puts "Processing [#{index + 1}/#{files.count}]: #{relative_path}" unless silent
 
           if interactive?
             if failed_files.any?
@@ -240,7 +240,7 @@ module Herb
           puts "Completed processing all files."
           print "\e[H\e[2J"
         else
-          puts "Completed processing all files."
+          puts "Completed processing all files." unless silent
         end
 
         log.puts ""

data/lib/herb/version.rb

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

data/lib/herb/visitor.rb

@@ -6,6 +6,8 @@
 
 module Herb
   class Visitor
+    include AST::Helpers
+
     #: (Herb::AST::Node) -> void
     def visit(node)
       node&.accept(self)

data/lib/herb.rb

@@ -15,6 +15,7 @@ require_relative "herb/parse_result"
 require_relative "herb/ast"
 require_relative "herb/ast/node"
 require_relative "herb/ast/nodes"
+require_relative "herb/ast/helpers"
 
 require_relative "herb/errors"
 require_relative "herb/warnings"
@@ -25,6 +26,7 @@ require_relative "herb/project"
 require_relative "herb/version"
 
 require_relative "herb/visitor"
+require_relative "herb/engine"
 
 begin
   major, minor, _patch = RUBY_VERSION.split(".") #: [String, String, String]

data/sig/herb/ast/helpers.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/herb/ast/helpers.rb with RBS::Inline
+
+module Herb
+  module AST
+    module Helpers
+      # : (Herb::AST::Node) -> bool
+      def erb_outputs?: (Herb::AST::Node) -> bool
+
+      # : (String) -> bool
+      def erb_comment?: (String) -> bool
+
+      # : (String) -> bool
+      def erb_output?: (String) -> bool
+    end
+  end
+end

data/sig/herb/ast/nodes.rbs

@@ -127,8 +127,10 @@ module Herb
 
       attr_reader is_void: bool
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::AST::HTMLOpenTagNode, Herb::Token, Array[Herb::AST::Node], Herb::AST::HTMLCloseTagNode, bool) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::AST::HTMLOpenTagNode, Herb::Token, Array[Herb::AST::Node], Herb::AST::HTMLCloseTagNode, bool) -> void
+      attr_reader source: String
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::AST::HTMLOpenTagNode, Herb::Token, Array[Herb::AST::Node], Herb::AST::HTMLCloseTagNode, bool, String) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::AST::HTMLOpenTagNode, Herb::Token, Array[Herb::AST::Node], Herb::AST::HTMLCloseTagNode, bool, String) -> void
 
       # : () -> serialized_html_element_node
       def to_hash: () -> serialized_html_element_node

data/sig/herb/engine/compiler.rbs

@@ -0,0 +1,109 @@
+# Generated from lib/herb/engine/compiler.rb with RBS::Inline
+
+module Herb
+  class Engine
+    class Compiler < ::Herb::Visitor
+      attr_reader tokens: untyped
+
+      def initialize: (untyped engine, ?untyped options) -> untyped
+
+      def generate_output: () -> untyped
+
+      def visit_document_node: (untyped node) -> untyped
+
+      def visit_html_element_node: (untyped node) -> untyped
+
+      def visit_html_open_tag_node: (untyped node) -> untyped
+
+      def visit_html_attribute_node: (untyped node) -> untyped
+
+      def visit_html_attribute_name_node: (untyped node) -> untyped
+
+      def visit_html_attribute_value_node: (untyped node) -> untyped
+
+      def visit_html_close_tag_node: (untyped node) -> untyped
+
+      def visit_html_text_node: (untyped node) -> untyped
+
+      def visit_literal_node: (untyped node) -> untyped
+
+      def visit_whitespace_node: (untyped node) -> untyped
+
+      def visit_html_comment_node: (untyped node) -> untyped
+
+      def visit_html_doctype_node: (untyped node) -> untyped
+
+      def visit_xml_declaration_node: (untyped node) -> untyped
+
+      def visit_cdata_node: (untyped node) -> untyped
+
+      def visit_erb_content_node: (untyped node) -> untyped
+
+      def visit_erb_control_node: (untyped node) ?{ (?) -> untyped } -> untyped
+
+      def visit_erb_if_node: (untyped node) -> untyped
+
+      def visit_erb_else_node: (untyped node) -> untyped
+
+      def visit_erb_unless_node: (untyped node) -> untyped
+
+      def visit_erb_case_node: (untyped node) -> untyped
+
+      def visit_erb_when_node: (untyped node) -> untyped
+
+      def visit_erb_for_node: (untyped node) -> untyped
+
+      def visit_erb_while_node: (untyped node) -> untyped
+
+      def visit_erb_until_node: (untyped node) -> untyped
+
+      def visit_erb_begin_node: (untyped node) -> untyped
+
+      def visit_erb_rescue_node: (untyped node) -> untyped
+
+      def visit_erb_ensure_node: (untyped node) -> untyped
+
+      def visit_erb_end_node: (untyped node) -> untyped
+
+      def visit_erb_case_match_node: (untyped node) -> untyped
+
+      def visit_erb_in_node: (untyped node) -> untyped
+
+      def visit_erb_yield_node: (untyped node) -> untyped
+
+      def visit_erb_block_node: (untyped node) -> untyped
+
+      def visit_erb_control_with_parts: (untyped node, *untyped parts) -> untyped
+
+      private
+
+      def current_context: () -> untyped
+
+      def push_context: (untyped context) -> untyped
+
+      def pop_context: () -> untyped
+
+      def add_context_aware_expression: (untyped code, untyped context) -> untyped
+
+      def process_erb_tag: (untyped node, ?skip_comment_check: untyped) -> untyped
+
+      def add_text: (untyped text) -> untyped
+
+      def add_code: (untyped code) -> untyped
+
+      def add_expression: (untyped code) -> untyped
+
+      def add_expression_escaped: (untyped code) -> untyped
+
+      def optimize_tokens: (untyped tokens) -> untyped
+
+      def process_erb_output: (untyped opening, untyped code) -> untyped
+
+      def should_escape_output?: (untyped opening) -> untyped
+
+      def add_expression_with_escaping: (untyped code, untyped should_escape) -> untyped
+
+      def handle_whitespace_trimming: (untyped node) -> untyped
+    end
+  end
+end

data/sig/herb/engine/debug.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/herb/engine/debug.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Debug
+      private
+
+      def debug?: () -> untyped
+
+      def process_debuggable_expression: (untyped node, untyped opening, untyped code, untyped should_escape) -> untyped
+
+      def add_debug_expr_start: (untyped erb_code, untyped output_content, untyped node) -> untyped
+
+      def add_debug_expr_end: () -> untyped
+
+      def should_debug_expression?: (untyped node) -> untyped
+
+      def find_top_level_elements: (untyped document_node) -> untyped
+
+      def should_add_debug_attributes_to_element?: (untyped open_tag_node) -> untyped
+
+      def find_parent_element_for_open_tag: (untyped open_tag_node) -> untyped
+
+      def add_debug_attributes_to_element: (untyped open_tag_node) -> untyped
+
+      def determine_view_type: () -> untyped
+
+      def partial?: () -> untyped
+
+      def component?: () -> untyped
+
+      def in_head_context?: () -> untyped
+
+      # TODO: convert this to analyze the Prism nodes once available
+      def complex_rails_helper?: (untyped code) -> untyped
+    end
+  end
+end

data/sig/herb/engine/debug_visitor.rbs

@@ -0,0 +1,70 @@
+# Generated from lib/herb/engine/debug_visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    class DebugVisitor < Herb::Visitor
+      def initialize: (untyped engine) -> untyped
+
+      def debug_enabled?: () -> untyped
+
+      def visit_document_node: (untyped node) -> untyped
+
+      def visit_html_element_node: (untyped node) -> untyped
+
+      def visit_html_attribute_node: (untyped node) -> untyped
+
+      def visit_html_comment_node: (untyped node) -> untyped
+
+      def visit_html_doctype_node: (untyped node) -> untyped
+
+      def visit_erb_content_node: (untyped node) -> untyped
+
+      def visit_erb_yield_node: (untyped _node) -> untyped
+
+      private
+
+      def wrap_all_erb_nodes: (untyped node) -> untyped
+
+      # Creates a dummy location for AST nodes that don't need real location info
+      # : () -> Herb::Location
+      def dummy_location: () -> Herb::Location
+
+      # Creates a dummy range for tokens that don't need real range info
+      # : () -> Herb::Range
+      def dummy_range: () -> Herb::Range
+
+      def replace_erb_nodes_recursive: (untyped node) -> untyped
+
+      def find_top_level_elements: (untyped document_node) -> untyped
+
+      def should_add_debug_attributes_to_element?: (untyped open_tag_node) -> untyped
+
+      def find_parent_element_for_open_tag: (untyped open_tag_node) -> untyped
+
+      def add_debug_attributes_to_element: (untyped open_tag_node) -> untyped
+
+      def create_debug_attribute: (untyped name, untyped value) -> untyped
+
+      def create_token: (untyped type, untyped value) -> untyped
+
+      def create_debug_span_for_erb: (untyped erb_node) -> untyped
+
+      def determine_view_type: () -> untyped
+
+      def partial?: () -> untyped
+
+      def component?: () -> untyped
+
+      def in_head_context?: () -> untyped
+
+      def in_script_or_style_context?: () -> untyped
+
+      def in_excluded_context?: () -> untyped
+
+      def erb_output?: (untyped opening) -> untyped
+
+      # TODO: Rewrite using Prism Nodes once available
+      def complex_rails_helper?: (untyped code) -> untyped
+    end
+  end
+end