tapioca 0.4.1 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91a976cddc1429c3b08568b39d8fae5fe8d4d54a8b8b2b04deebb75f475987e8
-  data.tar.gz: 45074066696bd5c838ab09523980fd9c148faeb1b9f6ee800e8752e636edbd1a
+  metadata.gz: dd111409d415b9a17a11cd2d1a5d6d60fdab411934fc5bd1ade87b4bee9e27a3
+  data.tar.gz: 6cc495adc75090725de7f8cb873672e804452c16931d5a995c543827ab6400cb
 SHA512:
-  metadata.gz: 1646cf3ec4957442bf0895a636bfc684e00f0d88e2252502d119fd3f4b4073e41b773ce0cbe8f725766d0c82bae7f67b92381a32a123b6fa2067ddd6a9e2c8d2
-  data.tar.gz: 33f8dae8437b44c2bb2e7d4a1bb483adc11c0ae58322b62fa97a879698ba3d9abab4f198d38b7a8433e57f32f64df5b39ce1b5d8a13ebe37b011dae2d179d926
+  metadata.gz: 993e27b7960ce9830d58098a3a965214342821d87c3753e3b6a72ab8d9d33e86c1a5f454141cd2f19b73565ecfe9f3454c7c7d45825256c27c02ccd2d2396780
+  data.tar.gz: bfeb2377b5a5b059ce4897cbe1b7e39cef0657d799479ffd75c646897236928cd7fe317fd9cf9a49597b8dd28fc7657e90d9386eb82927cc9cdbb806203c4538

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")

data/README.md

@@ -8,6 +8,8 @@ As yet, no gem exports type information in a consumable format and it would be a
 
 When you run `tapioca sync` in a project, `tapioca` loads all the gems that are in your dependency list from the Gemfile into memory. It then performs runtime introspection on the loaded types to understand their structure and generates an appropriate RBI file for each gem with a versioned filename.
 
+## Manual gem requires
+
 For gems that have a normal default `require` and load all of their constants through such a require, everything works seamlessly. However, for gems that are marked as `require: false` in the Gemfile, or for gems that export optionally loaded types via different requires, where a single require does not load the whole gem code into memory, `tapioca` will not be able to load some of the types into memory and, thus, won't be able to generate complete RBIs for them. For this reason, we need to keep a small external file named `sorbet/tapioca/require.rb` that is executed after all the gems in the Gemfile have been required and before generation of gem RBIs have started. This file is responsible for adding the requires for additional files from gems, which are not covered by the default require.
 
 For example, suppose you are using the class `BetterHtml::Parser` exported from the `better_html` gem. Just doing a `require "better_html"` (which is the default require) does not load that type:
@@ -95,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.
@@ -103,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

@@ -44,8 +44,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

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

@@ -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,
@@ -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,
@@ -349,9 +360,9 @@ module Tapioca
               !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
         end
 
-        sig { params(column_type: Module).returns(String) }
+        sig { params(column_type: Object).returns(String) }
         def handle_unknown_type(column_type)
-          return "T.untyped" unless column_type < ActiveModel::Type::Value
+          return "T.untyped" unless ActiveModel::Type::Value === column_type
 
           lookup_return_type_of_method(column_type, :deserialize) ||
             lookup_return_type_of_method(column_type, :cast) ||
@@ -359,19 +370,33 @@ module Tapioca
             "T.untyped"
         end
 
-        sig { params(column_type: Module, method: Symbol).returns(T.nilable(String)) }
+        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
         def lookup_return_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.instance_method(method))
+          signature = T::Private::Methods.signature_for_method(column_type.method(method))
           return unless signature
 
-          return_type = signature.return_type.to_s
-          return_type if return_type != "<VOID>" && return_type != "<NOT-TYPED>"
+          return_type = signature.return_type
+          return if T::Types::Simple === return_type && T::Generic === return_type.raw_type
+          return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
+
+          return_type.to_s
         end
 
-        sig { params(column_type: Module, method: Symbol).returns(T.nilable(String)) }
+        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
         def lookup_arg_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.instance_method(method))
-          signature.arg_types.first.last.to_s if signature
+          signature = T::Private::Methods.signature_for_method(column_type.method(method))
+          return unless signature
+
+          arg_type = signature.arg_types.first.last
+          return if T::Types::Simple === arg_type && T::Generic === arg_type.raw_type
+
+          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

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/base.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "parlour"
+
 module Tapioca
   module Compilers
     module Dsl

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/requires_compiler.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # typed: strict
 
-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/symbol_table/symbol_generator.rb

