tapioca 0.5.6 → 0.6.0

data/lib/tapioca/generators/gem.rb

@@ -7,7 +7,7 @@ module Tapioca
       sig do
         params(
           gem_names: T::Array[String],
-          gem_excludes: T::Array[String],
+          exclude: T::Array[String],
           prerequire: T.nilable(String),
           postrequire: String,
           typed_overrides: T::Hash[String, String],
@@ -15,12 +15,14 @@ module Tapioca
           outpath: Pathname,
           file_header: T::Boolean,
           doc: T::Boolean,
-          file_writer: Thor::Actions
+          include_exported_rbis: T::Boolean,
+          file_writer: Thor::Actions,
+          number_of_workers: T.nilable(Integer)
         ).void
       end
       def initialize(
         gem_names:,
-        gem_excludes:,
+        exclude:,
         prerequire:,
         postrequire:,
         typed_overrides:,
@@ -28,15 +30,18 @@ module Tapioca
         outpath:,
         file_header:,
         doc:,
-        file_writer: FileWriter.new
+        include_exported_rbis:,
+        file_writer: FileWriter.new,
+        number_of_workers: nil
       )
         @gem_names = gem_names
-        @gem_excludes = gem_excludes
+        @exclude = exclude
         @prerequire = prerequire
         @postrequire = postrequire
         @typed_overrides = typed_overrides
         @outpath = outpath
         @file_header = file_header
+        @number_of_workers = number_of_workers
 
         super(default_command: default_command, file_writer: file_writer)
 
@@ -45,21 +50,20 @@ module Tapioca
         @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @doc = T.let(doc, T::Boolean)
+        @include_exported_rbis = include_exported_rbis
       end
 
       sig { override.void }
       def generate
         require_gem_file
 
-        gems_to_process = gems_to_generate(@gem_names).reject { |gem| @gem_excludes.include?(gem.name) }
-
+        gem_queue = gems_to_generate(@gem_names).reject { |gem| @exclude.include?(gem.name) }
         anything_done = [
           perform_removals,
-          gems_to_process.any?,
+          gem_queue.any?,
         ].any?
 
-        gems_to_process.each do |gem|
-          say("Processing '#{gem.name}' gem:", :green)
+        Executor.new(gem_queue, number_of_workers: @number_of_workers).run_in_parallel do |gem|
           shell.indent do
             compile_gem_rbi(gem)
             puts
@@ -119,6 +123,9 @@ module Tapioca
           explain_failed_require(@postrequire, e)
           exit(1)
         end
+
+        Tapioca::Trackers::Autoload.eager_load_all!
+
         say(" Done", :green)
         unless bundle.missing_specs.empty?
           say("  completed with missing specs: ")
@@ -144,7 +151,6 @@ module Tapioca
       sig { params(gem: Gemfile::GemSpec).void }
       def compile_gem_rbi(gem)
         gem_name = set_color(gem.name, :yellow, :bold)
