sorbet_view 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8a0b48778cd35569ebf4fd8e6ab0adac11232ba3b59199eb33fa0bb2a5281cf
+  data.tar.gz: 40283808c1562e713e70e3ce70d31fa1058841c0d5bffa29bc33124a8b005b98
+SHA512:
+  metadata.gz: 24e77a9a6b85ae1e2d33b837ce91e9b8fd694e97d568eea83f942666b46a8806779949baaa8c5c0694ef2fad104abe490d1a09cacbfffc8bb57adc8f52f4d429
+  data.tar.gz: 3e8c78986b0d889de56f026a24b4eb79be312b536cd49cf6fca45a8515788cb08fe7f133ec71259994cf831f2a59aa79f04ecf04fdb78f13be4d260e9fc673e3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 @kazzix14 - Kazuma Murata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
+
+Minitest::TestTask.create
+
+task default: :test

data/exe/sv

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

data/lib/sorbet_view/cli/runner.rb

@@ -0,0 +1,206 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module CLI
+    class Runner
+      extend T::Sig
+
+      COMMANDS = T.let({
+        'tc' => 'Compile templates and run srb tc',
+        'compile' => 'Compile templates to Ruby files',
+        'lsp' => 'Start LSP proxy server',
+        'clean' => 'Remove generated files',
+        'init' => 'Generate .sorbet_view.yml config file'
+      }.freeze, T::Hash[String, String])
+
+      sig { params(argv: T::Array[String]).void }
+      def self.start(argv)
+        command = argv[0]
+        args = argv[1..] || []
+
+        case command
+        when 'tc'
+          run_tc(args)
+        when 'compile'
+          run_compile(args)
+        when 'lsp'
+          run_lsp(args)
+        when 'clean'
+          run_clean(args)
+        when 'init'
+          run_init
+        else
+          print_usage
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        # Split args on "--": before is sv args, after is passthrough (e.g. to srb tc)
+        sig { params(args: T::Array[String]).returns([T::Array[String], T::Array[String]]) }
+        def split_args(args)
+          separator = args.index('--')
+          if separator
+            [args[0...separator], args[(separator + 1)..] || []]
+          else
+            [args, []]
+          end
+        end
+
+        sig { params(args: T::Array[String]).returns(Configuration) }
+        def parse_config(args)
+          sv_args, _ = split_args(args)
+          no_config = sv_args.include?('--no-config')
+          input_dirs = T.let([], T::Array[String])
+          output_dir = T.let(nil, T.nilable(String))
+
+          i = 0
+          while i < sv_args.length
+            case sv_args[i]
+            when '--no-config'
+              # handled above
+            when '-o', '--output'
+              output_dir = sv_args[i + 1]
+              i += 1
+            when /^-/
+              # skip unknown flags
+            else
+              input_dirs << T.must(sv_args[i])
+            end
+            i += 1
+          end
+
+          base = no_config ? Configuration.new : Configuration.load
+
+          overrides = {}
+          overrides['input_dirs'] = input_dirs unless input_dirs.empty?
+          overrides['output_dir'] = output_dir if output_dir
+
+          if overrides.empty?
+            base
+          else
+            Configuration.from_hash(base.serialize.merge(overrides))
+          end
+        end
+
+        sig { params(args: T::Array[String]).void }
+        def run_compile(args)
+          Perf.reset!
+          total_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          config = parse_config(args)
+          compiler = Compiler::TemplateCompiler.new(config: config)
+          component_compiler = Compiler::ComponentCompiler.new(config: config)
+          output_manager = FileSystem::OutputManager.new(config.output_dir)
+
+          templates = FileSystem::ProjectScanner.scan(config)
+          puts "Compiling #{templates.length} template(s)..."
+
+          templates.each do |path|
+            result = compiler.compile_file(path)
+
+            if result.source_map.entries.empty? && config.skip_missing_locals && requires_locals?(path)
+              next
+            end
+
+            output_manager.write(result)
+            puts "  #{path} -> #{result.source_map.ruby_path}"
+          end
+
+          components = FileSystem::ProjectScanner.scan_components(config)
+          if components.any?
+            puts "Compiling #{components.length} component(s) with erb_template..."
+
+            components.each do |path|
+              results = component_compiler.compile_file(path)
+              results.each do |result|
+                output_manager.write(result)
+                puts "  #{path} -> #{result.source_map.ruby_path}"
+              end
+            end
+          end
+
+          total_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - total_start) * 1000.0
+          puts "Done. (total: #{total_ms.round(1)}ms)"
+          Perf.report
+        end
+
+        sig { params(args: T::Array[String]).void }
+        def run_tc(args)
+          run_compile(args)
+
+          config = parse_config(args)
+          _, sorbet_args = split_args(args)
+          puts "\nRunning Sorbet..."
+          system(config.sorbet_path, 'tc', *sorbet_args)
+        end
+
+        sig { params(args: T::Array[String]).void }
+        def run_lsp(args)
+          $stdin.binmode
+          $stdout.binmode
+          server = Lsp::Server.new
+          server.start
+        end
+
+        sig { params(args: T::Array[String]).void }
+        def run_clean(args)
+          config = parse_config(args)
+          output_manager = FileSystem::OutputManager.new(config.output_dir)
+          output_manager.clean
+          puts "Cleaned #{config.output_dir}"
+        end
+
+        sig { void }
+        def run_init
+          if File.exist?(SorbetView::CONFIG_FILE_NAME)
+            puts "#{SorbetView::CONFIG_FILE_NAME} already exists"
+            return
+          end
+
+          File.write(SorbetView::CONFIG_FILE_NAME, <<~YAML)
+            # SorbetView configuration
+            input_dirs:
+              - app/views
+
+            exclude_paths: []
+
+            output_dir: sorbet/templates
+
+            extra_includes: []
+
+            skip_missing_locals: true
+          YAML
+
+          puts "Created #{SorbetView::CONFIG_FILE_NAME}"
+        end
+
+        sig { void }
+        def print_usage
+          puts 'Usage: sv <command> [paths...] [options]'
+          puts ''
+          puts 'Commands:'
+          COMMANDS.each do |cmd, desc|
+            puts "  #{cmd.ljust(12)} #{desc}"
+          end
+          puts ''
+          puts 'Options:'
+          puts '  [paths...]         Input directories (overrides config)'
+          puts '  -o, --output DIR   Output directory (overrides config)'
+          puts '  --no-config        Ignore .sorbet_view.yml'
+          puts '  -- [args...]       Pass remaining args to srb tc (tc only)'
+        end
+
+        sig { params(path: String).returns(T::Boolean) }
+        def requires_locals?(path)
+          basename = File.basename(path)
+          basename.start_with?('_') || basename.end_with?('.turbo_stream.erb')
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/adapters/erb_adapter.rb