@@ -29,7 +29,7 @@ module Tapioca
         def generate
           symbols
             .sort
-            .map(&method(:generate_from_symbol))
+            .map { |symbol| generate_from_symbol(symbol) }
             .compact
             .join("\n\n")
             .concat("\n")
@@ -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/gemfile.rb

@@ -28,7 +28,7 @@ module Tapioca
     sig { returns(T::Array[Gem]) }
     def dependencies
       @dependencies ||= begin
-        specs = definition.specs.to_a
+        specs = definition.locked_gems.specs.to_a
 
         definition
           .resolve
@@ -79,17 +79,18 @@ module Tapioca
       extend(T::Sig)
 
       IGNORED_GEMS = T.let(%w{
-        sorbet sorbet-static sorbet-runtime tapioca
+        sorbet sorbet-static sorbet-runtime
       }.freeze, T::Array[String])
 
       sig { returns(String) }
-      attr_reader :full_gem_path
+      attr_reader :full_gem_path, :version
 
       sig { params(spec: Spec).void }
       def initialize(spec)
         @spec = T.let(spec, Tapioca::Gemfile::Spec)
         real_gem_path = to_realpath(@spec.full_gem_path)
         @full_gem_path = T.let(real_gem_path, String)
+        @version = T.let(version_string, String)
       end
 
       sig { params(gemfile_dir: String).returns(T::Boolean) }
@@ -109,11 +110,6 @@ module Tapioca
         @spec.name
       end
 
-      sig { returns(::Gem::Version) }
-      def version
-        @spec.version
-      end
-
       sig { returns(String) }
       def rbi_file_name
         "#{name}@#{version}.rbi"
@@ -121,11 +117,38 @@ module Tapioca
 
       sig { params(path: String).returns(T::Boolean) }
       def contains_path?(path)
-        to_realpath(path).start_with?(full_gem_path)
+        to_realpath(path).start_with?(full_gem_path) || has_parent_gemspec?(path)
       end
 
       private
 
+      sig { returns(String) }
+      def version_string
+        version = @spec.version.to_s
+        version += "-#{@spec.source.revision}" if Bundler::Source::Git === @spec.source
+        version
+      end
+
+      sig { params(path: String).returns(T::Boolean) }
+      def has_parent_gemspec?(path)
+        # For some Git installed gems the location of the loaded file can
+        # be different from the gem path as indicated by the spec file
+        #
+        # To compensate for these cases, we walk up the directory hierarchy
+        # from the given file and try to match a <gem-name.gemspec> file in
+        # one of those folders to see if the path really belongs in the given gem
+        # or not.
+        return false unless Bundler::Source::Git === @spec.source
+        parent = Pathname.new(path)
+
+        until parent.root?
+          parent = parent.parent.expand_path
+          return true if parent.join("#{name}.gemspec").file?
+        end
+
+        false
+      end
+
       sig { params(path: T.any(String, Pathname)).returns(String) }
       def to_realpath(path)
         path_string = path.to_s

data/lib/tapioca/generator.rb

@@ -162,6 +162,11 @@ module Tapioca
 
     private
 
+    EMPTY_RBI_COMMENT = <<~CONTENT
+      # THIS IS AN EMPTY RBI FILE.
+      # see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+    CONTENT
+
     sig { returns(Gemfile) }
     def bundle
       @bundle ||= Gemfile.new
@@ -422,20 +427,25 @@ module Tapioca
       say("Compiling #{gem_name}, this may take a few seconds... ")
 
       strictness = config.typed_overrides[gem.name] || "true"
-
+      rbi_body_content = compiler.compile(gem)
       content = String.new
       content << rbi_header(
         config.generate_command,
         reason: "types exported from the `#{gem.name}` gem",
         strictness: strictness
       )
-      content << compiler.compile(gem)
 
       FileUtils.mkdir_p(config.outdir)
       filename = config.outpath / gem.rbi_file_name
-      File.write(filename.to_s, content)
 
-      say("Done", :green)
+      if rbi_body_content.strip.empty?
+        content << EMPTY_RBI_COMMENT
+        say("Done (empty output)", :yellow)
+      else
+        content << rbi_body_content
+        say("Done", :green)
+      end
+      File.write(filename.to_s, content)
 
       Pathname.glob((config.outpath / "#{gem.name}@*.rbi").to_s) do |file|
         remove(file) unless file.basename.to_s == gem.rbi_file_name

data/lib/tapioca/loader.rb

@@ -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.1"
+  VERSION = "0.4.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.6
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-27 00:00:00.000000000 Z
+date: 2020-09-15 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