reactionview 0.4.1 → 0.6.0

data/lib/reactionview/slots/resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ReActionView
+  module Slots
+    class Resolver < ActionView::FileSystemResolver
+      private
+
+      def build_unbound_template(template)
+        unbound = super
+        details = unbound.details
+
+        return unbound unless details.format == :html
+
+        ActionView::UnboundTemplate.new(
+          source_for_template(template),
+          template,
+          details: ActionView::TemplateDetails.new(details.locale, details.handler, Slots::FORMAT, details.variant),
+          virtual_path: unbound.virtual_path
+        )
+      end
+
+      def unbound_templates_from_path(path)
+        super.select { |unbound| unbound.format == Slots::FORMAT }
+      end
+    end
+  end
+end

data/lib/reactionview/slots/state_overrides.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ReActionView
+  module Slots
+    # Parses the `Herb-State` request header a client sends with a values request.
+    #
+    # The header carries the client's state so the compiled values program evaluates
+    # the branches the client is showing. The parse is lenient on purpose, since a
+    # malformed or oversized header must degrade to the compiled defaults and never
+    # break a render.
+    #
+    module StateOverrides
+      HEADER = "Herb-State" #: String
+      MAX_BYTES = 8192 #: Integer
+
+      #: (String?) -> Hash[String, Hash[String, untyped]]?
+      def self.parse(header_value)
+        return nil if header_value.nil? || header_value.strip.empty?
+        return nil if header_value.bytesize > MAX_BYTES
+
+        raw = ::JSON.parse(header_value)
+
+        return nil unless raw.is_a?(::Hash)
+
+        overrides = raw.select { |key, value| key.is_a?(::String) && value.is_a?(::Hash) }
+
+        overrides.empty? ? nil : overrides
+      rescue ::JSON::ParserError
+        nil
+      end
+    end
+
+    module StateOverridesHelper
+      #: () -> Hash[String, Hash[String, untyped]]?
+      def __herb_state_overrides
+        return @__herb_state_overrides if defined?(@__herb_state_overrides)
+
+        header = __herb_values_request? ? request.headers[StateOverrides::HEADER] : nil
+
+        @__herb_state_overrides = StateOverrides.parse(header)
+      end
+
+      #: () -> bool
+      def __herb_values_request?
+        return false unless respond_to?(:request) && request
+        return false unless request.respond_to?(:format)
+
+        request.format&.symbol == Slots::FORMAT
+      end
+
+      #: (?String?, ?untyped) -> untyped
+      def herb_state(name = nil, default = nil)
+        overrides = __herb_state_overrides
+
+        return overrides if name.nil?
+        return default if overrides.nil?
+
+        overrides.each_value do |states|
+          return states[name] if states.key?(name)
+        end
+
+        default
+      end
+    end
+  end
+end

data/lib/reactionview/slots.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ReActionView
+  module Slots
+    FORMAT = :slots #: Symbol
+    MIME_TYPE = "application/vnd.herb.slots+json" #: String
+    REGION_MARKER = "herb-region:" #: String
+
+    #: () -> untyped
+    def self.dependencies
+      root = ReActionView.config.project_path
+
+      @dependencies = nil if @root != root
+      @root = root
+      @dependencies ||= ::Herb::Engine::Slots::Dependencies.new(
+        root,
+        compile: ->(source, path) { ReActionView::Template::Handlers::Herb.compile_for_dependencies(source, path) }
+      )
+    end
+
+    #: () -> void
+    def self.reset_dependencies!
+      @dependencies = nil
+    end
+
+    #: (String, Integer) -> String?
+    def self.block_program(path, index)
+      mtime = ::File.mtime(path)
+      key = [path, index, mtime]
+
+      (@block_programs_lock ||= ::Mutex.new).synchronize do
+        programs = (@block_programs ||= {})
+        programs.clear if programs.size > 128 && !programs.key?(key)
+        programs[key] ||= ReActionView::Template::Handlers::Herb.compile_for_block(::File.read(path), path, index)
+      end
+    end
+  end
+end

