tapioca 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aedd5a0415cca7e554021e114401254561649803acceed6caaa2cb24b9b4c8c
-  data.tar.gz: 376290c5b3cad6f082e9fc186cbb2ed32a9bb239c5c37bc8f9f464c78a2d951e
+  metadata.gz: 91a976cddc1429c3b08568b39d8fae5fe8d4d54a8b8b2b04deebb75f475987e8
+  data.tar.gz: 45074066696bd5c838ab09523980fd9c148faeb1b9f6ee800e8752e636edbd1a
 SHA512:
-  metadata.gz: e65c8822f8312788075a84f24d5b9c95221bba2ced2dd877f150a377696fd70eff96bc936fdd3cf482fa6d4ac1b2d86a0201ed91c386c1ee1ce0bd19e8defd9c
-  data.tar.gz: bace8a6fca5ca72789c5fdfa121fb7b30bf415e9f04d6c715f43237f4d022c4507a6d6182161c4928a7258f9759c957a22c2559cc73ebc56d093f5864dcd872f
+  metadata.gz: 1646cf3ec4957442bf0895a636bfc684e00f0d88e2252502d119fd3f4b4073e41b773ce0cbe8f725766d0c82bae7f67b92381a32a123b6fa2067ddd6a9e2c8d2
+  data.tar.gz: 33f8dae8437b44c2bb2e7d4a1bb483adc11c0ae58322b62fa97a879698ba3d9abab4f198d38b7a8433e57f32f64df5b39ce1b5d8a13ebe37b011dae2d179d926

data/Gemfile

@@ -7,5 +7,29 @@ gemspec
 gem 'rubocop-shopify', require: false
 
 group(:deployment, :development) do
-  gem("rake", "~> 12.3")
+  gem("rake")
+end
+
+gem("bundler", "~> 1.17")
+gem("pry-byebug")
+gem("minitest")
+gem("minitest-hooks")
+gem("minitest-fork_executor")
+gem("minitest-reporters")
+gem("sorbet")
+
+group(:development, :test) do
+  gem("smart_properties", ">= 1.15.0", require: false)
+  gem("frozen_record", ">= 0.17", require: false)
+  gem("sprockets", "~> 3.7", require: false)
+  gem("rails", "~> 5.2", require: false)
+  gem("state_machines", "~> 0.5.0", require: false)
+  gem("activerecord-typedstore", "~> 1.3", require: false)
+  gem("sqlite3")
+  gem("identity_cache", "~> 1.0", require: false)
+  gem('cityhash', git: 'https://github.com/csfrancis/cityhash.git',
+                  ref: '3cfc7d01f333c01811d5e834f1495eaa29f87c36', require: false)
+  gem("activemodel-serializers-xml", "~> 1.0", require: false)
+  gem("activeresource", "~> 5.1", require: false)
+  gem("google-protobuf", "~>3.12.0", require: false)
 end

data/README.md

@@ -31,6 +31,13 @@ In order to make sure that `tapioca` can reflect on that type, we need to add th
 
 If you ever run into a case, where you add a gem or update the version of a gem and run `tapioca sync` but don't have some types you expect in the generated gem RBI files, you will need to make sure you have added the necessary requires to the `sorbet/tapioca/require.rb` file.
 
