feat: add tapioca dsl compiler and rbs batch generation

Author: hakanensari

.rubocop.yml

@@ -7,3 +7,5 @@ inherit_gem:
 AllCops:
   NewCops: enable
   TargetRubyVersion: 3.2
+  Exclude:
+    - "**/*.rbi"

CHANGELOG.md

@@ -5,6 +5,11 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- Add Tapioca DSL compiler for Sorbet users (`lib/tapioca/dsl/compilers/structure.rb`)
+- Add `Structure::RBS.write_all` for batch RBS generation from arrays or modules
+
 ## [4.3.0] - 2025-12-02
 
 ### Added

Gemfile

@@ -12,4 +12,5 @@ gem "rubocop-minitest", require: false
 gem "rubocop-rake", require: false
 gem "rubocop-shopify", require: false
 gem "steep", require: false
+gem "tapioca", require: false
 gem "yard"

README.md

@@ -581,6 +581,31 @@ The generated signatures work for code that uses your Structure classes, but Ste
 
 See also: [RBS Data/Struct documentation](https://github.com/ruby/rbs/blob/master/docs/data_and_struct.md), [RBS issue #654](https://github.com/ruby/rbs/issues/654), [RBS issue #1077](https://github.com/ruby/rbs/issues/1077)
 
+### Sorbet Support (Tapioca)
+
+For Sorbet users, Structure includes a Tapioca DSL compiler that automatically generates RBI files:
+
+```bash
+# In your project using Structure
+bundle exec tapioca dsl
+```
+
+This will generate RBI files for all Structure classes in your project, giving you full type checking with Sorbet.
+
+### Batch RBS Generation
+
+Generate RBS files for multiple classes at once:
+
+```ruby
+require 'structure/rbs'
+
+# From an array of classes
+Structure::RBS.write_all([User, Order, Product], dir: "sig")
+
+# From a module namespace
+Structure::RBS.write_all(MyApp::Models, dir: "sig")
+```
+
 ## Development
 
 ```bash

Steepfile

@@ -3,6 +3,7 @@
 target :lib do
   signature "sig"
   check "lib"
+  ignore "lib/tapioca"
 
   library "fileutils"
   library "pathname"

lib/structure/rbs.rb

@@ -59,8 +59,32 @@ def write(klass, dir: "sig")
         file_path
       end
 
+      # Write RBS files for multiple classes or all Structure classes in a module
+      #
+      # @param classes [Array<Class>, Module] Classes to generate RBS for, or a module to scan
+      # @param dir [String] Output directory (default: "sig")
+      # @return [Array<String>] Paths of written RBS files
+      #
+      # @example With array of classes
+      #   Structure::RBS.write_all([Person, Address, Order])
+      #
+      # @example With module namespace
+      #   Structure::RBS.write_all(Peddler::Models)
+      def write_all(classes, dir: "sig")
+        classes = structure_classes_in(classes) if classes.is_a?(Module)
+
+        classes.filter_map { |klass| write(klass, dir: dir) }
+      end
+
       private
 
+      def structure_classes_in(mod)
+        mod.constants.filter_map do |const_name|
+          const = mod.const_get(const_name)
+          const if const.is_a?(Class) && const < Data && const.respond_to?(:__structure_meta__)
+        end
+      end
+
       def emit_rbs_content(class_name:, attributes:, types:, required:, has_structure_modules:, custom_methods:)
         # @type var lines: Array[String]
         lines = []

lib/tapioca/dsl/compilers/structure.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Tapioca::Dsl::Compiler)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Generates RBI files for Structure-based Data classes.
+      #
+      # For example, given:
+      #
+      #   Person = Structure.new do
+      #     attribute :name, String
+      #     attribute? :age, Integer
+      #   end
+      #
+      # This compiler will generate:
+      #
+      #   class Person < Data
+      #     sig { params(name: String, age: T.nilable(Integer)).returns(Person) }
+      #     sig { params(name: String, age: T.nilable(Integer)).void }
+      #     def initialize(name:, age: nil); end
+      #
+      #     sig { returns(String) }
+      #     def name; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def age; end
+      #
+      #     sig { params(data: T::Hash[T.any(String, Symbol), T.untyped]).returns(Person) }
+      #     def self.parse(data = {}); end
+      #   end
+      class Structure < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::Data) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select do |klass|
+              klass < ::Data && klass.respond_to?(:__structure_meta__)
+            end
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          meta = constant.__structure_meta__
+          return unless meta
+
+          attributes = meta[:mappings]&.keys || constant.members
+          types = meta.fetch(:types, {})
+          required = meta.fetch(:required, attributes)
+
+          root.create_path(constant) do |klass|
+            generate_new_and_brackets(klass, attributes, types, required)
+            generate_parse(klass)
+            generate_load_dump(klass)
+            generate_members(klass, attributes)
+            generate_attr_readers(klass, attributes, types)
+            generate_to_h(klass, attributes, types)
+            generate_boolean_predicates(klass, types)
+          end
+        end
+
+        private
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped], required: T::Array[Symbol]).void }
+        def generate_new_and_brackets(klass, attributes, types, required)
+          params = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr])
+            is_required = required.include?(attr)
+            if is_required
+              create_kw_param(attr.to_s, type: type)
+            else
+              create_kw_opt_param(attr.to_s, type: type, default: "nil")
+            end
+          end
+
+          klass.create_method("initialize", parameters: params, return_type: "void")
+          klass.create_method("new", parameters: params, return_type: constant.name.to_s, class_method: true)
+          klass.create_method("[]", parameters: params, return_type: constant.name.to_s, class_method: true)
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def generate_parse(klass)
+          klass.create_method(
+            "parse",
+            parameters: [
+              create_opt_param("data", type: "T::Hash[T.any(String, Symbol), T.untyped]", default: "{}"),
+              create_opt_param("overrides", type: "T.nilable(T::Hash[Symbol, T.untyped])", default: "nil"),
+            ],
+            return_type: constant.name.to_s,
+            class_method: true,
+          )
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def generate_load_dump(klass)
+          klass.create_method(
+            "load",
+            parameters: [create_param("data", type: "T.nilable(T::Hash[T.any(String, Symbol), T.untyped])")],
+            return_type: "T.nilable(#{constant.name})",
+            class_method: true,
+          )
+          klass.create_method(
+            "dump",
+            parameters: [create_param("value", type: "T.nilable(#{constant.name})")],
+            return_type: "T.nilable(T::Hash[Symbol, T.untyped])",
+            class_method: true,
+          )
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol]).void }
+        def generate_members(klass, attributes)
+          members_type = "[#{attributes.map { |a| ":#{a}" }.join(", ")}]"
+          klass.create_method("members", return_type: members_type, class_method: true)
+          klass.create_method("members", return_type: members_type)
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped]).void }
+        def generate_attr_readers(klass, attributes, types)
+          attributes.each do |attr|
+            type = map_type_to_sorbet(types[attr])
+            klass.create_method(attr.to_s, return_type: type)
+          end
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped]).void }
+        def generate_to_h(klass, attributes, types)
+          hash_pairs = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr])
+            "#{attr}: #{type}"
+          end.join(", ")
+
+          klass.create_method("to_h", return_type: "{ #{hash_pairs} }")
+        end
+
+        sig { params(klass: RBI::Scope, types: T::Hash[Symbol, T.untyped]).void }
+        def generate_boolean_predicates(klass, types)
+          types.each do |attr, type|
+            next unless type == :boolean
+            next if attr.to_s.end_with?("?")
+
+            klass.create_method("#{attr}?", return_type: "T::Boolean")
+          end
+        end
+
+        sig { params(type: T.untyped).returns(String) }
+        def map_type_to_sorbet(type)
+          case type
+          when Class
+            if type == Array
+              "T::Array[T.untyped]"
+            elsif type == Hash
+              "T::Hash[T.untyped, T.untyped]"
+            else
+              "T.nilable(#{type.name || "T.untyped"})"
+            end
+          when :boolean
+            "T.nilable(T::Boolean)"
+          when :self
+            "T.nilable(#{constant.name})"
+          when Array
+            if type.size == 1
+              element_type = map_type_to_sorbet_element(type.first)
+              "T.nilable(T::Array[#{element_type}])"
+            else
+              "T.nilable(T.untyped)"
+            end
+          when Proc
+            "T.nilable(T.untyped)"
+          else
+            "T.nilable(T.untyped)"
+          end
+        end
+
+        sig { params(type: T.untyped).returns(String) }
+        def map_type_to_sorbet_element(type)
+          case type
+          when Class
+            type.name || "T.untyped"
+          when :boolean
+            "T::Boolean"
+          when :self
+            constant.name.to_s
+          else
+            "T.untyped"
+          end
+        end
+      end
+    end
+  end
+end

sig/structure/rbs.rbs

@@ -4,7 +4,9 @@ module Structure
 
     def self.emit: (untyped klass) -> String?
     def self.write: (untyped klass, ?dir: String) -> String?
+    def self.write_all: (Array[untyped] | Module classes, ?dir: String) -> Array[String]
 
+    private def self.structure_classes_in: (Module mod) -> Array[untyped]
     private def self.emit_rbs_content: (class_name: String, attributes: Array[Symbol], types: Hash[Symbol, untyped], required: Array[Symbol], has_structure_modules: bool, custom_methods: untyped) -> String
     private def self.parse_data_type: (untyped type, String class_name) -> String
     private def self.map_type_to_rbs: (untyped type, String class_name) -> String

test/fixtures/category.rbi

@@ -0,0 +1,34 @@
+class Category
+  sig { params(name: T.nilable(String), children: T.nilable(T::Array[Category])).void }
+  def initialize(name:, children:); end
+
+  sig { params(name: T.nilable(String), children: T.nilable(T::Array[Category])).returns(Category) }
+  def self.new(name:, children:); end
+
+  sig { params(name: T.nilable(String), children: T.nilable(T::Array[Category])).returns(Category) }
+  def self.[](name:, children:); end
+
+  sig { params(data: T::Hash[T.any(String, Symbol), T.untyped], overrides: T.nilable(T::Hash[Symbol, T.untyped])).returns(Category) }
+  def self.parse(data = {}, overrides = nil); end
+
+  sig { params(data: T.nilable(T::Hash[T.any(String, Symbol), T.untyped])).returns(T.nilable(Category)) }
+  def self.load(data); end
+
+  sig { params(value: T.nilable(Category)).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+  def self.dump(value); end
+
+  sig { returns([:name, :children]) }
+  def self.members; end
+
+  sig { returns([:name, :children]) }
+  def members; end
+
+  sig { returns(T.nilable(String)) }
+  def name; end
+
+  sig { returns(T.nilable(T::Array[Category])) }
+  def children; end
+
+  sig { returns({ name: T.nilable(String), children: T.nilable(T::Array[Category]) }) }
+  def to_h; end
+end

test/fixtures/person.rbi

@@ -0,0 +1,43 @@
+class Person
+  sig { params(name: T.nilable(String), age: T.nilable(Integer), active: T.nilable(T::Boolean), email: T.nilable(String)).void }
+  def initialize(name:, age: nil, active:, email:); end
+
+  sig { params(name: T.nilable(String), age: T.nilable(Integer), active: T.nilable(T::Boolean), email: T.nilable(String)).returns(Person) }
+  def self.new(name:, age: nil, active:, email:); end
+
+  sig { params(name: T.nilable(String), age: T.nilable(Integer), active: T.nilable(T::Boolean), email: T.nilable(String)).returns(Person) }
+  def self.[](name:, age: nil, active:, email:); end
+
+  sig { params(data: T::Hash[T.any(String, Symbol), T.untyped], overrides: T.nilable(T::Hash[Symbol, T.untyped])).returns(Person) }
+  def self.parse(data = {}, overrides = nil); end
+
+  sig { params(data: T.nilable(T::Hash[T.any(String, Symbol), T.untyped])).returns(T.nilable(Person)) }
+  def self.load(data); end
+
+  sig { params(value: T.nilable(Person)).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+  def self.dump(value); end
+
+  sig { returns([:name, :age, :active, :email]) }
+  def self.members; end
+
+  sig { returns([:name, :age, :active, :email]) }
+  def members; end
+
+  sig { returns(T.nilable(String)) }
+  def name; end
+
+  sig { returns(T.nilable(Integer)) }
+  def age; end
+
+  sig { returns(T.nilable(T::Boolean)) }
+  def active; end
+
+  sig { returns(T.nilable(String)) }
+  def email; end
+
+  sig { returns({ name: T.nilable(String), age: T.nilable(Integer), active: T.nilable(T::Boolean), email: T.nilable(String) }) }
+  def to_h; end
+
+  sig { returns(T::Boolean) }
+  def active?; end
+end