data/lib/reactionview/template/dependencies.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ReActionView
+  class Template
+    class Dependencies
+      def self.current
+        @current ||= new
+      end
+
+      def self.reset!
+        @current = nil
+      end
+
+      def engine_roots
+        @engine_roots ||= engines.filter_map { |engine| directory(engine.root) }
+      end
+
+      def gem_paths_outside(app_root)
+        return [] unless app_root
+
+        gem_paths.reject { |path| app_root.start_with?(path) }
+      end
+
+      def app_view_paths
+        @app_view_paths ||= (registered_view_paths - engine_view_paths).filter_map { |path| directory(path) }
+      end
+
+      def view_paths
+        @view_paths ||= registered_view_paths.filter_map { |path| directory(path) }
+      end
+
+      private
+
+      def gem_paths
+        @gem_paths ||= begin
+          specs = defined?(::Gem) && ::Gem.respond_to?(:loaded_specs) ? ::Gem.loaded_specs.values : []
+
+          specs.filter_map { |spec| directory(spec.full_gem_path) }
+        end
+      end
+
+      def engines
+        return [] unless defined?(::Rails::Engine)
+
+        @engines ||= ::Rails::Engine.subclasses.filter_map { |klass| engine_instance(klass) }
+      end
+
+      def engine_instance(klass)
+        return nil unless klass.respond_to?(:instance)
+
+        engine = klass.instance
+
+        return nil if engine.nil? || engine == application
+        return nil unless engine.respond_to?(:root) && engine.root
+
+        engine
+      rescue StandardError
+        nil
+      end
+
+      def engine_view_paths
+        engines.flat_map do |engine|
+          engine.paths["app/views"].existent
+        rescue StandardError
+          []
+        end
+      end
+
+      def registered_view_paths
+        return [] unless defined?(::ActionController::Base)
+
+        ::ActionController::Base.view_paths.filter_map { |resolver| resolver.path if resolver.respond_to?(:path) }
+      rescue StandardError
+        []
+      end
+
+      def application
+        ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
+      end
+
+      def directory(path)
+        return nil if path.nil?
+
+        expanded = File.expand_path(path.to_s)
+
+        expanded.empty? ? nil : "#{expanded.chomp("/")}/"
+      end
+    end
+  end
+end

data/lib/reactionview/template/handlers/erb.rb

@@ -6,9 +6,17 @@ module ReActionView
       class ERB < ActionView::Template::Handlers::ERB
         include ReActionView::Template::LocalTemplate
 
+        INTERCEPTED_FORMATS = [:html, ::ReActionView::Slots::FORMAT].freeze
+
         autoload :Herb, "reactionview/template/handlers/herb/herb"
 
         def call(template, source)
