tapioca 0.4.2 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46bdcc628673ddc597495e267b471e3a6f4c705b8f8d8d32dffba17c69470c21
-  data.tar.gz: 4a2e597d03ea9354835e73f52034d088b1c15ac65f445d0f6963bbbca09c2b23
+  metadata.gz: a2ebe6488f101318e156ba0025de299975fce0d348f05ae9cd7bd38cf77ffe28
+  data.tar.gz: 3e22db95ccff12b1915f7f783e5669400cb5381078c49f370565da655459d62b
 SHA512:
-  metadata.gz: 51c134a7948c262721672f61105e08e1e31146b70d982fac0944b0d42be91d5e2210a110775596d11704e60eac68d6b2e27c016587777c658fab2b64131f7a1e
-  data.tar.gz: 1f048066d59bc2cc08a62fb93de96afdb7146d8e1c987c2a98677edd4920b08896096f9beaa658466ebd54be729c2bf6947ef1c409ab7329dac5ac27f7847dbc
+  metadata.gz: cb2d0ac2308cd8c44159a737e92090965dfa0ec616aaf83a6ad4b3cea69348bb12d61ecdce7f527db78d75c129fec19e765845ea475c375a74efcc240e1d2f25
+  data.tar.gz: d4c98b1c97946544c1032f13e920e77a1a62d61ad00e4f6522bef129690b68d2db07d7c08af74f9f7a245c3a771299534fa4a1cf2d464deaf03821e9180b73f6

data/Gemfile

@@ -11,6 +11,7 @@ group(:deployment, :development) do
 end
 
 gem("bundler", "~> 1.17")
+gem("yard", "~> 0.9.25")
 gem("pry-byebug")
 gem("minitest")
 gem("minitest-hooks")
@@ -33,3 +34,5 @@ group(:development, :test) do
   gem("activeresource", "~> 5.1", require: false)
   gem("google-protobuf", "~>3.12.0", require: false)
 end
+
+gem "rubocop-sorbet", ">= 0.4.1"

data/README.md

@@ -97,6 +97,12 @@ Command: `tapioca todo`
 
 This will generate the file `sorbet/rbi/todo.rbi` defining all unresolved constants as empty modules.
 
+### Generate DSL RBI files
+
+Command: `tapioca dsl [constant...]`
+
+This will generate DSL RBIs for specified constants (or for all handled constants, if a constant name is not supplied). You can read about DSL RBI generators supplied by `tapioca` in [the manual](manual/generators.md).
+
 ### Flags
 
 - `--prerequire [file]`: A file to be required before `Bundler.require` is called.
