rails-on-sorbet 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d255de247b08a136edde26f15049767590f2e303a78e2551df4ef8998ab84512
-  data.tar.gz: 1d6c912134b2345bd3d6e537b99ab1d89f68f6b6c1ad60f9ea9556a8c025ff3f
+  metadata.gz: 20f5398f4347bd7235077b77dcbce2916b0ec30001eab8ce4da12d290322515d
+  data.tar.gz: 59caf094a17595e0e6c4d5ea26b870098dc0d7b9a06d8f8edcb55fa9aeecd033
 SHA512:
-  metadata.gz: 7bb596b03ee49d914a6d555eb646b1074357ea2368d24b2dd5a424ce3265de740ab44cbbd7191095cb39622e6991b77e6affa21762a3f5dad6dba078778fea27
-  data.tar.gz: da155d5a8360f016a854a2d9f9ff9b2ee28b60a83f397d6593773730ff4186ecd4af5ed39ca5966f00317862e95235f4479c6ce062ba41cbde709503560ae178
+  metadata.gz: e389aaf40e8f111aec4c8d2bbdf6cc7e17af5d70ebcefd18d65b5876339cc0223c8e6c2dbec086dcb4840d2fcd75fa9a0092dfd8a32be46d1ae0932a03daed54
+  data.tar.gz: 4a54cd049174abcb664f80e8c22fdda7b18b62234f29d63f35cb8c285c79677a986a01a59190cab94a53a884e9724513bbdeaabeb258083e4a0f06429107cbe0

data/CHANGELOG.md

@@ -12,6 +12,21 @@ Add changes in new features here. Do not change the gem's version in pull/merge
 ### Changes
 -
 
