tapioca 0.4.27 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91440af4ff5a8cd586284d4d5a2cc35600ec803b825bdcd57492a3eb94b65bf3
-  data.tar.gz: d6db15fe94c5cd0e8100f8bf1fd8fb9a760123891cee3b079470011719dc55e0
+  metadata.gz: 8201f29f7abb78a5625f206893b18ff2a8f1ac9ffcae2784a90446764680bda3
+  data.tar.gz: 680b85b7a109985b60e4a727fd3295507daec445f26983703c6ba27a2882b24a
 SHA512:
-  metadata.gz: 536bcacea8d4b5848dc8075fc94f50d34d80c23f00b9ea331862f911be6eb58c3a62b30d529663ddfd60441f632aab62e6250d8dc1c7a1a8f32dbfc0d510ae18
-  data.tar.gz: 57942419606b3d054fb392b6c3c026bff5aa7f63cb3cfc58defb8dbc81e49e72902eb26a8ebb9713561f21d4822a644fd6b9a36c7f2c0a135461b3b4e1d9c267
+  metadata.gz: 0df81ab9e557367adc414569a5bc67e581b2c98a13aa728ba46bcc831dfe490d4c3b81b9fe828c677f9eae74521b94f13c2217014dd900ddbe43144085f1cb83
+  data.tar.gz: 72f0f551108b0d1e2d3b7ce5420ff638fc81bec650a1563b5f0223c04b4646ce625cf5203b047495c873b4cb454b7fd2d910cafffd1afc39b987bac081b7e958

data/Gemfile

@@ -11,28 +11,28 @@ 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")
 end
 
 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("smart_properties", require: false)
+  gem("frozen_record", require: false)
+  gem("sprockets", require: false)
+  gem("rails", require: false)
+  gem("state_machines", require: false)
+  gem("activerecord-typedstore", require: false)
   gem("sqlite3")
-  gem("identity_cache", "~> 1.0", require: false)
+  gem("identity_cache", 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)
-  # Fix version to 0.14.1 since it is the last version to support Ruby 2.4
-  gem("shopify-money", "= 0.14.1", require: false)
-  gem("sidekiq", "~> 5.0", require: false) # Version 6 dropped support for Ruby 2.4
-  gem("nokogiri", "1.10.10", require: false) # Lock to last supported for Ruby 2.4
+  gem("activeresource", require: false)
+  gem("google-protobuf", require: false)
+  gem("shopify-money", require: false)
+  gem("sidekiq", require: false)
+  gem("nokogiri", require: false)
+  gem("config", require: false)
+  gem("aasm", require: false)
+  gem("bcrypt", require: false)
 end

data/README.md

@@ -117,8 +117,8 @@ This will generate DSL RBIs for specified constants (or for all handled constant
 
 ## 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.
+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/main/CODE_OF_CONDUCT.md) code of conduct.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://github.com/Shopify/tapioca/blob/master/LICENSE.txt).
+The gem is available as open source under the terms of the [MIT License](https://github.com/Shopify/tapioca/blob/main/LICENSE.txt).

data/Rakefile

@@ -2,7 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
-Dir['tasks/**/*.rake'].each { |t| load t }
+Dir["tasks/**/*.rake"].each { |t| load t }
 
 Rake.application.options.trace = false
 
@@ -10,15 +10,13 @@ Rake::TestTask.new do |t|
   t.libs << "lib"
   t.libs << "spec"
   t.warning = false
-  t.test_files = FileList['spec/**/*_spec.rb']
+  t.test_files = FileList["spec/**/*_spec.rb"]
 end
 
 task(:spec) do
-  begin
-    Rake::Task[:test].execute
-  rescue RuntimeError
-    exit(1)
-  end
+  Rake::Task[:test].execute
+rescue RuntimeError
+  exit(1)
 end
 
 task(default: :spec)

data/exe/tapioca

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
+require "sorbet-runtime"
 
 begin
   T::Configuration.default_checked_level = :never
@@ -20,4 +20,4 @@ end
 
 require_relative "../lib/tapioca/internal"
 
-Tapioca::Cli::Main.start(ARGV)
+Tapioca::Cli.start(ARGV)

data/lib/tapioca/cli.rb

@@ -1,8 +1,178 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'thor'
+require "thor"
 
 module Tapioca
-  module Cli; end
+  class Cli < Thor
+    class_option :outdir,
+      aliases: ["--out", "-o"],
+      banner: "directory",
+      desc: "The output directory for generated RBI files"
+    class_option :generate_command,
+      aliases: ["--cmd", "-c"],
+      banner: "command",
+      desc: "The command to run to regenerate RBI files"
+    class_option :file_header,
+      type: :boolean,
+      default: true,
+      desc: "Add a \"This file is generated\" header on top of each generated RBI file"
+    class_option :verbose,
+      aliases: ["-V"],
+      type: :boolean,
+      default: false,
+      desc: "Verbose output for debugging purposes"
+
+    map T.unsafe(["--version", "-v"] => :__print_version)
+
+    desc "init", "initializes folder structure"
+    def init
+      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.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.generate
+      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"
+    option :exclude_generators,
+      type: :array,
+      banner: "generator [generator ...]",
+      desc: "Exclude supplied DSL generators"
+    option :verify,
+      type: :boolean,
+      default: false,
+      desc: "Verifies RBIs are up-to-date"
+    option :quiet,
+      aliases: ["-q"],
+      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.generate
+      end
+    end
+
+    desc "gem [gem...]", "generate RBIs from gems"
+    option :all,
+      type: :boolean,
+      default: false,
+      desc: "Regenerate RBI files for all 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"
+    option :verify,
+      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
+
+        unless gems.empty?
+          raise MalformattedArgumentError, "Option '--all' must be provided without any other arguments" if all
+          raise MalformattedArgumentError, "Option '--verify' must be provided without any other arguments" if verify
+        end
+
+        if gems.empty? && !all
+          generator.sync(should_verify: verify)
+        else
+          generator.generate
+        end
+      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
+      end
+    end
+  end
 end

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

@@ -0,0 +1,122 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+  require "aasm"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::AASM` generate types for AASM state machines.
+      # This gem dynamically defines constants and methods at runtime. For
+      # example, given a class:
+      #
+      #   class MyClass
+      #     include AASM
+      #
+      #     aasm do
+      #       state :sleeping, initial: true
+      #       state :running, :cleaning
+      #
+      #       event :run do
+      #         transitions from: :sleeping, to: :running
+      #       end
+      #     end
+      #   end
+      #
+      # This will result in the following constants being defined:
+      #
+      #   STATE_SLEEPING, STATE_RUNNING, STATE_CLEANING
+      #
+      # and the following methods being defined:
+      #
+      #   sleeping?, running?, cleaning?
+      #   run, run!, run_without_validation!, may_run?
+      #
+      class AASM < Tapioca::Compilers::Dsl::Base
+        extend T::Sig
+
+        # Taken directly from the AASM::Core::Event class, here:
+        # https://github.com/aasm/aasm/blob/0e03746/lib/aasm/core/event.rb#L21-L29
+        EVENT_CALLBACKS =
+          T.let(
+            ["after", "after_commit", "after_transaction", "before", "before_transaction", "ensure", "error",
+             "before_success", "success"].freeze,
+            T::Array[String]
+          )
+
+        sig { override.params(root: RBI::Tree, constant: T.all(::AASM::ClassMethods, Class)).void }
+        def decorate(root, constant)
+          aasm = constant.aasm
+          return if !aasm || aasm.states.empty?
+
+          root.create_path(constant) do |model|
+            # Create all of the constants and methods for each state
+            aasm.states.each do |state|
+              model.create_constant("STATE_#{state.name.upcase}", value: "T.let(T.unsafe(nil), Symbol)")
+              model.create_method("#{state.name}?", return_type: "T::Boolean")
+            end
+
+            # Create all of the methods for each event
+            parameters = [create_rest_param("opts", type: "T.untyped")]
+            aasm.events.each do |event|
+              model.create_method(event.name.to_s, parameters: parameters)
+              model.create_method("#{event.name}!", parameters: parameters)
+              model.create_method("#{event.name}_without_validation!", parameters: parameters)
+              model.create_method("may_#{event.name}?", return_type: "T::Boolean")
+            end
+
+            # Create the overall state machine method, which will return an
+            # instance of the PrivateAASMMachine class.
+            model.create_method(
+              "aasm",
+              parameters: [
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("block", type: "T.nilable(T.proc.bind(PrivateAASMMachine).void)"),
+              ],
+              return_type: "PrivateAASMMachine",
+              class_method: true
+            )
+
+            # Create a private machine class that we can pass around for the
+            # purpose of binding various procs passed to methods without having
+            # to explicitly bind self in each one.
+            model.create_class("PrivateAASMMachine", superclass_name: "AASM::Base") do |machine|
+              machine.create_method(
+                "event",
+                parameters: [
+                  create_param("name", type: "T.untyped"),
+                  create_opt_param("options", default: "nil", type: "T.untyped"),
+                  create_block_param("block", type: "T.proc.bind(PrivateAASMEvent).void"),
+                ]
+              )
+
+              # Create a private event class that we can pass around for the
+              # purpose of binding all of the callbacks without having to
+              # explicitly bind self in each one.
+              machine.create_class("PrivateAASMEvent", superclass_name: "AASM::Core::Event") do |event|
+                EVENT_CALLBACKS.each do |method|
+                  event.create_method(
+                    method,
+                    parameters: [
+                      create_block_param("block", type: "T.proc.bind(#{constant.name}).void"),
+                    ]
+                  )
+                end
+              end
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          T.cast(ObjectSpace.each_object(::AASM::ClassMethods), T::Enumerable[Module])
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "action_controller"
 rescue LoadError
@@ -72,38 +70,54 @@ module Tapioca
 
         sig do
           override
-            .params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionController::Base))
+            .params(root: RBI::Tree, constant: T.class_of(::ActionController::Base))
             .void
         end
         def decorate(root, constant)
+          helpers_module = constant._helpers
+          proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
+
           helper_proxy_name = "HelperProxy"
           helper_methods_name = "HelperMethods"
-          proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
 
           # Define the helpers method
-          root.path(constant) do |controller|
-            create_method(controller, 'helpers', return_type: helper_proxy_name)
+          root.create_path(constant) do |controller|
+            controller.create_method("helpers", return_type: helper_proxy_name)
 
             # Create helper method module
             controller.create_module(helper_methods_name) do |helper_methods|
-              helpers_module = constant._helpers
+              # If the controller has no helper defined, then it just inherits
+              # the Action Controlller base helper methods module, so we should
+              # just add that as an include and stop doing more processing.
+              if helpers_module.name == "ActionController::Base::HelperMethods"
+                next helper_methods.create_include(T.must(qualified_name_of(helpers_module)))
+              end
 
+              # Find all the included helper modules and generate an include
+              # for each of those helper modules
               gather_includes(helpers_module).each do |ancestor|
                 helper_methods.create_include(ancestor)
               end
 
+              # Generate a method definition in the helper module for each
+              # helper method defined via the `helper_method` call in the controller.
               helpers_module.instance_methods(false).each do |method_name|
                 method = if proxied_helper_methods.include?(method_name)
-                  constant.instance_method(method_name)
+                  helper_method_proxy_target(constant, method_name)
                 else
                   helpers_module.instance_method(method_name)
                 end
-                create_method_from_def(helper_methods, method)
+
+                if method
+                  create_method_from_def(helper_methods, method)
+                else
+                  create_unknown_proxy_method(helper_methods, method_name)
+                end
               end
             end
 
             # Create helper proxy class
-            controller.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
+            controller.create_class(helper_proxy_name, superclass_name: "::ActionView::Base") do |proxy|
               proxy.create_include(helper_methods_name)
             end
           end
@@ -111,16 +125,42 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionController::Base.descendants.reject(&:abstract?).select(&:name)
+          descendants_of(::ActionController::Base).reject(&:abstract?).select(&:name)
         end
 
         private
 
+        sig do
+          params(
+            constant: T.class_of(::ActionController::Base),
+            method_name: Symbol
+          ).returns(T.nilable(UnboundMethod))
+        end
+        def helper_method_proxy_target(constant, method_name)
+          # Lookup the proxy target method only if it is defined as a public/protected or private method.
+          if constant.method_defined?(method_name) || constant.private_method_defined?(method_name)
+            constant.instance_method(method_name)
+          end
+        end
+
+        sig { params(helper_methods: RBI::Scope, method_name: Symbol).void }
+        def create_unknown_proxy_method(helper_methods, method_name)
+          helper_methods.create_method(
+            method_name.to_s,
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_kw_rest_param("kwargs", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
+            ],
+            return_type: "T.untyped"
+          )
+        end
+
         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| "::#{ancestor.name}" }
+            .map { |ancestor| T.must(qualified_name_of(ancestor)) }
             .reverse
         end
       end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "action_mailer"
 rescue LoadError
@@ -38,17 +36,16 @@ module Tapioca
       class ActionMailer < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionMailer::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActionMailer::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |mailer|
+          root.create_path(constant) do |mailer|
             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(
-                mailer,
+              parameters = compile_method_parameters_to_rbi(method_def)
+              mailer.create_method(
                 mailer_method,
                 parameters: parameters,
-                return_type: '::ActionMailer::MessageDelivery',
+                return_type: "::ActionMailer::MessageDelivery",
                 class_method: true
               )
             end
@@ -57,7 +54,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionMailer::Base.descendants.reject(&:abstract?)
+          descendants_of(::ActionMailer::Base).reject(&:abstract?)
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_job"
 rescue LoadError
@@ -42,25 +40,23 @@ module Tapioca
       class ActiveJob < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActiveJob::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveJob::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |job|
-            next unless constant.instance_methods(false).include?(:perform)
+          return unless constant.instance_methods(false).include?(:perform)
 
+          root.create_path(constant) do |job|
             method = constant.instance_method(:perform)
-            parameters = compile_method_parameters_to_parlour(method)
-            return_type = compile_method_return_type_to_parlour(method)
+            parameters = compile_method_parameters_to_rbi(method)
+            return_type = compile_method_return_type_to_rbi(method)
 
-            create_method(
-              job,
+            job.create_method(
               "perform_later",
               parameters: parameters,
               return_type: "T.any(#{constant.name}, FalseClass)",
               class_method: true
             )
 
-            create_method(
-              job,
+            job.create_method(
               "perform_now",
               parameters: parameters,
               return_type: return_type,
@@ -71,7 +67,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveJob::Base.descendants
+          descendants_of(::ActiveJob::Base)
         end
       end
     end