tapioca 0.14.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7488dd17c4950978384fa4da4908f6e2f7ad0ad87266a018044e21d565f704aa
-  data.tar.gz: 572b9cb88a228d86c46b36c3bb1b938781dfaf528301c1c0a61e0e3258e5b65a
+  metadata.gz: f93b130a7096e0712ccd91b8406d92ce537287afafc8aad7586e7f670d88a131
+  data.tar.gz: b2cc1e6d2658002600c1edd9c5c88b22704e3f4170ff19aff93bb9fc21df688e
 SHA512:
-  metadata.gz: 1565590d51799b64e7bf57a4d4d25bfe5e20d1455345183412773be5eb5c4f3c7bfecca49438aa2ce67283d1260695d2f072303a5951d7daa1540bd3d4f8ef5c
-  data.tar.gz: 00e81fc94389204d15f54e0eb469ca1da367d3b69fedd73e2146f2b0a768d3928848decc94c52fd212e7405d7e8d177571de8e92986090c07ba694c030ae7e66
+  metadata.gz: aa10ff7ffd4768cea802b63dc68273fa0abf7f69b61a83b1325669e97d706cb8afcc704093c93596a830662fe04b01ad2ded3c166abd69a5c69097bd28f586c9
+  data.tar.gz: 63499428de9374990372beb46ece3f98d0f446ba28ef02bfa181179113e37e587ff9867bbe0d729d67c03ddb2813943f6f04d14f2065589a603a766a06ce8096

data/README.md