+## [0.3.5] - 21.10.2025
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.3.4...v0.3.5)
+
+### Changes
+- Fix `TypedRelation` RBI and tapioca compiler
+
+## [0.3.4] - 21.10.2025
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.3.3...v0.3.4)
+
+### Changes
+- Add `Map::Params`
+- Require `TypedRelation` automatically
+
 ## [0.3.3] - 20.10.2025
 
 [Diff](https://github.com/espago/rails-on-sorbet/compare/v0.3.2...v0.3.3)

data/lib/rails/on/sorbet/map.rb

@@ -6,6 +6,9 @@ require 'active_support'
 
 module Map
   extend T::Generic
+
+  # Map type for API params.
+  Params = T.type_alias { Map[T.any(String, Symbol), T.untyped] }
 end
 
 def Map(val) = val # rubocop:disable Style/TopLevelMethodDefinition,Naming/MethodName

data/lib/rails/on/sorbet/version.rb

@@ -3,7 +3,7 @@
 module Rails
   module On
     module Sorbet
-      VERSION = '0.3.3'
+      VERSION = '0.3.5'
     end
   end
 end

data/lib/rails/on/sorbet.rb

@@ -16,3 +16,4 @@ require_relative 'sorbet/alias_association'
 require_relative 'sorbet/current_attributes'
 require_relative 'sorbet/map'
 require_relative 'sorbet/timelike'
+require_relative 'sorbet/typed_relation'

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

@@ -22,28 +22,34 @@ module Tapioca
         root.create_path(constant) do |klass|
           private_relation = klass.create_class('PrivateRelation', superclass_name: '::ActiveRecord::Relation')
           private_relation.create_include('::TypedRelation')
+          private_relation.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_relation_group_chain = klass.create_class('PrivateRelationGroupChain',
                                                             superclass_name: 'PrivateRelation',)
           private_relation_group_chain.create_include('::TypedRelation::GroupChain')
+          private_relation_group_chain.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_relation_where_chain = klass.create_class('PrivateRelationWhereChain', superclass_name: '::ActiveRecord::QueryMethods::WhereChain')
           private_relation_where_chain.create_include('::TypedRelation::WhereChain')
-
+          private_relation_where_chain.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_association_relation = klass.create_class('PrivateAssociationRelation', superclass_name: '::ActiveRecord::AssociationRelation')
           private_association_relation.create_include('::TypedAssociation::Relation')
+          private_association_relation.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_relation_group_chain = klass.create_class('PrivateAssociationRelationGroupChain',
                                                             superclass_name: 'PrivateAssociationRelation',)
           private_relation_group_chain.create_include('::TypedAssociation::Relation::GroupChain')
+          private_relation_group_chain.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_relation_where_chain = klass.create_class('PrivateAssociationRelationWhereChain',
                                                             superclass_name: '::ActiveRecord::QueryMethods::WhereChain',)
           private_relation_where_chain.create_include('::TypedAssociation::Relation::WhereChain')
+          private_relation_where_chain.create_type_variable('Elem', type: 'type_member', variance: :out)
 
           private_collection_proxy = klass.create_class('PrivateCollectionProxy', superclass_name: '::ActiveRecord::Associations::CollectionProxy')
           private_collection_proxy.create_include('::TypedAssociation::CollectionProxy')
+          private_collection_proxy.create_type_variable('Elem', type: 'type_member', variance: :out)
         end
       end
 

data/rbi/map.rbi

@@ -4,6 +4,32 @@
 #: (ActionController::Parameters | ActiveSupport::HashWithIndifferentAccess) -> Map[String | Symbol, untyped]
 def Map(val); end
 
+# `Map` represents a hash-like object
+# Use the `Map` type in a signature.
+#
+#     #: (Map[Symbol | String, Integer]) -> void
+#     def foo(m)
+#       m["foo"] #=> Integer?
+#     end
+#
+#     hash = { "foo" => 4 } #: Hash[String, Integer]
+#     m = Map(hash) #=> Map[Symbol | String, Integer]
+#     foo(m) # OK
+#
+#     hash = { "foo" => 4 }.with_indifferent_access # => ActiveSupport::HashWithIndifferentAccess
+#     m = Map(hash) #=> Map[Symbol | String, untyped]
+#     foo(m) # OK
+#
+#     params = ActionController::Parameters.new # => ActionController::Parameters
+#     m = Map(params) #=> Map[Symbol | String, untyped]
+#     foo(m) # OK
+#
+# Cast a `Hash`, `ActionController::Parameters` or `ActiveSupport::HashWithIndifferentAccess`
+# to a `Map`. The `Map` type defines common methods shared between these hash-like types.
+#
+# Due to current Sorbet limitations, hash-like types cannot directly implement the `Map` interface.
+# The `Map` method provides a way to cast between hash-like types and `Map` to enable type-safe usage.
+#
 # @requires_ancestor: Object
 # @abstract
 #: [out K, out V]

data/rbi/typed_relation.rbi

@@ -417,15 +417,17 @@ module TypedCommonRelationMethods
   # END CommonRelationMethods
 end
 
+# Represents a typed `ActiveRecord::Relation`.
+#
 # @abstract
 module TypedRelation
   extend T::Generic
   Elem = type_member(:out)
 
   class << self
-    #: (ActiveRecord::Relation) -> GroupChain[untyped]
+    #: (ActiveRecord::Relation) -> TypedRelation::GroupChain[untyped]
     def GroupChain(val); end
-    #: (ActiveRecord::QueryMethods::WhereChain) -> WhereChain[untyped]
+    #: (ActiveRecord::QueryMethods::WhereChain) -> TypedRelation::WhereChain[untyped]
     def WhereChain(val); end
   end
 
@@ -805,7 +807,7 @@ end
 
 module TypedAssociation
   class << self
-    #: (::ActiveRecord::Relation) -> Relation[untyped]
+    #: (::ActiveRecord::Relation) -> TypedAssociation::Relation[untyped]
     def Relation(val); end
     #: (::ActiveRecord::Associations::CollectionProxy) -> CollectionProxy[untyped]
     def CollectionProxy(val); end
@@ -820,9 +822,9 @@ module TypedAssociation
     Elem = type_member(:out)
 
     class << self
-      #: (ActiveRecord::Relation) -> GroupChain[untyped]
+      #: (ActiveRecord::Relation) -> TypedAssociation::Relation::GroupChain[untyped]
       def GroupChain(val); end
-      #: (ActiveRecord::QueryMethods::WhereChain) -> WhereChain[untyped]
+      #: (ActiveRecord::QueryMethods::WhereChain) -> TypedAssociation::Relation::WhereChain[untyped]
       def WhereChain(val); end
     end
 
@@ -831,20 +833,20 @@ module TypedAssociation
       extend T::Generic
       Elem = type_member(:out)
 
-      sig { abstract.params(args: T.untyped).returns(Relation[Elem]) }
+      sig { abstract.params(args: T.untyped).returns(TypedAssociation::Relation[Elem]) }
       def associated(*args); end
 
-      sig { abstract.params(args: T.untyped).returns(Relation[Elem]) }
+      sig { abstract.params(args: T.untyped).returns(TypedAssociation::Relation[Elem]) }
       def missing(*args); end
 
-      sig { abstract.params(opts: T.untyped, rest: T.untyped).returns(Relation[Elem]) }
+      sig { abstract.params(opts: T.untyped, rest: T.untyped).returns(TypedAssociation::Relation[Elem]) }
       def not(opts, *rest); end
     end
 
     # @abstract
     module GroupChain
       extend T::Generic
-      include Relation
+      include TypedAssociation::Relation
 
       Elem = type_member(:out)
 
@@ -884,6 +886,8 @@ module TypedAssociation
     end
   end
 
+  # Represents a typed `ActiveRecord::Associations::CollectionProxy`
+  #
   # @abstract
   module CollectionProxy
     extend T::Generic

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-on-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Mateusz Drewniak