tapioca 0.4.0 → 0.4.5

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

@@ -0,0 +1,212 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "rails/railtie"
+  require "identity_cache"
+rescue LoadError
+  # means IdentityCache is not installed,
+  # so let's not even define the generator.
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::DSL::ActiveRecordIdentityCache` generates RBI files for ActiveRecord models
+      #  that use `include IdentityCache`.
+      # `IdentityCache` is a blob level caching solution to plug into ActiveRecord. (see https://github.com/Shopify/identity_cache).
+      #
+      # For example, with the following ActiveRecord class:
+      #
+      # ~~~rb
+      # # post.rb
+      # class Post < ApplicationRecord
+      #    include IdentityCache
+      #
+      #    cache_index :blog_id
+      #    cache_index :title, unique: true
+      #    cache_index :title, :review_date, unique: true
+      #
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   sig { params(blog_id: T.untyped, includes: T.untyped).returns(T::Array[::Post])
+      #   def fetch_by_blog_id(blog_id, includes: nil); end
+      #
+      #   sig { params(blog_ids: T.untyped, includes: T.untyped).returns(T::Array[::Post])
+      #   def fetch_multi_by_blog_id(index_values, includes: nil); end
+      #
+      #   sig { params(title: T.untyped, includes: T.untyped).returns(::Post) }
+      #   def fetch_by_title!(title, includes: nil); end
+      #
+      #   sig { params(title: T.untyped, includes: T.untyped).returns(T.nilable(::Post)) }
+      #   def fetch_by_title(title, includes: nil); end
+      #
+      #   sig { params(index_values: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+      #   def fetch_multi_by_title(index_values, includes: nil); end
+      #
+      #   sig { params(title: T.untyped, review_date: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+      #   def fetch_by_title_and_review_date!(title, review_date, includes: nil); end
+      #
+      #   sig { params(title: T.untyped, review_date: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+      #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
+      # end
+      # ~~~
+      class ActiveRecordIdentityCache < Base
+        extend T::Sig
+
+        COLLECTION_TYPE = T.let(
+          ->(type) { "T::Array[::#{type}]" },
+          T.proc.params(type: Module).returns(String)
+        )
+
+        sig do
+          override
+            .params(
+              root: Parlour::RbiGenerator::Namespace,
+              constant: T.class_of(::ActiveRecord::Base)
+            )
+            .void
+        end
+        def decorate(root, constant)
+          caches = constant.send(:all_cached_associations)
+          cache_indexes = constant.send(:cache_indexes)
+          return if caches.empty? && cache_indexes.empty?
+
+          root.path(constant) do |k|
+            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)
+            end
+
+            cache_manys.values.each do |field|
+              create_fetch_field_methods(field, k, returns_collection: true)
+            end
+
+            cache_ones.values.each do |field|
+              create_fetch_field_methods(field, k, returns_collection: false)
+            end
+
+            cache_belongs.values.each do |field|
+              create_fetch_field_methods(field, k, returns_collection: false)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActiveRecord::Base.descendants.select do |klass|
+            klass < IdentityCache
+          end
+        end
+
+        private
+
+        sig do
+          params(
+            field: T.untyped,
+            returns_collection: T::Boolean
+          )
+            .returns(String)
+        end
+        def type_for_field(field, returns_collection:)
+          cache_type = field.reflection.compute_class(field.reflection.class_name)
+          if returns_collection
+            COLLECTION_TYPE.call(cache_type)
+          else
+            "::#{cache_type}"
+          end
+        rescue ArgumentError
+          "T.untyped"
+        end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: Parlour::RbiGenerator::Namespace,
+            returns_collection: T::Boolean
+          )
+            .void
+        end
+        def create_fetch_field_methods(field, klass, returns_collection:)
+          name = field.cached_accessor_name.to_s
+          type = type_for_field(field, returns_collection: returns_collection)
+          klass.create_method(name, return_type: type)
+
+          if field.respond_to?(:cached_ids_name)
+            klass.create_method(field.cached_ids_name, return_type: "T::Array[T.untyped]")
+          elsif field.respond_to?(:cached_id_name)
+            klass.create_method(field.cached_id_name, return_type: "T.untyped")
+          end
+        end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(::ActiveRecord::Base),
+          )
+            .void
+        end
+        def create_fetch_by_methods(field, klass, constant)
+          field_length = field.key_fields.length
+          fields_name = field.key_fields.join("_and_")
+
+          parameters = field.key_fields.map do |arg|
+            Parlour::RbiGenerator::Parameter.new(arg.to_s, type: "T.untyped")
+          end
+          parameters << Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped")
+
+          name = "fetch_by_#{fields_name}"
+          if field.unique
+            klass.create_method(
+              "#{name}!",
+              class_method: true,
+              parameters: parameters,
+              return_type: "::#{constant}"
+            )
+
+            klass.create_method(
+              name,
+              class_method: true,
+              parameters: parameters,
+              return_type: "T.nilable(::#{constant})"
+            )
+          else
+            klass.create_method(
+              name,
+              class_method: true,
+              parameters: parameters,
+              return_type: COLLECTION_TYPE.call(constant)
+            )
+          end
+
+          if field_length == 1
+            name = "fetch_multi_by_#{fields_name}"
+            klass.create_method(
+              name,
+              class_method: true,
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("index_values", type: "T.untyped"),
+                Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped"),
+              ],
+              return_type: COLLECTION_TYPE.call(constant)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+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).
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      #   scope :public_kind, -> { where.not(kind: 'private') }
+      #   scope :private_kind, -> { where(kind: 'private') }
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   extend Post::GeneratedRelationMethods
+      # end
+      #
+      # module Post::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
+      # end
+      # ~~~
+      class ActiveRecordScope < Base
+        extend T::Sig
+
+        sig do
+          override.params(
+            root: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(::ActiveRecord::Base)
+          ).void
+        end
+        def decorate(root, constant)
+          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)
+            end
+          end
+
+          root.path(constant) do |k|
+            k.create_extend(module_name)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActiveRecord::Base.descendants.reject(&:abstract_class?)
+        end
+
+        private
+
+        sig do
+          params(
+            scope_method: String,
+            mod: Parlour::RbiGenerator::Namespace,
+          ).void
+        end
+        def generate_scope_method(scope_method, mod)
+          # This return type should actually be Model::ActiveRecord_Relation
+          return_type = "T.untyped"
+
+          create_method(
+            mod,
+            scope_method,
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+              Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+            ],
+            return_type: return_type,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+require "tapioca/core_ext/class"
+
+begin
+  require "activerecord-typedstore"
+rescue LoadError
+  # means ActiveRecord::TypedStore is not installed,
+  # so let's not even define the generator.
+  return
+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).
+      #
+      # For example, with the following ActiveRecord class:
+      #
+      # ~~~rb
+      # # post.rb
+      # class Post < ApplicationRecord
+      #   typed_store :metadata do |s|
+      #     s.string(:reviewer, blank: false, accessor: false)
+      #     s.date(:review_date)
+      #     s.boolean(:reviewed, null: false, default: false)
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   sig { params(review_date: T.nilable(Date)).returns(T.nilable(Date)) }
+      #   def review_date=(review_date); end
+      #
+      #   sig { returns(T.nilable(Date)) }
+      #   def review_date; end
+      #
+      #   sig { returns(T.nilable(Date)) }
+      #   def review_date_was; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def review_date_changed?; end
+      #
+      #   sig { returns(T.nilable(Date)) }
+      #   def review_date_before_last_save; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def saved_change_to_review_date?; end
+      #
+      #   sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+      #   def review_date_change; end
+      #
+      #   sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+      #   def saved_change_to_review_date; end
+      #
+      #   sig { params(reviewd: T::Boolean).returns(T::Boolean) }
+      #   def reviewed=(reviewed); end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def reviewed; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def reviewed_was; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def reviewed_changed?; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def reviewed_before_last_save; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def saved_change_to_reviewed?; end
+      #
+      #   sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+      #   def reviewed_change; end
+      #
+      #   sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+      #   def saved_change_to_reviewed; end
+      # end
+      # ~~~
+      class ActiveRecordTypedStore < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(
+              root: Parlour::RbiGenerator::Namespace,
+              constant: T.class_of(::ActiveRecord::Base)
+            )
+            .void
+        end
+        def decorate(root, constant)
+          stores = constant.typed_stores
+          return if stores.values.flat_map(&:accessors).empty?
+
+          root.path(constant) do |k|
+            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)
+              end
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActiveRecord::Base.descendants.select do |klass|
+            klass.include?(ActiveRecord::TypedStore::Behavior)
+          end
+        end
+
+        private
+
+        TYPES = T.let({
+          boolean: "T::Boolean",
+          integer: "Integer",
+          string: "String",
+          float: "Float",
+          date: "Date",
+          time: "Time",
+          datetime: "DateTime",
+          decimal: "BigDecimal",
+          any: "T.untyped",
+        }.freeze, T::Hash[Symbol, String])
+
+        sig { params(attr_type: Symbol).returns(String) }
+        def type_for(attr_type)
+          TYPES.fetch(attr_type, "T.untyped")
+        end
+
+        sig do
+          params(
+            name: String,
+            type: String,
+            klass: Parlour::RbiGenerator::Namespace
+          )
+            .void
+        end
+        def generate_methods(name, type, klass)
+          klass.create_method(
+            "#{name}=",
+            parameters: [Parlour::RbiGenerator::Parameter.new(name, type: type)],
+            return_type: type
+          )
+          klass.create_method(name, return_type: type)
+          klass.create_method("#{name}?", return_type: "T::Boolean")
+          klass.create_method("#{name}_was", return_type: type)
+          klass.create_method("#{name}_changed?", return_type: "T::Boolean")
+          klass.create_method("#{name}_before_last_save", return_type: type)
+          klass.create_method("saved_change_to_#{name}?", return_type: "T::Boolean")
+          klass.create_method("#{name}_change", return_type: "T.nilable([#{type}, #{type}])")
+          klass.create_method("saved_change_to_#{name}", return_type: "T.nilable([#{type}, #{type}])")
+        end
+      end
+    end
+  end
+end