@@ -0,0 +1,170 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    module Adapters
+      class ErbAdapter
+        extend T::Sig
+        include ParserAdapter
+
+        INDICATOR_PATTERN = /<%([=#-]?)(.*?)[-]?%>/m
+
+        sig { override.params(source: String).returns(T::Array[RubySegment]) }
+        def extract_segments(source)
+          Perf.measure('erb.extract_segments') do
+            if herb_available?
+              Perf.measure('erb.extract_with_herb') { extract_with_herb(source) }
+            else
+              Perf.measure('erb.extract_with_stdlib') { extract_with_stdlib(source) }
+            end
+          end
+        end
+
+        private
+
+        sig { returns(T::Boolean) }
+        def herb_available?
+          @herb_available = T.let(@herb_available, T.nilable(T::Boolean))
+          if @herb_available.nil?
+            @herb_available = begin
+              require 'herb'
+              true
+            rescue LoadError
+              false
+            end
+          end
+          T.must(@herb_available)
+        end
+
+        sig { params(source: String).returns(T::Array[RubySegment]) }
+        def extract_with_herb(source)
+          result = Herb.parse(source)
+          segments = T.let([], T::Array[RubySegment])
+          visit_herb_node(result.value, segments)
+          segments
+        end
+
+        sig { params(node: T.untyped, segments: T::Array[RubySegment]).void }
+        def visit_herb_node(node, segments)
+          class_name = node.class.name.to_s
+
+          if class_name.include?('ERBContentNode')
+            add_herb_segment(node, segments)
+            return
+          end
+
+          if class_name.include?('ERBEndNode')
+            add_herb_end_segment(node, segments)
+            return
+          end
+
+          erb_block = class_name.include?('ERBBlockNode') ||
+                      class_name.include?('ERBIfNode') || class_name.include?('ERBUnlessNode') ||
+                      class_name.include?('ERBCaseNode') || class_name.include?('ERBForNode') ||
+                      class_name.include?('ERBWhileNode') || class_name.include?('ERBUntilNode') ||
+                      class_name.include?('ERBBeginNode')
+
+          erb_clause = class_name.include?('ERBElsifNode') || class_name.include?('ERBElseNode') ||
+                       class_name.include?('ERBWhenNode') || class_name.include?('ERBRescueNode') ||
+                       class_name.include?('ERBEnsureNode')
+
+          if erb_block || erb_clause
+            add_herb_segment(node, segments)
+            node.statements.each { |s| visit_herb_node(s, segments) } if node.respond_to?(:statements)
+            node.body.each { |s| visit_herb_node(s, segments) } if node.respond_to?(:body)
+            visit_herb_node(node.subsequent, segments) if node.respond_to?(:subsequent) && node.subsequent
+            add_herb_end_segment(node.end_node, segments) if erb_block && node.respond_to?(:end_node) && node.end_node
+            return
+          end
+
+          # Non-ERB nodes: recurse into children and body
+          node.children.each { |child| visit_herb_node(child, segments) } if node.respond_to?(:children)
+          node.body.each { |child| visit_herb_node(child, segments) } if node.respond_to?(:body)
+        end
+
+        sig { params(node: T.untyped, segments: T::Array[RubySegment]).void }
+        def add_herb_segment(node, segments)
+          return unless node.respond_to?(:content) && node.content
+
+          content_token = node.content
+          code = content_token.value.to_s.strip
+          return if code.empty?
+
+          # Herb lines are 1-based, we use 0-based
+          loc = content_token.location
+          line = loc.start.line - 1
+          column = loc.start.column
+
+          tag = node.respond_to?(:tag_opening) ? node.tag_opening.value.to_s : '<%'
+          type = case tag
+          when '<%=' then :expression
+          when '<%#' then :comment
+          else :statement
+          end
+
+          segments << RubySegment.new(code: code, line: line, column: column, type: type)
+        end
+
+        sig { params(node: T.untyped, segments: T::Array[RubySegment]).void }
+        def add_herb_end_segment(node, segments)
+          return unless node.respond_to?(:content) && node.content
+
+          loc = node.content.location
+          segments << RubySegment.new(
+            code: 'end',
+            line: loc.start.line - 1,
+            column: loc.start.column,
+            type: :statement
+          )
+        end
+
+        # Fallback: regex-based extraction when Herb is not available
+        sig { params(source: String).returns(T::Array[RubySegment]) }
+        def extract_with_stdlib(source)
+          segments = T.let([], T::Array[RubySegment])
+          line_offsets = build_line_offsets(source)
+
+          source.scan(INDICATOR_PATTERN) do
+            match = T.must(Regexp.last_match)
+            indicator = match[1] || ''
+            code = (match[2] || '').strip
+            offset = T.must(match.begin(0))
+
+            next if code.empty?
+
+            line, column = offset_to_line_column(line_offsets, offset)
+            tag_prefix_len = 2 + indicator.length
+            code_column = column + tag_prefix_len
+
+            type = case indicator
+            when '#' then :comment
+            when '=' then :expression
+            else :statement
+            end
+
+            segments << RubySegment.new(code: code, line: line, column: code_column, type: type)
+          end
+
+          segments
+        end
+
+        sig { params(source: String).returns(T::Array[Integer]) }
+        def build_line_offsets(source)
+          offsets = [0]
+          source.each_char.with_index do |char, i|
+            offsets << (i + 1) if char == "\n"
+          end
+          offsets
+        end
+
+        sig { params(line_offsets: T::Array[Integer], offset: Integer).returns([Integer, Integer]) }
+        def offset_to_line_column(line_offsets, offset)
+          line = line_offsets.rindex { |o| o <= offset } || 0
+          column = offset - (line_offsets[line] || 0)
+          [line, column]
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/component_compiler.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    class ComponentCompiler
+      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(path: String, source: String).returns(T::Array[CompileResult]) }
+      def compile(path, source)
+        extractions = HeredocExtractor.extract(source, path)
+        extractions.map do |extraction|
+          segments = @adapter.extract_segments(extraction.erb_source)
+
+          # Add line_offset/column_offset so source map points to correct positions in the .rb file
+          adjusted = segments.map do |seg|
+            RubySegment.new(
+              code: seg.code,
+              line: seg.line + extraction.line_offset,
+              column: seg.column + extraction.column_offset,
+              type: seg.type
+            )
+          end
+
+          context = TemplateContext.resolve_component(
+            extraction.component_path,
+            extraction.class_name,
+            @config
+          )
+          @generator.generate(segments: adjusted, context: context, config: @config, component_mode: true)
+        end
+      end
+
+      sig { params(path: String).returns(T::Array[CompileResult]) }
+      def compile_file(path)
+        source = File.read(path)
+        compile(path, source)
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/heredoc_extractor.rb

@@ -0,0 +1,112 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    class HeredocExtraction < T::Struct
+      const :erb_source, String
+      const :line_offset, Integer
+      const :column_offset, Integer
+      const :class_name, String
+      const :component_path, String
+    end
+
+    class HeredocExtractor
+      extend T::Sig
+
+      ERB_TEMPLATE_PATTERN = /erb_template\s+<<~([A-Z_]+)/
+
+      sig { params(source: String).returns(T::Boolean) }
+      def self.contains_erb_template?(source)
+        ERB_TEMPLATE_PATTERN.match?(source)
+      end
+
+      sig { params(source: String, file_path: String).returns(T::Array[HeredocExtraction]) }
+      def self.extract(source, file_path)
+        extractions = T.let([], T::Array[HeredocExtraction])
+        lines = source.lines
+
+        i = 0
+        while i < lines.length
+          line = T.must(lines[i])
+          match = ERB_TEMPLATE_PATTERN.match(line)
+          if match
+            delimiter = T.must(match[1])
+            heredoc_start = i + 1
+            heredoc_lines = T.let([], T::Array[String])
+
+            j = heredoc_start
+            while j < lines.length
+              heredoc_line = T.must(lines[j])
+              break if heredoc_line.strip == delimiter
+
+              heredoc_lines << heredoc_line
+              j += 1
+            end
+
+            erb_source, column_offset = dedent_heredoc(heredoc_lines)
+            class_name = class_name_from_source(source)
+
+            extractions << HeredocExtraction.new(
+              erb_source: erb_source,
+              line_offset: heredoc_start,
+              column_offset: column_offset,
+              class_name: class_name,
+              component_path: file_path
+            )
+
+            i = j + 1
+          else
+            i += 1
+          end
+        end
+
+        extractions
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(lines: T::Array[String]).returns([String, Integer]) }
+        def dedent_heredoc(lines)
+          # Reproduce Ruby's <<~ indent stripping behavior
+          non_empty_lines = lines.reject { |l| l.strip.empty? }
+          return [lines.join, 0] if non_empty_lines.empty?
+
+          min_indent = T.let(nil, T.nilable(Integer))
+          non_empty_lines.each do |line|
+            indent = T.must(line.match(/^(\s*)/))[1]&.length || 0
+            min_indent = indent if min_indent.nil? || indent < min_indent
+          end
+          min_indent ||= 0
+
+          dedented = lines.map do |line|
+            if line.strip.empty?
+              "\n"
+            else
+              line[min_indent..] || line
+            end
+          end.join
+
+          [dedented, min_indent]
+        end
+
+        sig { params(source: String).returns(String) }
+        def class_name_from_source(source)
+          parts = T.let([], T::Array[String])
+          source.each_line do |line|
+            if (m = line.match(/^\s*module\s+([A-Z][\w:]*)/))
+              parts << T.must(m[1])
+            elsif (m = line.match(/^\s*class\s+([A-Z][\w:]*)/))
+              parts << T.must(m[1])
+              break
+            end
+          end
+          parts.join('::')
+        end
+      end
+    end
+  end
+end

data/lib/sorbet_view/compiler/parser_adapter.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Compiler
+    module ParserAdapter
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(source: String).returns(T::Array[RubySegment]) }
+      def extract_segments(source); end
+    end
+  end
+end