@@ -47,6 +47,7 @@ Tapioca makes it easy to work with [Sorbet](https://sorbet.org) in your codebase
     * [Changing the typed strictness of annotations files](#changing-the-typed-strictness-of-annotations-files)
   * [Generating RBI files for Rails and other DSLs](#generating-rbi-files-for-rails-and-other-dsls)
     * [Keeping RBI files for DSLs up-to-date](#keeping-rbi-files-for-dsls-up-to-date)
+    * [Using DSL compiler options](#using-dsl-compiler-options)
     * [Writing custom DSL compilers](#writing-custom-dsl-compilers)
     * [Writing custom DSL extensions](#writing-custom-dsl-extensions)
   * [RBI files for missing constants and methods](#rbi-files-for-missing-constants-and-methods)
@@ -501,6 +502,7 @@ Options:
              [--halt-upon-load-error], [--no-halt-upon-load-error], [--skip-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
                                                                                                    # Default: true
              [--skip-constant=constant [constant ...]]                                             # Do not generate RBI definitions for the given application constant(s)
+             [--compiler-options=key:value]                                                        # Options to pass to the DSL compilers
   -c,        [--config=<config file path>]                                                         # Path to the Tapioca configuration file
                                                                                                    # Default: sorbet/tapioca/config.yml
   -V,        [--verbose], [--no-verbose], [--skip-verbose]                                         # Verbose output for debugging purposes
@@ -545,6 +547,25 @@ if Rails.env.development?
   end
 ```
 
+#### Using DSL compiler options
+
+Some DSL compilers are able to change their behaviour based on the options passed to them. For example, the
+`ActiveRecordColumns` compiler can be configured to change how it generates types for method related to Active Record
+column attributes. To pass options during DSL RBI generation, use the `--compiler-options` flag:
+```shell
+$ bin/tapioca dsl --compiler-options=ActiveRecordColumnTypes:untyped
+```
+which will make the `ActiveRecordColumns` compiler generate untyped signatures for column attribute methods.
+
+Compiler options can be passed through the configuration file, as like any other option, and we expect most users to
+configure them this way. For example, to configure the `ActiveRecordColumns` compiler to generate untyped signatures,
+you need to add the following to your `sorbet/tapioca/config.yml` file:
+```yaml
+dsl:
+  compiler_options:
+    ActiveRecordColumnTypes: untyped
+```
+
 #### Writing custom DSL compilers
 
 It is possible to create your own compilers for DSLs not supported by Tapioca out of the box.
@@ -935,6 +956,7 @@ dsl:
   app_root: "."
   halt_upon_load_error: true
   skip_constant: []
+  compiler_options: {}
 gem:
   outdir: sorbet/rbi/gems
   file_header: true

data/lib/tapioca/cli.rb

@@ -140,6 +140,10 @@ module Tapioca
       banner: "constant [constant ...]",
       desc: "Do not generate RBI definitions for the given application constant(s)",
       default: []
+    option :compiler_options,
+      type: :hash,
+      desc: "Options to pass to the DSL compilers",
+      default: {}
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -161,6 +165,7 @@ module Tapioca
         rbi_formatter: rbi_formatter(options),
         app_root: options[:app_root],
         halt_upon_load_error: options[:halt_upon_load_error],
+        compiler_options: options[:compiler_options],
       }
 
       command = if options[:verify]

data/lib/tapioca/commands/abstract_dsl.rb

@@ -27,6 +27,7 @@ module Tapioca
           rbi_formatter: RBIFormatter,
           app_root: String,
           halt_upon_load_error: T::Boolean,
+          compiler_options: T::Hash[String, T.untyped],
         ).void
       end
       def initialize(
@@ -45,7 +46,8 @@ module Tapioca
         gem_dir: DEFAULT_GEM_DIR,
         rbi_formatter: DEFAULT_RBI_FORMATTER,
         app_root: ".",
-        halt_upon_load_error: true
+        halt_upon_load_error: true,
+        compiler_options: {}
       )
         @requested_constants = requested_constants
         @requested_paths = requested_paths
@@ -63,6 +65,7 @@ module Tapioca
         @app_root = app_root
         @halt_upon_load_error = halt_upon_load_error
         @skip_constant = skip_constant
+        @compiler_options = compiler_options
 
         super()
       end
@@ -129,6 +132,7 @@ module Tapioca
           },
           skipped_constants: constantize(@skip_constant, ignore_missing: true),
           number_of_workers: @number_of_workers,
+          compiler_options: @compiler_options,
         )
       end
 

data/lib/tapioca/commands/annotations.rb

@@ -46,22 +46,22 @@ module Tapioca
         GitAttributes.create_vendored_attribute_file(@outpath)
       end
 
-      sig { returns(T::Array[String]) }
+      sig { returns(T::Array[GemInfo]) }
       def list_gemfile_gems
         say("Listing gems from Gemfile.lock... ", [:blue, :bold])
         gemfile = Bundler.read_file("Gemfile.lock")
         parser = Bundler::LockfileParser.new(gemfile)
-        gem_names = parser.specs.map(&:name)
+        gem_info = parser.specs.map { |spec| GemInfo.from_spec(spec) }
         say("Done", :green)
-        gem_names
+        gem_info
       end
 
-      sig { params(project_gems: T::Array[String]).void }
+      sig { params(project_gems: T::Array[GemInfo]).void }
       def remove_expired_annotations(project_gems)
         say("Removing annotations for gems that have been removed... ", [:blue, :bold])
 
         annotations = Pathname.glob(@outpath.join("*.rbi")).map { |f| f.basename(".*").to_s }
-        expired = annotations - project_gems
+        expired = annotations - project_gems.map(&:name)
 
         if expired.empty?
           say(" Nothing to do")
@@ -109,14 +109,14 @@ module Tapioca
         index
       end
 
-      sig { params(gem_names: T::Array[String]).returns(T::Array[String]) }
-      def fetch_annotations(gem_names)
+      sig { params(project_gems: T::Array[GemInfo]).returns(T::Array[String]) }
+      def fetch_annotations(project_gems)
         say("Fetching gem annotations from central repository... ", [:blue, :bold])
-        fetchable_gems = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
+        fetchable_gems = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[GemInfo, T::Array[String]])
 
-        gem_names.each_with_object(fetchable_gems) do |gem_name, hash|
+        project_gems.each_with_object(fetchable_gems) do |gem_info, hash|
           @indexes.each do |uri, index|
-            T.must(hash[gem_name]) << uri if index.has_gem?(gem_name)
+            T.must(hash[gem_info]) << uri if index.has_gem?(gem_info.name)
           end
         end
 
@@ -127,13 +127,16 @@ module Tapioca
         end
 
         say("\n")
-        fetched_gems = fetchable_gems.select { |gem_name, repo_uris| fetch_annotation(repo_uris, gem_name) }
+        fetched_gems = fetchable_gems.select { |gem_info, repo_uris| fetch_annotation(repo_uris, gem_info) }
         say("\nDone", :green)
-        fetched_gems.keys.sort
+        fetched_gems.keys.map(&:name).sort
       end
 
-      sig { params(repo_uris: T::Array[String], gem_name: String).void }
-      def fetch_annotation(repo_uris, gem_name)
+      sig { params(repo_uris: T::Array[String], gem_info: GemInfo).void }
+      def fetch_annotation(repo_uris, gem_info)
+        gem_name = gem_info.name
+        gem_version = gem_info.version
+
         contents = repo_uris.map do |repo_uri|
           fetch_file(repo_uri, "#{CENTRAL_REPO_ANNOTATIONS_DIR}/#{gem_name}.rbi")
         end
@@ -142,6 +145,7 @@ module Tapioca
         return unless content
 
         content = apply_typed_override(gem_name, content)
+        content = filter_versions(gem_version, content)
         content = add_header(gem_name, content)
 
         say("\n  Fetched #{set_color(gem_name, :yellow, :bold)}", :green)
@@ -221,6 +225,14 @@ module Tapioca
         Spoom::Sorbet::Sigils.update_sigil(content, strictness)
       end
 
+      sig { params(gem_version: ::Gem::Version, content: String).returns(String) }
+      def filter_versions(gem_version, content)
+        rbi = RBI::Parser.parse_string(content)
+        rbi.filter_versions!(gem_version)
+
+        rbi.string
+      end
+
       sig { params(gem_name: String, contents: T::Array[String]).returns(T.nilable(String)) }
       def merge_files(gem_name, contents)
         return if contents.empty?

data/lib/tapioca/dsl/compiler.rb

@@ -22,6 +22,9 @@ module Tapioca
       sig { returns(RBI::Tree) }
       attr_reader :root
 
+      sig { returns(T::Hash[String, T.untyped]) }
+      attr_reader :options
+
       class << self
         extend T::Sig
 
@@ -60,11 +63,19 @@ module Tapioca
         end
       end
 
-      sig { params(pipeline: Tapioca::Dsl::Pipeline, root: RBI::Tree, constant: ConstantType).void }
-      def initialize(pipeline, root, constant)
+      sig do
+        params(
+          pipeline: Tapioca::Dsl::Pipeline,
+          root: RBI::Tree,
+          constant: ConstantType,
+          options: T::Hash[String, T.untyped],
+        ).void
+      end
+      def initialize(pipeline, root, constant, options = {})
         @pipeline = pipeline
         @root = root
         @constant = constant
+        @options = options
         @errors = T.let([], T::Array[String])
       end
 

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

@@ -15,6 +15,21 @@ module Tapioca
       # created for columns and virtual attributes that are defined in the Active Record
       # model.
       #
+      # This compiler accepts a `ActiveRecordColumnTypes` option that can be used to specify
+      # how the types of the column related methods should be generated. The option can be one of the following:
+      #  - `persisted` (_default_): The methods will be generated with the type that matches the actual database
+      #  column type as the return type. This means that if the column is a string, the method return type
+      #  will be `String`, but if the column is also nullable, then the return type will be `T.nilable(String)`. This
+      #  mode basically treats each model as if it was a valid and persisted model. Note that this makes typing
+      #  Active Record models easier, but does not match the behaviour of non-persisted or invalid models, which can
+      #  have all kinds of non-sensical values in their column attributes.
+      #  - `nilable`: All column methods will be generated with `T.nilable` return types. This is strictly the most
+      #  correct way to type the methods, but it can make working with the models more cumbersome, as you will have to
+      #  handle the `nil` cases explicitly using `T.must` or the safe navigation operator `&.`, even for valid
+      #  persisted models.
+      #  - `untyped`: The methods will be generated with `T.untyped` return types. This mode is practical if you are not
+      #  ready to start typing your models strictly yet, but still want to generate RBI files for them.
+      #
       # For example, with the following model class:
       # ~~~rb
       # class Post < ActiveRecord::Base
@@ -33,7 +48,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this compiler will produce the following methods in the RBI file
+      # this compiler will, by default, produce the following methods in the RBI file
       # `post.rbi`:
       #
       # ~~~rbi
@@ -94,6 +109,17 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #
+      # However, if `ActiveRecordColumnTypes` is set to `nilable`, the `title` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
+      # ~~~
+      # and if the option is set to `untyped`, the `title` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(T.untyped) }
+      #     def title; end
+      # ~~~
       class ActiveRecordColumns < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
@@ -147,6 +173,21 @@ module Tapioca
 
         private
 
+        ColumnTypeOption = Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption
+
+        sig { returns(ColumnTypeOption) }
+        def column_type_option
+          @column_type_option ||= T.let(
+            ColumnTypeOption.from_options(options) do |value, default_column_type_option|
+              add_error(<<~MSG.strip)
+                Unknown value for compiler option `ActiveRecordColumnTypes` given: `#{value}`.
+                Proceeding with the default value: `#{default_column_type_option.serialize}`.
+              MSG
+            end,
+            T.nilable(ColumnTypeOption),
+          )
+        end
+
         sig do
           params(
             klass: RBI::Scope,
@@ -174,7 +215,7 @@ module Tapioca
         end
         def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
           getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper
-            .new(constant)
+            .new(constant, column_type_option: column_type_option)
             .type_for(attribute_name, column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read

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

@@ -37,6 +37,7 @@ module Tapioca
         extend T::Sig
 
         ConstantType = type_member { { fixed: T.class_of(ActiveSupport::TestCase) } }
+        MISSING = Object.new
 
         sig { override.void }
         def decorate
@@ -46,6 +47,7 @@ module Tapioca
             method_names_from_eager_fixture_loader
           end
 
+          method_names.select! { |name| fixture_class_mapping_from_fixture_files[name] != MISSING }
           return if method_names.empty?
 
           root.create_path(constant) do |mod|
@@ -96,15 +98,14 @@ module Tapioca
           T.unsafe(fixture_loader).fixture_sets.keys
         end
 
-        sig { returns(T::Array[Symbol]) }
+        sig { returns(T::Array[String]) }
         def method_names_from_eager_fixture_loader
           fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
             .drop(1) # drop the anonymous class itself from the array
             .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
-            .map! do |mod|
-              [mod.private_instance_methods(false), mod.instance_methods(false)]
+            .flat_map do |mod|
+              mod.private_instance_methods(false).map(&:to_s) + mod.instance_methods(false).map(&:to_s)
             end
-            .flatten # merge methods into a single list
         end
 
         sig { params(mod: RBI::Scope, name: String).void }
@@ -190,10 +191,14 @@ module Tapioca
                   next unless ::File.file?(file)
 
                   ActiveRecord::FixtureSet::File.open(file) do |fh|
+                    fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
                     next unless fh.model_class
 
-                    fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
                     mapping[fixture_name] = fh.model_class
+                  rescue ActiveRecord::Fixture::FormatError
+                    # For fixtures that are not associated to any models and just contain raw data or fixtures that
+                    # contain invalid formatting, we want to skip them and avoid crashing
+                    mapping[fixture_name] = MISSING
                   end
                 end
               end

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

@@ -190,7 +190,7 @@ module Tapioca
             # Grab all Spawn methods
             query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
             # Remove the ones we know are private API
-            query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+            query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
             # Remove "group" which needs a custom return type for GroupChains
             query_methods -= [:group]
             # Remove "where" which needs a custom return type for WhereChains

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

@@ -98,8 +98,7 @@ module Tapioca
             stores.values.each do |store_data|
               store_data.accessors.each do |accessor, name|
                 field = store_data.fields.fetch(accessor)
-                type = type_for(field.type_sym)
-                type = as_nilable_type(type) if field.null
+                type = type_for(field)
                 name ||= field.name # support < 1.5.0
 
                 generate_methods(store_accessors_module, name.to_s, type)
@@ -136,9 +135,23 @@ module Tapioca
           T::Hash[Symbol, String],
         )
 
-        sig { params(attr_type: Symbol).returns(String) }
-        def type_for(attr_type)
-          TYPES.fetch(attr_type, "T.untyped")
+        sig { params(field: ActiveRecord::TypedStore::Field).returns(String) }
+        def type_for(field)
+          type = TYPES.fetch(field.type_sym, "T.untyped")
+
+          type = if field.array
+            # `null: false` applies to the array itself, not the elements, which are always nilable.
+            # https://github.com/byroot/activerecord-typedstore/blob/2f3fb98/spec/support/models.rb#L46C34-L46C45
+            # https://github.com/byroot/activerecord-typedstore/blob/2f3fb98/spec/active_record/typed_store_spec.rb#L854-L857
+            nilable_element_type = as_nilable_type(type)
+            "T::Array[#{nilable_element_type}]"
+          else
+            type
+          end
+
+          type = as_nilable_type(type) if field.null
+
+          type
         end
 
         sig do

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

@@ -49,7 +49,7 @@ module Tapioca
           mixed_in_class_methods = dependencies
             .uniq # Deduplicate
             .filter_map do |concern| # Map to class methods module name, if exists
-              "#{qualified_name_of(concern)}::ClassMethods" if concern.const_defined?(:ClassMethods)
+              "#{qualified_name_of(concern)}::ClassMethods" if concern.const_defined?(:ClassMethods, false)
             end
 
           return if mixed_in_class_methods.empty?

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

@@ -216,7 +216,10 @@ module Tapioca
           ).void
         end
         def create_aliased_fetch_by_methods(field, klass)
-          type, _ = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(field.alias_name.to_s)
+          type, _ = Helpers::ActiveRecordColumnTypeHelper.new(
+            constant,
+            column_type_option: Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption::Nilable,
+          ).type_for(field.alias_name.to_s)
           multi_type = type.delete_prefix("T.nilable(").delete_suffix(")").delete_prefix("::")
           suffix = field.send(:fetch_method_suffix)
 
@@ -228,7 +231,7 @@ module Tapioca
             "fetch_#{suffix}",
             class_method: true,
             parameters: parameters,
-            return_type: type,
+            return_type: field.unique ? type : COLLECTION_TYPE.call(type),
           )
 
           klass.create_method(

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

@@ -29,7 +29,7 @@ module Tapioca
       # ~~~rbi
       # # cart.rbi
       # # typed: strong
-      # class Cart
+      # class Cart < Google::Protobuf::AbstractMessage
       #   sig { returns(Integer) }
       #   def customer_id; end
       #
@@ -123,6 +123,9 @@ module Tapioca
                   class_method: true,
                 )
               when Google::Protobuf::Descriptor
+                raise "#{klass} is not a RBI::Class" unless klass.is_a?(RBI::Class)
+
+                klass.superclass_name = "Google::Protobuf::AbstractMessage"
                 descriptor.each_oneof { |oneof| create_oneof_method(klass, oneof) }
                 fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
                 fields.sort_by!(&:name)

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -10,12 +10,73 @@ module Tapioca
         extend T::Sig
         include RBIHelper
 
-        sig { params(constant: T.class_of(ActiveRecord::Base)).void }
-        def initialize(constant)
+        class ColumnTypeOption < T::Enum
+          extend T::Sig
+
+          enums do
+            Untyped = new("untyped")
+            Nilable = new("nilable")
+            Persisted = new("persisted")
+          end
+
+          class << self
+            extend T::Sig
+
+            sig do
+              params(
+                options: T::Hash[String, T.untyped],
+                block: T.proc.params(value: String, default_column_type_option: ColumnTypeOption).void,
+              ).returns(ColumnTypeOption)
+            end
+            def from_options(options, &block)
+              column_type_option = Persisted
+              value = options["ActiveRecordColumnTypes"]
+
+              if value
+                if has_serialized?(value)
+                  column_type_option = from_serialized(value)
+                else
+                  block.call(value, column_type_option)
+                end
+              end
+
+              column_type_option
+            end
+          end
+
+          sig { returns(T::Boolean) }
+          def persisted?
+            self == ColumnTypeOption::Persisted
+          end
+
+          sig { returns(T::Boolean) }
+          def nilable?
+            self == ColumnTypeOption::Nilable
+          end
+
+          sig { returns(T::Boolean) }
+          def untyped?
+            self == ColumnTypeOption::Untyped
+          end
+        end
+
+        sig do
+          params(
+            constant: T.class_of(ActiveRecord::Base),
+            column_type_option: ColumnTypeOption,
+          ).void
+        end
+        def initialize(constant, column_type_option: ColumnTypeOption::Persisted)
           @constant = constant
+          @column_type_option = column_type_option
         end
 
-        sig { params(attribute_name: String, column_name: String).returns([String, String]) }
+        sig do
+          params(
+            attribute_name: String,
+            column_name: String,
+          ).returns([String, String])
+        end
         def type_for(attribute_name, column_name = attribute_name)
           return id_type if attribute_name == "id"
 
@@ -27,7 +88,11 @@ module Tapioca
         sig { returns([String, String]) }
         def id_type
           if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
-            @constant.primary_key.map(&method(:column_type_for)).map { |tuple| "[#{tuple.join(", ")}]" }
+            @constant.primary_key.map do |column|
+              column_type_for(column)
+            end.map do |tuple|
+              "[#{tuple.join(", ")}]"
+            end
           else
             column_type_for(@constant.primary_key)
           end
@@ -35,7 +100,7 @@ module Tapioca
 
         sig { params(column_name: String).returns([String, String]) }
         def column_type_for(column_name)
-          return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(@constant)
+          return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
 
           column = @constant.columns_hash[column_name]
           column_type = @constant.attribute_types[column_name]
@@ -48,28 +113,24 @@ module Tapioca
               getter_type
             end
 
-          if column&.null
+          if @column_type_option.persisted? && !column&.null
+            [getter_type, setter_type]
+          else
             getter_type = as_nilable_type(getter_type) unless not_nilable_serialized_column?(column_type)
-            return [getter_type, as_nilable_type(setter_type)]
-          end
-
-          if Array(@constant.primary_key).include?(column_name) ||
-              column_name == "created_at" ||
-              column_name == "updated_at"
-            getter_type = as_nilable_type(getter_type)
+            [getter_type, as_nilable_type(setter_type)]
           end
-
-          [getter_type, setter_type]
         end
 
         sig { params(column_type: T.untyped).returns(String) }
         def type_for_activerecord_value(column_type)
           case column_type
-          when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+          when ->(type) { defined?(MoneyColumn) && MoneyColumn::ActiveRecordType === type }
             "::Money"
           when ActiveRecord::Type::Integer
             "::Integer"
-          when ActiveRecord::Encryption::EncryptedAttributeType
+          when ->(type) {
+                 defined?(ActiveRecord::Encryption) && ActiveRecord::Encryption::EncryptedAttributeType === type
+               }
             # Reflect to see if `ActiveModel::Type::Value` is being used first.
             getter_type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(column_type)
             return getter_type unless getter_type == "T.untyped"
@@ -95,32 +156,36 @@ module Tapioca
             "::String"
           when ActiveRecord::Type::Serialized
             serialized_column_type(column_type)
-          when defined?(ActiveRecord::Normalization::NormalizedValueType) &&
-            ActiveRecord::Normalization::NormalizedValueType
+          when ->(type) {
+                 defined?(ActiveRecord::Normalization::NormalizedValueType) &&
+                   ActiveRecord::Normalization::NormalizedValueType === type
+               }
             type_for_activerecord_value(column_type.cast_type)
-          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid) &&
-            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid === type
+               }
             "::String"
-          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr) &&
-            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr === type
+               }
             "::IPAddr"
-          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) &&
-            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore === type
+               }
             "T::Hash[::String, ::String]"
-          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) &&
-            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array === type
+               }
             "T::Array[#{type_for_activerecord_value(column_type.subtype)}]"
           else
             ActiveModelTypeHelper.type_for(column_type)
           end
         end
 