+You can use the command `tapioca require` to auto-populate the `sorbet/tapioca/require.rb` file with all the requires found
+in your application. Once the file generated, you should review it, remove all unnecessary requires and commit it.
+
+## How does tapioca compare to "srb rbi gems" ?
+
+[Please see the detailed answer on our wiki](https://github.com/Shopify/tapioca/wiki/How-does-tapioca-compare-to-%22srb-rbi-gems%22-%3F)
+
 ## Installation
 
 Add this line to your application's `Gemfile`:
@@ -49,6 +56,7 @@ Commands:
   tapioca generate [gem...]  # generate RBIs from gems
   tapioca help [COMMAND]     # Describe available commands or one specific command
   tapioca init               # initializes folder structure
+  tapioca require            # generate the list of files to be required by tapioca
   tapioca sync               # sync RBIs to Gemfile
   tapioca todo               # generate the list of unresolved constants
 
@@ -95,6 +103,10 @@ 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

@@ -3,10 +3,21 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError # rubocop:disable Lint/SuppressedException
+Rake.application.options.trace = false
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "spec"
+  t.warning = false
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task(:spec) do
+  begin
+    Rake::Task[:test].execute
+  rescue RuntimeError
+    exit(1)
+  end
 end
 
 task(default: :spec)

data/lib/tapioca.rb

@@ -36,8 +36,10 @@ require "tapioca/generator"
 require "tapioca/cli"
 require "tapioca/gemfile"
 require "tapioca/compilers/sorbet"
+require "tapioca/compilers/requires_compiler"
 require "tapioca/compilers/symbol_table_compiler"
 require "tapioca/compilers/symbol_table/symbol_generator"
 require "tapioca/compilers/symbol_table/symbol_loader"
 require "tapioca/compilers/todos_compiler"
+require "tapioca/compilers/dsl_compiler"
 require "tapioca/version"

data/lib/tapioca/cli.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: false
+# typed: true
 
 require 'thor'
 
@@ -52,6 +52,13 @@ module Tapioca
       end
     end
 
+    desc "require", "generate the list of files to be required by tapioca"
+    def require
+      Tapioca.silence_warnings do
+        generator.build_requires
+      end
+    end
+
     desc "todo", "generate the list of unresolved constants"
     def todo
       Tapioca.silence_warnings do
@@ -59,6 +66,18 @@ module Tapioca
       end
     end
 
+    desc "dsl [constant...]", "generate RBIs for dynamic methods"
+    option :generators,
+      type: :array,
+      aliases: ["--gen", "-g"],
+      banner: "generator [generator ...]",
+      desc: "Only run supplied DSL generators"
+    def dsl(*constants)
+      Tapioca.silence_warnings do
+        generator.build_dsl(constants)
+      end
+    end
+
     desc "generate [gem...]", "generate RBIs from gems"
     def generate(*gems)
       Tapioca.silence_warnings do
@@ -79,7 +98,10 @@ module Tapioca
       end
 
       def generator
-        @generator ||= Generator.new(ConfigBuilder.from_options(options))
+        current_command = T.must(current_command_chain.first)
+        @generator ||= Generator.new(
+          ConfigBuilder.from_options(current_command, options)
+        )
       end
     end
   end

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

@@ -0,0 +1,129 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "action_controller"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActionControllerHelpers` decorates RBI files for all
+      # subclasses of `::ActionController::Base`
+      # to add helper methods (see https://api.rubyonrails.org/classes/ActionController/Helpers.html).
+      #
+      # For example, with the following `MyHelper` module:
+      #
+      # ~~~rb
+      # module MyHelper
+      #   def greet(user)
+      #     # ...
+      #   end
+      #
+      #  def localized_time
+      #     # ...
+      #   end
+      # end
+      # ~~~
+      #
+      # and the following controller:
+      #
+      # ~~~rb
+      # class UserController < ActionController::Base
+      #   helper MyHelper
+      #   helper { def age(user) "99" end }
+      #   helper_method :current_user_name
+      #
+      #   def current_user_name
+      #     # ...
+      #   end
+      # end
+      #
+      # this generator will produce an RBI file `user_controller.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # user_controller.rbi
+      # # typed: strong
+      # class UserController
+      #   sig { returns(UserController::HelperProxy) }
+      #   def helpers; end
+      # end
+      #
+      # module UserController::HelperMethods
+      #    include MyHelper
+      #
+      #    sig { params(user: T.untyped).returns(T.untyped) }
+      #    def age(user); end
+      #
+      #    sig { returns(T.untyped) }
+      #    def current_user_name; end
+      #  end
+      #
+      # class UserController::HelperProxy < ::ActionView::Base
+      #   include UserController::HelperMethods
+      # end
+      # ~~~
+      class ActionControllerHelpers < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionController::Base))
+            .void
+        end
+        def decorate(root, constant)
+          helper_proxy_name = "#{constant}::HelperProxy"
+          helper_methods_name = "#{constant}::HelperMethods"
+          proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
+
+          # Create helper method module
+          root.create_module(helper_methods_name) do |helper_methods|
+            helpers_module = constant._helpers
+
+            gather_includes(helpers_module).each do |ancestor|
+              helper_methods.create_include(ancestor)
+            end
+
+            helpers_module.instance_methods(false).each do |method_name|
+              method = if proxied_helper_methods.include?(method_name)
+                constant.instance_method(method_name)
+              else
+                helpers_module.instance_method(method_name)
+              end
+              create_method_from_def(helper_methods, method)
+            end
+          end
+
+          # Create helper proxy class
+          root.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
+            proxy.create_include(helper_methods_name)
+          end
+
+          # Define the helpers method
+          root.path(constant) do |controller|
+            create_method(controller, 'helpers', return_type: helper_proxy_name)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActionController::Base.descendants.reject(&:abstract?)
+        end
+
+        private
+
+        sig { params(mod: Module).returns(T::Array[String]) }
+        def gather_includes(mod)
+          mod.ancestors
+            .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || ancestor.name.nil? }
+            .map { |ancestor| T.must(ancestor.name) }
+            .reverse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "action_mailer"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of `ActionMailer::Base`
+      # (see https://api.rubyonrails.org/classes/ActionMailer/Base.html).
+      #
+      # For example, with the following `ActionMailer` subclass:
+      #
+      # ~~~rb
+      # class NotifierMailer < ActionMailer::Base
+      #   def notify_customer(customer_id)
+      #     # ...
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `notifier_mailer.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # notifier_mailer.rbi
+      # # typed: true
+      # class NotifierMailer
+      #   sig { params(customer_id: T.untyped).returns(::ActionMailer::MessageDelivery) }
+      #   def self.notify_customer(customer_id); end
+      # end
+      # ~~~
+      class ActionMailer < Base
+        extend T::Sig
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionMailer::Base)).void }
+        def decorate(root, constant)
+          root.path(constant) do |k|
+            constant.action_methods.to_a.each do |mailer_method|
+              method_def = constant.instance_method(mailer_method)
+              parameters = compile_method_parameters_to_parlour(method_def)
+              create_method(
+                k,
+                mailer_method,
+                parameters: parameters,
+                return_type: '::ActionMailer::MessageDelivery',
+                class_method: true
+              )
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ::ActionMailer::Base.descendants.reject(&:abstract?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,285 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveRecordAssociations` refines RBI files for subclasses of `ActiveRecord::Base`
+      # (see https://api.rubyonrails.org/classes/ActiveRecord/Base.html). This generator is only
+      # responsible for defining the methods that would be created for the association that
+      # are defined in the Active Record model.
+      #
+      # For example, with the following model class:
+      #
+      # ~~~rb
+      # class Post < ActiveRecord::Base
+      #   belongs_to :category
+      #   has_many :comments
+      #   has_one :author, class_name: "User"
+      # end
+      # ~~~
+      #
+      # this generator will produce the following methods in the RBI file
+      # `post.rbi`:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      #
+      # class Post
+      #   include Post::GeneratedAssociationMethods
+      # end
+      #
+      # module Post::GeneratedAssociationMethods
+      #   sig { returns(T.nilable(::User)) }
+      #   def author; end
+      #
+      #   sig { params(value: T.nilable(::User)).void }
+      #   def author=(value); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   def build_author(*args, &blk); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   def build_category(*args, &blk); end
+      #
+      #   sig { returns(T.nilable(::Category)) }
+      #   def category; end
+      #
+      #   sig { params(value: T.nilable(::Category)).void }
+      #   def category=(value); end
+      #
+      #   sig { returns(T::Array[T.untyped]) }
+      #   def comment_ids; end
+      #
+      #   sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+      #   def comment_ids=(ids); end
+      #
+      #   sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
+      #   def comments; end
+      #
+      #   sig { params(value: T::Enumerable[::Comment]).void }
+      #   def comments=(value); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   def create_author(*args, &blk); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
+      #   def create_author!(*args, &blk); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   def create_category(*args, &blk); end
+      #
+      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
+      #   def create_category!(*args, &blk); end
+      #
+      #   sig { returns(T.nilable(::User)) }
+      #   def reload_author; end
+      #
+      #   sig { returns(T.nilable(::Category)) }
+      #   def reload_category; end
+      # end
+      # ~~~
+      class ActiveRecordAssociations < Base
+        extend T::Sig
+
+        ReflectionType = T.type_alias do
+          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
+        end
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        def decorate(root, constant)
+          return if constant.reflections.empty?
+
+          module_name = "#{constant}::GeneratedAssociationMethods"
+          root.create_module(module_name) do |mod|
+            constant.reflections.each do |association_name, reflection|
+              if reflection.collection?
+                populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
+              else
+                populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+              end
+            end
+          end
+
+          root.path(constant) do |klass|
+            klass.create_include(module_name)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          ActiveRecord::Base.descendants.reject(&:abstract_class?)
+        end
+
+        private
+
+        sig do
+          params(
+            klass: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(ActiveRecord::Base),
+            association_name: T.any(String, Symbol),
+            reflection: ReflectionType
+          ).void
+        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
+
+          create_method(
+            klass,
+            association_name.to_s,
+            return_type: association_type,
+          )
+          create_method(
+            klass,
+            "#{association_name}=",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("value", type: association_type),
+            ],
+            return_type: nil
+          )
+          create_method(
+            klass,
+            "reload_#{association_name}",
+            return_type: association_type,
+          )
+          if reflection.constructable?
+            create_method(
+              klass,
+              "build_#{association_name}",
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+              ],
+              return_type: association_type
+            )
+            create_method(
+              klass,
+              "create_#{association_name}",
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+              ],
+              return_type: association_type
+            )
+            create_method(
+              klass,
+              "create_#{association_name}!",
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+              ],
+              return_type: association_type
+            )
+          end
+        end
+
+        sig do
+          params(
+            klass: Parlour::RbiGenerator::Namespace,
+            constant: T.class_of(ActiveRecord::Base),
+            association_name: T.any(String, Symbol),
+            reflection: ReflectionType
+          ).void
+        end
+        def populate_collection_assoc_getter_setter(klass, constant, association_name, reflection)
+          association_class = type_for(constant, reflection)
+          relation_class = relation_type_for(constant, reflection)
+
+          create_method(
+            klass,
+            association_name.to_s,
+            return_type: relation_class,
+          )
+          create_method(
+            klass,
+            "#{association_name}=",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("value", type: "T::Enumerable[#{association_class}]"),
+            ],
+            return_type: nil,
+          )
+          create_method(
+            klass,
+            "#{association_name.to_s.singularize}_ids",
+            return_type: "T::Array[T.untyped]"
+          )
+          create_method(
+            klass,
+            "#{association_name.to_s.singularize}_ids=",
+            parameters: [
+              Parlour::RbiGenerator::Parameter.new("ids", type: "T::Array[T.untyped]"),
+            ],
+            return_type: "T::Array[T.untyped]"
+          )
+        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),
+            reflection: ReflectionType
+          ).returns(String)
+        end
+        def type_for(constant, reflection)
+          return "T.untyped" if !constant.table_exists? || polymorphic_association?(reflection)
+
+          "::#{reflection.klass.name}"
+        end
+
+        sig do
+          params(
+            constant: T.class_of(ActiveRecord::Base),
+            reflection: ReflectionType
+          ).returns(String)
+        end
+        def relation_type_for(constant, reflection)
+          "ActiveRecord::Associations::CollectionProxy" if !constant.table_exists? ||
+                                                            polymorphic_association?(reflection)
+
+          # Change to: "::#{reflection.klass.name}::ActiveRecord_Associations_CollectionProxy"
+          "::ActiveRecord::Associations::CollectionProxy[#{reflection.klass.name}]"
+        end
+
+        sig do
+          params(
+            reflection: ReflectionType
+          ).returns(T::Boolean)
+        end
+        def polymorphic_association?(reflection)
+          if reflection.through_reflection?
+            polymorphic_association?(reflection.source_reflection)
+          else
+            !!reflection.polymorphic?
+          end
+        end
+      end
+    end
+  end
+end