herb 0.9.7-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/lib/herb/dev/server_entry.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Herb
+  module Dev
+    class ServerEntry
+      SERVERS_DIR = File.expand_path("~/.herb/dev-servers").freeze
+      REQUIRED_KEYS = ["pid", "port", "project", "started_at"].freeze
+
+      attr_reader :pid, :port, :project, :started_at
+
+      def initialize(pid:, port:, project:, started_at: Time.now.utc.iso8601)
+        @pid = pid
+        @port = port
+        @project = project
+        @started_at = started_at
+      end
+
+      def save
+        FileUtils.mkdir_p(SERVERS_DIR)
+        File.write(file_path, to_json)
+      end
+
+      def remove
+        File.delete(file_path)
+      rescue StandardError
+        nil
+      end
+
+      def alive?
+        self.class.process_alive?(pid)
+      end
+
+      def to_hash
+        { pid: pid, port: port, project: project, started_at: started_at }
+      end
+
+      def to_json(*)
+        JSON.generate(to_hash)
+      end
+
+      def project_name
+        project&.split("/")&.last || "unknown"
+      end
+
+      def stop!
+        Process.kill("INT", pid)
+        remove
+        true
+      rescue Errno::ESRCH
+        remove
+        false
+      end
+
+      class << self
+        def all
+          FileUtils.mkdir_p(SERVERS_DIR)
+
+          Dir.glob(File.join(SERVERS_DIR, "*.json")).filter_map do |path|
+            entry = load_file(path)
+
+            if entry&.alive?
+              entry
+            else
+              begin
+                File.delete(path)
+              rescue StandardError
+                nil
+              end
+              nil
+            end
+          end
+        end
+
+        def find_by_port(port)
+          all.find { |entry| entry.port == port }
+        end
+
+        def find_by_project(project_path)
+          all.find { |entry| entry.project == project_path }
+        end
+
+        def stop_all
+          all.each(&:stop!)
+        end
+
+        def process_alive?(pid)
+          return false unless pid
+
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH, Errno::EPERM
+          false
+        end
+
+        private
+
+        def load_file(path)
+          data = JSON.parse(File.read(path))
+
+          return nil unless data.is_a?(Hash) && REQUIRED_KEYS.all? { |key| data.key?(key) }
+
+          new(
+            pid: data["pid"],
+            port: data["port"],
+            project: data["project"],
+            started_at: data["started_at"]
+          )
+        rescue JSON::ParserError, Errno::ENOENT, Errno::EACCES
+          begin
+            File.delete(path)
+          rescue StandardError
+            nil
+          end
+          nil
+        end
+      end
+
+      private
+
+      def file_path
+        File.join(SERVERS_DIR, "#{pid}.json")
+      end
+    end
+  end
+end

data/lib/herb/diff_operation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: true
+
+module Herb
+  DiffOperation = Data.define(
+    :type, #: Symbol
+    :path, #: Array[Integer]
+    :old_node, #: Herb::AST::Node?
+    :new_node, #: Herb::AST::Node?
+    :old_index, #: Integer
+    :new_index #: Integer
+  )
+
+  class DiffOperation
+    #: () -> Hash[Symbol, untyped]
+    def to_hash
+      {
+        type: type,
+        path: path,
+        old_node: old_node,
+        new_node: new_node,
+        old_index: old_index,
+        new_index: new_index,
+      }
+    end
+
+    alias to_h to_hash
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} type=#{type} path=[#{path.join(", ")}]>"
+    end
+  end
+end

data/lib/herb/diff_result.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# typed: true
+
+module Herb
+  class DiffResult
+    include Enumerable #[Herb::DiffOperation]
+
+    attr_reader :operations #: Array[Herb::DiffOperation]
+
+    #: (bool, Array[Herb::DiffOperation]) -> void
+    def initialize(identical, operations)
+      @identical = identical
+      @operations = operations.freeze
+      freeze
+    end
+
+    #: () { (Herb::DiffOperation) -> void } -> void
+    #: () -> Enumerator[Herb::DiffOperation, void]
+    def each(&block)
+      return operations.each unless block
+
+      operations.each(&block)
+    end
+
+    #: () -> bool
+    def identical?
+      @identical
+    end
+
+    #: () -> Integer
+    def operation_count
+      operations.size
+    end
+
+    #: () -> bool
+    def changed?
+      !identical?
+    end
+
+    #: () -> Hash[Symbol, untyped]
+    def to_hash
+      {
+        identical: identical?,
+        operations: operations.map(&:to_hash),
+      }
+    end
+
+    alias to_h to_hash
+
+    #: () -> String
+    def inspect
+      if identical?
+        "#<#{self.class.name} identical>"
+      else
+        "#<#{self.class.name} #{operation_count} operation#{"s" unless operation_count == 1}>"
+      end
+    end
+  end
+end

