sorbet_view 0.1.0

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

@@ -0,0 +1,265 @@
+# typed: true
+# frozen_string_literal: true
+
+return unless defined?(Tapioca::Dsl::Compiler)
+
+require 'srb_lens'
+require 'json'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      class SorbetView < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::SorbetView) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            [::SorbetView]
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          @module_cache = T.let({}, T::Hash[String, RBI::Scope])
+          @project = T.let(SrbLens::Project.load_or_index(Dir.pwd), T.untyped)
+
+          controllers = ObjectSpace.each_object(Class).select do |klass|
+            klass < ::ActionController::Base && !klass.abstract?
+          rescue StandardError
+            false
+          end
+
+          controllers.each do |controller|
+            process_controller(controller)
+          end
+
+          generate_ivar_mapping(controllers)
+          process_components
+        end
+
+        private
+
+        # Generate a mapping of controller_path -> defined instance variables
+        # Used by the compiler to declare undefined ivars as NilClass
+        sig { params(controllers: T::Array[T.untyped]).void }
+        def generate_ivar_mapping(controllers)
+          config = ::SorbetView::Configuration.load
+          mapping = T.let({}, T::Hash[String, T::Array[String]])
+
+          controllers.each do |controller|
+            path = controller.controller_path
+            ivars = extract_defined_ivars(controller)
+            mapping[path] = ivars unless ivars.empty?
+          end
+
+          mapping_path = File.join(config.output_dir, '.defined_ivars.json')
+          FileUtils.mkdir_p(File.dirname(mapping_path))
+          File.write(mapping_path, JSON.pretty_generate(mapping))
+        rescue StandardError
+          # Non-critical: if mapping fails, all ivars default to NilClass
+        end
+
+        # Extract instance variables assigned in the controller source
+        sig { params(controller: T.untyped).returns(T::Array[String]) }
+        def extract_defined_ivars(controller)
+          source_file = "app/controllers/#{controller.controller_path}_controller.rb"
+          return [] unless File.exist?(source_file)
+
+          source = File.read(source_file)
+          source.scan(/(?<!@)@([a-zA-Z_]\w*)\s*(?:=|\|\|=)/).map { |m| "@#{m[0]}" }.uniq.sort
+        end
+
+        sig { void }
+        def process_components
+          config = ::SorbetView::Configuration.load
+          return if config.component_dirs.empty?
+
+          component_files = ::SorbetView::FileSystem::ProjectScanner.scan_components(config)
+
+          component_files.each do |path|
+            source = File.read(path)
+            extractions = ::SorbetView::Compiler::HeredocExtractor.extract(source, path)
+            next if extractions.empty?
+
+            class_name = T.must(extractions.first).class_name
+            next if class_name.empty?
+
+            begin
+              klass = Object.const_get(class_name)
+            rescue NameError
+              next
+            end
+
+            generate_component_rbi(klass, class_name)
+          end
+        rescue StandardError
+          # Configuration may not be available in all environments
+        end
+
+        sig { params(klass: T.untyped, class_name: String).void }
+        def generate_component_rbi(klass, class_name)
+          methods = klass.instance_methods(false)
+
+          method_sigs = methods.filter_map do |method_name|
+            method_name_s = method_name.to_s
+            next unless method_name_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*[?!]?\z/)
+
+            method_info = find_method_info(klass, method_name_s)
+            next unless method_info
+
+            return_type = method_info&.return_type || ''
+            next if return_type.empty? || return_type == 'T.untyped'
+
+            params = build_params_from_srb_lens(method_info)
+            [method_name_s, params, return_type]
+          end
+
+          return if method_sigs.empty?
+
+          create_class_from_path(class_name) do |klass_rbi|
+            method_sigs.each do |method_name, params, return_type|
+              klass_rbi.create_method(method_name, parameters: params, return_type: return_type)
+            end
+          end
+        end
+
+        sig { params(controller: T.untyped).void }
+        def process_controller(controller)
+          helper_methods = extract_helper_methods(controller)
+          return if helper_methods.empty?
+
+          path = controller.controller_path
+          parts = path.split('/').map { |p| camelize(p) }
+
+          # 1) module SorbetView::Helpers::<controller_path> with helper methods
+          helper_module_name = "SorbetView::Helpers::#{parts.join('::')}"
+          create_module_from_path(helper_module_name) do |mod|
+            helper_methods.each do |method_name, params, return_type|
+              mod.create_method(method_name, parameters: params, return_type: return_type)
+            end
+          end
+
+          # 2) Each action's template class includes the helper module
+          actions = controller.action_methods.to_a
+          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)
+            end
+          end
+        end
+
+        # Returns [[method_name, params, return_type], ...]
+        sig { params(controller: T.untyped).returns(T::Array[T.untyped]) }
+        def extract_helper_methods(controller)
+          return [] unless controller.respond_to?(:_helper_methods)
+
+          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
+            return_type = method_info&.return_type || 'T.untyped'
+            return_type = 'T.untyped' if return_type.empty?
+
+            [name_s, params, return_type]
+          end
+        end
+
+        sig { params(controller: T.untyped, method_name: String).returns(T.untyped) }
+        def find_method_info(controller, method_name)
+          methods = @project.find_methods("#{controller.name}##{method_name}")
+          methods&.first
+        end
+
+        sig { params(method_info: T.untyped).returns(T::Array[RBI::Param]) }
+        def build_params_from_srb_lens(method_info)
+          method_info.arguments.filter_map do |arg|
+            name = arg.name.gsub(/\A[&*]+/, '') # strip *, **, & prefixes
+            type = arg.type || 'T.untyped'
+            type = 'T.untyped' if type.empty?
+
+            case arg.kind
+            when 'req' then create_param(name, type: type)
+            when 'opt' then create_opt_param(name, type: type, default: 'T.unsafe(nil)')
+            when 'rest' then create_rest_param(name.empty? ? 'args' : name, type: type)
+            when 'key_req', 'keyreq' then create_kw_param(name, type: type)
+            when 'key' then create_kw_opt_param(name, type: type, default: 'T.unsafe(nil)')
+            when 'key_rest', 'keyrest' then create_kw_rest_param(name.empty? ? 'kwargs' : name, type: type)
+            when 'block' then create_block_param(name.empty? ? 'blk' : name, type: type)
+            end
+          end
+        end
+
+        sig { params(controller: T.untyped, method_name: String).returns(T::Array[RBI::Param]) }
+        def build_params_from_reflection(controller, method_name)
+          method_obj = controller.instance_method(method_name)
+          method_obj.parameters.filter_map do |type, name|
+            param_name = name ? name.to_s.gsub(/\A[&*]+/, '') : nil
+            case type
+            when :req then create_param(param_name || 'arg', type: 'T.untyped')
+            when :opt then create_opt_param(param_name || 'arg', type: 'T.untyped', default: 'T.unsafe(nil)')
+            when :rest then create_rest_param(param_name.nil? || param_name.empty? ? 'args' : param_name, type: 'T.untyped')
+            when :keyreq then create_kw_param(param_name || 'arg', type: 'T.untyped')
+            when :key then create_kw_opt_param(param_name || 'arg', type: 'T.untyped', default: 'T.unsafe(nil)')
+            when :keyrest then create_kw_rest_param(param_name.nil? || param_name.empty? ? 'kwargs' : param_name, type: 'T.untyped')
+            when :block then create_block_param(param_name.nil? || param_name.empty? ? 'blk' : param_name, type: 'T.untyped')
+            end
+          end
+        rescue NameError
+          []
+        end
+
+        sig { params(str: String).returns(String) }
+        def camelize(str)
+          str.split('_').map(&:capitalize).join
+        end
+
+        sig { params(class_name: String, block: T.proc.params(klass: T.untyped).void).void }
+        def create_class_from_path(class_name, &block)
+          parts = class_name.split('::')
+          current = resolve_module_path(parts[0..-2])
+          current.create_class(T.must(parts.last), &block)
+        end
+
+        sig { params(module_name: String, block: T.proc.params(mod: T.untyped).void).void }
+        def create_module_from_path(module_name, &block)
+          parts = module_name.split('::')
+          current = resolve_module_path(parts[0..-2])
+          mod = current.create_module(T.must(parts.last))
+          block.call(mod)
+        end
+
+        sig { params(parts: T::Array[String]).returns(RBI::Scope) }
+        def resolve_module_path(parts)
+          current = root
+          path_so_far = +''
+
+          parts.each do |part|
+            path_so_far = path_so_far.empty? ? part : "#{path_so_far}::#{part}"
+            if T.must(@module_cache).key?(path_so_far)
+              current = T.must(T.must(@module_cache)[path_so_far])
+            else
+              current = current.create_module(part)
+              T.must(@module_cache)[path_so_far] = current
+            end
+          end
+
+          current
+        end
+      end
+    end
+  end
+end