@@ -105,10 +111,6 @@ This will generate the file `sorbet/rbi/todo.rbi` defining all unresolved consta
 - `--generate-command [command]`: The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
 - `--typed-overrides [gem:level]`: Overrides typed sigils for generated gem RBIs for gem `gem` to level `level` (`level` can be one of `ignore`, `false`, `true`, `strict`, or `strong`, see [the Sorbet docs](https://sorbet.org/docs/static#file-level-granularity-strictness-levels) for more details).
 
-### Strong typing option for ActiveRecord column methods
-
-`tapioca` gives you the option to generate stricter type signatures for your ActiveRecord column types. By default, methods generated for columns that are defined in the schema have signatures of T.untyped. However, if the object extends a module with name StrongTypeGeneration, tapioca will generate stricter signatures that follow closely with the types defined in the schema. Expectation is the StrongTypeGeneration module you define in your application won't allow objects to be initialized with "bad state". It will check all the attributes that are not nillable to ensure they are not nil.
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/tapioca. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://github.com/Shopify/tapioca/blob/master/CODE_OF_CONDUCT.md) code of conduct.

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
+Dir['tasks/**/*.rake'].each { |t| load t }
 
 Rake.application.options.trace = false
 

data/lib/tapioca.rb

@@ -4,10 +4,12 @@
 require "sorbet-runtime"
 
 module Tapioca
-  def self.silence_warnings
+  def self.silence_warnings(&blk)
     original_verbosity = $VERBOSE
     $VERBOSE = nil
-    yield
+    Gem::DefaultUserInteraction.use_ui(Gem::SilentUI.new) do
+      blk.call
+    end
   ensure
     $VERBOSE = original_verbosity
   end

data/lib/tapioca/cli.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'thor'
 
@@ -34,6 +34,8 @@ module Tapioca
                   banner: "gem:level [gem:level ...]",
                   desc: "Overrides for typed sigils for generated gem RBIs"
 
+    map T.unsafe(%w[--version -v] => :__print_version)
+
     desc "init", "initializes folder structure"
     def init
       create_file(Config::SORBET_CONFIG, skip: true) do
@@ -44,8 +46,8 @@ module Tapioca
       end
       create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
         <<~CONTENT
-          # frozen_string_literal: true
           # typed: false
+          # frozen_string_literal: true
 
           # Add your extra requires here
         CONTENT
@@ -92,6 +94,11 @@ module Tapioca
       end
     end
 
+    desc "--version, -v", "show version"
+    def __print_version
+      puts "Tapioca v#{Tapioca::VERSION}"
+    end
+
     no_commands do
       def self.exit_on_failure?
         true

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

@@ -42,6 +42,7 @@ module Tapioca
       #     # ...
       #   end
       # end
+      # ~~~
       #
       # this generator will produce an RBI file `user_controller.rbi` with the following content:
       #

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

@@ -45,10 +45,10 @@ module Tapioca
       #   sig { params(value: T.nilable(::User)).void }
       #   def author=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
       #   def build_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
       #   def build_category(*args, &blk); end
       #
       #   sig { returns(T.nilable(::Category)) }
@@ -69,16 +69,16 @@ module Tapioca
       #   sig { params(value: T::Enumerable[::Comment]).void }
       #   def comments=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
       #   def create_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
       #   def create_author!(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
       #   def create_category(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
       #   def create_category!(*args, &blk); end
       #
       #   sig { returns(T.nilable(::User)) }
@@ -132,11 +132,7 @@ module Tapioca
         end
         def populate_single_assoc_getter_setter(klass, constant, association_name, reflection)
           association_class = type_for(constant, reflection)
-          association_type = if belongs_to_and_required?(constant, reflection)
-            association_class
-          else
-            "T.nilable(#{association_class})"
-          end
+          association_type = "T.nilable(#{association_class})"
 
           create_method(
             klass,
@@ -164,7 +160,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
             create_method(
               klass,
@@ -173,7 +169,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
             create_method(
               klass,
@@ -182,7 +178,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
           end
         end
@@ -227,20 +223,6 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            constant: T.class_of(ActiveRecord::Base),
-            reflection: ReflectionType
-          ).returns(T::Boolean)
-        end
-        def belongs_to_and_required?(constant, reflection)
-          return false unless constant.table_exists?
-          return false unless reflection.belongs_to?
-          column_definition = constant.columns_hash[reflection.foreign_key.to_s]
-
-          !column_definition.nil? && !column_definition.null
-        end
-
         sig do
           params(
             constant: T.class_of(ActiveRecord::Base),

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

@@ -17,6 +17,17 @@ module Tapioca
       # responsible for defining the attribute methods that would be created for the columns that
       # are defined in the Active Record model.
       #
+      # **Note:** This generator, by default, generates weak signatures for column methods and treats each
+      # column to be `T.untyped`. This is done on purpose to ensure that the nilability of Active Record
+      # columns do not make it hard for existing code to adopt gradual typing. It is possible, however, to
+      # generate stricter type signatures for your ActiveRecord column types. If your ActiveRecord model extends
+      # a module with name `StrongTypeGeneration`, this generator will generate stricter signatures that follow
+      # closely with the types defined in the schema.
+      #
+      # The `StrongTypeGeneration` module you define in your application should add an `after_initialize` callback
+      # to the model and ensure that all the non-nilable attributes of the model are actually initialized with non-`nil`
+      # values.
+      #
       # For example, with the following model class:
       #
       # ~~~rb
@@ -196,25 +207,25 @@ module Tapioca
             klass,
             "#{attribute_name}_before_last_save",
             methods_to_add,
-            return_type: getter_type
+            return_type: as_nilable_type(getter_type)
           )
           add_method(
             klass,
             "#{attribute_name}_change_to_be_saved",
             methods_to_add,
-            return_type: "[#{getter_type}, #{getter_type}]"
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])"
           )
           add_method(
             klass,
             "#{attribute_name}_in_database",
             methods_to_add,
-            return_type: getter_type
+            return_type: as_nilable_type(getter_type)
           )
           add_method(
             klass,
             "saved_change_to_#{attribute_name}",
             methods_to_add,
-            return_type: "[#{getter_type}, #{getter_type}]"
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])"
           )
           add_method(
             klass,
@@ -235,7 +246,7 @@ module Tapioca
             klass,
             "#{attribute_name}_change",
             methods_to_add,
-            return_type: "[#{getter_type}, #{getter_type}]"
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])"
           )
           add_method(
             klass,
@@ -252,13 +263,13 @@ module Tapioca
             klass,
             "#{attribute_name}_was",
             methods_to_add,
-            return_type: getter_type
+            return_type: as_nilable_type(getter_type)
           )
           add_method(
             klass,
             "#{attribute_name}_previous_change",
             methods_to_add,
-            return_type: "[#{getter_type}, #{getter_type}]"
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])"
           )
           add_method(
             klass,
@@ -270,7 +281,7 @@ module Tapioca
             klass,
             "#{attribute_name}_previously_was",
             methods_to_add,
-            return_type: getter_type
+            return_type: as_nilable_type(getter_type)
           )
           add_method(
             klass,
@@ -381,6 +392,12 @@ module Tapioca
 
           arg_type.to_s
         end
+
+        sig { params(type: String).returns(String) }
+        def as_nilable_type(type)
+          return type if type.start_with?("T.nilable(")
+          "T.nilable(#{type})"
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::DSL::ActiveRecordIdentityCache` generates RBI files for ActiveRecord models
-      #  that use `include IdentityCache`
+      #  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:
@@ -61,7 +61,6 @@ module Tapioca
       #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
       # end
       # ~~~
-
       class ActiveRecordIdentityCache < Base
         extend T::Sig
 
@@ -127,7 +126,7 @@ module Tapioca
           if returns_collection
             COLLECTION_TYPE.call(cache_type)
           else
-            "::#{cache_type}"
+            "T.nilable(::#{cache_type})"
           end
         rescue ArgumentError
           "T.untyped"

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

@@ -37,7 +37,7 @@ module Tapioca
       # 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

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

@@ -86,8 +86,6 @@ module Tapioca
       #   def saved_change_to_reviewed; end
       # end
       # ~~~
-      # end
-
       class ActiveRecordTypedStore < Base
         extend T::Sig
 

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

@@ -34,7 +34,7 @@ module Tapioca
       #     # ...
       #   end
       # end
-      # ~~~rb
+      # ~~~
       #
       # this generator will produce an RBI file with the following content:
       # ~~~rbi

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

@@ -12,19 +12,19 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::Protobuf` decorates RBI files for subclasses of
-      # `Google::Protobuf::MessageExts`.
-      # (see https://github.com/coinbase/protoc-gen-rbi).
+      # `Google::Protobuf::MessageExts` (see https://github.com/protocolbuffers/protobuf/tree/master/ruby).
       #
       # For example, with the following "cart.rb" file:
       #
       # ~~~rb
       # Google::Protobuf::DescriptorPool.generated_pool.build do
-      # add_file("cart.proto", :syntax => :proto3) do
-      #   add_message "MyCart" do
-      #     optional :shop_id, :int32, 1
-      #     optional :customer_id, :int64, 2
-      #     optional :number_value, :double, 3
-      #     optional :string_value, :string, 4
+      #   add_file("cart.proto", :syntax => :proto3) do
+      #     add_message "MyCart" do
+      #       optional :shop_id, :int32, 1
+      #       optional :customer_id, :int64, 2
+      #       optional :number_value, :double, 3
+      #       optional :string_value, :string, 4
+      #     end
       #   end
       # end
       # ~~~

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

@@ -6,6 +6,7 @@ require "parlour"
 begin
   require "rails"
   require "action_controller"
+  require "action_view"
 rescue LoadError
   return
 end
@@ -13,6 +14,74 @@ end
 module Tapioca
   module Compilers
     module Dsl
+      # `Tapioca::Compilers::Dsl::UrlHelpers` generates RBI files for classes that include or extend
+      # `Rails.application.routes.url_helpers`
+      # (see https://api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
+      #
+      # For example, with the following setup:
+      #
+      # ~~~rb
+      # # config/application.rb
+      # class Application < Rails::Application
+      #   routes.draw do
+      #     resource :index
+      #   end
+      # end
+      # ~~~
+      #
+      # ~~~rb
+      # app/models/post.rb
+      # class Post
+      #   include Rails.application.routes.url_helpers
+      # end
+      # ~~~
+      #
+      # this generator will produce the following RBI files:
+      #
+      # ~~~rbi
+      # # generated_path_helpers_module.rbi
+      # # typed: true
+      # module GeneratedPathHelpersModule
+      #   include ActionDispatch::Routing::PolymorphicRoutes
+      #   include ActionDispatch::Routing::UrlFor
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def edit_index_path(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def index_path(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def new_index_path(*args); end
+      # end
+      # ~~~
+      #
+      # ~~~rbi
+      # # generated_url_helpers_module.rbi
+      # # typed: true
+      # module GeneratedUrlHelpersModule
+      #   include ActionDispatch::Routing::PolymorphicRoutes
+      #   include ActionDispatch::Routing::UrlFor
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def edit_index_url(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def index_url(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def new_index_url(*args); end
+      # end
+      # ~~~
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include GeneratedPathHelpersModule
+      #   include GeneratedUrlHelpersModule
+      # end
+      # ~~~
       class UrlHelpers < Base
         extend T::Sig
 
@@ -29,13 +98,18 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[T.untyped]) }
+        NON_DISCOVERABLE_INCLUDERS = T.let([
+          ActionDispatch::IntegrationTest,
+          ActionView::Helpers,
+        ], T::Array[Module])
+
+        sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
           Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
           Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
 
-          constants = ObjectSpace.each_object(Module).select do |mod|
-            mod = T.cast(mod, T.class_of(Module))
+          module_enumerator = T.cast(ObjectSpace.each_object(Module), T::Enumerator[Module])
+          constants = module_enumerator.select do |mod|
             next unless Module.instance_method(:name).bind(mod).call
 
             includes_helper?(mod, GeneratedUrlHelpersModule) ||
@@ -44,7 +118,7 @@ module Tapioca
               includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
           end
 
-          constants << ActionDispatch::IntegrationTest
+          constants.concat(NON_DISCOVERABLE_INCLUDERS)
         end
 
         private
@@ -67,8 +141,11 @@ module Tapioca
 
         sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module), helper_module: Module).void }
         def create_mixins_for(mod, constant, helper_module)
