tapioca 0.6.4 → 0.7.0

data/lib/tapioca/{generators → commands}/dsl.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Generators
-    class Dsl < Base
+  module Commands
+    class Dsl < Command
       sig do
         params(
           requested_constants: T::Array[String],
@@ -13,12 +13,11 @@ module Tapioca
           file_header: T::Boolean,
           compiler_path: String,
           tapioca_path: String,
-          default_command: String,
-          file_writer: Thor::Actions,
           should_verify: T::Boolean,
           quiet: T::Boolean,
           verbose: T::Boolean,
           number_of_workers: T.nilable(Integer),
+          rbi_formatter: RBIFormatter
         ).void
       end
       def initialize(
@@ -29,12 +28,11 @@ module Tapioca
         file_header:,
         compiler_path:,
         tapioca_path:,
-        default_command:,
-        file_writer: FileWriter.new,
         should_verify: false,
         quiet: false,
         verbose: false,
-        number_of_workers: nil
+        number_of_workers: nil,
+        rbi_formatter: DEFAULT_RBI_FORMATTER
       )
         @requested_constants = requested_constants
         @outpath = outpath
@@ -47,18 +45,19 @@ module Tapioca
         @quiet = quiet
         @verbose = verbose
         @number_of_workers = number_of_workers
+        @rbi_formatter = rbi_formatter
 
-        super(default_command: default_command, file_writer: file_writer)
+        super()
 
-        @loader = T.let(nil, T.nilable(Loader))
+        @loader = T.let(nil, T.nilable(Runtime::Loader))
       end
 
       sig { override.void }
-      def generate
+      def execute
         load_dsl_extensions
         load_application(eager_load: @requested_constants.empty?)
         abort_if_pending_migrations!
-        load_dsl_generators
+        load_dsl_compilers
 
         if @should_verify
           say("Checking for out-of-date RBIs...")
@@ -70,18 +69,18 @@ module Tapioca
         outpath = @should_verify ? Pathname.new(Dir.mktmpdir) : @outpath
         rbi_files_to_purge = existing_rbi_filenames(@requested_constants)
 
-        compiler = Compilers::DslCompiler.new(
+        pipeline = Tapioca::Dsl::Pipeline.new(
           requested_constants: constantize(@requested_constants),
-          requested_generators: constantize_generators(@only),
-          excluded_generators: constantize_generators(@exclude),
+          requested_compilers: constantize_compilers(@only),
+          excluded_compilers: constantize_compilers(@exclude),
           error_handler: ->(error) {
             say_error(error, :bold, :red)
           },
           number_of_workers: @number_of_workers
         )
 
-        processed_files = compiler.run do |constant, contents|
-          constant_name = T.must(Reflection.name_of(constant))
+        processed_files = pipeline.run do |constant, contents|
+          constant_name = T.must(Tapioca::Runtime::Reflection.name_of(constant))
 
           if @verbose && !@quiet
             say_status(:processing, constant_name, :yellow)
@@ -91,7 +90,7 @@ module Tapioca
             constant_name,
             contents,
             outpath: outpath,
-            quiet: @should_verify || @quiet && !@verbose
+            quiet: @should_verify || (@quiet && !@verbose)
           )
         end
 
@@ -137,14 +136,15 @@ module Tapioca
       end
 
       sig { void }
-      def load_dsl_generators
-        say("Loading DSL generator classes... ")
+      def load_dsl_compilers
+        say("Loading DSL compiler classes... ")
 
         Dir.glob([
           "#{@compiler_path}/*.rb",
-          "#{@tapioca_path}/generators/**/*.rb",
-        ]).each do |generator|
-          require File.expand_path(generator)
+          "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
+          "#{@tapioca_path}/compilers/**/*.rb",
+        ]).each do |compiler|
+          require File.expand_path(compiler)
         end
 
         say("Done", :green)
@@ -165,11 +165,11 @@ module Tapioca
 
       sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
       def constantize(constant_names)
-        constant_map = constant_names.map do |name|
+        constant_map = constant_names.to_h do |name|
           [name, Object.const_get(name)]
         rescue NameError
           [name, nil]
-        end.to_h
+        end
 
         unprocessable_constants = constant_map.select { |_, v| v.nil? }
         unless unprocessable_constants.empty?
@@ -185,22 +185,35 @@ 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.to_h do |name|
-          [name, Compilers::Dsl::Base.resolve(name)]
+      sig { params(compiler_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+      def constantize_compilers(compiler_names)
+        compiler_map = compiler_names.to_h do |name|
+          [name, resolve(name)]
         end
 
-        unprocessable_generators = generator_map.select { |_, v| v.nil? }
-        unless unprocessable_generators.empty?
-          unprocessable_generators.each do |name, _|
-            say("Error: Cannot find generator '#{name}'", :red)
+        unprocessable_compilers = compiler_map.select { |_, v| v.nil? }
+        unless unprocessable_compilers.empty?
+          unprocessable_compilers.each do |name, _|
+            say("Error: Cannot find compiler '#{name}'", :red)
           end
 
           exit(1)
         end
 
-        T.cast(generator_map.values, T::Array[T.class_of(Compilers::Dsl::Base)])
+        T.cast(compiler_map.values, T::Array[T.class_of(Tapioca::Dsl::Compiler)])
+      end
+
+      sig { params(name: String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
+      def resolve(name)
+        # Try to find built-in tapioca compiler first, then globally defined compiler.
+        potentials = Tapioca::Dsl::Compilers::NAMESPACES.map do |namespace|
+          Object.const_get(namespace + name)
+        rescue NameError
+          # Skip if we can't find compiler by the potential name
+          nil
+        end
+
+        potentials.compact.first
       end
 
       sig do
@@ -216,13 +229,14 @@ module Tapioca
 
         filename = outpath / rbi_filename_for(constant_name)
 
-        rbi.set_file_header(
+        @rbi_formatter.write_header!(
+          rbi,
           generate_command_for(constant_name),
-          reason: "dynamic methods in `#{constant_name}`",
-          display_heading: @file_header
-        )
+          reason: "dynamic methods in `#{constant_name}`"
+        ) if @file_header
 
-        create_file(filename, rbi.transformed_string, verbose: !quiet)
+        rbi_string = @rbi_formatter.print_file(rbi)
+        create_file(filename, rbi_string, verbose: !quiet)
 
         filename
       end
@@ -231,7 +245,7 @@ module Tapioca
       def perform_dsl_verification(dir)
         diff = verify_dsl_rbi(tmp_dir: dir)
 
-        report_diff_and_exit_if_out_of_date(diff, "dsl")
+        report_diff_and_exit_if_out_of_date(diff, :dsl)
       ensure
         FileUtils.remove_entry(dir)
       end
@@ -294,13 +308,13 @@ module Tapioca
         "  File(s) #{cause}:\n  - #{filenames}"
       end
 
-      sig { params(diff: T::Hash[String, Symbol], command: String).void }
+      sig { params(diff: T::Hash[String, Symbol], command: Symbol).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("  `#{@default_command} #{command}`", [:green, :bold])
+          say("  `#{default_command(command)}`", [:green, :bold])
           say("Once it is complete, be sure to commit and push any changes", :green)
 
           say("")
@@ -321,9 +335,9 @@ module Tapioca
         end.sort
       end
 
-      sig { returns(Loader) }
+      sig { returns(Runtime::Loader) }
       def loader
-        @loader ||= Loader.new
+        @loader ||= Runtime::Loader.new
       end
 
       sig { params(class_name: String).returns(String) }
@@ -345,12 +359,12 @@ module Tapioca
 
       sig { params(constant: String).returns(String) }
       def generate_command_for(constant)
-        "#{@default_command} dsl #{constant}"
+        default_command(:dsl, constant)
       end
 
       sig { void }
       def load_dsl_extensions
-        Dir["#{__dir__}/../compilers/dsl/extensions/*.rb"].sort.each { |f| require(f) }
+        Dir["#{__dir__}/../dsl/extensions/*.rb"].sort.each { |f| require(f) }
       end
     end
   end

data/lib/tapioca/{generators → commands}/gem.rb

@@ -2,8 +2,10 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Generators
-    class Gem < Base
+  module Commands
+    class Gem < Command
+      include SorbetHelper
+
       sig do
         params(
           gem_names: T::Array[String],
@@ -11,13 +13,14 @@ module Tapioca
           prerequire: T.nilable(String),
           postrequire: String,
           typed_overrides: T::Hash[String, String],
-          default_command: String,
           outpath: Pathname,
           file_header: T::Boolean,
           doc: T::Boolean,
           include_exported_rbis: T::Boolean,
-          file_writer: Thor::Actions,
-          number_of_workers: T.nilable(Integer)
+          number_of_workers: T.nilable(Integer),
+          auto_strictness: T::Boolean,
+          dsl_dir: String,
+          rbi_formatter: RBIFormatter
         ).void
       end
       def initialize(
@@ -26,13 +29,14 @@ module Tapioca
         prerequire:,
         postrequire:,
         typed_overrides:,
-        default_command:,
         outpath:,
         file_header:,
         doc:,
         include_exported_rbis:,
-        file_writer: FileWriter.new,
-        number_of_workers: nil
+        number_of_workers: nil,
+        auto_strictness: true,
+        dsl_dir: DEFAULT_DSL_DIR,
+        rbi_formatter: DEFAULT_RBI_FORMATTER
       )
         @gem_names = gem_names
         @exclude = exclude
@@ -42,10 +46,13 @@ module Tapioca
         @outpath = outpath
         @file_header = file_header
         @number_of_workers = number_of_workers
+        @auto_strictness = auto_strictness
+        @dsl_dir = dsl_dir
+        @rbi_formatter = rbi_formatter
 
-        super(default_command: default_command, file_writer: file_writer)
+        super()
 
-        @loader = T.let(nil, T.nilable(Loader))
+        @loader = T.let(nil, T.nilable(Runtime::Loader))
         @bundle = T.let(nil, T.nilable(Gemfile))
         @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
@@ -54,7 +61,7 @@ module Tapioca
       end
 
       sig { override.void }
-      def generate
+      def execute
         require_gem_file
 
         gem_queue = gems_to_generate(@gem_names).reject { |gem| @exclude.include?(gem.name) }
@@ -71,6 +78,8 @@ module Tapioca
         end
 
         if anything_done
+          update_strictnesses(gem_queue.map(&:name), gem_dir: @outpath.to_s, dsl_dir: @dsl_dir) if @auto_strictness
+
           say("All operations performed in working directory.", [:green, :bold])
           say("Please review changes and commit them.", [:green, :bold])
         else
@@ -93,6 +102,8 @@ module Tapioca
         ].any?
 
         if anything_done
+          update_strictnesses([], gem_dir: @outpath.to_s, dsl_dir: @dsl_dir) if @auto_strictness
+
           say("All operations performed in working directory.", [:green, :bold])
           say("Please review changes and commit them.", [:green, :bold])
         else
@@ -104,9 +115,9 @@ module Tapioca
 
       private
 
-      sig { returns(Loader) }
+      sig { returns(Runtime::Loader) }
       def loader
-        @loader ||= Loader.new
+        @loader ||= Runtime::Loader.new
       end
 
       sig { returns(Gemfile) }
@@ -124,7 +135,7 @@ module Tapioca
           exit(1)
         end
 
-        Tapioca::Trackers::Autoload.eager_load_all!
+        Runtime::Trackers::Autoload.eager_load_all!
 
         say(" Done", :green)
         unless bundle.missing_specs.empty?
@@ -153,24 +164,24 @@ module Tapioca
         gem_name = set_color(gem.name, :yellow, :bold)
 
         rbi = RBI::File.new(strictness: @typed_overrides[gem.name] || "true")
-        rbi.set_file_header(
-          "#{@default_command} gem #{gem.name}",
-          reason: "types exported from the `#{gem.name}` gem",
-          display_heading: @file_header
-        )
 
-        Compilers::SymbolTableCompiler.new.compile(gem, rbi, 0, @doc)
+        @rbi_formatter.write_header!(rbi,
+          default_command(:gem, gem.name),
+          reason: "types exported from the `#{gem.name}` gem",) if @file_header
+
+        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @doc).compile
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
 
         if rbi.empty?
-          rbi.set_empty_body_content
+          @rbi_formatter.write_empty_body_comment!(rbi)
           say("Compiled #{gem_name} (empty output)", :yellow)
         else
           say("Compiled #{gem_name}", :green)
         end
 
-        create_file(@outpath / gem.rbi_file_name, rbi.transformed_string)
+        rbi_string = @rbi_formatter.print_file(rbi)
+        create_file(@outpath / gem.rbi_file_name, rbi_string)
 
         T.unsafe(Pathname).glob((@outpath / "#{gem.name}@*.rbi").to_s) do |file|
           remove_file(file) unless file.basename.to_s == gem.rbi_file_name
@@ -191,7 +202,7 @@ module Tapioca
           diff[filename] = gem_rbi_exists?(gem_name) ? :changed : :added
         end
 
-        report_diff_and_exit_if_out_of_date(diff, "gem")
+        report_diff_and_exit_if_out_of_date(diff, :gem)
       end
 
       sig { void }
@@ -265,7 +276,7 @@ module Tapioca
         say_error("If you populated ", :yellow)
         say_error("#{file} ", :bold, :blue)
         say_error("with ", :yellow)
-        say_error("`#{@default_command} require`", :bold, :blue)
+        say_error("`#{default_command(:require)}`", :bold, :blue)
         say_error("you should probably review it and remove the faulty line.", :yellow)
       end
 
@@ -296,13 +307,13 @@ module Tapioca
         existing_rbis.key?(gem_name)
       end
 
-      sig { params(diff: T::Hash[String, Symbol], command: String).void }
+      sig { params(diff: T::Hash[String, Symbol], command: Symbol).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("  `#{@default_command} #{command}`", [:green, :bold])
+          say("  `#{default_command(command)}`", [:green, :bold])
           say("Once it is complete, be sure to commit and push any changes", :green)
 
           say("")
@@ -325,16 +336,14 @@ module Tapioca
       sig { returns(T::Hash[String, String]) }
       def existing_rbis
         @existing_rbis ||= Pathname.glob((@outpath / "*@*.rbi").to_s)
-          .map { |f| T.cast(f.basename(".*").to_s.split("@", 2), [String, String]) }
-          .to_h
+          .to_h { |f| T.cast(f.basename(".*").to_s.split("@", 2), [String, String]) }
       end
 
       sig { returns(T::Hash[String, String]) }
       def expected_rbis
         @expected_rbis ||= bundle.dependencies
           .reject { |gem| @exclude.include?(gem.name) }
-          .map { |gem| [gem.name, gem.version.to_s] }
-          .to_h
+          .to_h { |gem| [gem.name, gem.version.to_s] }
       end
 
       sig { params(gem_name: String, version: String).returns(Pathname) }
@@ -370,6 +379,60 @@ module Tapioca
         say_error("\n\n  RBIs exported by `#{gem.name}` contain errors and can't be used:", :yellow)
         say_error("Cause: #{e.message} (#{e.location})")
       end
+
+      sig { params(gem_names: T::Array[String], gem_dir: String, dsl_dir: String).void }
+      def update_strictnesses(gem_names, gem_dir: DEFAULT_GEM_DIR, dsl_dir: DEFAULT_DSL_DIR)
+        return unless File.directory?(dsl_dir)
+
+        error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+
+        say("Typechecking RBI files... ")
+        res = sorbet(
+          "--no-config",
+          "--error-url-base=#{error_url_base}",
+          "--isolate-error-code 4010",
+          dsl_dir,
+          gem_dir
+        )
+        say(" Done", :green)
+
+        errors = Spoom::Sorbet::Errors::Parser.parse_string(res.err)
+
+        if errors.empty?
+          say("No error found", [:green, :bold])
+          return
+        end
+
+        files = []
+
+        errors.each do |error|
+          # Collect the file with error
+          files << error.file
+          error.more.each do |line|
+            # Also collect the conflicting definition file paths
+            next unless line.include?("Previous definition")
+            files << line.split(":").first&.strip
+          end
+        end
+
+        files
+          .uniq
+          .sort
+          .select do |file|
+            name = gem_name_from_rbi_path(file)
+            file.start_with?(gem_dir) && (gem_names.empty? || gem_names.include?(name))
+          end.each do |file|
+            Spoom::Sorbet::Sigils.change_sigil_in_file(file, "false")
+            say("\n  Changed strictness of #{file} to `typed: false` (conflicting with DSL files)", [:yellow, :bold])
+          end
+
+        say("\n")
+      end
+
+      sig { params(path: String).returns(String) }
+      def gem_name_from_rbi_path(path)
+        T.must(File.basename(path, ".rbi").split("@").first)
+      end
     end
   end
 end

data/lib/tapioca/{generators → commands}/init.rb

@@ -2,36 +2,32 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Generators
-    class Init < Base
+  module Commands
+    class Init < Command
       sig do
         params(
           sorbet_config: String,
           tapioca_config: String,
-          default_postrequire: String,
-          default_command: String,
-          file_writer: Thor::Actions
+          default_postrequire: String
         ).void
       end
       def initialize(
         sorbet_config:,
         tapioca_config:,
-        default_postrequire:,
-        default_command:,
-        file_writer: FileWriter.new
+        default_postrequire:
       )
         @sorbet_config = sorbet_config
         @tapioca_config = tapioca_config
         @default_postrequire = default_postrequire
 
-        super(default_command: default_command, file_writer: file_writer)
+        super()
 
         @installer = T.let(nil, T.nilable(Bundler::Installer))
         @spec = T.let(nil, T.nilable(Bundler::StubSpecification))
       end
 
       sig { override.void }
-      def generate
+      def execute
         create_sorbet_config
         create_tapioca_config
         create_post_require
@@ -73,19 +69,19 @@ module Tapioca
           # typed: true
           # frozen_string_literal: true
 
-          # Add your extra requires here (`#{@default_command} require` can be used to boostrap this list)
+          # Add your extra requires here (`#{default_command(:require)}` can be used to boostrap this list)
         CONTENT
       end
 
       sig { void }
       def create_binstub
-        force = File.exist?(@default_command)
+        force = File.exist?(Tapioca::BINARY_FILE)
 
         installer.generate_bundler_executable_stubs(spec, { force: force })
 
         say_status(
           force ? :force : :create,
-          @default_command,
+          Tapioca::BINARY_FILE,
           force ? :yellow : :green
         )
       end

data/lib/tapioca/{generators → commands}/require.rb

@@ -2,26 +2,24 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Generators
-    class Require < Base
+  module Commands
+    class Require < Command
       sig do
         params(
           requires_path: String,
-          sorbet_config_path: String,
-          default_command: String,
-          file_writer: Thor::Actions
+          sorbet_config_path: String
         ).void
       end
-      def initialize(requires_path:, sorbet_config_path:, default_command:, file_writer: FileWriter.new)
+      def initialize(requires_path:, sorbet_config_path:)
         @requires_path = requires_path
         @sorbet_config_path = sorbet_config_path
 
-        super(default_command: default_command, file_writer: file_writer)
+        super()
       end
 
       sig { override.void }
-      def generate
-        compiler = Compilers::RequiresCompiler.new(@sorbet_config_path)
+      def execute
+        compiler = Static::RequiresCompiler.new(@sorbet_config_path)
         name = set_color(@requires_path, :yellow, :bold)
         say("Compiling #{name}, this may take a few seconds... ")
 
@@ -44,7 +42,7 @@ module Tapioca
         say("Done", :green)
 
         say("All requires from this application have been written to #{name}.", [:green, :bold])
-        cmd = set_color("#{@default_command} gem", :yellow, :bold)
+        cmd = set_color(default_command(:gem), :yellow, :bold)
         say("Please review changes and commit them, then run `#{cmd}`.", [:green, :bold])
       end
     end

data/lib/tapioca/commands/todo.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Commands
+    class Todo < Command
+      include SorbetHelper
+
+      sig do
+        params(
+          todo_file: String,
+          file_header: T::Boolean
+        ).void
+      end
+      def initialize(todo_file:, file_header:)
+        @todo_file = todo_file
+        @file_header = file_header
+
+        super()
+      end
+
+      sig { override.void }
+      def execute
+        say("Finding all unresolved constants, this may take a few seconds... ")
+
+        # Clean all existing unresolved constants before regenerating the list
+        # so Sorbet won't grab them as already resolved.
+        File.delete(@todo_file) if File.exist?(@todo_file)
+
+        constants = unresolved_constants
+
+        if constants.empty?
+          say("Nothing to do", :green)
+          return
+        end
+
+        say("Done", :green)
+        contents = rbi(constants, command: default_command(:todo))
+        create_file(@todo_file, contents.string, verbose: false)
+
+        name = set_color(@todo_file, :yellow, :bold)
+        say("\nAll unresolved constants have been written to #{name}.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
+
+      private
+
+      sig { params(constants: T::Array[String], command: String).returns(RBI::File) }
+      def rbi(constants, command:)
+        file = RBI::File.new
+
+        if @file_header
+          file.comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
+          file.comments << RBI::Comment.new("This is an autogenerated file for unresolved constants.")
+          file.comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+          file.comments << RBI::BlankLine.new
+        end
+
+        file.comments << RBI::Comment.new("typed: false")
+
+        constants.each do |name|
+          file << RBI::Module.new(name)
+        end
+
+        file
+      end
+
+      sig { returns(T::Array[String]) }
+      def unresolved_constants
+        # Taken from https://github.com/sorbet/sorbet/blob/master/gems/sorbet/lib/todo-rbi.rb
+        sorbet("--print=missing-constants", "--quiet", "--stdout-hup-hack", "--no-error-count")
+          .out
+          .strip
+          .each_line
+          .map do |line|
+            next if line.include?("<")
+            next if line.include?("class_of")
+            line.strip.gsub("T.untyped::", "")
+          end
+          .compact
+      end
+    end
+  end
+end