tapioca 0.5.1 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f8af6316243d26a0446636e00af5c9210296f5e5ac1f6065506af426d72c066
-  data.tar.gz: 7124feeb9e7ecc16c2de3897ae9dd2bd3a432be6295d66ab5c440c4377f6d1e1
+  metadata.gz: 6051054b5414fe5f3383fa6fefc8fabdfd426380c026f55fdf87ecee8e10d964
+  data.tar.gz: 5054dacc20c7a8881c957540d0fa624d7ec406d57f8486a9dab9e088e2d270d0
 SHA512:
-  metadata.gz: 720a2022478adcffea11b8a52b486dec808544611c9792c8508224c8565a3a4aaaed9f0a512bf51417da1259275ba6dbbd09b318f5e8e438544ae54558e0e028
-  data.tar.gz: 8b5148ed02e2105b0c44134b98c99cb0e2c03144e8eca2293c8cf558b8dcff3141a5812141cb369e83cd830acb847a540f14303d2472ba7877518d4de55545ca
+  metadata.gz: e67122acb9f97bef99088a6dd2cded0c29a73bde763ab8acaad0fae6470ba0b1fc4d2a9139e781ca9ba569595560a743eba69dc701b0632712b31104e41ce2cf
+  data.tar.gz: 3ebf64268dc86b2740e68d3a508fdc67d458f976028781a4a9bce95eba883d2852840560fec32d3792d7193cdd224898bdfe913ffe800ddf3d5ad7be8a914ca6

data/Gemfile

@@ -11,7 +11,6 @@ gem("pry-byebug")
 gem("rubocop-shopify", require: false)
 gem("rubocop-sorbet", ">= 0.4.1")
 gem("sorbet")
-gem("yard", "~> 0.9.25")
 
 group(:deployment, :development) do
   gem("rake")
@@ -35,4 +34,5 @@ group(:development, :test) do
   gem("nokogiri", require: false)
   gem("config", require: false)
   gem("aasm", require: false)
+  gem("bcrypt", require: false)
 end

data/lib/tapioca/cli.rb

@@ -5,8 +5,6 @@ require "thor"
 
 module Tapioca
   class Cli < Thor
-    include(Thor::Actions)
-
     class_option :outdir,
       aliases: ["--out", "-o"],
       banner: "directory",
@@ -29,22 +27,37 @@ module Tapioca
 
     desc "init", "initializes folder structure"
     def init
-      create_config
-      create_post_require
-      generate_binstub
+      generator = Generators::Init.new(
+        sorbet_config: Config::SORBET_CONFIG,
+        default_postrequire: Config::DEFAULT_POSTREQUIRE,
+        default_command: Config::DEFAULT_COMMAND
+      )
+      generator.generate
     end
 
     desc "require", "generate the list of files to be required by tapioca"
     def require
+      generator = Generators::Require.new(
+        requires_path: ConfigBuilder.from_options(:require, options).postrequire,
+        sorbet_config_path: Config::SORBET_CONFIG,
+        default_command: Config::DEFAULT_COMMAND
+      )
       Tapioca.silence_warnings do
-        generator.build_requires
+        generator.generate
       end
     end
 
     desc "todo", "generate the list of unresolved constants"
     def todo
+      current_command = T.must(current_command_chain.first)
+      config = ConfigBuilder.from_options(current_command, options)
+      generator = Generators::Todo.new(
+        todos_path: config.todos_path,
+        file_header: config.file_header,
+        default_command: Config::DEFAULT_COMMAND
+      )
       Tapioca.silence_warnings do
-        generator.build_todos
+        generator.generate
       end
     end
 
@@ -67,13 +80,23 @@ module Tapioca
       type: :boolean,
       desc: "Supresses file creation output"
     def dsl(*constants)
+      current_command = T.must(current_command_chain.first)
+      config = ConfigBuilder.from_options(current_command, options)
+      generator = Generators::Dsl.new(
+        requested_constants: constants,
+        outpath: config.outpath,
+        generators: config.generators,
+        exclude_generators: config.exclude_generators,
+        file_header: config.file_header,
+        compiler_path: Tapioca::Compilers::Dsl::COMPILERS_PATH,
+        tapioca_path: Config::TAPIOCA_PATH,
+        default_command: Config::DEFAULT_COMMAND,
+        should_verify: options[:verify],
+        quiet: options[:quiet],
+        verbose: options[:verbose]
+      )
       Tapioca.silence_warnings do
-        generator.build_dsl(
-          constants,
-          should_verify: options[:verify],
-          quiet: options[:quiet],
-          verbose: options[:verbose]
-        )
+        generator.generate
       end
     end
 
