sorbet_erb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4076d96d59afeaf2c9f40b7c6cb176482b78ffc0b48e0d262cf71bdc4f49a8ce
+  data.tar.gz: c697a0a90d4f9526fdac049f722a802f9f09f5c4a30c3c9447db3e3d0a7503bd
+SHA512:
+  metadata.gz: 1cfc74f6346706dee3bec11195b74ed0328f1e304f084d732b74b255eb8f6c8817aa41b10f9df8a0fa9b5c4d1384caab7285ac54b32ea69fed64e5a553abf4a8
+  data.tar.gz: f751e2301827f3f4b5a027689eb78e62b6adf821d3930688d6ad28a705bb43905a045d8d9cf971af603f5a93b7a3bf44bdb2c91eebf2a04f2f8a5389210ed762

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  TargetRubyVersion: 3.0.0
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false

data/README.md

@@ -0,0 +1,62 @@
+# SorbetErb
+
+`sorbet_erb` parses Rails ERB files and extracts the Ruby code so that
+you can run Sorbet typechecking over them. This assumes you're already
+using Sorbet and Tapioca together to generate RBI.
+
+Currently this only supports Rails applications since it generates Ruby
+scoped with a Rails `ApplicationController`. Feel free to file an issue
+if you're interested in using this in other contexts.
+
+### Limitations
+
+- You must manually specify extra_includes that aren't covered by Tapioca
+- Rails partials (files beginning with `_`) and Turbo streams must use
+  strict locals. sorbet_erb will skip them if there are no strict locals
+  defined unless you set `skip_missing_locals`.
+
+## Installation
+
+This gem isn't published to RubyGems yet, so you need to depend
+directly on the git repository:
+
+```
+gem 'sorbet_erb', git: 'https://github.com/franklinhu/sorbet_erb'
+```
+
+After installing the gem, run `bundle binstubs sorbet_erb` to install
+a helper script under `bin/sorbet_erb`.
+
+## Usage
+
+```
+bin/sorbet_erb input_dir output_dir
+```
+
+You'll most likely want to pass in your Rails app directory as input
+and use `sorbet/erb` as your output directory. Don't forget to add
+`sorbet/erb` to your `.gitignore`.
+
+```
+bin/sorbet_erb ./app ./sorbet/erb
+```
+
+### Sorbet signatures (experimental)
+Running typechecking in Rails ERB templates is more helpful if there
+are concrete types for the arguments.
+
+sorbet_erb supports Sorbet-type signatures as a magic comment.
+
+```
+<%# locals_sig: sig { params(x: Integer).void } %>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/franklinhu/sorbet_erb.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
+
+Minitest::TestTask.create
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/exe/sorbet_erb

@@ -0,0 +1,6 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/sorbet_erb'
+
+SorbetErb.start(ARGV)

data/lib/sorbet_erb/code_extractor.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'better_html'
+require 'better_html/parser'
+
+module SorbetErb
+  class CodeExtractor
+    def initialize; end
+
+    def extract(input)
+      buffer = Parser::Source::Buffer.new('(buffer)')
+      buffer.source = input
+      parser = BetterHtml::Parser.new(buffer)
+
+      p = CodeProcessor.new
+      p.process(parser.ast)
+      [p.output, p.locals, p.locals_sig]
+    end
+  end
+
+  class CodeProcessor
+    include AST::Processor::Mixin
+
+    LOCALS_PREFIX = 'locals:'
+    LOCALS_SIG_PREFIX = 'locals_sig:'
+
+    attr_accessor :output, :locals, :locals_sig
+
+    def initialize
+      @output = []
+      @locals = nil
+      @locals_sig = nil
+    end
+
+    def handler_missing(node)
+      # Some children may be strings, so only look for AST nodes
+      children = node.children.select { |c| c.is_a?(BetterHtml::AST::Node) }
+      process_all(children)
+    end
+
+    def on_erb(node)
+      indicator_node = node.children.compact.find { |c| c.type == :indicator }
+      code_node = node.children.compact.find { |c| c.type == :code }
+
+      return process(code_node) if indicator_node.nil?
+
+      indicator = indicator_node.children.first
+      case indicator
+      when '#'
+        # Ignore comments if it's not strict locals
+        code_text = code_node.children.first.strip
+        if code_text.start_with?(LOCALS_PREFIX)
+          # No need to parse the locals
+          @locals = code_text.delete_prefix(LOCALS_PREFIX).strip
+        elsif code_text.start_with?(LOCALS_SIG_PREFIX)
+          @locals_sig = code_text.delete_prefix(LOCALS_SIG_PREFIX).strip
+        end
+      else
+        process_all(node.children)
+      end
+    end
+
+    def on_code(node)
+      @output += node.children
+    end
+  end
+end

data/lib/sorbet_erb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SorbetErb
+  VERSION = '0.1.0'
+end

data/lib/sorbet_erb.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+require 'pathname'
+require 'psych'
+
+require_relative 'sorbet_erb/code_extractor'
+require_relative 'sorbet_erb/version'
+
+module SorbetErb
+  CONFIG_FILE_NAME = '.sorbet_erb.yml'
+
+  DEFAULT_CONFIG = {
+    'input_dirs' => ['app'],
+    'exclude_paths' => [],
+    'output_dir' => 'sorbet/erb',
+    'extra_includes' => [],
+    'extra_body' => '',
+    'skip_missing_locals' => true
+  }.freeze
+
+  USAGE = <<~USAGE
+    Usage: sorbet_erb input_dir output_dir
+      input_dir - where to scan for ERB files
+      output_dir - where to write files with Ruby extracted from ERB
+  USAGE
+
+  ERB_TEMPLATE = <<~ERB_TEMPLATE
+    # typed: true
+    class SorbetErb<%= class_suffix %> < ApplicationController
+      extend T::Sig
+      include ActionView::Helpers
+      include ApplicationController::HelperMethods
+      <% extra_includes.each do |i| %>
+        include <%= i %>
+      <% end %>
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def local_assigns
+        # Shim for typechecking
+        {}
+      end
+
+      <%= extra_body %>
+
+      <%= locals_sig %>
+      def body<%= locals %>
+        <% lines.each do |line| %>
+          <%= line %>
+        <% end %>
+      end
+    end
+  ERB_TEMPLATE
+
+  def self.extract_rb_from_erb(input_dir, output_dir)
+    config = read_config
+    input_dirs =
+      if input_dir
+        [input_dir]
+      else
+        config.fetch('input_dirs')
+      end
+    exclude_paths = config.fetch('exclude_paths')
+    output_dir ||= config.fetch('output_dir')
+    skip_missing_locals = config.fetch('skip_missing_locals')
+
+    puts 'Clearing output directory'
+    FileUtils.rm_rf(output_dir)
+
+    input_dir_to_paths = input_dirs.flat_map do |d|
+      Dir.glob(File.join(d, '**', '*.erb')).map do |p|
+        [d, p]
+      end
+    end
+    input_dir_to_paths.each do |d, p|
+      pathname = Pathname.new(p)
+
+      next if exclude_paths.any? { |p| p.include?(pathname.to_s) }
+
+      extractor = CodeExtractor.new
+      lines, locals, locals_sig = extractor.extract(File.read(p))
+
+      # Partials and Turbo streams must use strict locals
+      next if requires_defined_locals(pathname.basename.to_s) && locals.nil? && skip_missing_locals
+
+      locals ||= '()'
+      locals_sig ||= ''
+
+      rel_output_dir = File.join(
+        output_dir,
+        pathname.dirname.relative_path_from(d)
+      )
+      FileUtils.mkdir_p(rel_output_dir)
+
+      output_path = File.join(
+        rel_output_dir,
+        "#{pathname.basename}.generated.rb"
+      )
+      erb = ERB.new(ERB_TEMPLATE)
+      File.open(output_path, 'w') do |f|
+        result = erb.result_with_hash(
+          class_suffix: SecureRandom.hex(6),
+          locals: locals,
+          locals_sig: locals_sig,
+          extra_includes: config.fetch('extra_includes'),
+          extra_body: config.fetch('extra_body'),
+          lines: lines
+        )
+        f.write(result)
+      end
+    end
+  end
+
+  def self.read_config
+    path = File.join(Dir.pwd, CONFIG_FILE_NAME)
+    config =
+      if File.exist?(path)
+        Psych.safe_load_file(path)
+      else
+        {}
+      end
+    DEFAULT_CONFIG.merge(config)
+  end
+
+  def self.requires_defined_locals(file_name)
+    file_name.start_with?('_') || file_name.end_with?('.turbo_stream.erb')
+  end
+
+  def self.start(argv)
+    input = argv[0]
+    output = argv[1]
+
+    SorbetErb.extract_rb_from_erb(input, output)
+  end
+end

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

@@ -0,0 +1,119 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(ViewComponent)
+
+require 'sorbet-runtime'
+require 'tapioca/dsl'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Generates RBI for ViewComponent::Slotable
+      # See https://github.com/ViewComponent/view_component/blob/main/lib/view_component/slotable.rb
+      class ViewComponentSlotables < Tapioca::Dsl::Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::ViewComponent::Slotable) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes
+              .select { |c| c < ViewComponent::Slotable && c.name != 'ViewComponent::Base' }
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |klass|
+            T.unsafe(constant).registered_slots.each do |name, config|
+              renderable_type = config[:renderable]
+              renderable = T.let(
+                case renderable_type
+                when String
+                  renderable_type
+                when Class
+                  T.must(renderable_type.name)
+                else
+                  'T.untyped'
+                end,
+                String
+              )
+
+              is_many = T.let(config[:collection], T::Boolean)
+              return_type = renderable
+
+              module_name = 'ViewComponentSlotablesMethodsModule'
+              klass.create_module(module_name) do |mod|
+                generate_instance_methods(mod, name.to_s, return_type, is_many)
+              end
+              klass.create_include(module_name)
+            end
+          end
+        end
+
+        sig { params(klass: RBI::Scope, name: String, return_type: String, is_many: T::Boolean).void }
+        def generate_instance_methods(klass, name, return_type, is_many)
+          return_type_maybe_plural =
+            if is_many
+              "T::Enumerable[#{return_type}]"
+            else
+              return_type
+            end
+
+          klass.create_method(name, return_type: return_type_maybe_plural)
+          klass.create_method("#{name}?", return_type: 'T::Boolean')
+
+          klass.create_method(
+            "with_#{name}",
+            parameters: [
+              create_rest_param('args', type: 'T.untyped'),
+              create_block_param(
+                'block',
+                type: "T.nilable(T.proc.params(#{name}: #{return_type_maybe_plural}).returns(T.untyped))"
+              )
+            ],
+            return_type: return_type_maybe_plural
+          )
+
+          if is_many
+            # For collection subcomponents, ViewComponent generates methods for the singular version
+            # of the name.
+            singular_name = ActiveSupport::Inflector.singularize(name)
+
+            klass.create_method(
+              "with_#{singular_name}",
+              parameters: [
+                create_rest_param('args', type: 'T.untyped'),
+                create_block_param(
+                  'block',
+                  type: "T.nilable(T.proc.params(#{singular_name}: #{return_type}).returns(T.untyped))"
+                )
+              ],
+              return_type: return_type
+            )
+            klass.create_method(
+              "with_#{singular_name}_content",
+              parameters: [
+                create_param('content', type: 'T.untyped')
+              ],
+              return_type: 'T.untyped'
+            )
+
+          else
+            klass.create_method(
+              "with_#{name}_content",
+              parameters: [
+                create_param('content', type: 'T.untyped')
+              ],
+              return_type: return_type
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/sig/sorbet_erb.rbs

@@ -0,0 +1,4 @@
+module SorbetErb
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: sorbet_erb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Franklin Hu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: better_html
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+description: Extracts Ruby code from ERB files so you can run Sorbet over them
+email:
+- franklin@thisisfranklin.com
+executables:
+- sorbet_erb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- exe/sorbet_erb
+- lib/sorbet_erb.rb
+- lib/sorbet_erb/code_extractor.rb
+- lib/sorbet_erb/version.rb
+- lib/tapioca/dsl/compilers/view_component_slotables.rb
+- sig/sorbet_erb.rbs
+homepage: https://github.com/franklinhu/sorbet_erb
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/franklinhu/sorbet_erb
+  source_code_uri: https://github.com/franklinhu/sorbet_erb
+  changelog_uri: https://github.com/franklinhu/sorbet_erb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key: 
+specification_version: 4
+summary: Extracts Ruby code from ERB files for Sorbet
+test_files: []