tapioca 0.4.10 → 0.4.15

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

@@ -15,8 +15,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::ActiveRecordEnum` decorates RBI files for subclasses of
-      # `ActiveRecord::Base` which declare `enum` fields
-      # (see https://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
+      # `ActiveRecord::Base` which declare [`enum` fields](https://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
       #
       # For example, with the following `ActiveRecord::Base` subclass:
       #
@@ -32,26 +31,30 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { void }
-      #   def all_title!; end
+      #   include EnumMethodsModule
       #
-      #   sig { returns(T::Boolean) }
-      #   def all_title?; end
+      #   module EnumMethodsModule
+      #     sig { void }
+      #     def all_title!; end
       #
-      #   sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
-      #   def self.title_types; end
+      #     sig { returns(T::Boolean) }
+      #     def all_title?; end
       #
-      #   sig { void }
-      #   def book_title!; end
+      #     sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+      #     def self.title_types; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def book_title?; end
+      #     sig { void }
+      #     def book_title!; end
       #
-      #   sig { void }
-      #   def web_title!; end
+      #     sig { returns(T::Boolean) }
+      #     def book_title?; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def web_title?; end
+      #     sig { void }
+      #     def web_title!; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def web_title?; end
+      #   end
       # end
       # ~~~
       class ActiveRecordEnum < Base
@@ -61,17 +64,18 @@ module Tapioca
         def decorate(root, constant)
           return if constant.defined_enums.empty?
 
-          module_name = "#{constant}::EnumMethodsModule"
-          root.create_module(module_name) do |mod|
-            generate_instance_methods(constant, mod)
-          end
+          root.path(constant) do |model|
+            module_name = "EnumMethodsModule"
+
+            model.create_module(module_name) do |mod|
+              generate_instance_methods(constant, mod)
+            end
 
-          root.path(constant) do |k|
-            k.create_include(module_name)
+            model.create_include(module_name)
 
             constant.defined_enums.each do |name, enum_map|
               type = type_for_enum(enum_map)
-              create_method(k, name.pluralize, class_method: true, return_type: type)
+              create_method(model, name.pluralize, class_method: true, return_type: type)
             end
           end
         end

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

@@ -12,9 +12,9 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordScope` decorates RBI files for subclasses of
-      # `ActiveRecord::Base` which declare `scope` fields
-      # (see https://api.rubyonrails.org).
+      # `Tapioca::Compilers::Dsl::ActiveRecordScope` decorates RBI files for
+      # subclasses of `ActiveRecord::Base` which declare
+      # [`scope` fields](https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Named/ClassMethods.html#method-i-scope).
       #
       # For example, with the following `ActiveRecord::Base` subclass:
       #
@@ -31,15 +31,15 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   extend Post::GeneratedRelationMethods
-      # end
+      #   extend GeneratedRelationMethods
       #
-      # module Post::GeneratedRelationMethods
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
-      #   def private_kind(*args, &blk); end
+      #   module GeneratedRelationMethods
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+      #     def private_kind(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
-      #   def public_kind(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+      #     def public_kind(*args, &blk); end
+      #   end
       # end
       # ~~~
       class ActiveRecordScope < Base
@@ -55,15 +55,16 @@ module Tapioca
           scope_method_names = constant.send(:generated_relation_methods).instance_methods(false)
           return if scope_method_names.empty?
 
-          module_name = "#{constant}::GeneratedRelationMethods"
-          root.create_module(module_name) do |mod|
-            scope_method_names.each do |scope_method|
-              generate_scope_method(scope_method, mod)
+          root.path(constant) do |model|
+            module_name = "GeneratedRelationMethods"
+
+            model.create_module(module_name) do |mod|
+              scope_method_names.each do |scope_method|
+                generate_scope_method(scope_method, mod)
+              end
             end
-          end
 
-          root.path(constant) do |k|
-            k.create_extend(module_name)
+            model.create_extend(module_name)
           end
         end
 

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

@@ -15,8 +15,8 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::DSL::ActiveRecordTypedStore` generates RBI files for ActiveRecord models that use
-      # `ActiveRecord::TypedStore` features (see https://github.com/byroot/activerecord-typedstore).
+      # `Tapioca::Compilers::DSL::ActiveRecordTypedStore` generates RBI files for Active Record models that use
+      # [`ActiveRecord::TypedStore`](https://github.com/byroot/activerecord-typedstore) features.
       #
       # For example, with the following ActiveRecord class:
       #
@@ -101,13 +101,14 @@ module Tapioca
           stores = constant.typed_stores
           return if stores.values.flat_map(&:accessors).empty?
 
-          root.path(constant) do |k|
+          root.path(constant) do |model|
             stores.values.each do |store_data|
               store_data.accessors.each do |accessor|
                 field = store_data.fields[accessor]
                 type = type_for(field.type_sym)
                 type = "T.nilable(#{type})" if field.null && type != "T.untyped"
-                generate_methods(field.name.to_s, type, k)
+
+                generate_methods(model, field.name.to_s, type)
               end
             end
           end
@@ -141,13 +142,13 @@ module Tapioca
 
         sig do
           params(
+            klass: Parlour::RbiGenerator::Namespace,
             name: String,
-            type: String,
-            klass: Parlour::RbiGenerator::Namespace
+            type: String
           )
             .void
         end
-        def generate_methods(name, type, klass)
+        def generate_methods(klass, name, type)
           klass.create_method(
             "#{name}=",
             parameters: [Parlour::RbiGenerator::Parameter.new(name, type: type)],

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

@@ -13,8 +13,8 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::ActiveResource` decorates RBI files for subclasses of
-      # `ActiveResource::Base` which declare `schema` fields
-      # (see https://github.com/rails/activeresource).
+      # [`ActiveResource::Base`](https://github.com/rails/activeresource) which declare
+      # `schema` fields.
       #
       # For example, with the following `ActiveResource::Base` subclass:
       #
@@ -71,9 +71,10 @@ module Tapioca
         end
         def decorate(root, constant)
           return if constant.schema.blank?
-          root.path(constant) do |klass|
+
+          root.path(constant) do |resource|
             constant.schema.each do |attribute, type|
-              create_schema_methods(klass, attribute, type)
+              create_schema_methods(resource, attribute, type)
             end
           end
         end

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

@@ -13,9 +13,8 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::ActiveSupportCurrentAttributes` decorates RBI files for all
-      # subclasses of `ActiveSupport::CurrentAttributes`
-      #
-      # To add attributes see https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html
+      # subclasses of
+      # [`ActiveSupport::CurrentAttributes`](https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html).
       #
       # For example, with the following singleton class
       #
@@ -76,20 +75,20 @@ module Tapioca
           instance_methods = instance_methods_for(constant) - dynamic_methods
           return if dynamic_methods.empty? && instance_methods.empty?
 
-          root.path(constant) do |k|
+          root.path(constant) do |current_attributes|
             dynamic_methods.each do |method|
               method = method.to_s
               # We want to generate each method both on the class
-              generate_method(k, method, class_method: true)
+              generate_method(current_attributes, method, class_method: true)
               # and on the instance
-              generate_method(k, method, class_method: false)
+              generate_method(current_attributes, method, class_method: false)
             end
 
             instance_methods.each do |method|
               # instance methods are only elevated to class methods
               # no need to add separate instance methods for them
               method = constant.instance_method(method)
-              create_method_from_def(k, method, class_method: true)
+              create_method_from_def(current_attributes, method, class_method: true)
             end
           end
         end

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

@@ -61,7 +61,7 @@ module Tapioca
         end
         def create_method(namespace, name, options = {})
           return unless valid_method_name?(name)
-          T.unsafe(namespace).create_method(name, options)
+          T.unsafe(namespace).create_method(name, **options)
         end
 
         # Create a Parlour method inside `namespace` from its Ruby definition

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

@@ -12,8 +12,8 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::FrozenRecord` generates RBI files for subclasses of `FrozenRecord::Base`
-      # (see https://github.com/byroot/frozen_record).
+      # `Tapioca::Compilers::Dsl::FrozenRecord` generates RBI files for subclasses of
+      # [`FrozenRecord::Base`](https://github.com/byroot/frozen_record).
       #
       # For example, with the following FrozenRecord class:
       #
@@ -41,27 +41,27 @@ module Tapioca
       # # Student.rbi
       # # typed: strong
       # class Student
-      #   include Student::FrozenRecordAttributeMethods
-      # end
+      #   include FrozenRecordAttributeMethods
       #
-      # module Student::FrozenRecordAttributeMethods
-      #   sig { returns(T.untyped) }
-      #   def first_name; end
+      #   module FrozenRecordAttributeMethods
+      #     sig { returns(T.untyped) }
+      #     def first_name; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def first_name?; end
+      #     sig { returns(T::Boolean) }
+      #     def first_name?; end
       #
-      #   sig { returns(T.untyped) }
-      #   def id; end
+      #     sig { returns(T.untyped) }
+      #     def id; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def id?; end
+      #     sig { returns(T::Boolean) }
+      #     def id?; end
       #
-      #   sig { returns(T.untyped) }
-      #   def last_name; end
+      #     sig { returns(T.untyped) }
+      #     def last_name; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def last_name?; end
+      #     sig { returns(T::Boolean) }
+      #     def last_name?; end
+      #   end
       # end
       # ~~~
       class FrozenRecord < Base
@@ -72,17 +72,17 @@ module Tapioca
           attributes = constant.attributes
           return if attributes.empty?
 
-          module_name = "#{constant}::FrozenRecordAttributeMethods"
+          root.path(constant) do |record|
+            module_name = "FrozenRecordAttributeMethods"
 
-          root.create_module(module_name) do |mod|
-            attributes.each do |attribute|
-              create_method(mod, "#{attribute}?", return_type: 'T::Boolean')
-              create_method(mod, attribute.to_s, return_type: 'T.untyped')
+            record.create_module(module_name) do |mod|
+              attributes.each do |attribute|
+                create_method(mod, "#{attribute}?", return_type: 'T::Boolean')
+                create_method(mod, attribute.to_s, return_type: 'T.untyped')
+              end
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            record.create_include(module_name)
           end
         end
 