-          mod.create_include(T.must(helper_module.name)) if constant.ancestors.include?(helper_module)
-          mod.create_extend(T.must(helper_module.name)) if constant.singleton_class.ancestors.include?(helper_module)
+          include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
+          extend_helper = constant.singleton_class.ancestors.include?(helper_module)
+
+          mod.create_include(T.must(helper_module.name)) if include_helper
+          mod.create_extend(T.must(helper_module.name)) if extend_helper
         end
 
         sig { params(mod: Module, helper: Module).returns(T::Boolean) }

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -1,5 +1,5 @@
+# typed: strict
 # frozen_string_literal: true
-# typed: true
 
 require "tapioca/compilers/dsl/base"
 
@@ -30,7 +30,7 @@ module Tapioca
           T::Enumerable[Dsl::Base]
         )
         @requested_constants = requested_constants
-        @error_handler = error_handler || $stderr.method(:puts)
+        @error_handler = T.let(error_handler || $stderr.method(:puts), T.proc.params(error: String).void)
       end
 
       sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
@@ -54,9 +54,9 @@ module Tapioca
 
       private
 
-      sig { params(requested_generators: T::Array[String]).returns(Proc) }
+      sig { params(requested_generators: T::Array[String]).returns(T.proc.params(klass: Class).returns(T::Boolean)) }
       def generator_filter(requested_generators)
