sorbet_view 0.1.0

data/lib/sorbet_view/compiler/ruby_generator.rb

@@ -0,0 +1,211 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'json'
+
+module SorbetView
+  module Compiler
+    class CompileResult < T::Struct
+      const :ruby_source, String
+      const :source_map, SourceMap::SourceMap
+      const :locals, T.nilable(String)
+      const :locals_sig, T.nilable(String)
+    end
+
+    class RubyGenerator
+      extend T::Sig
+
+      LOCALS_PREFIX = 'locals:'
+      LOCALS_SIG_PREFIX = 'locals_sig:'
+
+      sig do
+        params(
+          segments: T::Array[RubySegment],
+          context: TemplateContext,
+          config: Configuration,
+          component_mode: T::Boolean
+        ).returns(CompileResult)
+      end
+      def generate(segments:, context:, config:, component_mode: false)
+        return Perf.measure('generator.generate') { _generate(segments: segments, context: context, config: config, component_mode: component_mode) }
+      end
+
+      sig do
+        params(
+          segments: T::Array[RubySegment],
+          context: TemplateContext,
+          config: Configuration,
+          component_mode: T::Boolean
+        ).returns(CompileResult)
+      end
+      def _generate(segments:, context:, config:, component_mode: false)
+        locals = T.let(nil, T.nilable(String))
+        locals_sig = T.let(nil, T.nilable(String))
+        code_segments = T.let([], T::Array[RubySegment])
+
+        # Extract locals declarations from comments, collect code segments
+        segments.each do |seg|
+          if seg.type == :comment
+            text = seg.code.strip
+            if text.start_with?(LOCALS_PREFIX)
+              locals = text.delete_prefix(LOCALS_PREFIX).strip
+            elsif text.start_with?(LOCALS_SIG_PREFIX)
+              locals_sig = text.delete_prefix(LOCALS_SIG_PREFIX).strip
+            end
+          else
+            code_segments << seg
+          end
+        end
+
+        lines = T.let([], T::Array[String])
+        mapping_entries = T.let([], T::Array[SourceMap::MappingEntry])
+
+        # Boilerplate header
+        lines << "# typed: #{config.typed_level}"
+        lines << '# generated by sorbet_view - do not edit'
+        lines << "# source: #{context.template_path}"
+        lines << ''
+        lines << "class #{context.class_name}#{context.superclass_clause}"
+
+        unless component_mode
+          lines << '  extend T::Sig'
+          context.includes.each { |inc| lines << "  include #{inc}" }
+          lines << ''
+
+          if config.extra_body.length > 0
+            config.extra_body.each_line { |l| lines << "  #{l.chomp}" }
+            lines << ''
+          end
+
+          lines << '  sig { returns(T::Hash[Symbol, T.untyped]) }'
+          lines << '  def local_assigns = {}'
+          lines << ''
+
+          if locals_sig
+            lines << "  #{locals_sig}"
+          end
+        end
+
+        method_args = component_mode ? '' : (locals || '()')
+        lines << "  def __sorbet_view_render#{method_args}"
+
+        # Declare undefined instance variables as NilClass
+        undefined_ivars = find_undefined_ivars(code_segments, context, config, component_mode)
+        undefined_ivars.each do |ivar|
+          lines << "    #{ivar} = T.let(nil, NilClass)"
+        end
+
+        # Body: extracted Ruby code
+        code_segments.each do |seg|
+          seg_lines = seg.code.split("\n", -1)
+          seg_lines = [seg.code] if seg_lines.empty?
+
+          seg_lines.each_with_index do |code_line, i|
+            ruby_line = lines.length
+            stripped = code_line.strip
+
+            next if stripped.empty? && i > 0 # skip trailing empty from split
+
+            lines << "    #{stripped}"
+
+            # Build mapping entry
+            template_start_col = if i == 0
+              seg.column
+            else
+              0
+            end
+
+            mapping_entries << SourceMap::MappingEntry.new(
+              template_range: SourceMap::Range.new(
+                start: SourceMap::Position.new(line: seg.line + i, column: template_start_col),
+                end_: SourceMap::Position.new(line: seg.line + i, column: template_start_col + code_line.strip.length)
+              ),
+              ruby_range: SourceMap::Range.new(
+                start: SourceMap::Position.new(line: ruby_line, column: 4),
+                end_: SourceMap::Position.new(line: ruby_line, column: 4 + stripped.length)
+              ),
+              type: seg.type == :expression ? :expression : :code
+            )
+          end
+        end
+
+        lines << '  end'
+        lines << 'end'
+        lines << '' # trailing newline
+
+        CompileResult.new(
+          ruby_source: lines.join("\n"),
+          source_map: SourceMap::SourceMap.new(
+            template_path: context.template_path,
+            ruby_path: context.ruby_path,
+            entries: mapping_entries
+          ),
+          locals: locals,
+          locals_sig: locals_sig
+        )
+      end
+
+      private
+
+      # Collect @variable references from code segments
+      sig { params(segments: T::Array[RubySegment]).returns(T::Array[String]) }
+      def collect_ivars(segments)
+        segments.flat_map { |seg| seg.code.scan(/(?<!@)@[a-zA-Z_]\w*/) }.uniq.sort
+      end
+
+      # Find instance variables used in the template but not defined
+      sig do
+        params(
+          segments: T::Array[RubySegment],
+          context: TemplateContext,
+          config: Configuration,
+          component_mode: T::Boolean
+        ).returns(T::Array[String])
+      end
+      def find_undefined_ivars(segments, context, config, component_mode)
+        all_ivars = collect_ivars(segments)
+        return [] if all_ivars.empty?
+
+        defined_ivars = if component_mode
+          load_component_defined_ivars(context.template_path)
+        else
+          load_view_defined_ivars(context.template_path, config)
+        end
+
+        all_ivars - defined_ivars
+      end
+
+      # Scan the component .rb source for @var = assignments
+      sig { params(component_path: String).returns(T::Array[String]) }
+      def load_component_defined_ivars(component_path)
+        return [] unless File.exist?(component_path)
+
+        source = File.read(component_path)
+        source.scan(/(?<!@)@([a-zA-Z_]\w*)\s*(?:=|\|\|=)/).map { |m| "@#{m[0]}" }.uniq
+      end
+
+      # Load defined ivars from the Tapioca-generated mapping for views
+      sig { params(template_path: String, config: Configuration).returns(T::Array[String]) }
+      def load_view_defined_ivars(template_path, config)
+        mapping_path = File.join(config.output_dir, '.defined_ivars.json')
+        return [] unless File.exist?(mapping_path)
+
+        @ivar_mapping = T.let(@ivar_mapping, T.nilable(T::Hash[String, T::Array[String]]))
+        @ivar_mapping ||= begin
+          JSON.parse(File.read(mapping_path))
+        rescue JSON::ParserError
+          {}
+        end
+
+        # Derive controller_path from template_path
+        # app/views/posts/show.html.erb → posts
+        # app/views/admin_area/v21/booths/show.html.erb → admin_area/v21/booths
+        controller_path = template_path
+          .sub(%r{^app/views/}, '')
+          .sub(%r{/[^/]+$}, '') # strip filename
+
+        @ivar_mapping[controller_path] || []
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/ruby_segment.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    class RubySegment < T::Struct
+      const :code, String
+      const :line, Integer    # 0-based line in the template
+      const :column, Integer  # 0-based column in the template
+      const :type, Symbol     # :statement (<% %>), :expression (<%= %>), :comment (<%# %>)
+    end
+  end
+end

