reactionview 0.4.1 → 0.6.1

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,201 @@ 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)
+          config.merge!(filename_annotation_options(template))
+
           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 filename_annotation_options(template)
+          return {} unless ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
+
+          beginning = "<!-- BEGIN #{template.short_identifier}\n-->"
+          ending = "<!-- END #{template.short_identifier} -->"
+
+          {
+            preamble: "@output_buffer.safe_append=#{beginning.dump};",
+            postamble: "@output_buffer.safe_append=#{ending.dump};@output_buffer",
+          }
+        end
+
+        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 +255,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 +270,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
 

data/lib/reactionview/template/local_template.rb

@@ -3,19 +3,50 @@
 module ReActionView
   class Template
     module LocalTemplate
+      FRAMEWORK_TEMPLATE_SEGMENT = "/action_dispatch/middleware/templates/" #: String
+
       private
 
+      def framework_template?(template)
+        return false unless template.respond_to?(:identifier) && template.identifier
+
+        template.identifier.to_s.include?(FRAMEWORK_TEMPLATE_SEGMENT)
+      end
+
       def local_template?(template)
-        return true unless template.respond_to?(:identifier) && template.identifier
-        return false if vendored_template?(template)
+        identifier = template_identifier(template)
+
+        return true unless identifier
+
+        app_root = application_root
+        dependencies = Dependencies.current
+
+        return false if under?(identifier, dependencies.engine_roots)
+        return false if under?(identifier, dependencies.gem_paths_outside(app_root))
+        return true if under?(identifier, dependencies.app_view_paths)
+        return true unless app_root
 
-        template.identifier.start_with?(Rails.root.to_s)
+        under?(identifier, [app_root])
       end
 
-      def vendored_template?(template)
-        return false unless defined?(Bundler)
+      def template_identifier(template)
+        return nil unless template.respond_to?(:identifier)
+
+        identifier = template.identifier
+
+        return nil if identifier.nil? || identifier.to_s.empty?
+
+        File.expand_path(identifier.to_s)
+      end
+
+      def application_root
+        return nil unless defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+
+        "#{File.expand_path(::Rails.root.to_s).chomp("/")}/"
+      end
 
-        template.identifier.start_with?(Bundler.bundle_path.to_s)
+      def under?(identifier, prefixes)
+        prefixes.any? { |prefix| identifier.start_with?(prefix) }
       end
     end
   end

data/lib/reactionview/template/partial_resolver.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ReActionView
+  class Template
+    # Answers a render's partial name with the file Rails would render, across every view path the
+    # application has registered.
+    #
+    # Herb resolves partials while it compiles, to check that a render names a template that
+    # exists, to inline one, and to read the states a caller binds through `state:`. On its own it
+    # looks under a single view root, which is a fair description of an application and wrong for
+    # everything around it. Rails has the application's own paths, its engines' and its gems' all
+    # registered, in an order the application controls, and `shared/album_card` may live in any of
+    # them.
+    #
+    # This asks Herb's own resolver once per registered path, in the order Rails registered them,
+    # so the file is the one Rails would have found and the identifier is the one that file's own
+    # compile reports for itself. That last part is what a state binding keys on, so the two sides
+    # of a binding agree by construction.
+    #
+    class PartialResolver
+      #: () -> PartialResolver
+      def self.current
+        @current ||= new
+      end
+
+      #: () -> void
+      def self.reset!
+        @current = nil
+      end
+
+      #: (?project_path: untyped, ?view_paths: Array[String]?) -> void
+      def initialize(project_path: nil, view_paths: nil)
+        @project_path = project_path
+        @view_paths = view_paths
+      end
+
+      #: (String, ?from: untyped, ?format: String?) -> untyped
+      def resolve(name, from: nil, format: nil)
+        resolvers.each do |resolver|
+          found = resolver.resolve(name, from: from, format: format)
+
+          return found if found
+        end
+
+        nil
+      end
+
+      #: (String, ?from: untyped) -> Array[untyped]
+      def candidates(name, from: nil)
+        resolvers.flat_map { |resolver| resolver.candidates(name, from: from) }.uniq
+      end
+
+      #: (String, ?from: untyped, ?limit: Integer) -> Array[String]
+      def similar(name, from: nil, limit: 3)
+        resolvers.flat_map { |resolver| resolver.similar(name, from: from, limit: limit) }.uniq.first(limit)
+      end
+
+      #: (untyped) -> String
+      def identifier_for(path)
+        resolvers.first.identifier_for(path)
+      end
+
+      private
+
+      #: () -> Array[untyped]
+      def resolvers
+        dependencies = @view_paths ? nil : Dependencies.current
+
+        unless dependencies.equal?(@dependencies)
+          @dependencies = dependencies
+          @resolvers = nil
+        end
+
+        @resolvers ||= roots(dependencies).map { |root| ::Herb::Analysis::PartialResolver.new(project_path, view_root: root) }
+      end
+
+      #: (untyped) -> Array[String?]
+      def roots(dependencies)
+        paths = @view_paths || dependencies.view_paths
+
+        paths.empty? ? [nil] : paths
+      end
+
+      #: () -> untyped
+      def project_path
+        @project_path ||= ::ReActionView.config.project_path
+      end
+    end
+  end
+end