-        return proc { true } if requested_generators.empty?
+        return ->(_klass) { true } if requested_generators.empty?
 
         generators = requested_generators.map(&:downcase)
 
@@ -70,7 +70,7 @@ module Tapioca
       def gather_generators(requested_generators)
         generator_filter = generator_filter(requested_generators)
 
-        Dsl::Base.descendants.select(&generator_filter).map(&:new)
+        T.cast(Dsl::Base.descendants.select(&generator_filter).map(&:new), T::Enumerable[Dsl::Base])
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }

data/lib/tapioca/compilers/requires_compiler.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
-require_relative '../sorbet_config_parser'
+require 'spoom'
 
 module Tapioca
   module Compilers
@@ -15,7 +15,7 @@ module Tapioca
 
       sig { returns(String) }
       def compile
-        config = SorbetConfig.parse_file(@sorbet_path)
+        config = Spoom::Sorbet::Config.parse_file(@sorbet_path)
         files = collect_files(config)
         files.flat_map do |file|
           collect_requires(file).reject do |req|
@@ -28,7 +28,7 @@ module Tapioca
 
       private
 
-      sig { params(config: SorbetConfig).returns(T::Array[String]) }
+      sig { params(config: Spoom::Sorbet::Config).returns(T::Array[String]) }
       def collect_files(config)
         config.paths.flat_map do |path|
           path = (Pathname.new(@sorbet_path) / "../.." / path).cleanpath