data/lib/sorbet_view/compiler/template_compiler.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    class TemplateCompiler
+      extend T::Sig
+
+      sig { params(adapter: ParserAdapter, config: Configuration).void }
+      def initialize(adapter: Adapters::ErbAdapter.new, config: Configuration.load)
+        @adapter = adapter
+        @generator = T.let(RubyGenerator.new, RubyGenerator)
+        @config = config
+      end
+
+      sig { params(template_path: String, source: String).returns(CompileResult) }
+      def compile(template_path, source)
+        Perf.measure('compiler.compile') do
+          segments = @adapter.extract_segments(source)
+          context = TemplateContext.resolve(template_path, @config)
+          @generator.generate(segments: segments, context: context, config: @config)
+        end
+      rescue => e
+        # On parse failure, generate a minimal file so Sorbet doesn't complain about missing files
+        context = TemplateContext.resolve(template_path, @config)
+        CompileResult.new(
+          ruby_source: "# typed: ignore\n# sorbet_view: failed to parse #{template_path}: #{e.message}\n",
+          source_map: SourceMap::SourceMap.empty(template_path, context.ruby_path),
+          locals: nil,
+          locals_sig: nil
+        )
+      end
+
+      sig { params(template_path: String).returns(CompileResult) }
+      def compile_file(template_path)
+        source = File.read(template_path)
+        compile(template_path, source)
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/template_context.rb

@@ -0,0 +1,170 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    class TemplateContext < T::Struct
+      const :class_name, String
+      const :superclass, T.nilable(String)
+      const :includes, T::Array[String]
+      const :template_path, String
+      const :ruby_path, String
+
+      extend T::Sig
+
+      sig { returns(String) }
+      def superclass_clause
+        superclass ? " < #{superclass}" : ''
+      end
+
+      sig { params(component_path: String, class_name: String, config: Configuration).returns(TemplateContext) }
+      def self.resolve_component(component_path, class_name, config)
+        ruby_path = File.join(config.output_dir, "#{component_path}__erb_template.rb")
+        new(
+          class_name: class_name,
+          superclass: nil,
+          includes: [],
+          template_path: component_path,
+          ruby_path: ruby_path
+        )
+      end
+
+      sig { params(template_path: String, config: Configuration).returns(TemplateContext) }
+      def self.resolve(template_path, config)
+        ruby_path = File.join(config.output_dir, "#{template_path}.rb")
+        classification = classify(template_path)
+
+        case classification
+        when :mailer_view
+          resolve_mailer_view(template_path, ruby_path, config)
+        when :layout
+          resolve_layout(template_path, ruby_path, config)
+        when :partial
+          resolve_partial(template_path, ruby_path, config)
+        when :controller_view
+          resolve_controller_view(template_path, ruby_path, config)
+        else
+          resolve_generic(template_path, ruby_path, config)
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(path: String).returns(Symbol) }
+        def classify(path)
+          basename = File.basename(path)
+
+          if path.include?('_mailer/') || path.include?('mailers/')
+            :mailer_view
+          elsif path.include?('app/views/layouts/')
+            :layout
+          elsif basename.start_with?('_')
+            :partial
+          elsif path.include?('app/views/')
+            :controller_view
+          else
+            :generic
+          end
+        end
+
+        sig { params(path: String).returns(String) }
+        def path_to_class_name(path)
+          # /abs/path/app/views/users/show.html.erb -> Users::Show
+          relative = path
+            .sub(%r{.*app/views/}, '')
+            .sub(%r{.*app/}, '')
+          basename = File.basename(relative).sub(/\..*$/, '') # strip all extensions
+          basename = basename.delete_prefix('_') # strip partial prefix
+          dir = File.dirname(relative)
+
+          parts = if dir == '.'
+            [basename]
+          else
+            dir.split('/') + [basename]
+          end
+
+          parts.map { |p| camelize(p) }.join('::')
+        end
+
+        sig { params(str: String).returns(String) }
+        def camelize(str)
+          str.split('_').map(&:capitalize).join
+        end
+
+        sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
+        def resolve_controller_view(path, ruby_path, config)
+          new(
+            class_name: "SorbetView::Generated::#{path_to_class_name(path)}",
+            superclass: nil,
+            includes: [
+              '::ActionView::Helpers',
+              '::ApplicationController::HelperMethods',
+              *config.extra_includes
+            ],
+            template_path: path,
+            ruby_path: ruby_path
+          )
+        end
+
+        sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
+        def resolve_mailer_view(path, ruby_path, config)
+          new(
+            class_name: "SorbetView::Generated::#{path_to_class_name(path)}",
+            superclass: nil,
+            includes: [
+              '::ActionView::Helpers',
+              '::ActionMailer::Base',
+              *config.extra_includes
+            ],
+            template_path: path,
+            ruby_path: ruby_path
+          )
+        end
+
+        sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
+        def resolve_layout(path, ruby_path, config)
+          new(
+            class_name: "SorbetView::Generated::#{path_to_class_name(path)}",
+            superclass: nil,
+            includes: [
+              '::ActionView::Helpers',
+              '::ApplicationController::HelperMethods',
+              *config.extra_includes
+            ],
+            template_path: path,
+            ruby_path: ruby_path
+          )
+        end
+
+        sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
+        def resolve_partial(path, ruby_path, config)
+          new(
+            class_name: "SorbetView::Generated::#{path_to_class_name(path)}",
+            superclass: nil,
+            includes: [
+              '::ActionView::Helpers',
+              '::ApplicationController::HelperMethods',
+              *config.extra_includes
+            ],
+            template_path: path,
+            ruby_path: ruby_path
+          )
+        end
+
+        sig { params(path: String, ruby_path: String, config: Configuration).returns(TemplateContext) }
+        def resolve_generic(path, ruby_path, config)
+          new(
+            class_name: "SorbetView::Generated::#{path_to_class_name(path)}",
+            superclass: nil,
+            includes: config.extra_includes,
+            template_path: path,
+            ruby_path: ruby_path
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/configuration.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'psych'
+
+module SorbetView
+  class Configuration < T::Struct
+    const :input_dirs, T::Array[String], default: ['app/views']
+    const :exclude_paths, T::Array[String], default: []
+    const :output_dir, String, default: 'sorbet/templates'
+    const :extra_includes, T::Array[String], default: []
+    const :extra_body, String, default: ''
+    const :skip_missing_locals, T::Boolean, default: true
+    const :sorbet_path, String, default: 'srb'
+    const :typed_level, String, default: 'true'
+    const :path_mapping, T::Hash[String, String], default: {}
+    const :component_dirs, T::Array[String], default: []
+
+    class << self
+      extend T::Sig
+
+      sig { returns(Configuration) }
+      def load
+        path = File.join(Dir.pwd, SorbetView::CONFIG_FILE_NAME)
+        hash = if File.exist?(path)
+          Psych.safe_load_file(path) || {}
+        else
+          {}
+        end
+        from_hash(hash)
+      end
+    end
+  end
+end

data/lib/sorbet_view/file_system/file_watcher.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'listen'
+
+module SorbetView
+  module FileSystem
+    class FileWatcher
+      extend T::Sig
+
+      sig do
+        params(
+          config: Configuration,
+          on_change: T.proc.params(modified: T::Array[String], added: T::Array[String], removed: T::Array[String]).void
+        ).void
+      end
+      def initialize(config:, &on_change)
+        @config = config
+        @on_change = on_change
+        @listener = T.let(nil, T.untyped)
+      end
+
+      sig { void }
+      def start
+        dirs = (@config.input_dirs + @config.component_dirs).select { |d| Dir.exist?(d) }
+        return if dirs.empty?
+
+        @listener = Listen.to(
+          *dirs,
+          only: /\.(erb|rb)$/,
+          wait_for_delay: 0.1
+        ) do |modified, added, removed|
+          # Filter out excluded paths; for .rb files, only pass those containing erb_template
+          modified = filter_paths(modified)
+          added = filter_paths(added)
+          removed = filter_paths(removed)
+
+          next if modified.empty? && added.empty? && removed.empty?
+
+          @on_change.call(modified, added, removed)
+        end
+
+        @listener.start
+      end
+
+      sig { void }
+      def stop
+        @listener&.stop
+      end
+
+      private
+
+      sig { params(paths: T::Array[String]).returns(T::Array[String]) }
+      def filter_paths(paths)
+        paths.reject do |path|
+          @config.exclude_paths.any? { |ex| path.include?(ex) }
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/file_system/output_manager.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'digest'
+
+module SorbetView
+  module FileSystem
+    class OutputManager
+      extend T::Sig
+
+      sig { params(output_dir: String).void }
+      def initialize(output_dir)
+        @output_dir = output_dir
+      end
+
+      sig { params(result: Compiler::CompileResult).void }
+      def write(result)
+        Perf.measure('output.write') do
+          path = result.source_map.ruby_path
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir)
+
+          # Only write if content changed (avoid unnecessary Watchman triggers)
+          if File.exist?(path)
+            existing = File.read(path)
+            next if existing == result.ruby_source
+          end
+
+          File.write(path, result.ruby_source)
+        end
+      end
+
+      sig { void }
+      def clean
+        FileUtils.rm_rf(@output_dir)
+      end
+    end
+  end
+end

