tapioca 0.4.24 → 0.5.1

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/symbol_table_compiler.rb

@@ -8,7 +8,7 @@ module Tapioca
 
       sig do
         params(
-          gem: Gemfile::Gem,
+          gem: Gemfile::GemSpec,
           indent: Integer
         ).returns(String)
       end

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

@@ -20,7 +20,7 @@ module Tapioca
     sig { returns(Bundler::Definition) }
     attr_reader(:definition)
 
-    sig { returns(T::Array[Gem]) }
+    sig { returns(T::Array[GemSpec]) }
     attr_reader(:dependencies)
 
     sig { returns(T::Array[String]) }
@@ -32,18 +32,18 @@ module Tapioca
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
       @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
       dependencies, missing_specs = load_dependencies
-      @dependencies = T.let(dependencies, T::Array[Gem])
+      @dependencies = T.let(dependencies, T::Array[GemSpec])
       @missing_specs = T.let(missing_specs, T::Array[String])
     end
 
-    sig { params(gem_name: String).returns(T.nilable(Gem)) }
+    sig { params(gem_name: String).returns(T.nilable(GemSpec)) }
     def gem(gem_name)
       dependencies.detect { |dep| dep.name == gem_name }
     end
 
     sig { void }
-    def require
-      T.unsafe(runtime).setup(*groups).require(*groups)
+    def require_bundle
+      T.unsafe(runtime).require(*groups)
     end
 
     private
@@ -51,23 +51,32 @@ module Tapioca
     sig { returns(File) }
     attr_reader(:gemfile, :lockfile)
 
-    sig { returns([T::Array[Gem], T::Array[String]]) }
+    sig { returns([T::Array[GemSpec], T::Array[String]]) }
     def load_dependencies
-      deps = definition.locked_gems.dependencies.values
-
-      missing_specs = T::Array[String].new
-
-      dependencies = definition
-        .resolve
-        .materialize(deps, missing_specs)
-        .map { |spec| Gem.new(spec) }
+      materialized_dependencies, missing_specs = materialize_deps
+      dependencies = materialized_dependencies
+        .map { |spec| GemSpec.new(spec) }
         .reject { |gem| gem.ignore?(dir) }
         .uniq(&:rbi_file_name)
         .sort_by(&:rbi_file_name)
-
       [dependencies, missing_specs]
     end
 
+    sig { returns([T::Enumerable[Spec], T::Array[String]]) }
+    def materialize_deps
+      deps = definition.locked_gems.dependencies.values
+      missing_specs = T::Array[String].new
+      materialized_dependencies = if definition.resolve.method(:materialize).arity == 1 # Support bundler >= v2.2.25
+        md = definition.resolve.materialize(deps)
+        missing_spec_names = md.missing_specs.map(&:name)
+        missing_specs = T.cast(md.missing_specs.map { |spec| "#{spec.name} (#{spec.version})" }, T::Array[String])
+        md.to_a.reject { |spec| missing_spec_names.include?(spec.name) }
+      else
+        definition.resolve.materialize(deps, missing_specs)
+      end
+      [materialized_dependencies, missing_specs]
+    end
+
     sig { returns(Bundler::Runtime) }
     def runtime
       Bundler::Runtime.new(File.dirname(gemfile.path), definition)
@@ -83,12 +92,10 @@ module Tapioca
       File.expand_path(gemfile.path + "/..")
     end
 
-    class Gem
+    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,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'pathname'
-require 'thor'
-require "tapioca/core_ext/string"
+require "pathname"
+require "thor"
 
 module Tapioca
   class Generator < ::Thor::Shell::Color
@@ -63,11 +62,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 +117,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 +138,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 +178,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 +206,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 +216,7 @@ module Tapioca
 
     sig { returns(Loader) }
     def loader
-      @loader ||= Loader.new(bundle)
+      @loader ||= Loader.new
     end
 
     sig { returns(Compilers::SymbolTableCompiler) }
@@ -217,7 +228,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 +236,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
@@ -260,7 +271,7 @@ module Tapioca
     def load_application(eager_load:)
       say("Loading Rails application... ")
 
-      loader.load_rails(
+      loader.load_rails_application(
         environment_load: true,
         eager_load: eager_load
       )
@@ -285,11 +296,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 +314,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 +356,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 +370,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) }
@@ -456,7 +491,7 @@ module Tapioca
 
     sig do
       params(gem_names: T::Array[String])
-        .returns(T::Array[Gemfile::Gem])
+        .returns(T::Array[Gemfile::GemSpec])
     end
     def gems_to_generate(gem_names)
       return bundle.dependencies if gem_names.empty?
@@ -483,10 +518,16 @@ 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::Gem).void }
+    sig { params(gem: Gemfile::GemSpec).void }
     def compile_gem_rbi(gem)
       compiler = Compilers::SymbolTableCompiler.new
       gem_name = set_color(gem.name, :yellow, :bold)
@@ -525,7 +566,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 +639,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 +691,27 @@ 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")
+      return unless defined?(::Rake)
 
-        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