-        sig { params(constant: Module).returns(T::Boolean) }
-        def do_not_generate_strong_types?(constant)
-          Object.const_defined?(:StrongTypeGeneration) &&
-            !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
-        end
-
         sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
         def enum_setter_type(column_type)
           # In Rails < 7 this method is private. When support for that is dropped we can call the method directly

data/lib/tapioca/dsl/pipeline.rb

@@ -33,6 +33,7 @@ module Tapioca
           error_handler: T.proc.params(error: String).void,
           skipped_constants: T::Array[Module],
           number_of_workers: T.nilable(Integer),
+          compiler_options: T::Hash[String, T.untyped],
         ).void
       end
       def initialize(
@@ -42,7 +43,8 @@ module Tapioca
         excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
         skipped_constants: [],
-        number_of_workers: nil
+        number_of_workers: nil,
+        compiler_options: {}
       )
         @active_compilers = T.let(
           gather_active_compilers(requested_compilers, excluded_compilers),
@@ -53,6 +55,7 @@ module Tapioca
         @error_handler = error_handler
         @skipped_constants = skipped_constants
         @number_of_workers = number_of_workers
+        @compiler_options = compiler_options
         @errors = T.let([], T::Array[String])
       end
 
@@ -197,7 +200,7 @@ module Tapioca
         active_compilers.each do |compiler_class|
           next unless compiler_class.handles?(constant)
 
-          compiler = compiler_class.new(self, file.root, constant)
+          compiler = compiler_class.new(self, file.root, constant, @compiler_options)
           compiler.decorate
         rescue
           $stderr.puts("Error: `#{compiler_class.name}` failed to generate RBI for `#{constant}`")

data/lib/tapioca/gem_info.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  class GemInfo < T::Struct
+    const :name, String
+    const :version, ::Gem::Version
+
+    class << self
+      extend(T::Sig)
+
+      sig { params(spec: Bundler::LazySpecification).returns(GemInfo) }
+      def from_spec(spec)
+        new(name: spec.name, version: spec.version)
+      end
+    end
+  end
+end

data/lib/tapioca/helpers/config_helper.rb

@@ -132,7 +132,9 @@ module Tapioca
         when :hash
           error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
             "`Hash[String, String]` but found `#{config_option_value}`"
-          all_strings = (config_option_value.keys + config_option_value.values).all? { |v| v.is_a?(String) }
+          values_to_validate = config_option_value.keys
+          values_to_validate += config_option_value.values
+          all_strings = values_to_validate.all? { |v| v.is_a?(String) }
           next build_error(error_msg) unless all_strings
         end
       end

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -29,9 +29,14 @@ module Tapioca
           context.activate_other_dsl_compilers(compiler_classes)
         end
 
-        sig { params(constant_name: T.any(Symbol, String)).returns(String) }
-        def rbi_for(constant_name)
-          context.rbi_for(constant_name)
+        sig do
+          params(
+            constant_name: T.any(Symbol, String),
+            compiler_options: T::Hash[Symbol, T.untyped],
+          ).returns(String)
+        end
+        def rbi_for(constant_name, compiler_options: {})
+          context.rbi_for(constant_name, compiler_options: compiler_options)
         end
 
         sig { returns(T::Array[String]) }
@@ -85,8 +90,13 @@ module Tapioca
             compiler_class.processable_constants.filter_map(&:name).sort
           end
 
-          sig { params(constant_name: T.any(Symbol, String)).returns(String) }
-          def rbi_for(constant_name)
+          sig do
+            params(
+              constant_name: T.any(Symbol, String),
+              compiler_options: T::Hash[Symbol, T.untyped],
+            ).returns(String)
+          end
+          def rbi_for(constant_name, compiler_options: {})
             # Make sure this is a constant that we can handle.
             unless gathered_constants.include?(constant_name.to_s)
               raise "`#{constant_name}` is not processable by the `#{compiler_class}` compiler."
@@ -95,7 +105,7 @@ module Tapioca
             file = RBI::File.new(strictness: "strong")
             constant = Object.const_get(constant_name)
 
-            compiler = compiler_class.new(pipeline, file.root, constant)
+            compiler = compiler_class.new(pipeline, file.root, constant, compiler_options.transform_keys(&:to_s))
             compiler.decorate
 
             rbi = Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)