+          if skip_external_template?(template)
+            @erb_fallback = true
+
+            return super
+          end
+
           return super unless intercept_template?(template)
 
           ::ReActionView::Template::Handlers::Herb.call(
@@ -19,13 +27,29 @@ module ReActionView
 
           log_external_template_error(template, e)
 
+          @erb_fallback = true
+
           super
         end
 
         private
 
+        def implementation_for(template)
+          return self.class.erb_implementation if @erb_fallback
+
+          super
+        end
+
+        def skip_external_template?(template)
+          return false unless INTERCEPTED_FORMATS.include?(template.format) && ReActionView.config.intercept_erb
+          return false if framework_template?(template) || local_template?(template)
+
+          ReActionView.config.external_template_mode == :skip
+        end
+
         def intercept_template?(template)
-          return false unless template.format == :html && ReActionView.config.intercept_erb
+          return false unless INTERCEPTED_FORMATS.include?(template.format) && ReActionView.config.intercept_erb
+          return false if framework_template?(template)
 
           local_template?(template) || ReActionView.config.external_template_mode != :skip
         end

data/lib/reactionview/template/handlers/herb/herb.rb

@@ -1,89 +1,101 @@
 # frozen_string_literal: true
 
 require "herb"
+require "herb/engine"
+
+begin
+  require "action_view/template/handlers/erb/herb"
+rescue LoadError
+  # Rails 8.1 and earlier ship no builtin Herb implementation
+end
 
 module ReActionView
   class Template
     module Handlers
       class Herb
-        class Herb < ::Herb::Engine
-          def initialize(input, properties = {})
-            @newline_pending = 0
+        if defined?(::ActionView::Template::Handlers::ERB::Herb)
+          class Herb < ::ActionView::Template::Handlers::ERB::Herb
+          end
+        else
+          class Herb < ::Herb::Engine
+            def initialize(input, properties = {})
+              @newline_pending = 0
 
-            # Dup properties so that we don't modify argument
-            properties = properties.to_h
+              # Dup properties so that we don't modify argument
+              properties = properties.to_h
 
-            properties[:bufvar]     ||= "@output_buffer"
-            properties[:preamble]   ||= ""
-            properties[:postamble]  ||= properties[:bufvar].to_s
+              properties[:bufvar]     ||= "@output_buffer"
+              properties[:preamble]   ||= ""
+              properties[:postamble]  ||= properties[:bufvar].to_s
 
-            # Tell Herb whether the template will be compiled with `frozen_string_literal: true`
-            properties[:freeze_template_literals] = !::ActionView::Template.frozen_string_literal
+              # Tell Herb whether the template will be compiled with `frozen_string_literal: true`
+              properties[:freeze_template_literals] = !::ActionView::Template.frozen_string_literal
 
-            # Disable all Herb escape functions - let ActionView::OutputBuffer handle escaping
-            properties[:escapefunc] = ""
-            properties[:attrfunc] = nil
-            properties[:jsfunc] = nil
-            properties[:cssfunc] = nil
+              # Disable all Herb escape functions - let ActionView::OutputBuffer handle escaping
+              properties[:escapefunc] = ""
+              properties[:attrfunc] = nil
+              properties[:jsfunc] = nil
+              properties[:cssfunc] = nil
 
-            super
-          end
+              super
+            end
 
-          private
+            private
 
-          def add_text(text)
-            return if text.empty?
+            def add_text(text)
+              return if text.empty?
 
-            if text == "\n"
-              @newline_pending += 1
-            else
-              with_buffer do
-                @src << ".safe_append='"
-                @src << ("\n" * @newline_pending) if @newline_pending.positive?
-                @src << text.gsub(/['\\]/, '\\\\\&') << @text_end
-              end
+              if text == "\n"
+                @newline_pending += 1
+              else
+                with_buffer do
+                  @src << ".safe_append='"
+                  @src << ("\n" * @newline_pending) if @newline_pending.positive?
+                  @src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+                end
 
-              @newline_pending = 0
+                @newline_pending = 0
+              end
             end
-          end
 
-          def add_expression(indicator, code)
-            flush_newline_if_pending(@src)
+            def add_expression(indicator, code)
+              flush_newline_if_pending(@src)
 
-            with_buffer do
-              @src << expression_append_method(indicator)
+              with_buffer do
+                @src << expression_append_method(indicator)
 
-              if expression_block?
-                @src << " " << code
-              else
-                @src << "(" << code << trailing_newline(code) << ")"
+                if expression_block?
+                  @src << " " << code
+                else
+                  @src << "(" << code << trailing_newline(code) << ")"
+                end
               end
             end
-          end
 
-          def expression_append_method(indicator)
-            if (indicator == "==") || @escape
-              ".safe_expr_append="
-            else
-              ".append="
+            def expression_append_method(indicator)
+              if (indicator == "==") || @escape
+                ".safe_expr_append="
+              else
+                ".append="
+              end
             end
-          end
 
-          def add_code(code)
-            flush_newline_if_pending(@src)
-            super
-          end
+            def add_code(code)
+              flush_newline_if_pending(@src)
+              super
+            end
 
-          def add_postamble(_)
-            flush_newline_if_pending(@src)
-            super
-          end
+            def add_postamble(_)
+              flush_newline_if_pending(@src)
+              super
+            end
 
-          def flush_newline_if_pending(src)
-            return unless @newline_pending.positive?
+            def flush_newline_if_pending(src)
+              return unless @newline_pending.positive?
 
-            with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
-            @newline_pending = 0
+              with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
+              @newline_pending = 0
+            end
           end
         end
       end

data/lib/reactionview/template/handlers/herb.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
+require "herb"
+require "herb/engine"
+require "herb/engine/slots/dynamics_compiler"
+require "herb/engine/slots/schema_compiler"
+
+require "herb/engine/visitors/debug_visitor"
+require "herb/engine/slots/visitor"
+require "herb/engine/slots/dependencies"
+require "herb/engine/visitors/content_for_visitor"
+require "herb/engine/validators"
+
 module ReActionView
   class Template
     module Handlers
@@ -10,33 +21,188 @@ module ReActionView
 
         class_attribute :erb_implementation, default: Handlers::Herb::Herb
 
+        VALUES_ESCAPING = {
+          escape: true,
+          escapefunc: "::ERB::Util.h",
+          attrfunc: nil,
+          jsfunc: nil,
+          cssfunc: nil,
+        }.freeze
+
         def self.call(template, source, validation_mode: nil)
           new.call(template, source, validation_mode: validation_mode)
         end
 
+        def self.compile_for_dependencies(source, path)
+          new.compile_for_dependencies(source, path)
+        end
+
+        def self.compile_for_schema(source, path)
+          new.compile_for_schema(source, path)
+        end
+
+        def self.compile_for_block(source, path, index)
+          new.compile_for_block(source, path, index)
+        end
+
         def call(template, source, validation_mode: nil)
-          visitors = []
+          mode = validation_mode || ReActionView.config.validation_mode
 
-          if ::ReActionView.config.debug_mode_enabled? && local_template?(template)
-            visitors << ::Herb::Engine::DebugVisitor.new(
-              file_path: translate_path_for_editor(template.identifier),
-              project_path: ::ReActionView.config.project_path
-            )
-          end
+          visitors = base_visitors(template, validation_mode: mode)
 
           config = {
-            filename: template.identifier,
-            project_path: Rails.root.to_s,
-            validation_mode: validation_mode || ReActionView.config.validation_mode,
-            content_for_head: reactionview_dev_tools_markup(template),
-            visitors: visitors + ReActionView.config.transform_visitors,
+            filename: translate_path_for_editor(template.identifier),
+            project_path: ::ReActionView.config.project_path,
+            visitors: visitors,
+            **engine_options,
           }
 
+          return values_source(template, source, config) if values_format?(template)
+
+          slots = slot_visitors(template, source)
+
+          config[:visitors] = compile_stack(template, validation_mode: mode, slots: slots)
+
           erb_implementation.new(source, config).src
         end
 
+        def compile_for_dependencies(source, path)
+          template = ::Struct.new(:identifier, :format).new(path, :html)
+          visitor = slot_visitors(template, source, mark: false).first
+
+          return nil unless visitor
+
+          erb_implementation.new(
+            source,
+            filename: translate_path_for_editor(path),
+            project_path: ::ReActionView.config.project_path,
+            visitors: [*base_visitors(template), visitor],
+            **engine_options
+          ).src
+
+          visitor
+        end
+
+        def compile_for_block(source, path, index)
+          template = ::Struct.new(:identifier, :format).new(path, :html)
+          visitor = slot_visitors(template, source, mark: false).first
+
+          return nil unless visitor
+
+          ::Herb::Engine::Slots::DynamicsCompiler.new(
+            source,
+            filename: translate_path_for_editor(path),
+            project_path: ::ReActionView.config.project_path,
+            visitors: base_visitors(template),
+            slot_visitor: visitor,
+            block: index,
+            **engine_options,
+            **VALUES_ESCAPING
+          ).src
+        end
+
+        def compile_for_schema(source, path)
+          template = ::Struct.new(:identifier, :format).new(path, :html)
+
+          ::Herb::Engine::Slots::SchemaCompiler.call(
+            source,
+            filename: translate_path_for_editor(path),
+            mode: ::ReActionView.config.slot_mode_for(source),
+            visitors: -> { base_visitors(template, validation_mode: schema_validation_mode) },
+            engine: erb_implementation,
+            options: { project_path: ::ReActionView.config.project_path, **engine_options }
+          )
+        end
+
         private
 
+        def base_visitors(template, validation_mode: ReActionView.config.validation_mode)
+          compile_stack(template, validation_mode: validation_mode).reject { |visitor| rewrites_erb_source?(visitor) }
+        end
+
+        def compile_stack(template, validation_mode:, slots: [])
+          visitors = [
+            *validation_visitors(validation_mode),
+            *debug_visitors(template),
+            *head_visitors(template),
+            *slots,
+            *::ReActionView.config.engine.visitors
+          ]
+
+          ::Herb::Visitor::Stack.arrange(visitors)
+        end
+
+        def engine_options
+          configured = ::ReActionView.config.engine.parser_options
+          options = resolver_option
+
+          return options if configured.empty?
+
+          defaults = ::Herb.configuration.engine_option("parser_options", {})
+
+          options.merge(parser_options: defaults.transform_keys(&:to_sym).merge(configured))
+        end
+
+        def resolver_option
+          return {} unless defined?(::Herb::Analysis::PartialResolver)
+
+          { resolver: ::ReActionView::Template::PartialResolver.current }
+        end
+
+        def rewrites_erb_source?(visitor)
+          klass = visitor.class
+
+          klass.respond_to?(:rewrites_erb_source?) && klass.rewrites_erb_source?
+        end
+
+        def schema_validation_mode
+          ReActionView.config.validation_mode == :none ? :none : :overlay
+        end
+
+        def values_source(template, source, config)
+          visitor = slot_visitors(template, source, mark: false).first
+
+          return "{}" unless visitor
+
+          ::Herb::Engine::Slots::DynamicsCompiler.new(source, config.merge(slot_visitor: visitor, **VALUES_ESCAPING)).src
+        end
+
+        def values_format?(template)
+          template.respond_to?(:format) && template.format == :slots
+        end
+
+        def validation_visitors(mode)
+          case mode
+          when :raise then ::Herb::Engine::Validators.all(fatal: true).to_a
+          when :overlay then ::Herb::Engine::Validators.all(fatal: false).to_a
+          else []
+          end
+        end
+
+        def debug_visitors(template)
+          return [] unless ::ReActionView.config.debug_mode_enabled? && local_template?(template)
+
+          [::Herb::Engine::DebugVisitor.new]
+        end
+
+        def head_visitors(template)
+          markup = reactionview_dev_tools_markup(template)
+
+          return [] if markup.nil? || markup.empty?
+
+          [::Herb::Engine::ContentForVisitor.new(markup, tag_name: "head")]
+        end
+
+        def slot_visitors(template, source, mark: true)
+          return [] unless values_format?(template) || (template.respond_to?(:format) && template.format == :html)
+
+          mode = ::ReActionView.config.slot_mode_for(source)
+
+          return [] unless mode
+
+          [::Herb::Engine::Slots::Visitor.new(mode: mode, mark: mark)]
+        end
+
         def layout_template?(template)
           return false unless template.respond_to?(:identifier) && template.identifier
 
@@ -76,9 +242,9 @@ module ReActionView
         end
 
         def reactionview_dev_tools_markup(template)
-          return nil unless ::ReActionView.config.debug_mode_enabled?
           return nil unless layout_template?(template)
           return nil unless local_template?(template)
+          return slots_meta_markup unless ::ReActionView.config.debug_mode_enabled?
 
           <<~HTML
             <meta name="herb-debug-mode" content="true">
@@ -91,6 +257,15 @@ module ReActionView
           HTML
         end
 
+        def slots_meta_markup
+          return nil unless ::ReActionView.config.slots && ::ReActionView.config.development?
+
+          <<~HTML
+            <meta name="herb-project-path" content="#{Rails.root}">
+            #{dev_server_port_meta_tag}
+          HTML
+        end
+
         def dismiss_hint_template
           return unless ::ReActionView.config.validation_mode == :overlay