structure 4.3.0 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9c2544c619e8f11dcafb8765dd9ebfee9c931927bf71d44aed73c7640d98915
-  data.tar.gz: 6156fbc60895981a25c1a5816fcdb6c367855552ac6a1397f19a7c22b602761c
+  metadata.gz: 548fe77f526e4c9f238da59611f13c3f13614f3111f3cf466054bacb84883b18
+  data.tar.gz: f6bda78f70879a1d373c8b5aa1aeb0ef3475004b0475ac5100adf9b6bfa5e657
 SHA512:
-  metadata.gz: '09728c8023e6d0102df31ab627d76e98aa6212a14dc7d98151f24dadeb7a46ff12c796a2990bb27a69fa78828dfe1b451669d3547041c3da2175d9dbb6bfebb4'
-  data.tar.gz: ee06e66c737f47ecc9c18a17470b995c6b5abe0c7708e875fbcb11e9b718371eea991d76aa6b31d2695048fc2203fb06b7d91258c8031b747e111b1fed907a9a
+  metadata.gz: 84f01c87a3e85b73d364d3994b1c0af646aedd50db182e9966b48bb21cc77432448342986931600f843b62c58677202247888791f58c901e809d1830e944915e
+  data.tar.gz: 8d65b5847a2c6839f49cd66ad9a0d08afa7eda6adeba4930dcb79fcff97b8f580e639b0b9a1c13c1a64c4f31c16a72a9517201998793d2c16143e44af69a7d95

data/lib/structure/builder.rb

@@ -41,14 +41,15 @@ module Structure
     # @example Non-nullable attribute
     #   attribute :id, String, null: false
     def attribute(name, type = nil, from: nil, default: nil, null: true, &block)
-      mappings[name] = (from || name).to_s
+      key = from || name
+      mappings[name] = key.is_a?(Symbol) ? key.name : -key.to_s
       defaults[name] = default unless default.nil?
       @non_nullable.add(name) unless null
 
       if type && block
         raise ArgumentError, "cannot specify both type and block for :#{name}"
       else
-        types[name] = type || block
+        types[name] = shareable(type) || shareable_block(block)
       end
     end
 
@@ -68,7 +69,7 @@ module Structure
     # @example Optional with default
     #   attribute? :status, String, default: "pending"
     #
-    # @example Optional but non-nullable when present
+    # @example Optional but non-nullable when present (e.g. GraphQL String!)
     #   attribute? :name, String, null: false
     def attribute?(name, type = nil, from: nil, default: nil, null: true, &block)
       attribute(name, type, from: from, default: default, null: null, &block)
@@ -77,15 +78,22 @@ module Structure
 
     # Defines a callback to run after parsing
     #
+    # @param callable [#call, nil] Object that receives the parsed instance, such as a module with a call method
     # @yield [instance] Block that receives the parsed instance
     # @return [void]
+    # @raise [ArgumentError] If both a callable and a block are provided
     #
     # @example Validation
     #   after_parse do |order|
     #     raise "Invalid order" if order.total < 0
     #   end
-    def after_parse(&block)
-      @after_parse_callback = block
+    #
+    # @example With a module, which any Ractor can call
+    #   after_parse(OrderValidator)
+    def after_parse(callable = nil, &block)
+      raise ArgumentError, "cannot specify both a callable and a block for after_parse" if callable && block
+
+      @after_parse_callback = callable || shareable_block(block)
     end
 
     # @api private
@@ -104,7 +112,7 @@ module Structure
     def coercions(context = nil)
       @types.to_h do |attr, type|
         coercion = Types.coerce(type, context)
-        [attr, coercion]
+        [attr, coercion] #: [Symbol, Proc]
       rescue ArgumentError => e
         raise ArgumentError, "#{e.message} for :#{attr}"
       end
@@ -118,5 +126,32 @@ module Structure
         end
       end.to_h
     end
+
+    private
+
+    # Before Ruby 4.1, Ractors that call the same shareable block share its $~
+    # (https://bugs.ruby-lang.org/issues/22216), so one that matches a Regexp would read another Ractor's match. A block
+    # is shared from 4.1 only, and only when Ruby can: one that uses a local variable from around it stays as it is.
+    if defined?(Ractor) && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("4.1")
+      def shareable_block(block)
+        block && Ractor.shareable_proc(&block) # steep:ignore
+      rescue Ractor::IsolationError, ArgumentError
+        block
+      end
+    else
+      def shareable_block(block)
+        block
+      end
+    end
+
+    # Returns the type as another Ractor can read it: a frozen copy of an Array or of a class name. The caller's own
+    # object is left as it is.
+    def shareable(type)
+      case type
+      when Array then type.map { |element| shareable(element) }.freeze
+      when String then -type
+      else type
+      end
+    end
   end
 end

