tapioca 0.4.3 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffc5e922b8cd11f0667bfe31aa52ffc1087d954e0de34fbf97bcd54f65f522df
-  data.tar.gz: 25b67e05f26e1c6eb9e1e9723d1d6ed853986e658f389da74203349b99fca1c2
+  metadata.gz: f225f517eb2bb6e6d7aa6910bb42a35280b57ad8223dbd8bc255ce92377c6eb3
+  data.tar.gz: f3672f181cbcd71b9c8056c815e77313d75fcb2a78d2be5dbad3d2e51e35de39
 SHA512:
-  metadata.gz: 1334f75cb44c365c0dd075e2aa52c65bd4b685634376a2b06db9de2c6d3d809997957568f6a14006ccb984cf845e267bf75c027906f20ee9546643e9f968462f
-  data.tar.gz: adad8cf61d2810cb823739616c77cbf4ac2d88a88d2fac60c84c837764cdd3940376815ee446b931e2ebe9ab41ac2b48daeb519db4892f680f9aeb2fa6888db4
+  metadata.gz: dcd0b9ebf36c2a467bb2e88cb91b1f0634cb772a3a5cf29f7dd3b716ddc3c4fd2ea4dd84b671df243255cc15651deb157d149578dde07f3f7eb26f0a8814a297
+  data.tar.gz: df7355fe19f05210797993286ead0f653a0f5b5f89263f469e8afece16d39026bde0cec1a0b266256ab236f43c27e95bd2912be3a9be74877ca6ca28037e09d7

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

@@ -1,6 +1,6 @@
 # Tapioca
 
-[![Build Status](https://travis-ci.org/Shopify/tapioca.svg?branch=master)](https://travis-ci.org/Shopify/tapioca)
+![Build Status](https://github.com/Shopify/tapioca/workflows/CI/badge.svg)
 
 Tapioca is a library used to generate RBI (Ruby interface) files for use with [Sorbet](https://sorbet.org). RBI files provide the structure (classes, modules, methods, parameters) of the gem/library to Sorbet to assist with typechecking.
 
@@ -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/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
 
@@ -109,7 +108,7 @@ module Tapioca
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
           ::ActiveRecord::Base.descendants.select do |klass|
-            klass < IdentityCache
+            klass < IdentityCache::WithoutPrimaryIndex
           end
         end
 
@@ -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

@@ -92,24 +92,28 @@ module Tapioca
           method_def = signature.nil? ? method_def : signature.method
           method_types = parameters_types_from_signature(method_def, signature)
 
-          method_def.parameters.each_with_index.map do |(type, name), i|
-            name ||= :_
-            name = name.to_s.gsub(/&|\*/, '_') # avoid incorrect names from `delegate`
+          method_def.parameters.each_with_index.map do |(type, name), index|
+            fallback_arg_name = "_arg#{index}"
+
+            name ||= fallback_arg_name
+            name = name.to_s.gsub(/&|\*/, fallback_arg_name) # avoid incorrect names from `delegate`
+            method_type = method_types[index]
+
             case type
             when :req
-              ::Parlour::RbiGenerator::Parameter.new(name, type: method_types[i])
+              ::Parlour::RbiGenerator::Parameter.new(name, type: method_type)
             when :opt
-              ::Parlour::RbiGenerator::Parameter.new(name, type: method_types[i], default: 'T.unsafe(nil)')
+              ::Parlour::RbiGenerator::Parameter.new(name, type: method_type, default: 'T.unsafe(nil)')
             when :rest
-              ::Parlour::RbiGenerator::Parameter.new("*#{name}", type: method_types[i])
+              ::Parlour::RbiGenerator::Parameter.new("*#{name}", type: method_type)
             when :keyreq
-              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_types[i])
+              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_type)
             when :key
-              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_types[i], default: 'T.unsafe(nil)')
+              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_type, default: 'T.unsafe(nil)')
             when :keyrest
-              ::Parlour::RbiGenerator::Parameter.new("**#{name}", type: method_types[i])
+              ::Parlour::RbiGenerator::Parameter.new("**#{name}", type: method_type)
             when :block
-              ::Parlour::RbiGenerator::Parameter.new("&#{name}", type: method_types[i])
+              ::Parlour::RbiGenerator::Parameter.new("&#{name}", type: method_type)
             else
               raise "Unknown type `#{type}`."
             end

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