@@ -49,7 +49,7 @@ module Tapioca
         end.compact
       end
 
-      sig { params(config: SorbetConfig, file: String).returns(T::Boolean) }
+      sig { params(config: Spoom::Sorbet::Config, file: String).returns(T::Boolean) }
       def file_ignored_by_sorbet?(config, file)
         config.ignore.any? do |path|
           Regexp.new(Regexp.escape(path)) =~ file

data/lib/tapioca/compilers/sorbet.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'pathname'
 require 'shellwords'

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'pathname'
 
@@ -383,8 +383,18 @@ module Tapioca
               indented("include(#{qualified_name_of(mod)})")
             end.join("\n")
 
-          mixed_in_module = dynamic_extends.find do |mod|
-            mod != constant && public_module?(mod)
+          ancestors = singleton_class_of(constant).ancestors
+          extends_as_concern = ancestors.any? do |mod|
+            qualified_name_of(mod) == "::ActiveSupport::Concern"
+          end
+          class_methods_module = resolve_constant("#{name_of(constant)}::ClassMethods")
+
+          mixed_in_module = if extends_as_concern && Module === class_methods_module
+            class_methods_module
+          else
+            dynamic_extends.find do |mod|
+              mod != constant && public_module?(mod)
+            end
           end
 
           return result if mixed_in_module.nil?