data/lib/structure/rbs.rb

@@ -28,6 +28,7 @@ module Structure
         types = meta.fetch(:types, default_types)
         # @type var required: Array[Symbol]
         required = meta.fetch(:required, attributes)
+        non_nullable = meta.fetch(:non_nullable, [])
         custom_methods = meta.fetch(:custom_methods, EMPTY_CUSTOM_METHODS)
 
         emit_rbs_content(
@@ -35,6 +36,7 @@ module Structure
           attributes:,
           types:,
           required:,
+          non_nullable:,
           has_structure_modules: meta.any?,
           custom_methods:,
         )
@@ -59,9 +61,33 @@ module Structure
         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 emit_rbs_content(class_name:, attributes:, types:, required:, has_structure_modules:, custom_methods:)
+      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:, non_nullable:, has_structure_modules:, custom_methods:)
         # @type var lines: Array[String]
         lines = []
         lines << "class #{class_name} < Data"
@@ -71,8 +97,9 @@ module Structure
           rbs_types = attributes.map do |attr|
             type = types.fetch(attr, nil)
             rbs_type = map_type_to_rbs(type, class_name)
+            nullable = !(required.include?(attr) && non_nullable.include?(attr))
 
-            [attr, rbs_type != "untyped" ? "#{rbs_type}?" : rbs_type]
+            [attr, rbs_type != "untyped" && nullable ? "#{rbs_type}?" : rbs_type]
           end.to_h
 
           # Sort keyword params: required first, then optional (with ? prefix)

data/lib/structure/types.rb

@@ -64,28 +64,39 @@ module Structure
         end
       end
 
+      # Makes an object shareable when Ruby can. A lambda that closes over a caller's unshareable object can't be,
+      # and comes back as it is. Where Ruby has no Ractor, nothing is shared.
+      if defined?(Ractor)
+        # @api private
+        def shareable(object)
+          Ractor.make_shareable(object)
+        rescue Ractor::IsolationError
+          object
+        end
+      else
+        # @api private
+        def shareable(object)
+          object
+        end
+      end
+
       private
 
       def boolean
-        @boolean ||= ->(val) { BOOLEAN_TRUTHY.include?(val) }
+        @boolean ||= shareable(->(val) { BOOLEAN_TRUTHY.include?(val) })
       end
 
       def self_referential(context)
-        ->(val) { context.parse(val) }
+        shareable(->(val) { context.parse(val) })
       end
 
       def lazy_class(class_name, context)
-        resolved_class = nil
-
-        ->(value) do
-          resolved_class ||= resolve_class(class_name, context)
-          # @type var resolved_class: untyped
-          resolved_class.parse(value)
-        end
+        key = shareable(Object.new)
+        shareable(->(value) { parse_as(resolved_class(key, class_name, context), value) })
       end
 
       def array(element_type, context = nil)
-        case element_type
+        coercion = case element_type
         when :self
           lambda do |value|
             unless value.respond_to?(:map)
@@ -95,16 +106,14 @@ module Structure
             value.map { |element| context.parse(element) }
           end
         when String
-          resolved_class = nil
-
+          key = shareable(Object.new)
           lambda do |value|
             unless value.respond_to?(:map)
               raise TypeError, "can't convert #{value.class} into Array"
             end
 
-            resolved_class ||= resolve_class(element_type, context)
-            # @type var resolved_class: untyped
-            value.map { |element| resolved_class.parse(element) }
+            element_class = resolved_class(key, element_type, context)
+            value.map { |element| parse_as(element_class, element) }
           end
         else
           element_coercer = coerce(element_type, context)
@@ -116,16 +125,38 @@ module Structure
             value.map { |element| element_coercer.call(element) }
           end
         end
+
+        shareable(coercion)
       end
 
       def parseable(type)
         @parseable_cache ||= {} # : Hash[untyped, Proc]
-        @parseable_cache[type] ||= ->(val) { type.parse(val) }
+        @parseable_cache[type] ||= shareable(->(val) { parse_as(type, val) })
+      end
+
+      # A method must make this call, not a lambda. A parser written in C, such as Date.parse, keeps its match in
+      # the caller's $~, and a lambda shared between Ractors shares its $~ too.
+      def parse_as(type, val)
+        type.parse(val)
       end
 
       def kernel(type)
         @kernel_cache ||= {} # : Hash[untyped, Proc]
-        @kernel_cache[type] ||= ->(val) { Kernel.send(type.name, val) }
+        @kernel_cache[type] ||= shareable(->(val) { Kernel.send(type.name, val) })
+      end
+
+      # Resolves a class given by name once in each Ractor. A shareable lambda can't keep the class itself, so it
+      # keeps a key into a weak map in the Ractor's local storage. Where Ruby has no Ractor, the key keeps the class.
+      if defined?(Ractor)
+        def resolved_class(key, class_name, context)
+          classes = Ractor.current[:__structure_classes__] ||= ObjectSpace::WeakMap.new # steep:ignore
+          classes[key] ||= resolve_class(class_name, context)
+        end
+      else
+        def resolved_class(key, class_name, context)
+          key.instance_variable_get(:@resolved) ||
+            key.instance_variable_set(:@resolved, resolve_class(class_name, context))
+        end
       end
 
       def resolve_class(class_name, context)

data/lib/structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Structure
-  VERSION = "4.3.0"
+  VERSION = "4.5.0"
 end

data/lib/structure.rb

@@ -4,7 +4,7 @@ require "structure/builder"
 
 # A library for parsing data into immutable Ruby Data objects with type coercion
 module Structure
-  TO_H_CHECKER = ->(x) { x.respond_to?(:to_h) && x }
+  TO_H_CHECKER = Types.shareable(->(x) { x.respond_to?(:to_h) && x })
   private_constant :TO_H_CHECKER
 
   class << self
@@ -29,7 +29,7 @@ module Structure
       # @type var klass: untyped
       klass = Data.define(*builder.attributes)
 
-      custom_methods_metadata = { instance: [], singleton: [] }.freeze # steep:ignore
+      custom_methods_metadata = { instance: [].freeze, singleton: [].freeze }.freeze # steep:ignore
 
       # Enable custom method definitions by evaluating block on the class
       if block
@@ -39,7 +39,7 @@ module Structure
         # Provide temporary dummy DSL methods to prevent NoMethodError during class_eval
         klass.define_singleton_method(:attribute) { |*args, **kwargs, &blk| }
         klass.define_singleton_method(:attribute?) { |*args, **kwargs, &blk| }
-        klass.define_singleton_method(:after_parse) { |&blk| }
+        klass.define_singleton_method(:after_parse) { |*args, &blk| }
 
         # Evaluate block in class context for method definitions
         klass.class_eval(&block)
@@ -60,7 +60,7 @@ module Structure
 
           {
             name: name,
-            parameters: klass.instance_method(name).parameters,
+            parameters: Types.shareable(klass.instance_method(name).parameters),
           }.freeze
         end
 
@@ -70,7 +70,7 @@ module Structure
 
           {
             name: name,
-            parameters: singleton_class.instance_method(name).parameters,
+            parameters: Types.shareable(singleton_class.instance_method(name).parameters),
           }.freeze
         end
 
@@ -81,42 +81,46 @@ module Structure
       end
 
       # Override initialize to make optional attributes truly optional
-      optional_attrs = builder.optional
+      optional_attrs = builder.optional.freeze
       unless optional_attrs.empty?
-        klass.class_eval do
-          alias_method(:__data_initialize__, :initialize)
+        klass.alias_method(:__data_initialize__, :initialize)
 
-          # steep:ignore:start
-          define_method(:initialize) do |**kwargs|
-            optional_attrs.each do |attr|
-              kwargs[attr] = nil unless kwargs.key?(attr)
-            end
-            __data_initialize__(**kwargs)
+        # steep:ignore:start
+        define_shareable_method(klass, :initialize) do |**kwargs|
+          optional_attrs.each do |attr|
+            kwargs[attr] = nil unless kwargs.key?(attr)
           end
-          # steep:ignore:end
+          __data_initialize__(**kwargs)
         end
+        # steep:ignore:end
       end
 
       builder.predicate_methods.each do |pred, attr|
-        klass.define_method(pred) { !!public_send(attr) }
+        define_common_method(klass, pred) { !!public_send(attr) }
       end
 
-      # Store metadata on class to avoid closure capture (memory optimization)
-      meta = {
-        types: builder.types,
-        defaults: builder.defaults,
-        mappings: builder.mappings,
-        coercions: builder.coercions(klass),
+      # Store metadata on class to avoid closure capture (memory optimization). What Structure builds of it is
+      # frozen, so the whole is shareable when the caller's own types, defaults and blocks are, and then any
+      # Ractor can parse.
+      klass.instance_variable_set(:@__structure_meta__, {
+        types: builder.types.freeze,
+        defaults: builder.defaults.freeze,
+        mappings: builder.mappings.freeze,
+        coercions: builder.coercions(klass).freeze,
         after_parse: builder.after_parse_callback,
-        required: builder.required,
-        non_nullable: builder.non_nullable,
+        required: builder.required.freeze,
+        non_nullable: builder.non_nullable.freeze,
         custom_methods: custom_methods_metadata,
-      }.freeze
-      klass.instance_variable_set(:@__structure_meta__, meta)
-      klass.singleton_class.attr_reader(:__structure_meta__)
+      }.freeze)
+      define_common_method(klass.singleton_class, :__structure_meta__) do
+        @__structure_meta__
+      rescue Ractor::IsolationError
+        raise Ractor::IsolationError,
+          "#{self} parses only in the main Ractor: a type, block, default or after_parse callback is not shareable"
+      end
 
       # recursive to_h