@@ -14,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
 

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,13 +28,14 @@ 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
           if path.directory?
             Dir.glob("#{path}/**/*.rb", File::FNM_EXTGLOB).reject do |file|
-              file_ignored_by_sorbet?(config, file)
+              relative_file_path = Pathname.new(file).relative_path_from(path)
+              file_ignored_by_sorbet?(config, relative_file_path)
             end
           else
             [path.to_s]
@@ -49,13 +50,40 @@ module Tapioca
         end.compact
       end
 
-      sig { params(config: SorbetConfig, file: String).returns(T::Boolean) }
-      def file_ignored_by_sorbet?(config, file)
-        config.ignore.any? do |path|
-          Regexp.new(Regexp.escape(path)) =~ file
+      sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
+      def file_ignored_by_sorbet?(config, file_path)
+        file_path_parts = path_parts(file_path)
+
+        config.ignore.any? do |ignore|
+          # Sorbet --ignore matching method:
+          # ---
+          # Ignores input files that contain the given
+          # string in their paths (relative to the input
+          # path passed to Sorbet).
+          #
+          # Strings beginning with / match against the
+          # prefix of these relative paths; others are
+          # substring matchs.
+
+          # Matches must be against whole folder and file
+          # names, so `foo` matches `/foo/bar.rb` and
+          # `/bar/foo/baz.rb` but not `/foo.rb` or
+          # `/foo2/bar.rb`.
+          ignore_parts = path_parts(Pathname.new(ignore))
+          file_path_part_sequences = file_path_parts.each_cons(ignore_parts.size)
+          # if ignore string begins with /, we only want the first sequence to match
+          file_path_part_sequences = [file_path_part_sequences.first].to_enum if ignore.start_with?("/")
+
+          # we need to match whole segments
+          file_path_part_sequences.include?(ignore_parts)
         end
       end
 
+      sig { params(path: Pathname).returns(T::Array[String]) }
+      def path_parts(path)
+        T.unsafe(path).descend.map { |part| part.basename.to_s }
+      end
+
       sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
       def name_in_project?(files, name)
         files.any? do |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'
 
@@ -209,7 +209,11 @@ module Tapioca
             method = "const" if prop.fetch(:immutable, false)
             type = prop.fetch(:type_object, "T.untyped")
 
-            indented("#{method} :#{name}, #{type}")
+            if prop.key?(:default)
+              indented("#{method} :#{name}, #{type}, default: T.unsafe(nil)")
+            else
+              indented("#{method} :#{name}, #{type}")
+            end
           end.join("\n")
         end
 
@@ -383,8 +387,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,15 +508,18 @@ 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)|
+          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
+            fallback_arg_name = "_arg#{index}"
+
             unless name
               # For attr_writer methods, Sorbet signatures have the name
               # of the method (without the trailing = sign) as the name of
@@ -512,22 +529,27 @@ module Tapioca
               # 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 &&
-                params.size == 1 &&
+              writer_method_with_sig = (
+                signature && type == :req &&
+                parameters.size == 1 &&
                 signature.arg_types.size == 1 &&
                 method_name[-1] == "="
+              )
 
               name = if writer_method_with_sig
-                method_name[0...-1].to_sym
+                T.must(method_name[0...-1]).to_sym
               else
-                :_
+                fallback_arg_name
               end
             end
 
             # Sanitize param names
-            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, fallback_arg_name)
+
+            [type, name]
+          end
 
+          parameter_list = sanitized_parameters.map do |type, name|
             case type
             when :req
               name
@@ -546,26 +568,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 = params.compact.map { |name, type| "#{name}: #{type}" }.join(", ")
-          returns = signature.return_type.to_s
+          params = parameters.map do |_, name|
+            type = parameter_types[name.to_sym]
+            "#{name}: #{type}"
+          end.join(", ")
+
+          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?
@@ -591,6 +618,7 @@ module Tapioca
           signature_body = signature_body
             .gsub(".returns(<VOID>)", ".void")
             .gsub("<NOT-TYPED>", "T.untyped")
+            .gsub(".params()", "")
             .gsub(TYPE_PARAMETER_MATCHER, "T.type_parameter(:\\1)")[1..-1]
 
           "sig { #{signature_body} }"
@@ -784,6 +812,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

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.8
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-19 00:00:00.000000000 Z
+date: 2020-11-05 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