data/sorbet_view.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sorbet_view/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'sorbet_view'
+  spec.version = SorbetView::VERSION
+  spec.authors = ['kazuma']
+  spec.summary = 'Sorbet type-checking for Rails view templates'
+  spec.description = 'Extracts Ruby code from view templates (ERB, etc.) for Sorbet type-checking, with LSP support'
+  spec.homepage = 'https://github.com/user/sorbet_view'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.2'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = ['sv']
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'herb'
+  spec.add_dependency 'listen', '~> 3.0'
+  spec.add_dependency 'psych'
+  spec.add_dependency 'sorbet-runtime'
+  spec.add_dependency 'srb_lens'
+end

data/vscode/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.vsix

data/vscode/.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+      "outFiles": ["${workspaceFolder}/dist/**/*.js"]
+    }
+  ]
+}

data/vscode/.vscodeignore

@@ -0,0 +1,4 @@
+src/
+node_modules/
+tsconfig.json
+.gitignore

data/vscode/package-lock.json

@@ -0,0 +1,140 @@
+{
+  "name": "sorbet-view",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "sorbet-view",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-languageclient": "^9.0.1"
+      },
+      "devDependencies": {
+        "@types/node": "^20.0.0",
+        "@types/vscode": "^1.91.0",
+        "typescript": "^5.3.0"
+      },
+      "engines": {
+        "vscode": "^1.91.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/vscode": {
+      "version": "1.109.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.109.0.tgz",
+      "integrity": "sha512-0Pf95rnwEIwDbmXGC08r0B4TQhAbsHQ5UyTIgVgoieDe4cOnf92usuR5dEczb6bTKEp7ziZH4TV1TRGPPCExtw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vscode-jsonrpc": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
+      "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/vscode-languageclient": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-9.0.1.tgz",
+      "integrity": "sha512-JZiimVdvimEuHh5olxhxkht09m3JzUGwggb5eRUkzzJhZ2KjCN0nh55VfiED9oez9DyF8/fz1g1iBV3h+0Z2EA==",
+      "license": "MIT",
+      "dependencies": {
+        "minimatch": "^5.1.0",
+        "semver": "^7.3.7",
+        "vscode-languageserver-protocol": "3.17.5"
+      },
+      "engines": {
+        "vscode": "^1.82.0"
+      }
+    },
+    "node_modules/vscode-languageserver-protocol": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
+      "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-jsonrpc": "8.2.0",
+        "vscode-languageserver-types": "3.17.5"
+      }
+    },
+    "node_modules/vscode-languageserver-types": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
+      "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
+      "license": "MIT"
+    }
+  }
+}