-        say("Compiling #{gem_name}, this may take a few seconds... ")
 
         rbi = RBI::File.new(strictness: @typed_overrides[gem.name] || "true")
         rbi.set_file_header(
@@ -155,17 +161,19 @@ module Tapioca
 
         Compilers::SymbolTableCompiler.new.compile(gem, rbi, 0, @doc)
 
+        merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
+
         if rbi.empty?
           rbi.set_empty_body_content
-          say("Done (empty output)", :yellow)
+          say("Compiled #{gem_name} (empty output)", :yellow)
         else
-          say("Done", :green)
+          say("Compiled #{gem_name}", :green)
         end
 
         create_file(@outpath / gem.rbi_file_name, rbi.transformed_string)
 
         T.unsafe(Pathname).glob((@outpath / "#{gem.name}@*.rbi").to_s) do |file|
-          remove(file) unless file.basename.to_s == gem.rbi_file_name
+          remove_file(file) unless file.basename.to_s == gem.rbi_file_name
         end
       end
 
@@ -201,7 +209,7 @@ module Tapioca
           else
             gems.each do |removed|
               filename = existing_rbi(removed)
-              remove(filename)
+              remove_file(filename)
             end
 
             anything_done = true
@@ -228,7 +236,7 @@ module Tapioca
           else
             require_gem_file
 
-            gems.each do |gem_name|
+            Executor.new(gems, number_of_workers: @number_of_workers).run_in_parallel do |gem_name|
               filename = expected_rbi(gem_name)
 
               if gem_rbi_exists?(gem_name)
@@ -261,13 +269,6 @@ module Tapioca
         say_error("you should probably review it and remove the faulty line.", :yellow)
       end
 
-      sig { params(filename: Pathname).void }
-      def remove(filename)
-        return unless filename.exist?
-        say("-- Removing: #{filename}")
-        filename.unlink
-      end
-
       sig { returns(T::Array[String]) }
       def removed_rbis
         (existing_rbis.keys - expected_rbis.keys).sort
@@ -301,7 +302,7 @@ module Tapioca
           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} #{command}`", [:green, :bold])
+          say("  `#{@default_command} #{command}`", [:green, :bold])
           say("Once it is complete, be sure to commit and push any changes", :green)
 
           say("")
@@ -331,7 +332,7 @@ module Tapioca
       sig { returns(T::Hash[String, String]) }
       def expected_rbis
         @expected_rbis ||= bundle.dependencies
-          .reject { |gem| @gem_excludes.include?(gem.name) }
+          .reject { |gem| @exclude.include?(gem.name) }
           .map { |gem| [gem.name, gem.version.to_s] }
           .to_h
       end
@@ -343,11 +344,31 @@ module Tapioca
 
       sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
       def build_error_for_files(cause, files)
-        filenames = files.map do |file|
-          @outpath / file
-        end.join("\n  - ")
+        "  File(s) #{cause}:\n  - #{files.join("\n  - ")}"
+      end
+
+      sig { params(gem: Gemfile::GemSpec, file: RBI::File).void }
+      def merge_with_exported_rbi(gem, file)
+        return file unless gem.export_rbi_files?
+        tree = gem.exported_rbi_tree
+
+        unless tree.conflicts.empty?
+          say_error("\n\n  RBIs exported by `#{gem.name}` contain conflicts and can't be used:", :yellow)
+
+          tree.conflicts.each do |conflict|
+            say_error("\n    #{conflict}", :yellow)
+            say_error("    Found at:", :yellow)
+            say_error("      #{conflict.left.loc}", :yellow)
+            say_error("      #{conflict.right.loc}", :yellow)
+          end
+
+          return file
+        end
 
-        "  File(s) #{cause}:\n  - #{filenames}"
+        file.root = RBI::Rewriters::Merge.merge_trees(file.root, tree, keep: RBI::Rewriters::Merge::Keep::LEFT)
+      rescue RBI::ParseError => e
+        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
     end
   end

data/lib/tapioca/generators/init.rb

@@ -7,13 +7,21 @@ module Tapioca
       sig do
         params(
           sorbet_config: String,
+          tapioca_config: String,
           default_postrequire: String,
           default_command: String,
           file_writer: Thor::Actions
         ).void
       end
-      def initialize(sorbet_config:, default_postrequire:, default_command:, file_writer: FileWriter.new)
+      def initialize(
+        sorbet_config:,
+        tapioca_config:,
+        default_postrequire:,
+        default_command:,
+        file_writer: FileWriter.new
+      )
         @sorbet_config = sorbet_config
+        @tapioca_config = tapioca_config
         @default_postrequire = default_postrequire
 
         super(default_command: default_command, file_writer: file_writer)
@@ -24,25 +32,41 @@ module Tapioca
 
       sig { override.void }
       def generate
-        create_config
+        create_sorbet_config
+        create_tapioca_config
         create_post_require
