tapioca 0.5.0 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f062008a7e93aa3119ee191492917febf4a97294753865bb58ae0bac91e582d8
-  data.tar.gz: d4b89c7368da54276c54977ae742ce1765178ac6700193a9aefb5c1e65bc9dcd
+  metadata.gz: 28c385b223b0ab1221b81420ad3a40222ff243552e121959e1e2290b1711357e
+  data.tar.gz: 1c06cd621dee12c9afd506a669c2762d2c7ca2f471f2a22b4e38bde6092f9f13
 SHA512:
-  metadata.gz: 4466416f851f4e6a7e8342a8dae5229e38ede32da3823c0a7cdd97dc3bff6a3e3711d983d5552fc083725789bb3b0a6899b4cf2edcc5c855bc33224054598987
-  data.tar.gz: d66b2a55050aae7089d7349e9c4e43cc1a2e2c1f181805f5c9d6b1a1e2c26c3b3c7b9d939efc0580f4d83cde4c615dd13e4d40f30682c2cfc441fde58e22f23a
+  metadata.gz: e8f6278d058bef31b5fdac1d94556814de7486355d1bcdf9fb2e29da6f33743ec5c330befb492b51ada82d392d10bae2e0c663eda7a365c1272631add49adce6
+  data.tar.gz: 4a342639d1ab6a79b83f6273ac9d44589919953f70773d0492c8c038250f344541d280801db88be72883dd8c55ff8ccd9fafa9ffcbff32e5421df2e821b59365

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,27 @@ module Tapioca
       type: :boolean,
       default: false,
       desc: "Verifies RBIs are up-to-date"
+    option :doc,
+      type: :boolean,
+      default: false,
+      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 +157,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_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_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/mixed_in_class_attributes.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_support/core_ext/class/attribute"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::MixedInClassAttributes` generates RBI files for modules that dynamically use
+      # `class_attribute` on classes.
+      #
+      # For example, given the following concern
+      #
+      # ~~~rb
+      # module Taggeable
+      #   extend ActiveSupport::Concern
+      #
+      #   included do
+      #     class_attribute :tag
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `taggeable.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # typed: strong
+      #
+      # module Taggeable
+      #   include GeneratedInstanceMethods
+      #
+      #   mixes_in_class_methods GeneratedClassMethods
+      #
+      #   module GeneratedClassMethods
+      #     def tag; end
+      #     def tag=(value); end
+      #     def tag?; end
+      #   end
+      #
+      #   module GeneratedInstanceMethods
+      #     def tag; end
+      #     def tag=(value); end
+      #     def tag?; end
+      #   end
+      # end
+      # ~~~
+      class MixedInClassAttributes < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: Module).void }
+        def decorate(root, constant)
+          mixin_compiler = DynamicMixinCompiler.new(constant)
+          return if mixin_compiler.empty_attributes?
+
+          root.create_path(constant) do |mod|
+            mixin_compiler.compile_class_attributes(mod)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # Select all non-anonymous modules that have overridden Module.included
+          all_modules.select do |mod|
+            !mod.is_a?(Class) && name_of(mod) && Tapioca::Reflection.method_of(mod, :included).owner != Module
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -84,10 +84,10 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          all_classes.select do |c|
-            c < ::SmartProperties
-          end.reject do |c|
-            name_of(c).nil? || c == ::SmartProperties::Validations::Ancestor
+          all_modules.select do |c|
+            name_of(c) &&
+              c != ::SmartProperties::Validations::Ancestor &&
+              c < ::SmartProperties && ::SmartProperties::ClassMethods === c
           end
         end
 

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -34,7 +34,7 @@ module Tapioca
         @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 }
+      sig { params(blk: T.proc.params(constant: Module, rbi: RBI::File).void).void }
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
 
@@ -51,6 +51,10 @@ module Tapioca
 
           blk.call(constant, rbi)
         end
+
+        generators.flat_map(&:errors).each do |msg|
+          report_error(msg)
+        end
       end
 
       private
@@ -77,7 +81,7 @@ module Tapioca
         constants
       end
 
-      sig { params(constant: Module).returns(T.nilable(String)) }
+      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
@@ -88,10 +92,7 @@ module Tapioca
 
         return if file.root.empty?
 
-        file.root.nest_non_public_methods!
-        file.root.group_nodes!
-        file.root.sort_nodes!
-        file.string
+        file
       end
 
       sig { params(error: String).returns(T.noreturn) }