-      klass.define_method(:to_h) do
+      define_shareable_method(klass, :to_h) do
         klass.members.to_h do |m|
           v = public_send(m)
           value = case v
@@ -130,10 +134,9 @@ module Structure
 
       # parse accepts JSON-ish hashes + optional overrides hash
       # overrides is a positional arg (not **kwargs) to avoid hash allocation when unused
-      #
-      # @type self: singleton(Data) & _StructuredDataClass
-      # @type var final: Hash[Symbol, untyped]
-      klass.singleton_class.define_method(:parse) do |data = {}, overrides = nil|
+      define_common_method(klass.singleton_class, :parse) do |data = {}, overrides = nil|
+        # @type self: singleton(Data) & _StructuredDataClass
+        # @type var final: Hash[Symbol, untyped]
         return data if data.is_a?(self)
 
         unless data.respond_to?(:merge!)
@@ -143,12 +146,13 @@ module Structure
         overrides&.each { |k, v| data[k.to_s] = v }
 
         final        = {}
-        mappings     = __structure_meta__[:mappings]
-        defaults     = __structure_meta__[:defaults]
-        coercions    = __structure_meta__[:coercions]
-        after_parse  = __structure_meta__[:after_parse]
-        required     = __structure_meta__[:required]
-        non_nullable = __structure_meta__[:non_nullable]
+        meta         = __structure_meta__
+        mappings     = meta[:mappings]
+        defaults     = meta[:defaults]
+        coercions    = meta[:coercions]
+        after_parse  = meta[:after_parse]
+        required     = meta[:required]
+        non_nullable = meta[:non_nullable]
 
         # Check for missing required attributes
         required.each do |attr|
@@ -186,10 +190,25 @@ module Structure
         obj
       end
 
-      klass.define_singleton_method(:load) { |data| parse(data) if data } # steep:ignore
-      klass.define_singleton_method(:dump) { |value| value&.to_h }
+      define_common_method(klass.singleton_class, :load) { |data| parse(data) if data } # steep:ignore
+      define_common_method(klass.singleton_class, :dump) { |value| value&.to_h }
 
       klass
     end
+
+    private
+
+    # Defines a method that any Ractor can call, not only the one that defined it. The block may read only locals
+    # that hold shareable values and are assigned once.
+    def define_shareable_method(target, name, &block)
+      target.define_method(name, &Types.shareable(block))
+    end
+
+    # The same, for a method whose block is identical for every structure. The first block given for a name is
+    # made shareable once and reused; later ones are ignored.
+    def define_common_method(target, name, &block)
+      @common_methods ||= {} # : Hash[Symbol, Proc]
+      target.define_method(name, &(@common_methods[name] ||= Types.shareable(block)))
+    end
   end
 end

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

@@ -0,0 +1,200 @@
+# 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
+      #: [ConstantType = singleton(::Data)]
+      class Structure < Compiler
+        extend T::Sig
+
+        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)
+          non_nullable = meta.fetch(:non_nullable, [])
+
+          root.create_path(constant) do |klass|
+            generate_new_and_brackets(klass, attributes, types, required, non_nullable)
+            generate_parse(klass)
+            generate_load_dump(klass)
+            generate_members(klass, attributes)
+            generate_attr_readers(klass, attributes, types, non_nullable, required)
+            generate_to_h(klass, attributes, types, non_nullable, required)
+            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], non_nullable: T::Array[Symbol]).void }
+        def generate_new_and_brackets(klass, attributes, types, required, non_nullable)
+          params = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(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], non_nullable: T::Array[Symbol], required: T::Array[Symbol]).void }
+        def generate_attr_readers(klass, attributes, types, non_nullable, required)
+          attributes.each do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(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], non_nullable: T::Array[Symbol], required: T::Array[Symbol]).void }
+        def generate_to_h(klass, attributes, types, non_nullable, required)
+          hash_pairs = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(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, nullable: T::Boolean).returns(String) }
+        def map_type_to_sorbet(type, nullable: true)
+          raw = case type
+          when Class
+            if type == Array
+              "T::Array[T.untyped]"
+            elsif type == Hash
+              "T::Hash[T.untyped, T.untyped]"
+            else
+              type.name || "T.untyped"
+            end
+          when :boolean
+            "T::Boolean"
+          when :self
+            constant.name.to_s
+          when Array
+            if type.size == 1
+              element_type = map_type_to_sorbet_element(type.first)
+              "T::Array[#{element_type}]"
+            else
+              "T.untyped"
+            end
+          when Proc
+            "T.untyped"
+          else
+            "T.untyped"
+          end
+
+          nullable ? "T.nilable(#{raw})" : raw
+        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