data/vscode/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "sorbet-view",
+  "displayName": "Sorbet View",
+  "description": "ERB template type-checking and LSP support via Sorbet",
+  "version": "0.1.0",
+  "publisher": "sorbet-view",
+  "license": "MIT",
+  "engines": {
+    "vscode": "^1.91.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Linters"
+  ],
+  "activationEvents": [
+    "onLanguage:erb",
+    "onLanguage:ruby"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "configuration": {
+      "title": "Sorbet View",
+      "properties": {
+        "sorbetView.command": {
+          "type": "string",
+          "default": "bundle exec sv lsp",
+          "description": "Command to start the LSP server"
+        },
+        "sorbetView.trace.server": {
+          "type": "string",
+          "enum": [
+            "off",
+            "messages",
+            "verbose"
+          ],
+          "default": "off",
+          "description": "Trace LSP communication (for debugging)"
+        }
+      }
+    },
+    "commands": [
+      {
+        "command": "sorbetView.restart",
+        "title": "Sorbet View: Restart Server"
+      }
+    ]
+  },
+  "scripts": {
+    "build": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "vscode:prepublish": "npm run build"
+  },
+  "dependencies": {
+    "vscode-languageclient": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.91.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}

data/vscode/src/extension.ts

@@ -0,0 +1,88 @@
+import * as vscode from "vscode";
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+} from "vscode-languageclient/node";
+
+let client: LanguageClient | undefined;
+let outputChannel: vscode.OutputChannel;
+
+export async function activate(
+  context: vscode.ExtensionContext
+): Promise<void> {
+  outputChannel = vscode.window.createOutputChannel("Sorbet View");
+
+  await startClient();
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand("sorbetView.restart", async () => {
+      outputChannel.appendLine("Restarting Sorbet View server...");
+      if (client) {
+        await client.restart();
+      } else {
+        await startClient();
+      }
+      outputChannel.appendLine("Sorbet View server restarted.");
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration(async (e) => {
+      if (e.affectsConfiguration("sorbetView.command")) {
+        outputChannel.appendLine("Configuration changed, restarting server...");
+        if (client) {
+          await client.stop();
+          client = undefined;
+        }
+        await startClient();
+      }
+    })
+  );
+}
+
+async function startClient(): Promise<void> {
+  const config = vscode.workspace.getConfiguration("sorbetView");
+  const commandLine = config.get<string>("command") || "bundle exec sv lsp";
+  const parts = commandLine.split(/\s+/);
+  const command = parts[0];
+  const args = parts.slice(1);
+
+  outputChannel.appendLine(`Starting: ${commandLine}`);
+
+  const serverOptions: ServerOptions = {
+    command,
+    args,
+    options: { env: { ...process.env }, shell: true },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [
+      { scheme: "file", language: "erb" },
+      { scheme: "file", language: "ruby" },
+    ],
+    outputChannel,
+  };
+
+  client = new LanguageClient(
+    "sorbetView",
+    "Sorbet View",
+    serverOptions,
+    clientOptions
+  );
+
+  try {
+    await client.start();
+    outputChannel.appendLine("Sorbet View server started.");
+  } catch (error) {
+    outputChannel.appendLine(`Failed to start server: ${error}`);
+    client = undefined;
+  }
+}
+
+export async function deactivate(): Promise<void> {
+  if (client) {
+    await client.stop();
+    client = undefined;
+  }
+}

data/vscode/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}