@@ -494,20 +504,46 @@ module Tapioca
           return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
 
           signature = signature_of(method)
-          method = signature.method if signature
+          method = T.let(signature.method, UnboundMethod) if signature
 
           method_name = method.name.to_s
           return unless valid_method_name?(method_name)
           return if struct_method?(constant, method_name)
           return if method_name.start_with?("__t_props_generated_")
 
-          params = T.let(method.parameters, T::Array[T::Array[Symbol]])
-          parameters = params.map do |(type, name)|
-            name ||= :_
+          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          sanitized_parameters = parameters.map do |type, name|
+            unless name
+              # For attr_writer methods, Sorbet signatures have the name
+              # of the method (without the trailing = sign) as the name of
+              # the only parameter. So, if the parameter does not have a name
+              # then the replacement name should be the name of the method
+              # (minus trailing =) if and only if there is a signature for the
+              # method and the parameter is required and there is a single
+              # parameter and the signature also defines a single parameter and
+              # the name of the method ends with a = character.
+              writer_method_with_sig = (
+                signature && type == :req &&
+                parameters.size == 1 &&
+                signature.arg_types.size == 1 &&
+                method_name[-1] == "="
+              )
+
+              name = if writer_method_with_sig
+                T.must(method_name[0...-1]).to_sym
+              else
+                :_
+              end
+            end
 
             # Sanitize param names
             name = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
 
+            [type, name]
+          end
+
+          parameter_list = sanitized_parameters.map do |type, name|
             case type
             when :req
               name
@@ -526,26 +562,31 @@ module Tapioca
             end
           end.join(', ')
 
-          parameters = "(#{parameters})" if parameters != ""
+          parameter_list = "(#{parameter_list})" if parameter_list != ""
+          signature_str = indented(compile_signature(signature, sanitized_parameters)) if signature
 
-          signature_str = indented(compile_signature(signature)) if signature
           [
             signature_str,
-            indented("def #{method_name}#{parameters}; end"),
+            indented("def #{method_name}#{parameter_list}; end"),
           ].compact.join("\n")
         end
 
         TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
 
-        sig { params(signature: T.untyped).returns(String) }
-        def compile_signature(signature)
-          params = signature.arg_types
-          params += signature.kwarg_types.to_a
-          params << [signature.rest_name, signature.rest_type] if signature.has_rest
-          params << [signature.block_name, signature.block_type] if signature.block_name
+        sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(String) }
+        def compile_signature(signature, parameters)
+          parameter_types = T.let(signature.arg_types.to_h, T::Hash[Symbol, T::Types::Base])
+          parameter_types.merge!(signature.kwarg_types)
+          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
+          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
+          parameter_types[signature.block_name] = signature.block_type if signature.block_name
+
+          params = parameters.map do |_, name|
+            type = parameter_types[name.to_sym]
+            "#{name}: #{type}"
+          end.join(", ")
 
-          params = params.compact.map { |name, type| "#{name}: #{type}" }.join(", ")
-          returns = signature.return_type.to_s
+          returns = type_of(signature.return_type)
 
           type_parameters = (params + returns).scan(TYPE_PARAMETER_MATCHER).flatten.uniq.map { |p| ":#{p}" }.join(", ")
           type_parameters = ".type_parameters(#{type_parameters})" unless type_parameters.empty?
@@ -764,6 +805,11 @@ module Tapioca
           nil
         end
 
+        sig { params(constant: Module).returns(String) }
+        def type_of(constant)
+          constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
+        end
+
         sig { params(constant: Module, other: BasicObject).returns(T::Boolean).checked(:never) }
         def are_equal?(constant, other)
           BasicObject.instance_method(:equal?).bind(constant).call(other)

data/lib/tapioca/compilers/symbol_table/symbol_loader.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'json'
 require 'tempfile'

data/lib/tapioca/compilers/symbol_table_compiler.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strong
+# frozen_string_literal: true
 
 module Tapioca
   module Compilers