data/lib/sorbet_view/file_system/project_scanner.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module FileSystem
+    class ProjectScanner
+      extend T::Sig
+
+      sig { params(config: Configuration).returns(T::Array[String]) }
+      def self.scan(config)
+        Perf.measure('scanner.scan_templates') do
+          config.input_dirs.flat_map do |dir|
+            Dir.glob(File.join(dir, '**', '*.erb'))
+          end.reject do |path|
+            config.exclude_paths.any? { |ex| path.start_with?(ex) }
+          end.sort
+        end
+      end
+
+      sig { params(config: Configuration).returns(T::Array[String]) }
+      def self.scan_components(config)
+        Perf.measure('scanner.scan_components') do
+          config.component_dirs.flat_map do |dir|
+            Dir.glob(File.join(dir, '**', '*.rb'))
+          end.reject do |path|
+            config.exclude_paths.any? { |ex| path.start_with?(ex) }
+          end.select do |path|
+            File.read(path).include?('erb_template')
+          end.sort
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/lsp/document_store.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Lsp
+    class Document < T::Struct
+      const :uri, String
+      prop :content, String
+      prop :version, Integer
+      prop :compile_result, T.nilable(Compiler::CompileResult)
+    end
+
+    # In-memory store of open template documents
+    class DocumentStore
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @documents = T.let({}, T::Hash[String, Document])
+      end
+
+      sig { params(uri: String, content: String, version: Integer).returns(Document) }
+      def open(uri, content, version)
+        doc = Document.new(uri: uri, content: content, version: version, compile_result: nil)
+        @documents[uri] = doc
+        doc
+      end
+
+      sig { params(uri: String, content: String, version: Integer).returns(T.nilable(Document)) }
+      def change(uri, content, version)
+        doc = @documents[uri]
+        return nil unless doc
+
+        doc.content = content
+        doc.version = version
+        doc.compile_result = nil # Invalidate
+        doc
+      end
+
+      sig { params(uri: String).void }
+      def close(uri)
+        @documents.delete(uri)
+      end
+
+      sig { params(uri: String).returns(T.nilable(Document)) }
+      def get(uri)
+        @documents[uri]
+      end
+
+      sig { returns(T::Array[Document]) }
+      def all
+        @documents.values
+      end
+    end
+  end
+end