@@ -104,10 +127,26 @@ module Tapioca
       type: :boolean,
       default: false,
       desc: "Verifies RBIs are up-to-date"
+    option :doc,
+      type: :boolean,
+      desc: "Include YARD documentation from sources when generating RBIs. Warning: this might be slow"
     def gem(*gems)
       Tapioca.silence_warnings do
         all = options[:all]
         verify = options[:verify]
+        current_command = T.must(current_command_chain.first)
+        config = ConfigBuilder.from_options(current_command, options)
+        generator = Generators::Gem.new(
+          gem_names: all ? [] : gems,
+          gem_excludes: config.exclude,
+          prerequire: config.prerequire,
+          postrequire: config.postrequire,
+          typed_overrides: config.typed_overrides,
+          default_command: Config::DEFAULT_COMMAND,
+          outpath: config.outpath,
+          file_header: config.file_header,
+          doc: config.doc
+        )
 
         raise MalformattedArgumentError, "Options '--all' and '--verify' are mutually exclusive" if all && verify
 
@@ -117,146 +156,22 @@ module Tapioca
         end
 
         if gems.empty? && !all
-          generator.sync_rbis_with_gemfile(should_verify: verify)
+          generator.sync(should_verify: verify)
         else
-          generator.build_gem_rbis(all ? [] : gems)
+          generator.generate
         end
       end
     end
 
-    desc "generate [gem...]", "DEPRECATED: generate RBIs from gems"
-    option :prerequire,
-      aliases: ["--pre", "-b"],
-      banner: "file",
-      desc: "A file to be required before Bundler.require is called"
-    option :postrequire,
-      aliases: ["--post", "-a"],
-      banner: "file",
-      desc: "A file to be required after Bundler.require is called"
-    option :exclude,
-      aliases: ["-x"],
-      type: :array,
-      banner: "gem [gem ...]",
-      desc: "Excludes the given gem(s) from RBI generation"
-    option :typed_overrides,
-      aliases: ["--typed", "-t"],
-      type: :hash,
-      banner: "gem:level [gem:level ...]",
-      desc: "Overrides for typed sigils for generated gem RBIs"
-    def generate(*gems)
-      gem_names = if gems.empty?
-        "--all"
-      else
-        gems.join(" ")
-      end
-      deprecation_message = <<~MSG
-        DEPRECATION: The `generate` command will be removed in a future release.
-
-        Start using `bin/tapioca gem #{gem_names}` instead.
-      MSG
-
-      say(deprecation_message, :red)
-      say("")
-
-      Tapioca.silence_warnings do
-        generator.build_gem_rbis(gems)
-      end
-
-      say("")
-      say(deprecation_message, :red)
-    end
-
-    desc "sync", "DEPRECATED: sync RBIs to Gemfile"
-    option :prerequire,
-      aliases: ["--pre", "-b"],
-      banner: "file",
-      desc: "A file to be required before Bundler.require is called"
-    option :postrequire,
-      aliases: ["--post", "-a"],
-      banner: "file",
-      desc: "A file to be required after Bundler.require is called"
-    option :exclude,
-      aliases: ["-x"],
-      type: :array,
-      banner: "gem [gem ...]",
-      desc: "Excludes the given gem(s) from RBI generation"
-    option :typed_overrides,
-      aliases: ["--typed", "-t"],
-      type: :hash,
-      banner: "gem:level [gem:level ...]",
-      desc: "Overrides for typed sigils for generated gem RBIs"
-    option :verify,
-      type: :boolean,
-      default: false,
-      desc: "Verifies RBIs are up-to-date"
-    def sync
-      deprecation_message = <<~MSG
-        DEPRECATION: The `sync` command will be removed in a future release.
-
-        Start using `bin/tapioca gem` instead.
-      MSG
-
-      say(deprecation_message, :red)
-      say("")
-
-      Tapioca.silence_warnings do
-        generator.sync_rbis_with_gemfile(should_verify: options[:verify])
-      end
-
-      say("")
-      say(deprecation_message, :red)
-    end
-
     desc "--version, -v", "show version"
     def __print_version
       puts "Tapioca v#{Tapioca::VERSION}"
     end
 
-    private
-
-    def create_config
-      create_file(Config::SORBET_CONFIG, skip: true) do
-        <<~CONTENT
-          --dir
-          .
-        CONTENT
-      end
-    end
-
-    def create_post_require
-      create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
-        <<~CONTENT
-          # typed: true
-          # frozen_string_literal: true
-
-          # Add your extra requires here (`tapioca require` can be used to boostrap this list)
-        CONTENT
-      end
-    end
-
-    def generate_binstub
-      bin_stub_exists = File.exist?("bin/tapioca")
-      installer = Bundler::Installer.new(Bundler.root, Bundler.definition)
-      spec = Bundler.definition.specs.find { |s| s.name == "tapioca" }
-      installer.generate_bundler_executable_stubs(spec, { force: true })
-      if bin_stub_exists
-        shell.say_status(:force, "bin/tapioca", :yellow)
-      else
-        shell.say_status(:create, "bin/tapioca", :green)
-      end
-    end
-
     no_commands do
       def self.exit_on_failure?
         true
       end