data/lib/tapioca/compilers/dsl/{active_record_identity_cache.rb → identity_cache.rb}

@@ -15,11 +15,12 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::DSL::ActiveRecordIdentityCache` generates RBI files for ActiveRecord models
+      # `Tapioca::Compilers::DSL::IdentityCache` generates RBI files for Active Record models
       #  that use `include IdentityCache`.
-      # `IdentityCache` is a blob level caching solution to plug into ActiveRecord. (see https://github.com/Shopify/identity_cache).
+      # [`IdentityCache`](https://github.com/Shopify/identity_cache) is a blob level caching solution
+      # to plug into Active Record.
       #
-      # For example, with the following ActiveRecord class:
+      # For example, with the following Active Record class:
       #
       # ~~~rb
       # # post.rb
@@ -61,7 +62,7 @@ module Tapioca
       #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
       # end
       # ~~~
-      class ActiveRecordIdentityCache < Base
+      class IdentityCache < Base
         extend T::Sig
 
         COLLECTION_TYPE = T.let(
@@ -82,25 +83,25 @@ module Tapioca
           cache_indexes = constant.send(:cache_indexes)
           return if caches.empty? && cache_indexes.empty?
 
-          root.path(constant) do |k|
+          root.path(constant) do |model|
             cache_manys = constant.send(:cached_has_manys)
             cache_ones = constant.send(:cached_has_ones)
             cache_belongs = constant.send(:cached_belongs_tos)
 
             cache_indexes.each do |field|
-              create_fetch_by_methods(field, k, constant)
+              create_fetch_by_methods(field, model, constant)
             end
 
             cache_manys.values.each do |field|
-              create_fetch_field_methods(field, k, returns_collection: true)
+              create_fetch_field_methods(field, model, returns_collection: true)
             end
 
             cache_ones.values.each do |field|
-              create_fetch_field_methods(field, k, returns_collection: false)
+              create_fetch_field_methods(field, model, returns_collection: false)
             end
 
             cache_belongs.values.each do |field|
-              create_fetch_field_methods(field, k, returns_collection: false)
+              create_fetch_field_methods(field, model, returns_collection: false)
             end
           end
         end
@@ -108,7 +109,7 @@ module Tapioca
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
           ::ActiveRecord::Base.descendants.select do |klass|
-            klass < IdentityCache::WithoutPrimaryIndex
+            klass < ::IdentityCache::WithoutPrimaryIndex
           end
         end
 

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

@@ -12,7 +12,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::Protobuf` decorates RBI files for subclasses of
-      # `Google::Protobuf::MessageExts` (see https://github.com/protocolbuffers/protobuf/tree/master/ruby).
+      # [`Google::Protobuf::MessageExts`](https://github.com/protocolbuffers/protobuf/tree/master/ruby).
       #
       # For example, with the following "cart.rb" file:
       #

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

@@ -0,0 +1,83 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "sidekiq"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::SidekiqWorker` generates RBI files classes that include
+      # [`Sidekiq::Worker`](https://github.com/mperham/sidekiq/wiki/Getting-Started).
+      #
+      # For example, with the following class that includes `Sidekiq::Worker`:
+      #
+      # ~~~rb
+      # class NotifierWorker
+      #   include Sidekiq::Worker
+      #   def perform(customer_id)
+      #     # ...
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `notifier_worker.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # notifier_worker.rbi
+      # # typed: true
+      # class NotifierWorker
+      #   sig { params(customer_id: T.untyped).returns(String) }
+      #   def self.perform_async(customer_id); end
+      #
+      #   sig { params(interval: T.any(DateTime, Time), customer_id: T.untyped).returns(String) }
+      #   def self.perform_at(interval, customer_id); end
+      #
+      #   sig { params(interval: Numeric, customer_id: T.untyped).returns(String) }
+      #   def self.perform_in(interval, customer_id); end
+      # end
+      # ~~~
+      class SidekiqWorker < Base
+        extend T::Sig
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::Sidekiq::Worker)).void }
+        def decorate(root, constant)
+          return unless constant.instance_methods.include?(:perform)
+
+          root.path(constant) do |worker|
+            method_def = constant.instance_method(:perform)
+
+            async_params = compile_method_parameters_to_parlour(method_def)
+
+            # `perform_at` and is just an alias for `perform_in` so both methods technically
+            # accept a datetime, time, or numeric but we're typing them differently so they
+            # semantically make sense.
+            at_params = [
+              Parlour::RbiGenerator::Parameter.new('interval', type: 'T.any(DateTime, Time)'),
+              *async_params,
+            ]
+            in_params = [
+              Parlour::RbiGenerator::Parameter.new('interval', type: 'Numeric'),
+              *async_params,
+            ]
+
+            create_method(worker, 'perform_async', parameters: async_params, return_type: 'String', class_method: true)
+            create_method(worker, 'perform_at', parameters: at_params, return_type: 'String', class_method: true)
+            create_method(worker, 'perform_in', parameters: in_params, return_type: 'String', class_method: true)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
+          classes.select { |c| c < Sidekiq::Worker }
+        end
+      end
+    end
+  end
+end