data/lib/herb/engine/compiler.rb

@@ -25,6 +25,7 @@ module Herb
         @last_trim_consumed_newline = false
         @pending_leading_whitespace = nil
         @pending_leading_whitespace_insert_index = 0
+        @current_element_source = nil
       end
 
       def generate_output
@@ -60,7 +61,20 @@ module Herb
         with_element_context(node) do
           visit(node.open_tag)
           visit_all(node.body)
-          visit(node.close_tag)
+
+          tag_name = node.tag_name&.value&.downcase
+
+          if node.open_tag.is_a?(Herb::AST::ERBOpenTagNode) && tag_name && node.close_tag
+            if node.close_tag.is_a?(Herb::AST::ERBEndNode)
+              remove_trailing_whitespace_from_last_token! if left_trim?(node.close_tag)
+              add_text("</#{tag_name}>")
+              @trim_next_whitespace = true
+            else
+              add_text("</#{tag_name}>")
+            end
+          else
+            visit(node.close_tag)
+          end
         end
       end
 
@@ -88,7 +102,9 @@ module Herb
 
         return unless node.value
 
-        add_text(node.equals.value)
+        has_equals = node.equals.value&.include?("=")
+        add_text(has_equals ? node.equals.value : "=")
+
         visit(node.value)
       end
 
@@ -106,6 +122,40 @@ module Herb
         pop_context
       end
 
+      def visit_erb_open_tag_node(node)
+        tag_name = node.tag_name&.value
+
+        if tag_name
+          is_void = Herb::HTML::Util.void_element?(tag_name)
+          uses_self_closing = is_void && @current_element_source != "ActionView::Helpers::TagHelper#tag"
+
+          add_text("<")
+          add_text(tag_name)
+
+          node.children.each do |child|
+            visit(child)
+          end
+
+          add_text(uses_self_closing ? " />" : ">")
+        else
+          process_erb_tag(node)
+        end
+      end
+
+      def visit_html_virtual_close_tag_node(node)
+        tag_name = node.tag_name&.value
+
+        return unless tag_name
+
+        add_text("</")
+        add_text(tag_name)
+        add_text(">")
+      end
+
+      def visit_ruby_literal_node(node)
+        add_expression(node.content)
+      end
+
       def visit_html_close_tag_node(node)
         tag_name = node.tag_name&.value&.downcase
 
@@ -165,7 +215,7 @@ module Herb
         process_erb_tag(node)
       end
 
-      def visit_erb_control_node(node, &_block)
+      def visit_erb_control_node(node, &)
         if node.content
           apply_trim(node, node.content.value.strip)
         end
@@ -332,6 +382,8 @@ module Herb
       #: (untyped node) { () -> untyped } -> untyped
       def with_element_context(node)
         tag_name = node.tag_name&.value&.downcase
+        previous_element_source = @current_element_source
+        @current_element_source = node.element_source
 
         @element_stack.push(tag_name) if tag_name
 
@@ -346,6 +398,7 @@ module Herb
         pop_context if ["script", "style"].include?(tag_name)
 
         @element_stack.pop if tag_name
+        @current_element_source = previous_element_source
       end
 
       def process_erb_tag(node, skip_comment_check: false)

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module Herb
+  class Engine
+    module Validators
+      class RenderValidator < Validator
+        def initialize(enabled: true, filename: nil, project_path: nil)
+          super(enabled: enabled)
+
+          @filename = filename
+          @project_path = project_path
+          @view_root = find_view_root
+        end
+
+        def visit_erb_render_node(node)
+          if node.dynamic?
+            warning(
+              "Dynamic render call cannot be statically resolved",
+              node.location,
+              code: "RenderDynamic",
+              source: "RenderValidator"
+            )
+          elsif node.static_partial?
+            validate_partial_exists(node)
+          end
+
+          super
+        end
+
+        private
+
+        def validate_partial_exists(node)
+          return unless @filename
+
+          source_directory = @project_path.join(@filename).dirname
+          resolved = node.resolve(view_root: @view_root, source_directory: source_directory)
+
+          return if resolved
+
+          message = "Partial '#{node.partial_path}' could not be resolved."
+          searched = node.candidate_paths(nil, @view_root, source_directory)
+
+          if searched.any?
+            relative_paths = searched.map { |path| relative_to_project(path) }.uniq
+            message += "\n     Looked in:\n"
+
+            relative_paths.each do |path|
+              message += "       - #{path}\n"
+            end
+          end
+
+          suggestions = node.similar_partials(view_root: @view_root, source_directory: source_directory)
+
+          if suggestions.any?
+            partial_suggestions, hint_suggestions = suggestions.partition { |suggestion| !suggestion.include?("exists as a template") }
+
+            if partial_suggestions.any?
+              message += "     Did you mean: #{partial_suggestions.map { |suggestion| "'#{suggestion}'" }.join(", ")}?\n"
+            end
+
+            hint_suggestions.each do |hint|
+              message += "\n     Note: #{hint}\n"
+            end
+          end
+
+          error(
+            message,
+            node.location,
+            code: "RenderUnresolved",
+            source: "RenderValidator"
+          )
+        end
+
+        def find_view_root
+          return nil unless @project_path
+
+          view_root = @project_path.join("app", "views")
+
+          view_root.directory? ? view_root : nil
+        end
+
+        def relative_to_project(path)
+          path.relative_path_from(@project_path).to_s
+        rescue ArgumentError
+          path.to_s
+        end
+      end
+    end
+  end
+end