data/lib/tapioca/compilers/todos_compiler.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strong
+# frozen_string_literal: true
 
 module Tapioca
   module Compilers

data/lib/tapioca/core_ext/class.rb

@@ -1,7 +1,9 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 class Class
+  extend T::Sig
+
   # Returns an array with all classes that are < than its receiver.
   #
   #   class C; end
@@ -15,9 +17,12 @@ class Class
   #
   #   class D < C; end
   #   C.descendants # => [B, A, D]
+  sig { returns(T::Array[Class]) }
   def descendants
-    ObjectSpace.each_object(singleton_class).reject do |k|
-      k.singleton_class? || k == self
+    result = ObjectSpace.each_object(singleton_class).reject do |k|
+      T.cast(k, Module).singleton_class? || k == self
     end
+
+    T.cast(result, T::Array[Class])
   end
 end

data/lib/tapioca/gemfile.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require "bundler"
 

data/lib/tapioca/generator.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require 'pathname'
 require 'thor'

data/lib/tapioca/loader.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 module Tapioca
   class Loader
@@ -99,6 +99,16 @@ module Tapioca
 
     sig { void }
     def eager_load_rails_app
+      if Object.const_defined?("ActiveSupport")
+        Object.const_get("ActiveSupport").run_load_hooks(
+          :before_eager_load,
+          Object.const_get("Rails").application
+        )
+      end
+      if Object.const_defined?("Zeitwerk::Loader")
+        zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
+        zeitwerk_loader.eager_load_all
+      end
       Object.const_get("Rails").autoloaders.each(&:eager_load)
     end
 

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.7
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-18 00:00:00.000000000 Z
+date: 2020-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -69,6 +69,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: spoom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -127,7 +141,6 @@ files:
 - lib/tapioca/gemfile.rb
 - lib/tapioca/generator.rb
 - lib/tapioca/loader.rb
-- lib/tapioca/sorbet_config_parser.rb
 - lib/tapioca/version.rb
 homepage: https://github.com/Shopify/tapioca
 licenses:
@@ -142,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.7
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/tapioca/sorbet_config_parser.rb

@@ -1,77 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  class SorbetConfig
-    extend T::Sig
-
-    sig { returns(T::Array[String]) }
-    attr_reader :paths, :ignore
-
-    sig { void }
-    def initialize
-      @paths = T.let([], T::Array[String])
-      @ignore = T.let([], T::Array[String])
-    end
-
-    class << self
-      extend T::Sig
-
-      sig { params(sorbet_config_path: String).returns(SorbetConfig) }
-      def parse_file(sorbet_config_path)
-        parse_string(File.read(sorbet_config_path))
-      end
-
-      sig { params(sorbet_config: String).returns(SorbetConfig) }
-      def parse_string(sorbet_config)
-        config = SorbetConfig.new
-        ignore = T.let(false, T::Boolean)
-        skip = T.let(false, T::Boolean)
-        sorbet_config.each_line do |line|
-          line = line.strip
-          case line
-          when /^--ignore$/
-            ignore = true
-            next
-          when /^--ignore=/
-            config.ignore << parse_option(line)
-            next
-          when /^--file$/
-            next
-          when /^--file=/
-            config.paths << parse_option(line)
-            next
-          when /^--dir$/
-            next
-          when /^--dir=/
-            config.paths << parse_option(line)
-            next
-          when /^--.*=/
-            next
-          when /^--/
-            skip = true
-          when /^-.*=?/
-            next
-          else
-            if ignore
-              config.ignore << line
-              ignore = false
-            elsif skip
-              skip = false
-            else
-              config.paths << line
-            end
-          end
-        end
-        config
-      end
-
-      private
-
-      sig { params(line: String).returns(String) }
-      def parse_option(line)
-        T.must(line.split("=").last).strip
-      end
-    end
-  end
-end