rails-on-sorbet 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ea28926ab10cc0fcae86ab5b28f3f0edcb837c108b2dce06dc4a0630dcf5b87
-  data.tar.gz: 6dd9264a458700cb250c6c75314475ed542f84bc4d9dcfa7dffe040db8939984
+  metadata.gz: b4812fc020427c13b159bdb9efef7c237a4b400a6ac2dee02746193f2a483777
+  data.tar.gz: ce29ecb1f8d1176e7ca596430fd17c883a32a14801061f9aeaea21b1724504b3
 SHA512:
-  metadata.gz: a7ce2795b1153542782e7b62764c71af68d7dbbf62fb0eed0b4b626d112d585ef70901138a88c8d6309649d7df5d8e769e5d2c15b4525e1207948c0819638e4b
-  data.tar.gz: ccd02ca4092d27b855f657847d89facf82f8a3737bbba890343095a84a4acfbb2d9d4f46796f0f0adeded61e1709a28cf0b8a040eb39082c230f02af29de1aaa
+  metadata.gz: ff2e0aa0fa03716b215d63f3548e7c6c5d6572831697115ae31db4c8df7af146fc01972fa23c105dc2f47d6f649706f3e0297777f4ff2353fbf80abff61dc731
+  data.tar.gz: 6564143b63c4d46f0c4bfa9a7fddd5c3ec2688c29a0d8a961545c6a78fe5fa9348dc0c1dd46c5d2823a1842ebbb3d90eb0029b1c1af8adb2fb715a0c15520249

data/CHANGELOG.md

@@ -12,6 +12,20 @@ Add changes in new features here. Do not change the gem's version in pull/merge
 ### Changes
 -
 
+## [0.6.0] - 16.01.2026
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.5.1...v0.6.0)
+
+### Breaking changes
+- Remove `TypedAssociated::Relation`, `TypedAssociation::Relation::GroupChain`, `TypedAssociation::Relation::WhereChain` in favour of `TypedRelation`, `TypedRelation::GroupChain`, `TypedRelation::WhereChain` respectively
+
+## [0.5.1] - 30.12.2025
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.5.0...v0.5.1)
+
+### Changes
+- Fix RBI signatures for `TypedRelation`
+
 ## [0.5.0] - 30.12.2025
 
 [Diff](https://github.com/espago/rails-on-sorbet/compare/v0.4.0...v0.5.0)

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

@@ -32,26 +32,6 @@ module TypedAssociation
     def CollectionProxy(val) = val # rubocop:disable Naming/MethodName
   end
 
-  # Represents a `X::PrivateAssociationRelation` tapioca generated class, where `X` is an ActiveRecord model.
-  module Relation
-    extend T::Generic
-
-    class << self
-      def GroupChain(val) = val # rubocop:disable Naming/MethodName
-      def WhereChain(val) = val # rubocop:disable Naming/MethodName
-      def CollectionProxy(val) = val # rubocop:disable Naming/MethodName
-    end
-
-    module GroupChain
-      extend T::Generic
-      include Relation
-    end
-
-    module WhereChain
-      extend T::Generic
-    end
-  end
-
   module CollectionProxy
     extend T::Generic
     include TypedRelation

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

@@ -3,7 +3,7 @@
 module Rails
   module On
     module Sorbet
-      VERSION = '0.5.0'
+      VERSION = '0.6.0'
     end
   end
 end

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

@@ -36,19 +36,19 @@ module Tapioca
                                                                     fixed: klass.fully_qualified_name,)
 
           private_association_relation = klass.create_class('PrivateAssociationRelation', superclass_name: '::ActiveRecord::AssociationRelation')
