sorbet_typed-props 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1a574f476951cc6ed98f8980d38b05af4d3d84133749ec11c53b21d0329707b
-  data.tar.gz: 03c9d3b394eb287a41ac07b353ddf33d104d6d6e1a46ec524e822bdeebf8eb02
+  metadata.gz: 3e03f38fb86ea87d47dddba75811d8f4e5e61772abd33f039fc4c8d044e2568e
+  data.tar.gz: 517097aab6f9f90ba81aca6a4879d4e93917a8097a357140a856a6125f54f2e9
 SHA512:
-  metadata.gz: 81293d96ac1958922e74bcd81ff1ede7d122833d3d7b31f5b8652d22e17d5eb76533c92920cd13fd30c30afbf95122da781462a11408d72ecc9c6e93bbcb090a
-  data.tar.gz: e4303aec243a78bc62e7a735ab86d151d4d8217a07c7fb8c811974aea3540cb48d0aea1fd47d6f1cbc108ad81e46b4f19057a3c9b80e59c52d654160e3f92b15
+  metadata.gz: 352ec5bdd85d44eb0c0d0162f38601fd31b43d90469feec2e1770021fb6f158af26e2412d3ccfde9945c8cef729258eab4e5821aac7be40879cbb333a6a38c98
+  data.tar.gz: 4651beb5802ba54e72da7b8859f44dcfd1fcf821011b60deee83b73d2d6f954caee3425f827ee862b1e07a4f6b8749ee9c4b2e58f97db26936a32ae73794d94e

data/.cz.yaml

@@ -15,7 +15,7 @@ commitizen:
     - mise run format
   tag_format: v$version
   update_changelog_on_bump: true
-  version: 1.1.1
+  version: 1.2.0
   version_files:
     - lib/sorbet_typed/props/version.rb
   version_scheme: semver2

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v1.2.0 (2025-11-26)
+
+### Feat
+
+- skip RBI generation for abstract classes
+
+### Fix
+
+- include superclass in generated RBI if it exists
+- ensure correct type signatures for optional props
+
 ## v1.1.1 (2025-11-25)
 
 ### Fix

data/lib/sorbet_typed/props/version.rb

@@ -5,7 +5,7 @@
 
 module SorbetTyped
   module Props
-    VERSION = '1.1.1'
+    VERSION = '1.2.0'
   end
 end
 

data/lib/tapioca/dsl/compilers/sorbet_typed_props_constructor/prop_to_param_converter.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+# spellchecker:ignore tnilable
+
 module Tapioca
   module Dsl
     module Compilers
@@ -18,14 +20,22 @@ module Tapioca
 
             extend T::Sig
 
+            const :_tnilable, T::Boolean, default: false
             const :type_object, T::Types::Simple
-            const :_nilable, T::Boolean, default: false
             const :default, Object, default: ParamValueEnum::ParamNotPresent
             const :factory, Object, default: ParamValueEnum::ParamNotPresent
 
             sig { returns(T::Boolean) }
             def optional?
-              _nilable || default != ParamValueEnum::ParamNotPresent || factory != ParamValueEnum::ParamNotPresent
+              # NOTE: explicitly not checking for _tnilable. This makes nilable
+              # props required, when no default or factory is set. The default
+              # behavior would have been to be optional with an implied default
+              # of nil
+              # (https://sorbet.org/docs/tstruct#tnilable-without-implying-default-nil).
+              # But because we don't know here, if a type alias has been used as
+              # workaround not not imply default, we simply never treat nilable
+              # as optional.
+              default != ParamValueEnum::ParamNotPresent || factory != ParamValueEnum::ParamNotPresent
             end
           end
 
@@ -51,7 +61,11 @@ module Tapioca
           sig { returns(RBI::TypedParam) }
           def create_rbi_parameter
             if optional?