data/lib/tapioca/internal.rb

@@ -45,6 +45,7 @@ require "tapioca/helpers/env_helper"
 
 require "tapioca/repo_index"
 require "tapioca/gemfile"
+require "tapioca/gem_info"
 require "tapioca/executor"
 
 require "tapioca/static/symbol_table_parser"

data/lib/tapioca/static/symbol_loader.rb

@@ -22,7 +22,7 @@ module Tapioca
         sig { params(gem: Gemfile::GemSpec).returns(T::Set[String]) }
         def engine_symbols(gem)
           gem_engine = engines.find do |engine|
-            gem.contains_path?(engine.config.root.to_s)
+            gem.full_gem_path == engine.config.root.to_s
           end
 
           return Set.new unless gem_engine

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.14.3"
+  VERSION = "0.15.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.14.3
+  version: 0.15.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-30 00:00:00.000000000 Z
+date: 2024-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -228,6 +228,7 @@ files:
 - lib/tapioca/gem/listeners/subconstants.rb
 - lib/tapioca/gem/listeners/yard_doc.rb
 - lib/tapioca/gem/pipeline.rb
+- lib/tapioca/gem_info.rb
 - lib/tapioca/gemfile.rb
 - lib/tapioca/helpers/cli_helper.rb
 - lib/tapioca/helpers/config_helper.rb
@@ -288,7 +289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.5.13
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard