tapioca 0.4.26 → 0.5.0

data/lib/tapioca/compilers/symbol_table/symbol_loader.rb

@@ -1,8 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'json'
-require 'tempfile'
+require "json"
+require "tempfile"
 
 module Tapioca
   module Compilers
@@ -25,7 +25,7 @@ module Tapioca
 
           sig { params(paths: T::Array[String]).returns(T::Set[String]) }
           def load_symbols(paths)
-            output = T.cast(Tempfile.create('sorbet') do |file|
+            output = T.cast(Tempfile.create("sorbet") do |file|
               file.write(Array(paths).join("\n"))
               file.flush
 
@@ -69,7 +69,7 @@ module Tapioca
               # TODO: CLASS is removed since v0.4.4730 of Sorbet
               # but keeping here for backward compatibility. Remove
               # once the minimum version is moved past that.
-              next unless %w[CLASS CLASS_OR_MODULE STATIC_FIELD].include?(kind)
+              next unless ["CLASS", "CLASS_OR_MODULE", "STATIC_FIELD"].include?(kind)
               next if name =~ /[<>()$]/
               next if name =~ /^[0-9]+$/
               next if name == "T::Helpers"

data/lib/tapioca/compilers/todos_compiler.rb

@@ -13,7 +13,7 @@ module Tapioca
       def compile
         list_todos.each_line.map do |line|
           next if line.include?("<") || line.include?("class_of")
-          "module #{line.strip.gsub('T.untyped::', '')}; end"
+          "module #{line.strip.gsub("T.untyped::", "")}; end"
         end.compact.join("\n")
       end
 

data/lib/tapioca/config.rb

@@ -9,9 +9,11 @@ module Tapioca
     const(:prerequire, T.nilable(String))
     const(:postrequire, String)
     const(:exclude, T::Array[String])
+    const(:exclude_generators, T::Array[String])
     const(:typed_overrides, T::Hash[String, String])
     const(:todos_path, String)
     const(:generators, T::Array[String])
+    const(:file_header, T::Boolean, default: true)
 
     sig { returns(Pathname) }
     def outpath

data/lib/tapioca/config_builder.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'yaml'
+require "yaml"
 
 module Tapioca
   class ConfigBuilder
@@ -33,7 +33,7 @@ module Tapioca
       sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
       def default_options(command)
         default_outdir = case command
-        when :sync, :generate
+        when :sync, :generate, :gem
           Config::DEFAULT_GEMDIR
         when :dsl
           Config::DEFAULT_DSLDIR
@@ -62,9 +62,11 @@ module Tapioca
       "postrequire" => Config::DEFAULT_POSTREQUIRE,
       "outdir" => nil,
       "exclude" => [],
+      "exclude_generators" => [],
       "typed_overrides" => Config::DEFAULT_OVERRIDES,
       "todos_path" => Config::DEFAULT_TODOSPATH,
       "generators" => [],
+      "file_header" => true,
     }.freeze, T::Hash[String, T.untyped])
   end
 end

data/lib/tapioca/constant_locator.rb

@@ -1,7 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module Tapioca
   # Registers a TracePoint immediately upon load to track points at which
@@ -9,15 +9,14 @@ module Tapioca
   # correspondence between classes/modules and files, as this information isn't
   # available in the ruby runtime without extra accounting.
   module ConstantLocator
-    @class_files = {}
+    extend Reflection
 
-    NAME = Module.instance_method(:name)
-    private_constant :NAME
+    @class_files = {}
 
     # Immediately activated upon load. Observes class/module definition.
     TracePoint.trace(:class) do |tp|
       unless tp.self.singleton_class?
-        key = NAME.bind(tp.self).call
+        key = name_of(tp.self)
         @class_files[key] ||= Set.new
         @class_files[key] << tp.path
       end
@@ -26,11 +25,10 @@ module Tapioca
     # Returns the files in which this class or module was opened. Doesn't know
     # about situations where the class was opened prior to +require+ing,
     # or where metaprogramming was used via +eval+, etc.
-    def files_for(klass)
-      name = String === klass ? klass : NAME.bind(klass).call
+    def self.files_for(klass)
+      name = String === klass ? klass : name_of(klass)
       files = @class_files[name]
       files || Set.new
     end
-    module_function :files_for
   end
 end

data/lib/tapioca/gemfile.rb

@@ -62,7 +62,7 @@ module Tapioca
       [dependencies, missing_specs]
     end
 
-    sig { returns([T::Array[::Gem::Specification], T::Array[String]]) }
+    sig { returns([T::Enumerable[Spec], T::Array[String]]) }
     def materialize_deps
       deps = definition.locked_gems.dependencies.values
       missing_specs = T::Array[String].new
@@ -95,9 +95,7 @@ module Tapioca
     class GemSpec
       extend(T::Sig)
 
-      IGNORED_GEMS = T.let(%w{
-        sorbet sorbet-static sorbet-runtime
-      }.freeze, T::Array[String])
+      IGNORED_GEMS = T.let(["sorbet", "sorbet-static", "sorbet-runtime"].freeze, T::Array[String])
 
       sig { returns(String) }
       attr_reader :full_gem_path, :version

data/lib/tapioca/generator.rb

@@ -1,9 +1,9 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'pathname'
-require 'thor'
-require "tapioca/core_ext/string"
+require "pathname"
+require "thor"
+require "rake"
 
 module Tapioca
   class Generator < ::Thor::Shell::Color
@@ -63,11 +63,8 @@ module Tapioca
       File.delete(requires_path) if File.exist?(requires_path)
 
       content = String.new
-      content << rbi_header(
-        "#{Config::DEFAULT_COMMAND} require",
-        reason: "explicit gem requires",
-        strictness: "false"
-      )
+      content << "# typed: true\n"
+      content << "# frozen_string_literal: true\n\n"
       content << rb_string
 
       outdir = File.dirname(requires_path)
@@ -121,11 +118,13 @@ module Tapioca
       params(
         requested_constants: T::Array[String],
         should_verify: T::Boolean,
-        quiet: T::Boolean
+        quiet: T::Boolean,
+        verbose: T::Boolean
       ).void
     end
-    def build_dsl(requested_constants, should_verify: false, quiet: false)
+    def build_dsl(requested_constants, should_verify: false, quiet: false, verbose: false)
       load_application(eager_load: requested_constants.empty?)
+      abort_if_pending_migrations!
       load_dsl_generators
 
       if should_verify
@@ -140,20 +139,26 @@ module Tapioca
 
       compiler = Compilers::DslCompiler.new(
         requested_constants: constantize(requested_constants),
-        requested_generators: config.generators,
+        requested_generators: constantize_generators(config.generators),
+        excluded_generators: constantize_generators(config.exclude_generators),
         error_handler: ->(error) {
           say_error(error, :bold, :red)
         }
       )
 
       compiler.run do |constant, contents|
-        constant_name = Module.instance_method(:name).bind(constant).call
+        constant_name = T.must(Reflection.name_of(constant))
+
+        if verbose && !quiet
+          say("Processing: ", [:yellow])
+          say(constant_name)
+        end
 
         filename = compile_dsl_rbi(
           constant_name,
           contents,
           outpath: outpath,
-          quiet: should_verify || quiet
+          quiet: should_verify || quiet && !verbose
         )
 
         if filename
@@ -174,8 +179,15 @@ module Tapioca
       end
     end
 
-    sig { void }
-    def sync_rbis_with_gemfile
+    sig { params(should_verify: T::Boolean).void }
+    def sync_rbis_with_gemfile(should_verify: false)
+      if should_verify
+        say("Checking for out-of-date RBIs...")
+        say("")
+        perform_sync_verification
+        return
+      end
+
       anything_done = [
         perform_removals,
         perform_additions,
@@ -195,7 +207,7 @@ module Tapioca
 
     EMPTY_RBI_COMMENT = <<~CONTENT
       # THIS IS AN EMPTY RBI FILE.
-      # see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+      # see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
     CONTENT
 
     sig { returns(Gemfile) }
@@ -205,7 +217,7 @@ module Tapioca
 
     sig { returns(Loader) }
     def loader
-      @loader ||= Loader.new(bundle)
+      @loader ||= Loader.new
     end
 
     sig { returns(Compilers::SymbolTableCompiler) }
@@ -217,7 +229,7 @@ module Tapioca
     def require_gem_file
       say("Requiring all gems to prepare for compiling... ")
       begin
-        loader.load_bundle(config.prerequire, config.postrequire)
+        loader.load_bundle(bundle, config.prerequire, config.postrequire)
       rescue LoadError => e
         explain_failed_require(config.postrequire, e)
         exit(1)
@@ -225,7 +237,7 @@ module Tapioca
       say(" Done", :green)
       unless bundle.missing_specs.empty?
         say("  completed with missing specs: ")
-        say(bundle.missing_specs.join(', '), :yellow)
+        say(bundle.missing_specs.join(", "), :yellow)
       end
       puts
     end
@@ -285,11 +297,9 @@ module Tapioca
     sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
     def constantize(constant_names)
       constant_map = constant_names.map do |name|
-        begin
-          [name, Object.const_get(name)]
-        rescue NameError
-          [name, nil]
-        end
+        [name, Object.const_get(name)]
+      rescue NameError
+        [name, nil]
       end.to_h
 
       unprocessable_constants = constant_map.select { |_, v| v.nil? }
@@ -305,6 +315,32 @@ module Tapioca
       constant_map.values
     end
 
+    sig { params(generator_names: T::Array[String]).returns(T::Array[T.class_of(Compilers::Dsl::Base)]) }
+    def constantize_generators(generator_names)
+      generator_map = generator_names.map do |name|
+        # Try to find built-in tapioca generator first, then globally defined generator. The
+        # explicit `break` ensures the class is returned, not the `potential_name`.
+        generator_klass = ["Tapioca::Compilers::Dsl::#{name}", name].find do |potential_name|
+          break Object.const_get(potential_name)
+        rescue NameError
+          # Skip if we can't find generator by the potential name
+        end
+
+        [name, generator_klass]
+      end.to_h
+
+      unprocessable_generators = generator_map.select { |_, v| v.nil? }
+      unless unprocessable_generators.empty?
+        unprocessable_generators.each do |name, _|
+          say("Error: Cannot find generator '#{name}'", :red)
+        end
+
+        exit(1)
+      end
+
+      generator_map.values
+    end
+
     sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
     def existing_rbi_filenames(requested_constants, path: config.outpath)
       filenames = if requested_constants.empty?
@@ -321,7 +357,7 @@ module Tapioca
     sig { returns(T::Hash[String, String]) }
     def existing_rbis
       @existing_rbis ||= Pathname.glob((config.outpath / "*@*.rbi").to_s)
-        .map { |f| T.cast(f.basename(".*").to_s.split('@', 2), [String, String]) }
+        .map { |f| T.cast(f.basename(".*").to_s.split("@", 2), [String, String]) }
         .to_h
     end
 
@@ -335,7 +371,7 @@ module Tapioca
 
     sig { params(constant_name: String).returns(Pathname) }
     def dsl_rbi_filename(constant_name)
-      config.outpath / "#{constant_name.underscore}.rbi"
+      config.outpath / "#{underscore(constant_name)}.rbi"
     end
 
     sig { params(gem_name: String, version: String).returns(Pathname) }
@@ -483,7 +519,13 @@ module Tapioca
         # typed: #{strictness}
       SIGIL
 
-      [statement, sigil].compact.join("\n").strip.concat("\n\n")
+      if config.file_header
+        [statement, sigil].compact.join("\n").strip.concat("\n\n")
+      elsif sigil
+        sigil.strip.concat("\n\n")
+      else
+        ""
+      end
     end
 
     sig { params(gem: Gemfile::GemSpec).void }
@@ -525,7 +567,7 @@ module Tapioca
     def compile_dsl_rbi(constant_name, contents, outpath: config.outpath, quiet: false)
       return if contents.nil?
 
-      rbi_name = constant_name.underscore + ".rbi"
+      rbi_name = underscore(constant_name) + ".rbi"
       filename = outpath / rbi_name
 
       out = String.new
@@ -598,11 +640,47 @@ module Tapioca
     def perform_dsl_verification(dir)
       diff = verify_dsl_rbi(tmp_dir: dir)
 
+      report_diff_and_exit_if_out_of_date(diff, "dsl")
+    ensure
+      FileUtils.remove_entry(dir)
+    end
+
+    sig { params(files: T::Set[Pathname]).void }
+    def purge_stale_dsl_rbi_files(files)
+      if files.any?
+        say("Removing stale RBI files...")
+
+        files.sort.each do |filename|
+          remove(filename)
+        end
+        say("")
+      end
+    end
+
+    sig { void }
+    def perform_sync_verification
+      diff = {}
+
+      removed_rbis.each do |gem_name|
+        filename = existing_rbi(gem_name)
+        diff[filename] = :removed
+      end
+
+      added_rbis.each do |gem_name|
+        filename = expected_rbi(gem_name)
+        diff[filename] = gem_rbi_exists?(gem_name) ? :changed : :added
+      end
+
+      report_diff_and_exit_if_out_of_date(diff, "sync")
+    end
+
+    sig { params(diff: T::Hash[String, Symbol], command: String).void }
+    def report_diff_and_exit_if_out_of_date(diff, command)
       if diff.empty?
         say("Nothing to do, all RBIs are up-to-date.")
       else
         say("RBI files are out-of-date. In your development environment, please run:", :green)
-        say("  `#{Config::DEFAULT_COMMAND} dsl`", [:green, :bold])
+        say("  `#{Config::DEFAULT_COMMAND} #{command}`", [:green, :bold])
         say("Once it is complete, be sure to commit and push any changes", :green)
 
         say("")
@@ -614,20 +692,26 @@ module Tapioca
 
         exit(1)
       end
-    ensure
-      FileUtils.remove_entry(dir)
     end
 
-    sig { params(files: T::Set[Pathname]).void }
-    def purge_stale_dsl_rbi_files(files)
-      if files.any?
-        say("Removing stale RBI files...")
+    sig { void }
+    def abort_if_pending_migrations!
+      return unless File.exist?("config/application.rb")
 
-        files.sort.each do |filename|
-          remove(filename)
-        end
-        say("")
-      end
+      Rails.application.load_tasks
+      Rake::Task["db:abort_if_pending_migrations"].invoke if Rake::Task.task_defined?("db:abort_if_pending_migrations")
+    end
+
+    sig { params(class_name: String).returns(String) }
+    def underscore(class_name)
+      return class_name unless /[A-Z-]|::/.match?(class_name)
+
+      word = class_name.to_s.gsub("::", "/")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
     end
   end
 end

data/lib/tapioca/generic_type_registry.rb

@@ -20,14 +20,15 @@ module Tapioca
   # variable to type variable serializers. This allows us to associate type variables
   # to the constant names that represent them, easily.
   module GenericTypeRegistry
+    TypeVariable = T.type_alias { T.any(TypeMember, TypeTemplate) }
     @generic_instances = T.let(
       {},
       T::Hash[String, Module]
     )
 
     @type_variables = T.let(
-      {},
-      T::Hash[Integer, T::Hash[Integer, String]]
+      {}.compare_by_identity,
+      T::Hash[Module, T::Hash[TypeVariable, String]]
     )
 
     class << self
@@ -49,7 +50,7 @@ module Tapioca
         # Build the name of the instantiated generic type,
         # something like `"Foo[X, Y, Z]"`
         type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
-        name = "#{name_of(constant)}[#{type_list}]"
+        name = "#{Reflection.name_of(constant)}[#{type_list}]"
 
         # Create a generic type with an overridden `name`
         # method that returns the name we constructed above.
@@ -59,35 +60,30 @@ module Tapioca
         @generic_instances[name] ||= create_generic_type(constant, name)
       end
 
-      sig do
-        params(
-          constant: T.untyped,
-          type_member: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).void
-      end
-      def register_type_member(constant, type_member, fixed, lower, upper)
-        register_type_variable(constant, :type_member, type_member, fixed, lower, upper)
+      sig { params(constant: Module).returns(T.nilable(T::Hash[TypeVariable, String])) }
+      def lookup_type_variables(constant)
+        @type_variables[constant]
       end
 
+      # This method is called from intercepted calls to `type_member` and `type_template`.
+      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+      #
+      # This method creates a `String` with that data and stores it in the
+      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+      #
+      # Finally, the original `type_variable` is returned from this method, so that the caller
+      # can return it from the original methods as well.
       sig do
         params(
           constant: T.untyped,
-          type_template: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
+          type_variable: TypeVariable,
         ).void
       end
-      def register_type_template(constant, type_template, fixed, lower, upper)
-        register_type_variable(constant, :type_template, type_template, fixed, lower, upper)
-      end
+      def register_type_variable(constant, type_variable)
+        type_variables = lookup_or_initialize_type_variables(constant)
 
-      sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
-      def lookup_type_variables(constant)
-        @type_variables[object_id_of(constant)]
+        type_variables[type_variable] = type_variable.serialize
       end
 
       private
@@ -117,39 +113,6 @@ module Tapioca
         generic_type
       end
 
-      # This method is called from intercepted calls to `type_member` and `type_template`.
-      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
-      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
-      #
-      # This method creates a `String` with that data and stores it in the
-      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
-      #
-      # Finally, the original `type_variable` is returned from this method, so that the caller
-      # can return it from the original methods as well.
-      sig do
-        params(
-          constant: T.untyped,
-          type_variable_type: T.enum([:type_member, :type_template]),
-          type_variable: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).void
-      end
-      # rubocop:disable Metrics/ParameterLists
-      def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper)
-        # rubocop:enable Metrics/ParameterLists
-        type_variables = lookup_or_initialize_type_variables(constant)
-
-        type_variables[object_id_of(type_variable)] = serialize_type_variable(
-          type_variable_type,
-          type_variable.variance,
-          fixed,
-          lower,
-          upper
-        )
-      end
-
       sig { params(constant: Class).returns(Class) }
       def create_safe_subclass(constant)
         # Lookup the "inherited" class method
@@ -164,11 +127,9 @@ module Tapioca
           # Otherwise, some inherited method could be preventing us
           # from creating subclasses, so let's override it and rescue
           owner.send(:define_method, :inherited) do |s|
-            begin
-              inherited_method.call(s)
-            rescue
-              # Ignoring errors
-            end
+            inherited_method.call(s)
+          rescue
+            # Ignoring errors
           end
 
           # return a subclass
@@ -179,43 +140,9 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Hash[Integer, String]) }
+      sig { params(constant: Module).returns(T::Hash[TypeVariable, String]) }
       def lookup_or_initialize_type_variables(constant)
-        @type_variables[object_id_of(constant)] ||= {}
-      end
-
-      sig do
-        params(
-          type_variable_type: Symbol,
-          variance: Symbol,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).returns(String)
-      end
-      def serialize_type_variable(type_variable_type, variance, fixed, lower, upper)
-        parts = []
-        parts << ":#{variance}" unless variance == :invariant
-        parts << "fixed: #{fixed}" if fixed
-        parts << "lower: #{lower}" unless lower == T.untyped
-        parts << "upper: #{upper}" unless upper == BasicObject
-
-        parameters = parts.join(", ")
-
-        serialized = T.let(type_variable_type.to_s, String)
-        serialized += "(#{parameters})" unless parameters.empty?
-
-        serialized
-      end
-
-      sig { params(constant: Module).returns(T.nilable(String)) }
-      def name_of(constant)
-        Module.instance_method(:name).bind(constant).call
-      end
-
-      sig { params(object: BasicObject).returns(Integer) }
-      def object_id_of(object)
-        Object.instance_method(:object_id).bind(object).call
+        @type_variables[constant] ||= {}.compare_by_identity
       end
     end
   end