-
-      def generator
-        current_command = T.must(current_command_chain.first)
-        @generator ||= Generator.new(
-          ConfigBuilder.from_options(current_command, options)
-        )
-      end
     end
   end
 end

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

@@ -0,0 +1,101 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_model"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveModelSecurePassword` decorates RBI files for all
+      # classes that use [`ActiveModel::SecurePassword`](http://api.rubyonrails.org/classes/ActiveModel/SecurePassword/ClassMethods.html).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User
+      #   include ActiveModel::SecurePassword
+      #
+      #   has_secure_password
+      #   has_secure_password :token
+      # end
+      # ~~~
+      #
+      # this generator will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate_password(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate_token(unencrypted_password); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def password; end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def password=(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def password_confirmation=(unencrypted_password); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def token; end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def token=(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def token_confirmation=(unencrypted_password); end
+      # end
+      # ~~~
+      class ActiveModelSecurePassword < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(root: RBI::Tree, constant: T.all(Class, ::ActiveModel::SecurePassword::ClassMethods))
+            .void
+        end
+        def decorate(root, constant)
+          instance_methods_modules = if constant < ActiveModel::SecurePassword::InstanceMethodsOnActivation
+            # pre Rails 6.0, this used to be a single static module
+            [ActiveModel::SecurePassword::InstanceMethodsOnActivation]
+          else
+            # post Rails 6.0, this is now using a dynmaic module builder pattern
+            # and we can have multiple different ones included into the model
+            constant.ancestors.grep(ActiveModel::SecurePassword::InstanceMethodsOnActivation)
+          end
+
+          return if instance_methods_modules.empty?
+
+          methods = instance_methods_modules.flat_map { |mod| mod.instance_methods(false) }
+          return if methods.empty?
+
+          root.create_path(constant) do |klass|
+            methods.each do |method|
+              create_method_from_def(klass, constant.instance_method(method))
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # This selects all classes that are `ActiveModel::SecurePassword::ClassMethods === klass`.
+          # In other words, we select all classes that have `ActiveModel::SecurePassword::ClassMethods`
+          # as an ancestor of its singleton class, i.e. all classes that have extended the
+          # `ActiveModel::SecurePassword::ClassMethods` module.
+          all_classes.grep(::ActiveModel::SecurePassword::ClassMethods)
+        end
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          descendants_of(::ActiveRecord::Base)
         end
 
         private

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

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rails"
+  require "active_record"
+  require "active_record/fixtures"
+  require "active_support/test_case"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveRecordFixtures` decorates RBIs for test fixture methods
+      # that are created dynamically by Rails.
+      #
+      # For example, given an application with a posts table, we can have a fixture file
+      #
+      # ~~~yaml
+      # first_post:
+      #   author: John
+      #   title: My post
+      # ~~~
+      #
+      # Rails will allow us to invoke `posts(:first_post)` in tests to get the fixture record.
+      # The generated RBI by this generator will produce the following
+      #
+      # ~~~rbi
+      # # test_case.rbi
+      # # typed: true
+      # class ActiveSupport::TestCase
+      #   sig { params(fixture_names: Symbol).returns(T.untyped) }
+      #   def posts(*fixture_names); end
+      # end
+      # ~~~
+      class ActiveRecordFixtures < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveSupport::TestCase)).void }
+        def decorate(root, constant)
+          method_names = fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
+            .drop(1) # drop the anonymous class itself from the array
+            .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
+            .map! do |mod|
+              [mod.private_instance_methods(false), mod.instance_methods(false)]
+            end
+            .flatten # merge methods into a single list
+          return if method_names.empty?
+
+          root.create_path(constant) do |mod|
+            method_names.each do |name|
+              create_fixture_method(mod, name.to_s)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          [ActiveSupport::TestCase]
+        end
+
+        private
+
+        sig { returns(Class) }
+        def fixture_loader
+          Class.new do
+            T.unsafe(self).include(ActiveRecord::TestFixtures)
+            T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+            T.unsafe(self).fixtures(:all)
+          end
+        end
+
+        sig { params(mod: RBI::Scope, name: String).void }
+        def create_fixture_method(mod, name)
+          mod.create_method(
+            name,
+            parameters: [create_rest_param("fixture_names", type: "Symbol")],
+            return_type: "T.untyped"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -34,53 +34,57 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { params(review_date: T.nilable(Date)).returns(T.nilable(Date)) }
-      #   def review_date=(review_date); end
+      #   include StoreAccessors
       #
-      #   sig { returns(T.nilable(Date)) }
-      #   def review_date; end
+      #   module StoreAccessors
+      #     sig { params(review_date: T.nilable(Date)).returns(T.nilable(Date)) }
+      #     def review_date=(review_date); end
       #
-      #   sig { returns(T.nilable(Date)) }
-      #   def review_date_was; end
+      #     sig { returns(T.nilable(Date)) }
+      #     def review_date; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def review_date_changed?; end
+      #     sig { returns(T.nilable(Date)) }
+      #     def review_date_was; end
       #
-      #   sig { returns(T.nilable(Date)) }
-      #   def review_date_before_last_save; end
+      #     sig { returns(T::Boolean) }
+      #     def review_date_changed?; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def saved_change_to_review_date?; end
+      #     sig { returns(T.nilable(Date)) }
+      #     def review_date_before_last_save; end
       #
-      #   sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
-      #   def review_date_change; end
+      #     sig { returns(T::Boolean) }
+      #     def saved_change_to_review_date?; end
       #
-      #   sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
-      #   def saved_change_to_review_date; end
+      #     sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+      #     def review_date_change; end
       #
-      #   sig { params(reviewd: T::Boolean).returns(T::Boolean) }
-      #   def reviewed=(reviewed); end
+      #     sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+      #     def saved_change_to_review_date; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def reviewed; end
+      #     sig { params(reviewd: T::Boolean).returns(T::Boolean) }
+      #     def reviewed=(reviewed); end
       #
-      #   sig { returns(T::Boolean) }
-      #   def reviewed_was; end
+      #     sig { returns(T::Boolean) }
+      #     def reviewed; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def reviewed_changed?; end
+      #     sig { returns(T::Boolean) }
+      #     def reviewed_was; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def reviewed_before_last_save; end
+      #     sig { returns(T::Boolean) }
+      #     def reviewed_changed?; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def saved_change_to_reviewed?; end
+      #     sig { returns(T::Boolean) }
+      #     def reviewed_before_last_save; end
       #
-      #   sig { returns(T.nilable([T::Boolean, T::Boolean])) }
-      #   def reviewed_change; end
+      #     sig { returns(T::Boolean) }
+      #     def saved_change_to_reviewed?; end
       #
-      #   sig { returns(T.nilable([T::Boolean, T::Boolean])) }
-      #   def saved_change_to_reviewed; end
+      #     sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+      #     def reviewed_change; end
+      #
+      #     sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+      #     def saved_change_to_reviewed; end
+      #   end
       # end
       # ~~~
       class ActiveRecordTypedStore < Base
@@ -105,7 +109,11 @@ module Tapioca
                 type = type_for(field.type_sym)
                 type = "T.nilable(#{type})" if field.null && type != "T.untyped"
 
-                generate_methods(model, field.name.to_s, type)
+                model.create_module("StoreAccessors") do |store_accessors_module|
+                  generate_methods(store_accessors_module, field.name.to_s, type)
+                end
+
+                model.create_include("StoreAccessors")
               end
             end
           end

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

@@ -9,8 +9,6 @@ rescue LoadError
   return
 end
 
-return unless Tapioca::Compilers::Sorbet.supports?(:mixes_in_class_methods_multiple_args)
-
 module Tapioca
   module Compilers
     module Dsl

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

@@ -6,6 +6,8 @@ require "tapioca/rbi_ext/model"
 module Tapioca
   module Compilers
     module Dsl
+      COMPILERS_PATH = T.let(File.expand_path("..", __FILE__).to_s, String)
+
       class Base
         extend T::Sig
         extend T::Helpers
@@ -17,9 +19,13 @@ module Tapioca
         sig { returns(T::Set[Module]) }
         attr_reader :processable_constants
 
+        sig { returns(T::Array[String]) }
+        attr_reader :errors
+
         sig { void }
         def initialize
           @processable_constants = T.let(Set.new(gather_constants), T::Set[Module])
+          @errors = T.let([], T::Array[String])
         end
 
         sig { params(constant: Module).returns(T::Boolean) }
@@ -41,6 +47,12 @@ module Tapioca
         sig { abstract.returns(T::Enumerable[Module]) }
         def gather_constants; end
 
+        # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+        sig { params(error: String).void }
+        def add_error(error)
+          @errors << error
+        end
+
         private
 
         sig { returns(T::Enumerable[Class]) }

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

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 begin
-  require "rails/railtie"
   require "identity_cache"
 rescue LoadError
   # means IdentityCache is not installed,