herb 0.7.5 → 0.8.0

data/lib/herb/cli.rb

@@ -6,6 +6,8 @@
 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
 
   def initialize(args)
@@ -27,6 +29,8 @@ class Herb::CLI
       puts result.value.to_json
     else
       puts result.value.inspect
+
+      print_error_summary(result.errors) if @command == "parse" && result.respond_to?(:errors) && result.errors.any?
     end
   end
 
@@ -223,6 +227,33 @@ class Herb::CLI
 
   private
 
+  def print_error_summary(errors)
+    puts
+    puts white("#{bold(red("Errors"))} #{dimmed("(#{errors.size} total)")}")
+    puts
+
+    errors.each_with_index do |error, index|
+      error_type = error.error_name
+      error_location = format_location_for_copy(error.location)
+      error_message = error.message
+
+      puts white("  #{bold("#{index + 1}.")} #{bold(red(error_type))} #{dimmed("at #{error_location}")}")
+      puts white("     #{error_message}")
+      puts unless index == errors.size - 1
+    end
+  end
+
+  def format_location_for_copy(location)
+    line = location.start.line
+    column = location.start.column
+
+    if @file
+      "#{@file}:#{line}:#{column}"
+    else
+      "#{line}:#{column}"
+    end
+  end
+
   def compile_template
     require_relative "engine"
 

data/lib/herb/colors.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# typed: true
+
+# rbs_inline: enabled
+
+module Herb
+  module Colors
+    module_function
+
+    #: () -> bool
+    def enabled?
+      return false if ENV["NO_COLOR"]
+      return false if defined?(IRB)
+      return false if defined?(Minitest)
+
+      $stdout.tty?
+    end
+
+    #: (String) -> String
+    def white(string)
+      return string unless enabled?
+
+      "\e[37m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def yellow(string)
+      return string unless enabled?
+
+      "\e[33m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def green(string)
+      return string unless enabled?
+
+      "\e[32m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def red(string)
+      return string unless enabled?
+
+      "\e[31m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def magenta(string)
+      return string unless enabled?
+
+      "\e[35m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def cyan(string)
+      return string unless enabled?
+
+      "\e[36m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def bright_magenta(string)
+      return string unless enabled?
+
+      "\e[95m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def dimmed(string)
+      return string unless enabled?
+
+      "\e[2m#{string}\e[0m"
+    end
+
+    #: (String) -> String
+    def bold(string)
+      return string unless enabled?
+
+      "\e[1m#{string}\e[0m"
+    end
+  end
+end

data/lib/herb/engine/compiler.rb

@@ -10,6 +10,9 @@ module Herb
 
         @engine = engine
         @escape = options.fetch(:escape) { options.fetch(:escape_html, false) }
+        @attrfunc = options.fetch(:attrfunc, @escape ? "__herb.attr" : "::Herb::Engine.attr")
+        @jsfunc = options.fetch(:jsfunc, @escape ? "__herb.js" : "::Herb::Engine.js")
+        @cssfunc = options.fetch(:cssfunc, @escape ? "__herb.css" : "::Herb::Engine.css")
         @tokens = [] #: Array[untyped]
         @element_stack = [] #: Array[String]
         @context_stack = [:html_content]
@@ -83,7 +86,7 @@ module Herb
       end
 
       def visit_html_attribute_node(node)
-        add_text(" ")
+        add_whitespace(" ")
 
         visit(node.name)
 
@@ -131,7 +134,7 @@ module Herb
       end
 
       def visit_whitespace_node(node)
-        add_text(node.value.value) if node.value
+        add_whitespace(node.value.value)
       end
 
       def visit_html_comment_node(node)
@@ -159,11 +162,13 @@ module Herb
       end
 
       def visit_erb_content_node(node)
+        return if inline_ruby_comment?(node)
+
         process_erb_tag(node)
       end
 
       def visit_erb_control_node(node, &_block)
-        add_code(node.content.value.strip)
+        apply_trim(node, node.content.value.strip)
 
         yield if block_given?
       end
@@ -227,7 +232,7 @@ module Herb
       end
 
       def visit_erb_case_match_node(node)
-        visit_erb_control_with_parts(node, :children, :conditions, :else_clause, :end_node)
+        visit_erb_control_with_parts(node, :conditions, :else_clause, :end_node)
       end
 
       def visit_erb_in_node(node)
@@ -294,11 +299,17 @@ module Herb
       def add_context_aware_expression(code, context)
         case context
         when :attribute_value
-          @engine.send(:with_buffer) { @engine.instance_variable_get(:@src) << " << ::Herb::Engine.attr((" << code << "))" }
+          @engine.send(:with_buffer) {
+            @engine.src << " << #{@attrfunc}((" << code << "))"
+          }
         when :script_content
-          @engine.send(:with_buffer) { @engine.instance_variable_get(:@src) << " << ::Herb::Engine.js((" << code << "))" }
+          @engine.send(:with_buffer) {
+            @engine.src << " << #{@jsfunc}((" << code << "))"
+          }
         when :style_content
-          @engine.send(:with_buffer) { @engine.instance_variable_get(:@src) << " << ::Herb::Engine.css((" << code << "))" }
+          @engine.send(:with_buffer) {
+            @engine.src << " << #{@cssfunc}((" << code << "))"
+          }
         else
           @engine.send(:add_expression_result_escaped, code)
         end
@@ -314,17 +325,15 @@ module Herb
         if erb_output?(opening)
           process_erb_output(opening, code)
         else
-          add_code(code)
+          apply_trim(node, code)
         end
-
-        handle_whitespace_trimming(node)
       end
 
       def add_text(text)
         return if text.empty?
 
         if @trim_next_whitespace
-          text = text.lstrip
+          text = text.sub(/\A[ \t]*\r?\n/, "")
           @trim_next_whitespace = false
         end
 
@@ -333,6 +342,10 @@ module Herb
         @tokens << [:text, text, current_context]
       end
 
+      def add_whitespace(whitespace)
+        @tokens << [:whitespace, whitespace, current_context]
+      end
+
       def add_code(code)
         @tokens << [:code, code, current_context]
       end
@@ -348,11 +361,13 @@ module Herb
       def optimize_tokens(tokens)
         return tokens if tokens.empty?
 
+        compacted = compact_whitespace_tokens(tokens)
+
         optimized = [] #: Array[untyped]
         current_text = ""
         current_context = nil
 
-        tokens.each do |type, value, context|
+        compacted.each do |type, value, context|
           if type == :text
             current_text += value
             current_context ||= context
@@ -373,6 +388,56 @@ module Herb
         optimized
       end
 
+      def compact_whitespace_tokens(tokens)
+        return tokens if tokens.empty?
+
+        tokens.map.with_index { |token, index|
+          next token unless token[0] == :whitespace
+
+          next nil if adjacent_whitespace?(tokens, index)
+          next nil if whitespace_before_code_sequence?(tokens, index)
+
+          [:text, token[1], token[2]]
+        }.compact
+      end
+
+      def adjacent_whitespace?(tokens, index)
+        prev_token = index.positive? ? tokens[index - 1] : nil
+        next_token = index < tokens.length - 1 ? tokens[index + 1] : nil
+
+        trailing_whitespace?(prev_token) || leading_whitespace?(next_token)
+      end
+
+      def trailing_whitespace?(token)
+        return false unless token
+
+        token[0] == :whitespace || (token[0] == :text && token[1] =~ /\s\z/)
+      end
+
+      def leading_whitespace?(token)
+        token && token[0] == :text && token[1] =~ /\A\s/
+      end
+
+      def whitespace_before_code_sequence?(tokens, current_index)
+        previous_token = tokens[current_index - 1] if current_index.positive?
+
+        return false unless previous_token && previous_token[0] == :code
+
+        token_before_code = find_token_before_code_sequence(tokens, current_index)
+
+        return false unless token_before_code
+
+        trailing_whitespace?(token_before_code)
+      end
+
+      def find_token_before_code_sequence(tokens, whitespace_index)
+        search_index = whitespace_index - 1
+
+        search_index -= 1 while search_index >= 0 && tokens[search_index][0] == :code
+
+        search_index >= 0 ? tokens[search_index] : nil
+      end
+
       def process_erb_output(opening, code)
         should_escape = should_escape_output?(opening)
         add_expression_with_escaping(code, should_escape)
@@ -391,8 +456,69 @@ module Herb
         end
       end
 
-      def handle_whitespace_trimming(node)
-        @trim_next_whitespace = true if node.tag_closing&.value == "-%>"
+      def at_line_start?
+        @tokens.empty? ||
+          @tokens.last[0] != :text ||
+          @tokens.last[1].empty? ||
+          @tokens.last[1].end_with?("\n") ||
+          @tokens.last[1] =~ /\A[ \t]+\z/ ||
+          @tokens.last[1] =~ /\n[ \t]+\z/
+      end
+
+      def extract_lspace
+        return "" unless @tokens.last && @tokens.last[0] == :text
+
+        text = @tokens.last[1]
+
+        return Regexp.last_match(1) if text =~ /\n([ \t]+)\z/ || text =~ /\A([ \t]+)\z/
+
+        ""
+      end
+
+      def extract_and_remove_lspace!
+        lspace = extract_lspace
+        return lspace if lspace.empty?
+
+        text = @tokens.last[1]
+        if text =~ /\n[ \t]+\z/
+          text.sub!(/[ \t]+\z/, "")
+        elsif text =~ /\A[ \t]+\z/
+          text.replace("")
+        end
+        @tokens.last[1] = text
+
+        lspace
+      end
+
+      def apply_trim(node, code)
+        has_left_trim = node.tag_opening.value.start_with?("<%-")
+        node.tag_closing&.value
+
+        remove_trailing_whitespace_from_last_token! if has_left_trim
+
+        if at_line_start?
+          lspace = extract_and_remove_lspace!
+          rspace = " \n"
+
+          @tokens << [:code, "#{lspace}#{code}#{rspace}", current_context]
+          @trim_next_whitespace = true
+        else
+          @tokens << [:code, code, current_context]
+        end
+      end
+
+      def remove_trailing_whitespace_from_last_token!
+        return unless @tokens.last && @tokens.last[0] == :text
+
+        text = @tokens.last[1]
+
+        if text =~ /\n[ \t]+\z/
+          text.sub!(/[ \t]+\z/, "")
+          @tokens.last[1] = text
+        elsif text =~ /\A[ \t]+\z/
+          text.replace("")
+          @tokens.last[1] = text
+        end
       end
     end
   end

data/lib/herb/engine/debug_visitor.rb

@@ -180,9 +180,7 @@ module Herb
           debug_attributes << create_debug_attribute("data-herb-debug-attach-to-parent", "true")
         end
 
-        debug_attributes.each do |attr|
-          open_tag_node.children << attr
-        end
+        open_tag_node.children.concat(debug_attributes)
 
         @debug_attributes_applied = true
       end
@@ -233,9 +231,7 @@ module Herb
         ]
 
         debug_attributes << create_debug_attribute("data-herb-debug-line", line.to_s) if line
-
         debug_attributes << create_debug_attribute("data-herb-debug-column", (column + 1).to_s) if column
-
         debug_attributes << create_debug_attribute("style", "display: contents;")
 
         tag_name_token = create_token(:tag_name, "span")

data/lib/herb/engine/parser_error_overlay.rb

@@ -529,7 +529,7 @@ module Herb
           HTML
         end
 
-        section_id = "suggestions-#{rand(1000)}"
+        section_id = "suggestions-#{Digest::MD5.hexdigest(suggestions.inspect)}"
 
         <<~HTML
           <div class="herb-section">

data/lib/herb/engine.rb

@@ -43,7 +43,7 @@ module Herb
 
       @bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
       @escape = properties.fetch(:escape) { properties.fetch(:escape_html, false) }
-      @escapefunc = properties[:escapefunc]
+      @escapefunc = properties.fetch(:escapefunc, @escape ? "__herb.h" : "::Herb::Engine.h")
       @src = properties[:src] || String.new
       @chain_appends = properties[:chain_appends]
       @buffer_on_stack = false
@@ -67,12 +67,6 @@ module Herb
               "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" : "'"
@@ -93,11 +87,9 @@ module Herb
       end
 
       @src << "__herb = ::Herb::Engine; " if @escape && @escapefunc == "__herb.h"
-
       @src << preamble
-      @src << "\n" unless preamble.end_with?("\n")
 
-      parse_result = ::Herb.parse(input)
+      parse_result = ::Herb.parse(input, track_whitespace: true)
       ast = parse_result.value
       parser_errors = parse_result.errors
 
@@ -136,7 +128,7 @@ module Herb
       end
 
       @src << "\n" unless @src.end_with?("\n")
-      send(:add_postamble, postamble)
+      add_postamble(postamble)
 
       @src << "; ensure\n  #{@bufvar} = __original_outvar\nend\n" if properties[:ensure]
 
@@ -196,6 +188,8 @@ module Herb
       if code.include?("=begin") || code.include?("=end")
         @src << "\n" << code << "\n"
       else
+        @src.chomp! if @src.end_with?("\n") && code.start_with?(" ") && !code.end_with?("\n")
+
         @src << " " << code
 
         # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
@@ -291,10 +285,10 @@ module Herb
       when :overlay
         add_parser_error_overlay(parser_errors, input)
         @src << "\n" unless @src.end_with?("\n")
-        send(:add_postamble, "#{@bufvar}.to_s\n")
+        add_postamble("#{@bufvar}.to_s\n")
       when :none
         @src << "\n" unless @src.end_with?("\n")
-        send(:add_postamble, "#{@bufvar}.to_s\n")
+        add_postamble("#{@bufvar}.to_s\n")
       end
     end
 
@@ -350,7 +344,7 @@ module Herb
             data-filename="#{escape_attr(@relative_file_path)}"
             data-message="#{escaped_message}"
             #{"data-suggestion=\"#{escaped_suggestion}\"" if error[:suggestion]}
-            data-timestamp="#{Time.now.iso8601}"
+            data-timestamp="#{Time.now.utc.iso8601}"
           >#{html_fragment}</template>
         TEMPLATE
       }.join