-              create_kw_opt_param(parameter_name, type:, default: 'nil')
+              # NOTE: unfortunately, there is no way to get the actual default
+              # value as code string from within this compiler, as everything
+              # has already been processed at this point. So we use
+              # `T.unsafe(nil)` as stand-in.
+              create_kw_opt_param(parameter_name, type:, default: 'T.unsafe(nil)')
             else
               create_kw_param(parameter_name, type:)
             end
@@ -66,13 +80,7 @@ module Tapioca
 
           sig { returns(String) }
           def type
-            details_type = details.type_object.name
-
-            if optional?
-              "T.nilable(#{details_type})"
-            else
-              details_type.to_s
-            end
+            details.type_object.name.to_s
           end
 
           sig { returns(String) }

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

@@ -11,7 +11,7 @@ module Tapioca
         extend T::Sig
         extend T::Generic
 
-        ConstantType = type_member { { fixed: T.class_of(SorbetTyped::Props) } }
+        ConstantType = type_member { { upper: T::Class[SorbetTyped::Props] } }
 
         sig { override.returns(T::Enumerable[T::Module[T.anything]]) }
         def self.gather_constants
@@ -21,24 +21,34 @@ module Tapioca
 
         sig { override.void }
         def decorate
+          # NOTE: skip RBI generation for abstract classes, as they cannot be instantiated anyways
+          return if T::AbstractUtils.abstract_module?(constant)
           # NOTE: do not generate a new initializer signature, if the class sets
           # its own and doesn't use the prop generated one.
           return if constant.private_instance_methods(false).include?(:initialize)
-
-          props = constant.props
           return if props.empty?
 
-          params = params_from_props(props:)
-          define_initializer_sig(constant:, params:)
+          define_initializer_sig
         end
 
         private
 
-        sig { params(props: T.untyped).returns(T::Array[RBI::TypedParam]) }
-        def params_from_props(props:)
-          props.map do |name, details|
-            create_param_from_prop(name:, details:)
-          end
+        sig { returns(T::Hash[Symbol, T::Hash[Symbol, T.untyped]]) }
+        def props
+          # NOTE: we already filtered in `::gather_constants` for classes that
+          # include `SorbetTyped::Props`, so we know it must be this type and
+          # has method `props`.
+          @props ||= T.let(T.unsafe(constant).props, T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.untyped]]))
+        end
+
+        sig { returns(T::Array[RBI::TypedParam]) }
+        def params
+          @params ||= T.let(
+            props.map do |name, details|
+              create_param_from_prop(name:, details:)
+            end,
+            T.nilable(T::Array[RBI::TypedParam])
+          )
         end
 
         sig { params(name: Symbol, details: T.untyped).returns(RBI::TypedParam) }
@@ -55,23 +65,23 @@ module Tapioca
             create_rbi_parameter
         end
 
-        # HACK: `T.class_of(SorbetTyped::Props)` fails when passed one of the
-        # anonymous test classes. But active typechecking isn't that relevant
-        # here.
-        sig { params(constant: T.class_of(SorbetTyped::Props), params: T::Array[RBI::TypedParam]).void.checked(:never) }
-        def define_initializer_sig(constant:, params:)
-          root.create_path(constant) do |klass|
+        sig { void }
+        def define_initializer_sig
+          superclass = constant.superclass
+          superclass_name = superclass == Object ? nil : superclass.to_s
+
+          root.create_class(constant.to_s, superclass_name:) do |klass|
             klass.create_method(
               'initialize',
-              parameters: params_with_optional_last(params:),
+              parameters: params_with_optional_last,
               return_type: 'void',
               comments: [RBI::Comment.new('Generated from sorbet SorbetTyped::Props')]
             )
           end
         end
 
-        sig { params(params: T::Array[RBI::TypedParam]).returns(T::Array[RBI::TypedParam]) }
-        def params_with_optional_last(params:)
+        sig { returns(T::Array[RBI::TypedParam]) }
+        def params_with_optional_last
           required_params, optional_params = params.partition do |param|
             param.param.is_a?(RBI::KwParam)
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet_typed-props
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Richard Kramer