tapioca 0.5.1 → 0.5.5

data/lib/tapioca/generators/gem.rb

@@ -0,0 +1,345 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Gem < Base
+      sig do
+        params(
+          gem_names: T::Array[String],
+          gem_excludes: T::Array[String],
+          prerequire: T.nilable(String),
+          postrequire: String,
+          typed_overrides: T::Hash[String, String],
+          default_command: String,
+          outpath: Pathname,
+          file_header: T::Boolean,
+          doc: T::Boolean,
+          file_writer: Thor::Actions
+        ).void
+      end
+      def initialize(
+        gem_names:,
+        gem_excludes:,
+        prerequire:,
+        postrequire:,
+        typed_overrides:,
+        default_command:,
+        outpath:,
+        file_header:,
+        doc:,
+        file_writer: FileWriter.new
+      )
+        @gem_names = gem_names
+        @gem_excludes = gem_excludes
+        @prerequire = prerequire
+        @postrequire = postrequire
+        @typed_overrides = typed_overrides
+        @outpath = outpath
+        @file_header = file_header
+
+        super(default_command: default_command, file_writer: file_writer)
+
+        @loader = T.let(nil, T.nilable(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]))
+        @doc = T.let(doc, T::Boolean)
+      end
+
+      sig { override.void }
+      def generate
+        require_gem_file
+
+        gems_to_generate(@gem_names)
+          .reject { |gem| @gem_excludes.include?(gem.name) }
+          .each do |gem|
+            say("Processing '#{gem.name}' gem:", :green)
+            shell.indent do
+              compile_gem_rbi(gem)
+              puts
+            end
+          end
+
+        say("All operations performed in working directory.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
+
+      sig { params(should_verify: T::Boolean).void }
+      def sync(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,
+        ].any?
+
+        if anything_done
+          say("All operations performed in working directory.", [:green, :bold])
+          say("Please review changes and commit them.", [:green, :bold])
+        else
+          say("No operations performed, all RBIs are up-to-date.", [:green, :bold])
+        end
+
+        puts
+      end
+
+      private
+
+      sig { returns(Loader) }
+      def loader
+        @loader ||= Loader.new
+      end
+
+      sig { returns(Gemfile) }
+      def bundle
+        @bundle ||= Gemfile.new
+      end
+
+      sig { void }
+      def require_gem_file
+        say("Requiring all gems to prepare for compiling... ")
+        begin
+          loader.load_bundle(bundle, @prerequire, @postrequire)
+        rescue LoadError => e
+          explain_failed_require(@postrequire, e)
+          exit(1)
+        end
+        say(" Done", :green)
+        unless bundle.missing_specs.empty?
+          say("  completed with missing specs: ")
+          say(bundle.missing_specs.join(", "), :yellow)
+        end
+        puts
+      end
+
+      sig { params(gem_names: T::Array[String]).returns(T::Array[Gemfile::GemSpec]) }
+      def gems_to_generate(gem_names)
+        return bundle.dependencies if gem_names.empty?
+
+        gem_names.map do |gem_name|
+          gem = bundle.gem(gem_name)
+          if gem.nil?
+            say("Error: Cannot find gem '#{gem_name}'", :red)
+            exit(1)
+          end
+          gem
+        end
+      end
+
+      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(
+          "#{@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)
+
+        if rbi.empty?
+          rbi.set_empty_body_content
+          say("Done (empty output)", :yellow)
+        else
+          say("Done", :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
+        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, "gem")
+      end
+
+      sig { void }
+      def perform_removals
+        say("Removing RBI files of gems that have been removed:", [:blue, :bold])
+        puts
+
+        anything_done = T.let(false, T::Boolean)
+
+        gems = removed_rbis
+
+        shell.indent do
+          if gems.empty?
+            say("Nothing to do.")
+          else
+            gems.each do |removed|
+              filename = existing_rbi(removed)
+              remove(filename)
+            end
+
+            anything_done = true
+          end
+        end
+
+        puts
+
+        anything_done
+      end
+
+      sig { void }
+      def perform_additions
+        say("Generating RBI files of gems that are added or updated:", [:blue, :bold])
+        puts
+
+        anything_done = T.let(false, T::Boolean)
+
+        gems = added_rbis
+
+        shell.indent do
+          if gems.empty?
+            say("Nothing to do.")
+          else
+            require_gem_file
+
+            gems.each do |gem_name|
+              filename = expected_rbi(gem_name)
+
+              if gem_rbi_exists?(gem_name)
+                old_filename = existing_rbi(gem_name)
+                move(old_filename, filename) unless old_filename == filename
+              end
+
+              gem = T.must(bundle.gem(gem_name))
+              compile_gem_rbi(gem)
+              puts
+            end
+          end
+
+          anything_done = true
+        end
+
+        puts
+
+        anything_done
+      end
+
+      sig { params(file: String, error: LoadError).void }
+      def explain_failed_require(file, error)
+        say_error("\n\nLoadError: #{error}", :bold, :red)
+        say_error("\nTapioca could not load all the gems required by your application.", :yellow)
+        say_error("If you populated ", :yellow)
+        say_error("#{file} ", :bold, :blue)
+        say_error("with ", :yellow)
+        say_error("`#{@default_command} require`", :bold, :blue)
+        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
+      end
+
+      sig { params(gem_name: String).returns(Pathname) }
+      def existing_rbi(gem_name)
+        gem_rbi_filename(gem_name, T.must(existing_rbis[gem_name]))
+      end
+
+      sig { returns(T::Array[String]) }
+      def added_rbis
+        expected_rbis.select do |name, value|
+          existing_rbis[name] != value
+        end.keys.sort
+      end
+
+      sig { params(gem_name: String).returns(Pathname) }
+      def expected_rbi(gem_name)
+        gem_rbi_filename(gem_name, T.must(expected_rbis[gem_name]))
+      end
+
+      sig { params(gem_name: String).returns(T::Boolean) }
+      def gem_rbi_exists?(gem_name)
+        existing_rbis.key?(gem_name)
+      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} #{command}`", [:green, :bold])
+          say("Once it is complete, be sure to commit and push any changes", :green)
+
+          say("")
+
+          say("Reason:", [:red])
+          diff.group_by(&:last).sort.each do |cause, diff_for_cause|
+            say(build_error_for_files(cause, diff_for_cause.map(&:first)))
+          end
+
+          exit(1)
+        end
+      end
+
+      sig { params(old_filename: Pathname, new_filename: Pathname).void }
+      def move(old_filename, new_filename)
+        say("-> Moving: #{old_filename} to #{new_filename}")
+        old_filename.rename(new_filename.to_s)
+      end
+
+      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
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def expected_rbis
+        @expected_rbis ||= bundle.dependencies
+          .reject { |gem| @gem_excludes.include?(gem.name) }
+          .map { |gem| [gem.name, gem.version.to_s] }
+          .to_h
+      end
+
+      sig { params(gem_name: String, version: String).returns(Pathname) }
+      def gem_rbi_filename(gem_name, version)
+        @outpath / "#{gem_name}@#{version}.rbi"
+      end
+
+      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  - #{filenames}"
+      end
+    end
+  end
+end

data/lib/tapioca/generators/init.rb

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Init < Base
+      sig do
+        params(
+          sorbet_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)
+        @sorbet_config = sorbet_config
+        @default_postrequire = default_postrequire
+
+        super(default_command: default_command, file_writer: file_writer)
+
+        @installer = T.let(nil, T.nilable(Bundler::Installer))
+        @spec = T.let(nil, T.nilable(Bundler::StubSpecification))
+      end
+
+      sig { override.void }
+      def generate
+        create_config
+        create_post_require
+        if File.exist?(@default_command)
+          generate_binstub!
+        else
+          generate_binstub
+        end
+      end
+
+      private
+
+      sig { void }
+      def create_config
+        create_file(@sorbet_config, <<~CONTENT, skip: true, force: false)
+          --dir
+          .
+        CONTENT
+      end
+
+      sig { void }
+      def create_post_require
+        create_file(@default_postrequire, <<~CONTENT, skip: true, force: false)
+          # typed: true
+          # frozen_string_literal: true
+
+          # Add your extra requires here (`#{@default_command} require` can be used to boostrap this list)
+        CONTENT
+      end
+
+      sig { void }
+      def generate_binstub!
+        installer.generate_bundler_executable_stubs(spec, { force: true })
+        say_status(:force, @default_command, :yellow)
+      end
+
+      sig { void }
+      def generate_binstub
+        installer.generate_bundler_executable_stubs(spec)
+        say_status(:create, @default_command, :green)
+      end
+
+      sig { returns(Bundler::Installer) }
+      def installer
+        @installer ||= Bundler::Installer.new(Bundler.root, Bundler.definition)
+      end
+
+      sig { returns(Bundler::StubSpecification) }
+      def spec
+        @spec ||= Bundler.definition.specs.find { |s| s.name == "tapioca" }
+      end
+    end
+  end
+end

data/lib/tapioca/generators/require.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Require < Base
+      sig do
+        params(
+          requires_path: String,
+          sorbet_config_path: String,
+          default_command: String,
+          file_writer: Thor::Actions
+        ).void
+      end
+      def initialize(requires_path:, sorbet_config_path:, default_command:, file_writer: FileWriter.new)
+        @requires_path = requires_path
+        @sorbet_config_path = sorbet_config_path
+
+        super(default_command: default_command, file_writer: file_writer)
+      end
+
+      sig { override.void }
+      def generate
+        compiler = Compilers::RequiresCompiler.new(@sorbet_config_path)
+        name = set_color(@requires_path, :yellow, :bold)
+        say("Compiling #{name}, this may take a few seconds... ")
+
+        rb_string = compiler.compile
+        if rb_string.empty?
+          say("Nothing to do", :green)
+          return
+        end
+
+        # Clean all existing requires before regenerating the list so we update
+        # it with the new one found in the client code and remove the old ones.
+        File.delete(@requires_path) if File.exist?(@requires_path)
+
+        content = +"# typed: true\n"
+        content << "# frozen_string_literal: true\n\n"
+        content << rb_string
+
+        create_file(@requires_path, content, verbose: false)
+
+        say("Done", :green)
+
+        say("All requires from this application have been written to #{name}.", [:green, :bold])
+        cmd = set_color("#{@default_command} gem", :yellow, :bold)
+        say("Please review changes and commit them, then run `#{cmd}`.", [:green, :bold])
+      end
+    end
+  end
+end

data/lib/tapioca/generators/todo.rb

@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Todo < Base
+      sig do
+        params(
+          todos_path: 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
+        @file_header = file_header
+
+        super(default_command: default_command, file_writer: file_writer)
+      end
+
+      sig { override.void }
+      def generate
+        compiler = Compilers::TodosCompiler.new
+        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(@todos_path) if File.exist?(@todos_path)
+
+        rbi_string = compiler.compile
+        if rbi_string.empty?
+          say("Nothing to do", :green)
+          return
+        end
+
+        content = String.new
+        content << rbi_header(
+          "#{@default_command} todo",
+          reason: "unresolved constants",
+          strictness: "false"
+        )
+        content << rbi_string
+        content << "\n"
+
+        say("Done", :green)
+        create_file(@todos_path, content, verbose: false)
+
+        name = set_color(@todos_path, :yellow, :bold)
+        say("\nAll unresolved constants have been written to #{name}.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
+
+      sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
+      def rbi_header(command, reason: nil, strictness: nil)
+        statement = <<~HEAD
+          # DO NOT EDIT MANUALLY
+          # This is an autogenerated file for #{reason}.
+          # Please instead update this file by running `#{command}`.
+        HEAD
+
+        sigil = <<~SIGIL if strictness
+          # typed: #{strictness}
+        SIGIL
+
+        if @file_header
+          [statement, sigil].compact.join("\n").strip.concat("\n\n")
+        elsif sigil
+          sigil.strip.concat("\n\n")
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/generators.rb

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "generators/base"
+require_relative "generators/dsl"
+require_relative "generators/init"
+require_relative "generators/gem"
+require_relative "generators/require"
+require_relative "generators/todo"

data/lib/tapioca/internal.rb

@@ -3,13 +3,12 @@
 
 require "tapioca"
 require "tapioca/loader"
-require "tapioca/constant_locator"
 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/generator"
+require "tapioca/generators"
 require "tapioca/cli"
 require "tapioca/gemfile"
 require "tapioca/compilers/sorbet"

data/lib/tapioca/loader.rb

@@ -9,10 +9,10 @@ module Tapioca
     def load_bundle(gemfile, initialize_file, require_file)
       require_helper(initialize_file)
 
-      gemfile.require_bundle
-
       load_rails_application
 
+      gemfile.require_bundle
+
       require_helper(require_file)
 
       load_rails_engines

data/lib/tapioca/rbi_ext/model.rb

@@ -4,6 +4,50 @@
 require "rbi"
 
 module RBI
+  class File
+    extend T::Sig
+
+    sig { returns(String) }
+    def transformed_string
+      transform_rbi!
+      string
+    end
+
+    sig { void }
+    def transform_rbi!
+      root.nest_singleton_methods!
+      root.nest_non_public_methods!
+      root.group_nodes!
+      root.sort_nodes!
+    end
+
+    sig do
+      params(
+        command: String,
+        reason: T.nilable(String),
+        display_heading: T::Boolean
+      ).void
+    end
+    def set_file_header(command, reason: nil, display_heading: true)
+      return unless display_heading
+      comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
+      comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
+      comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+    end
+
+    sig { void }
+    def set_empty_body_content
+      comments << RBI::BlankLine.new unless comments.empty?
+      comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
+      comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
+    end
+
+    sig { returns(T::Boolean) }
+    def empty?
+      root.empty?
+    end
+  end
+
   class Tree
     extend T::Sig
 

data/lib/tapioca/reflection.rb

@@ -17,6 +17,7 @@ module Tapioca
     PUBLIC_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:public_instance_methods), UnboundMethod)
     PROTECTED_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:protected_instance_methods), UnboundMethod)
     PRIVATE_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:private_instance_methods), UnboundMethod)