-        if File.exist?(@default_command)
-          generate_binstub!
-        else
-          generate_binstub
-        end
+        create_binstub
       end
 
       private
 
       sig { void }
-      def create_config
+      def create_sorbet_config
         create_file(@sorbet_config, <<~CONTENT, skip: true, force: false)
           --dir
           .
         CONTENT
       end
 
+      sig { void }
+      def create_tapioca_config
+        create_file(@tapioca_config, <<~YAML, skip: true, force: false)
+          gem:
+            # Add your `gem` command parameters here:
+            #
+            # exclude:
+            # - gem_name
+            # doc: true
+            # workers: 5
+          dsl:
+            # Add your `dsl` command parameters here:
+            #
+            # exclude:
+            # - SomeGeneratorName
+            # workers: 5
+        YAML
+      end
+
       sig { void }
       def create_post_require
         create_file(@default_postrequire, <<~CONTENT, skip: true, force: false)
@@ -54,15 +78,16 @@ module Tapioca
       end
 
       sig { void }
-      def generate_binstub!
-        installer.generate_bundler_executable_stubs(spec, { force: true })
-        say_status(:force, @default_command, :yellow)
-      end
+      def create_binstub
+        force = File.exist?(@default_command)
 
-      sig { void }
-      def generate_binstub
-        installer.generate_bundler_executable_stubs(spec)
-        say_status(:create, @default_command, :green)
+        installer.generate_bundler_executable_stubs(spec, { force: force })
+
+        say_status(
+          force ? :force : :create,
+          @default_command,
+          force ? :yellow : :green
+        )
       end
 
       sig { returns(Bundler::Installer) }

data/lib/tapioca/generators/todo.rb

@@ -6,14 +6,14 @@ module Tapioca
     class Todo < Base
       sig do
         params(
-          todos_path: String,
+          todo_file: String,
           file_header: T::Boolean,
           default_command: String,
           file_writer: Thor::Actions
         ).void
       end
-      def initialize(todos_path:, file_header:, default_command:, file_writer: FileWriter.new)
-        @todos_path = todos_path
+      def initialize(todo_file:, file_header:, default_command:, file_writer: FileWriter.new)
+        @todo_file = todo_file
         @file_header = file_header
 
         super(default_command: default_command, file_writer: file_writer)
@@ -26,7 +26,7 @@ module Tapioca
 
         # Clean all existing unresolved constants before regenerating the list
         # so Sorbet won't grab them as already resolved.
-        File.delete(@todos_path) if File.exist?(@todos_path)
+        File.delete(@todo_file) if File.exist?(@todo_file)
 
         rbi_string = compiler.compile
         if rbi_string.empty?
@@ -44,9 +44,9 @@ module Tapioca
         content << "\n"
 
         say("Done", :green)
-        create_file(@todos_path, content, verbose: false)
+        create_file(@todo_file, content, verbose: false)
 
-        name = set_color(@todos_path, :yellow, :bold)
+        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

data/lib/tapioca/helpers/cli_helper.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "thor"
+
+module Tapioca
+  module CliHelper
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor::Shell }
+
+    sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+    def say_error(message = "", *color)
+      force_new_line = (message.to_s !~ /( |\t)\Z/)
+      # NOTE: This is a hack. We're no longer subclassing from Thor::Shell::Color
+      # so we no longer have access to the prepare_message call.
+      # We should update this to remove this.
+      buffer = shell.send(:prepare_message, *T.unsafe([message, *T.unsafe(color)]))
+      buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
+
+      $stderr.print(buffer)
+      $stderr.flush
+    end
+  end
+end

data/lib/tapioca/helpers/config_helper.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "yaml"
+
+module Tapioca
+  module ConfigHelper
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :command_name
+
+    sig { returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    attr_reader :defaults
+
+    sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
+    def initialize(args = [], local_options = {}, config = {})
+      # Store current command
+      command = config[:current_command]
+      command_options = config[:command_options]
+      @command_name = T.let(command.name, String)
+      @merged_options = T.let(nil, T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
+      @defaults = T.let(Thor::CoreExt::HashWithIndifferentAccess.new, Thor::CoreExt::HashWithIndifferentAccess)
+
+      # Filter command options unless we are handling the help command.
+      # This is so that the defaults are printed
+      filter_defaults(command_options) unless command_name == "help"
+
+      super
+    end
+
+    sig { returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    def options
+      @merged_options ||= begin
+        original_options = super
+        config_options = config_options(original_options)
+
+        merge_options(defaults, config_options, original_options)
+      end
+    end
+
+    private
+
+    sig { params(options: T::Hash[Symbol, Thor::Option]).void }
+    def filter_defaults(options)
+      options.each do |key, option|
+        # Store the value of the current default in our defaults hash
+        defaults[key] = option.default
+        # Remove the default value from the option
+        option.instance_variable_set(:@default, nil)
+      end
+    end
+
+    sig { params(options: Thor::CoreExt::HashWithIndifferentAccess).returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    def config_options(options)
+      config_file = options[:config]
+      config = {}
+
+      if File.exist?(config_file)
+        config = YAML.load_file(config_file, fallback: {})
+      end
+
+      Thor::CoreExt::HashWithIndifferentAccess.new(config[command_name] || {})
+    end
+
+    sig do
+      params(options: T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
+        .returns(Thor::CoreExt::HashWithIndifferentAccess)
+    end
+    def merge_options(*options)
+      merged = options.each_with_object({}) do |option, result|
+        result.merge!(option || {}) do |_, this_val, other_val|
+          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+            Thor::CoreExt::HashWithIndifferentAccess.new(this_val.merge(other_val))
+          else
+            other_val
+          end
+        end
+      end
+
+      Thor::CoreExt::HashWithIndifferentAccess.new(merged)
+    end
+  end
+end

data/lib/tapioca/helpers/test/content.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Tapioca
+  module Helpers
+    module Test
+      module Content
+        extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { Kernel }
+
+        sig { void }
+        def teardown
+          super
+          remove_tmp_path
+        end
+
+        sig { params(args: String).returns(String) }
+        def tmp_path(*args)
+          @tmp_path = T.let(@tmp_path, T.nilable(String))
+          @tmp_path ||= Dir.mktmpdir
+          T.unsafe(File).join(@tmp_path, *args)
+        end
+
+        sig { void }
+        def remove_tmp_path
+          FileUtils.rm_rf(tmp_path)
+        end
+
+        sig { params(name: String, content: String, require_file: T::Boolean).returns(String) }
+        def add_ruby_file(name, content, require_file: true)
+          add_content_file(name, content).tap do |file_name|
+            Tapioca.silence_warnings { require(file_name) } if require_file
+          end
+        end
+
+        sig { params(name: String, content: String).returns(String) }
+        def add_content_file(name, content)
+          file_name = tmp_path("lib/#{name}")
+          raise ArgumentError, "a file named '#{name}' was already added; cannot overwrite." if File.exist?(file_name)
+          FileUtils.mkdir_p(File.dirname(file_name))
+          File.write(file_name, content)
+          file_name
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/helpers/test/isolation.rb

@@ -0,0 +1,125 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Helpers
+    module Test
+      # Copied from ActiveSupport::Testing::Isolation since we cannot require
+      # constants from ActiveSupport without polluting the global namespace.
+      module Isolation
+        extend T::Sig
+        require "thread"
+
+        sig { returns(T::Boolean) }
+        def self.forking_env?
+          !ENV["NO_FORK"] && Process.respond_to?(:fork)
+        end
+
+        def run
+          serialized = T.unsafe(self).run_in_isolation do
+            super
+          end
+
+          Marshal.load(serialized)
+        end
+
+        module Forking
+          extend T::Sig
+          include Kernel
+
+          sig { params(_blk: T.untyped).returns(String) }
+          def run_in_isolation(&_blk)
+            read, write = IO.pipe
+            read.binmode
+            write.binmode
+
+            this = T.cast(self, Minitest::Test)
+            pid = fork do
+              read.close
+              yield
+              begin
+                if this.error?
+                  this.failures.map! do |e|
+                    Marshal.dump(e)
+                    e
+                  rescue TypeError
+                    ex = Exception.new(e.message)
+                    ex.set_backtrace(e.backtrace)
+                    Minitest::UnexpectedError.new(ex)
+                  end
+                end
+                test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : this.dup
+                result = Marshal.dump(test_result)
+              end
+
+              write.puts [result].pack("m")
+              write.close
+              exit!(false)
+            end
+
+            write.close
+            result = read.read
+            read.close
+
+            Process.wait2(T.must(pid))
+            T.must(result).unpack1("m")
+          end
+        end
+
+        module Subprocess
+          extend T::Sig
+          include Kernel
+          ORIG_ARGV = T.let(ARGV.dup, T::Array[T.untyped]) unless defined?(ORIG_ARGV)
+
+          # Crazy H4X to get this working in windows / jruby with
+          # no forking.
+          sig { params(_blk: T.untyped).returns(String) }
+          def run_in_isolation(&_blk)
+            this = T.cast(self, Minitest::Test)
+            require "tempfile"
+
+            if ENV["ISOLATION_TEST"]
+              yield
+              test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : this.dup
+              File.open(T.must(ENV["ISOLATION_OUTPUT"]), "w") do |file|
+                file.puts [Marshal.dump(test_result)].pack("m")
+              end
+              exit!(false)
+            else
+              Tempfile.open("isolation") do |tmpfile|
+                env = {
+                  "ISOLATION_TEST" => this.class.name,
+                  "ISOLATION_OUTPUT" => tmpfile.path,
+                }
+
+                test_opts = "-n#{this.class.name}##{this.name}"
+
+                load_path_args = []
+                $-I.each do |p|
+                  load_path_args << "-I"
+                  load_path_args << File.expand_path(p)
+                end
+
+                child = IO.popen([env, Gem.ruby, *load_path_args, $PROGRAM_NAME, *ORIG_ARGV, test_opts])
+
+                begin
+                  Process.wait(child.pid)
+                rescue Errno::ECHILD # The child process may exit before we wait
+                  nil
+                end
+
+                return T.must(tmpfile.read).unpack1("m")
+              end
+            end
+          end
+        end
+
+        if forking_env?
+          include(Forking)
+        else
+          include(Subprocess)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/helpers/test/template.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "erb"
+
+module Tapioca
+  module Helpers
+    module Test
+      module Template
+        include Kernel
+        extend T::Sig
+        ERB_SUPPORTS_KVARGS = T.let(
+          ::ERB.instance_method(:initialize).parameters.assoc(:key), T.nilable([Symbol, Symbol])
+        )
+
+        sig { params(selector: String).returns(T::Boolean) }
+        def ruby_version(selector)
+          Gem::Requirement.new(selector).satisfied_by?(Gem::Version.new(RUBY_VERSION))
+        end
+
+        sig { params(src: String).returns(String) }
+        def template(src)
+          erb = if ERB_SUPPORTS_KVARGS
+            ::ERB.new(src, trim_mode: ">")
+          else
+            ::ERB.new(src, nil, ">")
+          end
+
+          erb.result(binding)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/internal.rb

@@ -6,11 +6,12 @@ require "tapioca/loader"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/generic_type_registry"
-require "tapioca/config"
-require "tapioca/config_builder"
+require "tapioca/helpers/cli_helper"
+require "tapioca/helpers/config_helper"
 require "tapioca/generators"
 require "tapioca/cli"
 require "tapioca/gemfile"
+require "tapioca/executor"
 require "tapioca/compilers/sorbet"
 require "tapioca/compilers/requires_compiler"
 require "tapioca/compilers/symbol_table_compiler"