data/lib/herb/engine.rb

@@ -14,12 +14,23 @@ require_relative "engine/validation_error_overlay"
 require_relative "engine/validators/security_validator"
 require_relative "engine/validators/nesting_validator"
 require_relative "engine/validators/accessibility_validator"
+require_relative "engine/validators/render_validator"
 
 module Herb
   class Engine
     attr_reader :src, :filename, :project_path, :relative_file_path, :bufvar, :debug, :content_for_head,
                 :validation_error_template, :visitors, :enabled_validators
 
+    # @rbs!
+    #   def self.optimize_warning_issued: () -> bool
+    #   def self.optimize_warning_issued=: (bool) -> bool
+
+    class << self
+      attr_accessor :optimize_warning_issued #: bool
+    end
+
+    self.optimize_warning_issued = false
+
     ESCAPE_TABLE = {
       "&" => "&amp;",
       "<" => "&lt;",
@@ -64,12 +75,20 @@ module Herb
       @src = properties[:src] || String.new
       @chain_appends = properties[:chain_appends]
       @buffer_on_stack = false
-      @debug = properties.fetch(:debug, false)
+      @debug = properties.fetch(:debug, Herb.configuration.engine_option("debug", false))
       @content_for_head = properties[:content_for_head]
       @validation_error_template = nil
       @validation_mode = properties.fetch(:validation_mode, :raise)
       @enabled_validators = Herb.configuration.enabled_validators(properties[:validators] || {})
-      @strict = properties.fetch(:strict, true)
+      @optimize = properties.fetch(:optimize, Herb.configuration.engine_option("optimize", false))
+      @parser_options = properties.fetch(:parser_options, default_parser_options).transform_keys(&:to_sym)
+
+      if @optimize && !self.class.optimize_warning_issued
+        self.class.optimize_warning_issued = true
+
+        warn "[Herb] Compile-time optimizations are experimental. Output may differ from standard ActionView rendering."
+      end
+
       @visitors = properties.fetch(:visitors, default_visitors)
 
       if @debug && @visitors.empty?
@@ -110,7 +129,11 @@ module Herb
       @src << "__herb = ::Herb::Engine; " if @escape && @escapefunc == "__herb.h"
       @src << preamble
 
-      parse_result = ::Herb.parse(input, track_whitespace: true, strict: @strict)
+      action_view_helpers = @optimize && source_may_contain_action_view_helpers?(input)
+      transform_conditionals = @optimize && action_view_helpers
+      parse_result = ::Herb.parse(input, **@parser_options, track_whitespace: true,
+                                                            action_view_helpers: action_view_helpers,
+                                                            transform_conditionals: transform_conditionals)
       ast = parse_result.value
       parser_errors = parse_result.errors
 
@@ -197,6 +220,10 @@ module Herb
       end
     end
 
+    def self.nested_attribute_value(value)
+      value.is_a?(::String) || value.is_a?(::Symbol) ? value.to_s : value.to_json
+    end
+
     def self.comment?(code)
       code.include?("#")
     end
@@ -205,6 +232,26 @@ module Herb
       code.match?(/<<[~-]?\s*['"`]?\w/)
     end
 
+    def source_may_contain_action_view_helpers?(source)
+      self.class.action_view_helper_pattern.match?(source)
+    end
+
+    def self.action_view_helper_pattern
+      @action_view_helper_pattern ||= begin
+        require_relative "action_view/helper_registry"
+
+        names = ::Herb::ActionView::HelperRegistry.supported.flat_map { |entry|
+          if entry.receiver_call_detect?
+            "#{entry.name}."
+          else
+            [entry.name, *entry.aliases]
+          end
+        }
+
+        Regexp.new("\\b(?:#{names.map { |name| Regexp.escape(name) }.join("|")})")
+      end
+    end
+
     protected
 
     def add_text(text)
@@ -337,7 +384,7 @@ module Herb
       @src << postamble
     end
 
-    def with_buffer(&_block)
+    def with_buffer(&)
       if @chain_appends
         @src << "; " << @bufvar unless @buffer_on_stack
         yield
@@ -472,6 +519,13 @@ module Herb
       []
     end
 
+    #: () -> Hash[Symbol, untyped]
+    def default_parser_options
+      fallback = {} #: Hash[Symbol, untyped]
+
+      Herb.configuration.engine_option("parser_options", fallback)
+    end
+
     def ensure_valid_ruby!(source)
       RubyVM::InstructionSequence.compile(source)
     rescue SyntaxError => e

data/lib/herb/html/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Herb
+  module HTML
+    module Util
+      # TODO: extract to shared utility for all languages in .yml
+      VOID_ELEMENTS = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"].freeze #: Array[String]
+
+      #: (String) -> bool
+      def self.void_element?(tag_name)
+        VOID_ELEMENTS.include?(tag_name.downcase)
+      end
+    end
+  end
+end

data/lib/herb/project.rb

@@ -903,12 +903,7 @@ module Herb
     def ensure_parallel!
       return if defined?(Parallel)
 
-      require "bundler/inline"
-
-      gemfile(true, quiet: true) do
-        source "https://rubygems.org"
-        gem "parallel"
-      end
+      Herb.ensure_installed { gem "parallel" } # steep:ignore
     end
 
     def separator

data/lib/herb/version.rb

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

data/lib/herb.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 # typed: false
 
+module Herb
+  PARTIAL_EXTENSIONS = [
+    ".html.erb", ".html.herb", ".erb", ".herb", ".turbo_stream.erb", ".turbo_stream.herb"
+  ].freeze
+
+  PARTIAL_GLOB_PATTERN = "_*.{html.erb,html.herb,erb,herb,turbo_stream.erb,turbo_stream.herb}"
+end
+
 require_relative "herb/colors"
 require_relative "herb/range"
 require_relative "herb/position"
@@ -13,12 +21,15 @@ require_relative "herb/result"
 require_relative "herb/lex_result"
 require_relative "herb/parser_options"
 require_relative "herb/parse_result"
+require_relative "herb/diff_operation"
+require_relative "herb/diff_result"
 
 require_relative "herb/ast"
 require_relative "herb/ast/node"
 require_relative "herb/ast/nodes"
 require_relative "herb/ast/erb_content_node"
 require_relative "herb/ast/helpers"
+require_relative "herb/ast/erb_render_node"
 
 require_relative "herb/errors"
 require_relative "herb/warnings"
@@ -29,6 +40,7 @@ require_relative "herb/configuration"
 
 require_relative "herb/version"
 
+require_relative "herb/html/util"
 require_relative "herb/visitor"
 require_relative "herb/engine"
 
@@ -69,13 +81,13 @@ end
 module Herb
   class << self
     #: (String path, ?arena_stats: bool) -> LexResult
-    def lex_file(path, **options)
-      lex(File.read(path), **options)
+    def lex_file(path, **)
+      lex(File.read(path), **)
     end
 
-    #: (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?arena_stats: bool) -> ParseResult
-    def parse_file(path, **options)
-      parse(File.read(path), **options)
+    #: (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
+    def parse_file(path, **)
+      parse(File.read(path), **)
     end
 
     #: (String source) -> Prism::ParseResult
@@ -96,5 +108,29 @@ module Herb
     def reset_configuration!
       @configuration = nil
     end
+
+    def dev_server_port(project_path = nil)
+      require_relative "herb/dev/server_entry"
+
+      project_path ||= Dir.pwd
+      entry = Dev::ServerEntry.find_by_project(project_path)
+      entry&.port
+    rescue StandardError
+      nil
+    end
+
+    def ensure_installed(&block)
+      require "bundler/inline"
+
+      verbose = $VERBOSE
+      $VERBOSE = nil
+
+      gemfile(true, quiet: true) do # steep:ignore
+        source "https://rubygems.org" # steep:ignore
+        instance_eval(&block) # steep:ignore
+      end
+    ensure
+      $VERBOSE = verbose
+    end
   end
 end