sorbet_view 0.17.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 858b6bd700e41b846fc44258e8a702bb8f32f25d952a3c64c1468500619c92f0
-  data.tar.gz: 4bbe6e97e5726844fd6135fcb148d486d01c196e33e4c1ef200f088fb79ed1a0
+  metadata.gz: a4a6dcbfa73d97af80ddfc038337a094df6adcfe3be2cdb95997e2eb6304993e
+  data.tar.gz: 5d96c0eabf3534f72abebb91738f22546f157266368d7f92cf6faf6ac38ce44e
 SHA512:
-  metadata.gz: 48c1d98ade67fdb02c84c7650c985fe97ba35e38bdd7973fdb2586bfc4cd89e4fd654435cf5d3e9f8d6b07129cf2573ac76b10c4a857db3f919e92333a6b6b79
-  data.tar.gz: fb8bd91ca32e0473c1a533adbf3211d4c75ddbd8283bfc980ac9497c24acb3548efd7007d13d8ae771667753fbaec1951a4215a0cf94592a959c56770288710e
+  metadata.gz: b6781e594f6fbcb73e9b7a62c9931c97c5f8cbf5375530dff6a6e4a35c7fce73e2333d586aa81e079c32d92b19c59b5b493abe27b0e638ca24e6bc9654d7987d
+  data.tar.gz: 7a026a08b7eb1ebddbb586799095a9de5c39159e26886bc3b0ad2c11ce8382b28bc57c79ef7768c0b929cd3c4083c49663fa11a0b7d81aeb8777b0ce3c3ebd4a

data/lib/sorbet_view/compiler/template_context.rb

@@ -51,6 +51,8 @@ module SorbetView
       class << self
         extend T::Sig
 
+        @all_concrete_controllers = T.let(nil, T.nilable(T::Array[T.untyped]))
+
         private
 
         # Strip the matching input_dir prefix from a template path
@@ -93,15 +95,23 @@ module SorbetView
         sig { params(path: String, config: Configuration).returns(String) }
         def path_to_class_name(path, config)
           relative = strip_input_dir(path, config)
-          basename = File.basename(relative).sub(/\..*$/, '') # strip all extensions
+          filename = File.basename(relative)
+          filename_parts = filename.split('.')
+
+          basename = T.must(filename_parts.first)
           basename = basename.delete_prefix('_') # strip partial prefix
+
+          # With 3+ parts (e.g. show.html.erb → [show, html, erb]), the last is the
+          # template handler and the middle parts are format/variant extensions.
+          # Nest them as sub-classes so show.html.erb and show.turbo_stream.erb
+          # don't collide as the same class name.
+          format_parts = filename_parts.length >= 3 ? T.must(filename_parts[1..-2]) : []
+
           dir = File.dirname(relative)
 
-          parts = if dir == '.'
-            [basename]
-          else
-            dir.split('/') + [basename]
-          end
+          parts = dir == '.' ? [basename] : dir.split('/') + [basename]
+
+          parts += format_parts
 
           parts.map { |p| camelize(p) }.join('::')
         end
@@ -113,11 +123,12 @@ module SorbetView
 
         sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
         def resolve_controller_view(path, ruby_path, config)