+    METHOD_METHOD = T.let(Kernel.instance_method(:method), UnboundMethod)
 
     sig { params(object: BasicObject).returns(Class).checked(:never) }
     def class_of(object)
@@ -30,7 +31,8 @@ module Tapioca
 
     sig { params(constant: Module).returns(T.nilable(String)) }
     def name_of(constant)
-      NAME_METHOD.bind(constant).call
+      name = NAME_METHOD.bind(constant).call
+      name&.start_with?("#<") ? nil : name
     end
 
     sig { params(constant: Module).returns(Class) }
@@ -106,6 +108,11 @@ module Tapioca
       type.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
     end
 
+    sig { params(constant: Module, method: Symbol).returns(Method) }
+    def method_of(constant, method)
+      METHOD_METHOD.bind(constant).call(method)
+    end
+
     # Returns an array with all classes that are < than the supplied class.
     #
     #   class C; end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.5.1"
+  VERSION = "0.5.5"
 end

data/lib/tapioca.rb

@@ -18,6 +18,8 @@ module Tapioca
 end
 
 require "tapioca/reflection"
+require "tapioca/constant_locator"
 require "tapioca/compilers/dsl/base"
+require "tapioca/compilers/dynamic_mixin_compiler"
 require "tapioca/helpers/active_record_column_type_helper"
 require "tapioca/version"