data/sig/structure/builder.rbs

@@ -3,7 +3,7 @@ module Structure
     @mappings: Hash[Symbol, String]
     @types: Hash[Symbol, untyped]
     @defaults: Hash[Symbol, untyped]
-    @after_parse_callback: Proc?
+    @after_parse_callback: untyped
     @optional: Set[Symbol]
     @non_nullable: Set[Symbol]
 
@@ -13,7 +13,7 @@ module Structure
     def attribute?: (Symbol name, untyped type, ?from: String | Symbol | nil, ?default: untyped, ?null: bool) ?{ (untyped) -> untyped } -> void
                   | (Symbol name, ?from: String | Symbol | nil, ?default: untyped, ?null: bool) ?{ (untyped) -> untyped } -> void
 
-    def after_parse: () { (Data) -> void } -> void
+    def after_parse: (?untyped callable) ?{ (Data) -> void } -> void
 
     def attributes: () -> Array[Symbol]
     def mappings: () -> Hash[Symbol, String]
@@ -24,7 +24,10 @@ module Structure
     def optional: () -> Array[Symbol]
     def required: () -> Array[Symbol]
     def non_nullable: () -> Array[Symbol]
-    def after_parse_callback: () -> (Proc | nil)
+    def after_parse_callback: () -> untyped
+
+    private def shareable: (untyped type) -> untyped
+    private def shareable_block: (Proc? block) -> Proc?
 
     def method_missing: (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
     def respond_to_missing?: (Symbol, bool) -> bool

data/sig/structure/rbs.rbs

@@ -4,8 +4,10 @@ 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.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.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], non_nullable: 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
     private def self.format_method_signature: (Hash[Symbol, untyped] method_meta, singleton: bool) -> String

data/sig/structure/types.rbs

@@ -12,14 +12,17 @@ module Structure
     self.@string_class_cache: Hash[Array[untyped], Proc]
 
     def self.coerce: (untyped type, ?untyped? context) -> untyped
+    def self.shareable: [T] (T object) -> T
 
     private def self.boolean: () -> Proc
     private def self.self_referential: (_ParseableClass context) -> Proc
     private def self.lazy_class: (String class_name, untyped? context) -> Proc
     private def self.array: (untyped element_type, ?untyped? context) -> Proc
     private def self.parseable: (untyped type) -> Proc
+    private def self.parse_as: (untyped type, untyped val) -> untyped
     private def self.kernel: (Class type) -> Proc
     private def self.parse: (untyped val) -> untyped
+    private def self.resolved_class: (Object key, String class_name, untyped? context) -> _ParseableClass
     private def self.resolve_class: (String class_name, untyped? context) -> _ParseableClass
   end
 end

data/sig/structure.rbs

@@ -1,6 +1,8 @@
 module Structure
   TO_H_CHECKER: Proc
 
+  self.@common_methods: Hash[Symbol, Proc]
+
   interface _StructuredDataClass
     def __structure_meta__: () -> {
       types: Hash[Symbol, untyped],
@@ -15,4 +17,7 @@ module Structure
   # Block evaluated twice: first for DSL methods (attribute calls), then for custom methods
   # Context set to Builder so DSL methods are recognized
   def self.new: () ?{ () [self: Structure::Builder] -> void } -> untyped
+
+  private def self.define_shareable_method: (untyped target, Symbol name) { (?) -> untyped } -> void
+  private def self.define_common_method: (untyped target, Symbol name) { (?) -> untyped } -> void
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.5.0
 platform: ruby
 authors:
 - Hakan Ensari
@@ -20,6 +20,7 @@ files:
 - lib/structure/rbs.rb
 - lib/structure/types.rb
 - lib/structure/version.rb
+- lib/tapioca/dsl/compilers/structure.rb
 - sig/structure.rbs
 - sig/structure/builder.rbs
 - sig/structure/rbs.rbs
@@ -36,14 +37,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Structure your data
 test_files: []