+          helper_includes = resolve_runtime_helper_includes(path, config)
           new(
             class_name: "SorbetView::Generated::#{path_to_class_name(path, config)}",
             superclass: '::ActionView::Base',
             includes: [
-              '::ApplicationController::HelperMethods',
+              *helper_includes,
               *config.extra_includes
             ],
             template_path: path,
@@ -141,11 +152,12 @@ module SorbetView
 
         sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
         def resolve_layout(path, ruby_path, config)
+          helper_includes = resolve_runtime_helper_includes(path, config)
           new(
             class_name: "SorbetView::Generated::#{path_to_class_name(path, config)}",
             superclass: '::ActionView::Base',
             includes: [
-              '::ApplicationController::HelperMethods',
+              *helper_includes,
               *config.extra_includes
             ],
             template_path: path,
@@ -155,11 +167,12 @@ module SorbetView
 
         sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
         def resolve_partial(path, ruby_path, config)
+          helper_includes = resolve_runtime_helper_includes(path, config)
           new(
             class_name: "SorbetView::Generated::#{path_to_class_name(path, config)}",
             superclass: '::ActionView::Base',
             includes: [
-              '::ApplicationController::HelperMethods',
+              *helper_includes,
               *config.extra_includes
             ],
             template_path: path,
@@ -177,6 +190,107 @@ module SorbetView
             ruby_path: ruby_path
           )
         end
+
+        sig { params(path: String, config: Configuration).returns(T::Array[String]) }
+        def resolve_runtime_helper_includes(path, config)
+          return ['::ApplicationController::HelperMethods'] unless defined?(::ActionController::Base)
+
+          relative = strip_input_dir(path, config)
+          names = []
+          if relative.start_with?('layouts/')
+            names = helper_modules_for_layout(relative)
+          elsif File.basename(relative).start_with?('_')
+            names = helper_modules_for_partial(relative)
+          else
+            names = helper_modules_for_controller_view(relative)
+          end
+
+          return ['::ApplicationController::HelperMethods'] if names.empty?
+
+          names.map { |name| "::#{name}" }
+        rescue StandardError => e
+          $stderr.puts "[SorbetView] resolve_runtime_helper_includes failed: #{e.class}: #{e.message}"
+          ['::ApplicationController::HelperMethods']
+        end
+
+        sig { params(relative: String).returns(T::Array[String]) }
+        def helper_modules_for_controller_view(relative)
+          controller_path = File.dirname(relative)
+          return [] if controller_path.nil? || controller_path.empty? || controller_path == '.'
+
+          controller = find_controller_by_path(controller_path)
+          helper_module_names_for(controller)
+        end
+
+        sig { params(relative: String).returns(T::Array[String]) }
+        def helper_modules_for_layout(relative)
+          filename = File.basename(relative)
+          layout_name = T.must(filename.split('.').first).to_s
+          return [] if layout_name.empty?
+
+          all_concrete_controllers.flat_map do |controller|
+            next [] unless controller.respond_to?(:_layout)
+            next [] unless controller._layout == layout_name
+
+            helper_module_names_for(controller)
+          end.uniq.sort
+        end
+
+        sig { params(relative: String).returns(T::Array[String]) }
+        def helper_modules_for_partial(relative)
+          dir = File.dirname(relative)
+          return [] if dir.nil? || dir.empty? || dir == '.'
+
+          # Partials can live under subdirectories that share a parent controller
+          # (e.g. users/forms/_field.html.erb should use UsersController helpers).
+          parts = dir.split('/')
+          candidates = parts.length.downto(1).map { |i| parts.first(i).join('/') }
+
+          candidates.each do |controller_path|
+            controller = find_controller_by_path(controller_path)
+            names = helper_module_names_for(controller)
+            return names unless names.empty?
+          end
+
+          []
+        end
+
+        sig { params(controller_path: String).returns(T.untyped) }
+        def find_controller_by_path(controller_path)
+          all_concrete_controllers.find do |controller|
+            controller.respond_to?(:controller_path) && controller.controller_path == controller_path
+          end
+        end
+
+        sig { returns(T::Array[T.untyped]) }
+        def all_concrete_controllers
+          controllers = @all_concrete_controllers
+          return controllers if controllers
+
+          controllers = ObjectSpace.each_object(Class).select do |klass|
+            klass < ::ActionController::Base && !klass.abstract?
+          rescue StandardError
+            false
+          end.sort_by { |klass| (klass.name || "AnonymousController:#{klass.object_id}").to_s }
+
+          @all_concrete_controllers = controllers
+          controllers
+        end
+
+        sig { params(controller: T.untyped).returns(T::Array[String]) }
+        def helper_module_names_for(controller)
+          return [] unless controller
+          return [] unless controller.respond_to?(:_helpers)
+
+          # Use the actual runtime helper chain for this controller.
+          controller._helpers.ancestors.filter_map do |mod|
+            next unless mod.is_a?(Module) && !mod.is_a?(Class)
+            name = mod.name
+            next if name.nil? || name.empty?
+            next if name.start_with?('ActionController::') || name.start_with?('AbstractController::')
+            name
+          end.uniq
+        end
       end
     end
   end

data/lib/sorbet_view/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module SorbetView
-  VERSION = '0.17.2'
+  VERSION = '0.19.0'
 end

data/lib/tapioca/dsl/compilers/sorbet_view.rb

@@ -26,6 +26,7 @@ module Tapioca
         sig { override.void }
         def decorate
           @module_cache = T.let({}, T::Hash[String, RBI::Scope])
+          @layout_contributions = T.let({}, T::Hash[String, T::Array[T::Hash[Symbol, T.untyped]]])
           @project = T.let(SrbLens::Project.load_or_index(Dir.pwd), T.untyped)
 
           # Ensure all controllers are loaded
@@ -37,10 +38,17 @@ module Tapioca
             false
           end
 
+          # Deterministic order: ObjectSpace has no order guarantee, and "last controller wins" for
+          # shared layout classes made RBI diffs unstable. Sort by constant name; anonymous classes
+          # fall back to object_id.
+          controllers = controllers.sort_by { |c| controller_sort_key(c) }
+
           controllers.each do |controller|
             process_controller(controller)
           end
 
+          emit_merged_layout_includes
+
           generate_ivar_mapping(controllers)
           process_components
           compile_all_templates
@@ -61,7 +69,7 @@ module Tapioca
           controllers.each do |controller|
             path = controller.controller_path
 
-            controller.action_methods.each do |action_name|
+            controller.action_methods.to_a.sort.each do |action_name|
               next unless action_name.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
 
               action_ivars = extract_ivars_from_srb_lens(controller, action_name.to_s)
@@ -120,11 +128,7 @@ module Tapioca
           common_keys.each do |key|
             type_a = T.must(a[key])
             type_b = T.must(b[key])
-            result[key] = if type_a == type_b
-              type_a
-            else
-              "T.all(#{type_a}, #{type_b})"
-            end
+            result[key] = type_a == type_b ? type_a : "T.all(#{type_a}, #{type_b})"
           end
           result
         end
@@ -213,7 +217,8 @@ module Tapioca
 
         sig { params(klass: T.untyped, class_name: String).void }
         def generate_component_rbi(klass, class_name)
-          methods = klass.instance_methods(false)
+          # Instance method order is not guaranteed; sort for stable RBI.
+          methods = klass.instance_methods(false).sort
 
           method_sigs = methods.filter_map do |method_name|
             method_name_s = method_name.to_s
@@ -258,19 +263,126 @@ module Tapioca
             end
           end
 
-          # 2) Each action's template class includes the helper module and controller-specific helper modules
-          actions = controller.action_methods.to_a
+          # 2) Each action's template class includes the helper module and controller-specific helper modules.
+          # Templates compile to format-nested classes (e.g. Users::Show::Html, Users::Show::TurboStream),
+          # so emit RBI for each format variant found on disk. Falls back to the action-base class
+          # when no format-suffixed templates exist.
+          actions = controller.action_methods.to_a.sort
           actions.each do |action_name|
             next unless action_name.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
 
-            class_name = "SorbetView::Generated::#{parts.join('::')}::#{camelize(action_name)}"
-            create_class_from_path(class_name) do |klass|
-              klass.create_include(helper_module_name) if helper_module_name
-              controller_helper_modules.each do |mod_name|
-                klass.create_include("::#{mod_name}")
+            base_class_name = "SorbetView::Generated::#{parts.join('::')}::#{camelize(action_name)}"
+            format_suffixes = find_template_format_suffixes(path, action_name.to_s)
+            class_names = format_suffixes.empty? ? [base_class_name] : format_suffixes.map { |fs| "#{base_class_name}::#{fs}" }
+
+            class_names.each do |class_name|
+              create_class_from_path(class_name) do |klass|
+                apply_includes_for_action!(klass, helper_module_name, controller_helper_modules)
               end
             end
           end
+
+          layout_name = controller._layout if controller.respond_to?(:_layout)
+          if layout_name.is_a?(String) && !layout_name.empty?
+            base_class_name = "SorbetView::Generated::Layouts::#{camelize(layout_name)}"
+            format_suffixes = find_template_format_suffixes('layouts', layout_name)
+            class_names = format_suffixes.empty? ? [base_class_name] : format_suffixes.map { |fs| "#{base_class_name}::#{fs}" }
+
+            class_names.each do |class_name|
+              contribs = T.must(@layout_contributions)[class_name] ||= []
+              contribs << {
+                controller_name: controller_sort_key(controller),
+                helper_module_name: helper_module_name,
+                controller_helper_modules: controller_helper_modules
+              }
+            end
+          end
+        end
+
+        # Stable sort key for controllers (anonymous classes have no #name).
+        sig { params(controller: T.untyped).returns(String) }
+        def controller_sort_key(controller)
+          (controller.name || "AnonymousController:#{controller.object_id}").to_s
+        end
+
+        # Apply include lines for a single controller's view class. Order: SorbetView::Helpers
+        # module first (if any), then controller-specific helper modules in Rails MRO order
+        # (see extract_controller_helper_modules).
+        sig do
+          params(
+            klass: T.untyped,
+            helper_module_name: T.nilable(String),
+            controller_helper_modules: T::Array[String]
+          ).void
+        end
+        def apply_includes_for_action!(klass, helper_module_name, controller_helper_modules)
+          klass.create_include(helper_module_name) if helper_module_name
+          controller_helper_modules.each do |mod_name|
+            klass.create_include("::#{mod_name}")
+          end
+        end
+
+        # Layout template classes are shared by every controller that uses the same layout.
+        # Record per-controller includes, then merge once with deterministic rules:
+        # - contributors sorted by controller_sort_key
+        # - within each contributor: helper module first, then MRO order (unchanged)
+        # - same constant name only included once: first contribution in the sorted list wins
+        #   (preserves a single stable precedence for duplicate modules).
+        sig { void }
+        def emit_merged_layout_includes
+          T.must(@layout_contributions).sort_by(&:first).each do |class_name, contribs|
+            lines = merge_layout_include_lines(contribs)
+            next if lines.empty?
+
+            create_class_from_path(class_name) do |klass_rbi|
+              lines.each { |line| klass_rbi.create_include(line) }
+            end
+          end
+        end
+
+        # Returns the exact `create_include` string for each line (unprefixed SorbetView path or ::Foo).
+        sig { params(contributions: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Array[String]) }
+        def merge_layout_include_lines(contributions)
+          seen = T.let({}, T::Hash[String, T::Boolean])
+          out = T.let([], T::Array[String])
+
+          contributions.sort_by { |c| c[:controller_name].to_s }.each do |c|
+            h = c[:helper_module_name]
+            if h && !seen[h]
+              seen[h] = true
+              out << h
+            end
+            c[:controller_helper_modules].to_a.each do |mod_name|
+              next if seen[mod_name]
+
+              seen[mod_name] = true
+              out << "::#{mod_name}"
+            end
+          end
+
+          out
+        end
+
+        # Scan view dirs for format suffixes of a given action's templates.
+        # e.g. ["Html", "TurboStream"] for show.html.erb + show.turbo_stream.erb.
+        # Templates with no format (e.g. show.erb) contribute no suffix — for those,
+        # callers fall back to the action-base class name.
+        sig { params(controller_path: String, action_name: String).returns(T::Array[String]) }
+        def find_template_format_suffixes(controller_path, action_name)
+          suffixes = T.let([], T::Array[String])
+
+          resolve_view_dirs.each do |vd|
+            Dir.glob(File.join(vd, controller_path, "#{action_name}.*")).each do |file|
+              fname_parts = File.basename(file).split('.')
+              next unless fname_parts.first == action_name
+              next unless fname_parts.length >= 3
+
+              middle_parts = T.must(fname_parts[1..-2])
+              suffixes << middle_parts.map { |p| camelize(p) }.join('::')
+            end
+          end
+
+          suffixes.uniq.sort
         end
 
         # Returns [[method_name, params, return_type], ...]
@@ -278,42 +390,29 @@ module Tapioca
         def extract_helper_methods(controller)
           return [] unless controller.respond_to?(:_helper_methods)
 
-          controller._helper_methods.filter_map do |name|
+          rows = controller._helper_methods.filter_map do |name|
             name_s = name.to_s
             next unless name_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*[?!]?\z/)
 
             method_info = find_method_info(controller, name_s)
-            params = if method_info
-              build_params_from_srb_lens(method_info)
-            else
-              build_params_from_reflection(controller, name_s)
-            end
+            params = method_info ? build_params_from_srb_lens(method_info) : build_params_from_reflection(controller, name_s)
             return_type = method_info&.return_type || 'T.untyped'
             return_type = 'T.untyped' if return_type.empty?
 
             [name_s, params, return_type]
           end
+          rows.sort_by { |row| T.must(row).first }
         end
 
-        # Returns controller-specific helper module names (modules included via `helper` that are not in ApplicationController)
+        # Returns runtime helper module names for the controller.
         sig { params(controller: T.untyped).returns(T::Array[String]) }
         def extract_controller_helper_modules(controller)
           return [] unless controller.respond_to?(:_helpers)
 
-          base_helpers = if defined?(::ApplicationController) && ::ApplicationController.respond_to?(:_helpers)
-            ::ApplicationController._helpers.ancestors
-          else
-            []
-          end
-
-          controller_helpers = controller._helpers.ancestors
-          specific_modules = controller_helpers - base_helpers
-
-          specific_modules.filter_map do |mod|
+          controller._helpers.ancestors.filter_map do |mod|
             next unless mod.is_a?(Module) && !mod.is_a?(Class)
             name = mod.name
             next if name.nil? || name.empty?
-            next if name.include?('HelperMethods')
             next if name.start_with?('ActionController::') || name.start_with?('AbstractController::')
             name
           end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sorbet_view
 version: !ruby/object:Gem::Version
-  version: 0.17.2
+  version: 0.19.0
 platform: ruby
 authors:
 - kazuma
 bindir: exe
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: herb