-          private_association_relation.create_include('::TypedAssociation::Relation')
+          private_association_relation.create_include('::TypedRelation')
           private_association_relation.create_type_variable('Elem', type:  'type_member',
                                                                     fixed: klass.fully_qualified_name,)
 
           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_include('::TypedRelation::GroupChain')
           private_relation_group_chain.create_type_variable('Elem', type:  'type_member',
                                                                     fixed: klass.fully_qualified_name,)
 
           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_include('::TypedRelation::WhereChain')
           private_relation_where_chain.create_type_variable('Elem', type:  'type_member',
                                                                     fixed: klass.fully_qualified_name,)
 

data/rbi/typed_relation.rbi

@@ -7,7 +7,7 @@ def TypedRelation(val); end
 # @abstract
 module TypedCommonRelationMethods
   extend T::Generic
-  include Enumerable[Elem]
+  include Enumerable
 
   Elem = type_member(:out)
 
@@ -699,7 +699,7 @@ module TypedGeneratedAssociationRelationMethods
   sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
   def from(*args, &blk); end
 
-  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(TypedAssociation::Relation::GroupChain[Elem]) }
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(TypedRelation::GroupChain[Elem]) }
   def group(*args, &blk); end
 
   sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
@@ -800,7 +800,7 @@ module TypedGeneratedAssociationRelationMethods
   sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
   def unscope(*args, &blk); end
 
-  sig { returns(TypedAssociation::Relation::WhereChain[Elem]) }
+  sig { returns(TypedRelation::WhereChain[Elem]) }
   sig { params(args: T.untyped).returns(T.self_type) }
   def where(*args); end
 
@@ -816,85 +816,12 @@ end
 
 module TypedAssociation
   class << self
-    #: (::ActiveRecord::Relation) -> TypedAssociation::Relation[untyped]
+    #: (::ActiveRecord::Relation) -> TypedRelation[untyped]
     def Relation(val); end
     #: (::ActiveRecord::Associations::CollectionProxy) -> CollectionProxy[untyped]
     def CollectionProxy(val); end
   end
 
-  # @abstract
-  module Relation
-    extend T::Generic
-    include TypedCommonRelationMethods
-    include TypedGeneratedAssociationRelationMethods
-
-    Elem = type_member(:out)
-
-    class << self
-      #: (ActiveRecord::Relation) -> TypedAssociation::Relation::GroupChain[untyped]
-      def GroupChain(val); end
-      #: (ActiveRecord::QueryMethods::WhereChain) -> TypedAssociation::Relation::WhereChain[untyped]
-      def WhereChain(val); end
-    end
-
-    # @abstract
-    module WhereChain
-      extend T::Generic
-      Elem = type_member(:out)
-
-      sig { abstract.params(args: T.untyped).returns(TypedAssociation::Relation[Elem]) }
-      def associated(*args); end
-
-      sig { abstract.params(args: T.untyped).returns(TypedAssociation::Relation[Elem]) }
-      def missing(*args); end
-
-      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 TypedAssociation::Relation
-
-      Elem = type_member(:out)
-
-      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
-      def average(column_name); end
-
-      sig do
-        abstract.params(
-          operation: Symbol,
-          column_name: T.any(String, Symbol)
-        ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
-      end
-      def calculate(operation, column_name); end
-
-      sig { abstract.params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
-      def count(column_name = nil); end
-
-      sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
-      def having(*args, &blk); end
-
-      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
-      def maximum(column_name); end
-
-      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
-      def minimum(column_name); end
-
-      sig { abstract.returns(T::Hash[T.untyped, Integer]) }
-      def size; end
-
-      sig do
-        abstract.params(
-          column_name: T.nilable(T.any(String, Symbol)),
-          block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
-        ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
-      end
-      def sum(column_name = nil, &block); end
-    end
-  end
-
   # Represents a typed `ActiveRecord::Associations::CollectionProxy`
   #
   # @abstract
@@ -954,7 +881,7 @@ module TypedAssociation
     end
     def replace(other_array); end
 
-    sig { abstract.returns(TypedAssociation::Relation[Elem]) }
+    sig { abstract.returns(TypedRelation[Elem]) }
     def scope; end
 
     sig { abstract.returns(T::Array[Elem]) }

metadata

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