data/lib/reactionview/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReActionView
-  VERSION = "0.4.1"
+  VERSION = "0.6.1"
 end

data/lib/reactionview.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation"
+
 require_relative "reactionview/version"
 require_relative "reactionview/config"
 
@@ -17,6 +19,14 @@ require_relative "reactionview/config"
 
 # require_relative "reactionview/source_annotation_extractor"
 
+require_relative "reactionview/slots"
+require_relative "reactionview/slots/resolver"
+require_relative "reactionview/slots/rendering"
+require_relative "reactionview/slots/state_overrides"
+require_relative "reactionview/slots/dev_compiler"
+
+require_relative "reactionview/template/dependencies"
+require_relative "reactionview/template/partial_resolver"
 require_relative "reactionview/template/local_template"
 
 require_relative "reactionview/template/handlers/erb"
@@ -26,4 +36,7 @@ require_relative "reactionview/template/handlers/herb/herb"
 require_relative "reactionview/railtie" if defined?(Rails::Railtie)
 
 module ReActionView
+  def self.deprecator
+    @deprecator ||= ::ActiveSupport::Deprecation.new("1.0", "ReActionView")
+  end
 end

data/reactionview.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.email = ["marco.roth@intergga.ch"]
   spec.license = "MIT"
 
-  spec.summary = "An ActionView-compatible ERB engine with modern DX - re-imagined with Herb."
-  spec.description = spec.summary
+  spec.summary = "Reactive views for the HTML+ERB you already have."
+  spec.description = "You get what a client-side framework gives you, without adopting one."
   spec.homepage = "https://reactionview.dev"
   spec.required_ruby_version = ">= 3.2.0"
 
@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "actionview", ">= 7.0"
-  spec.add_dependency "cruise"
-  spec.add_dependency "herb", ">= 0.10.4", "< 0.11.0"
+  spec.add_dependency "cruise", ">= 0.3.0"
+  spec.add_dependency "herb", ">= 0.11.2"
+  spec.add_dependency "websocket", "~> 1.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: reactionview
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.1
 platform: ruby
 authors:
 - Marco Roth
 bindir: exe
 cert_chain: []
-date: 2026-09-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -29,36 +29,43 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: herb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.4
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.4
-    - - "<"
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
-description: An ActionView-compatible ERB engine with modern DX - re-imagined with
-  Herb.
+        version: '1.2'
+description: You get what a client-side framework gives you, without adopting one.
 email:
 - marco.roth@intergga.ch
 executables: []
@@ -72,18 +79,29 @@ files:
 - app/assets/javascripts/reactionview-dev-tools.esm.js.map
 - app/assets/javascripts/reactionview-dev-tools.umd.js
 - app/assets/javascripts/reactionview-dev-tools.umd.js.map
+- app/assets/javascripts/reactionview.esm.js
+- app/assets/javascripts/reactionview.esm.js.map
 - lib/generators/reactionview/install_generator.rb
 - lib/reaction_view.rb
 - lib/reactionview.rb
 - lib/reactionview/asset_manifest.rb
 - lib/reactionview/config.rb
+- lib/reactionview/importmap.rb
+- lib/reactionview/instrumentation.rb
 - lib/reactionview/middleware/asset_manifest_check.rb
 - lib/reactionview/railtie.rb
+- lib/reactionview/slots.rb
+- lib/reactionview/slots/dev_compiler.rb
+- lib/reactionview/slots/rendering.rb
+- lib/reactionview/slots/resolver.rb
+- lib/reactionview/slots/state_overrides.rb
 - lib/reactionview/stale_asset_manifest_error.rb
+- lib/reactionview/template/dependencies.rb
 - lib/reactionview/template/handlers/erb.rb
 - lib/reactionview/template/handlers/herb.rb
 - lib/reactionview/template/handlers/herb/herb.rb
 - lib/reactionview/template/local_template.rb
+- lib/reactionview/template/partial_resolver.rb
 - lib/reactionview/version.rb
 - reactionview.gemspec
 - sig/reactionview.rbs
@@ -109,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.20
 specification_version: 4
-summary: An ActionView-compatible ERB engine with modern DX - re-imagined with Herb.
+summary: Reactive views for the HTML+ERB you already have.
 test_files: []