tapioca 0.9.4 → 0.10.0

data/lib/tapioca/gemfile.rb

@@ -136,6 +136,22 @@ module Tapioca
       extend(T::Sig)
       include GemHelper
 
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[String, Gemfile::GemSpec]) }
+        def spec_lookup_by_file_path
+          @lookup ||= T.let(
+            [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs]
+              .map! { |spec| new(spec.to_spec) }
+              .flat_map do |spec|
+                spec.files.filter_map { |file| [file.realpath.to_s, spec] if file.exist? }
+              end.to_h,
+            T.nilable(T::Hash[String, Gemfile::GemSpec])
+          )
+        end
+      end
+
       IGNORED_GEMS = T.let(
         [
           "sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime",
@@ -160,6 +176,11 @@ module Tapioca
         @files = T.let(collect_files, T::Array[Pathname])
       end
 
+      sig { params(other: BasicObject).returns(T::Boolean) }
+      def ==(other)
+        GemSpec === other && other.name == name && other.version == version
+      end
+
       sig { params(gemfile_dir: String).returns(T::Boolean) }
       def ignore?(gemfile_dir)
         gem_ignored? || gem_in_app_dir?(gemfile_dir, full_gem_path)
@@ -211,6 +232,15 @@ module Tapioca
         rewriter.tree
       end
 
+      sig { params(file: Pathname).returns(Pathname) }
+      def relative_path_for(file)
+        if default_gem?
+          file.realpath.relative_path_from(RbConfig::CONFIG["rubylibdir"])
+        else
+          file.realpath.relative_path_from(full_gem_path)
+        end
+      end
+
       private
 
       sig { returns(T::Array[Pathname]) }

data/lib/tapioca/helpers/config_helper.rb

@@ -100,7 +100,7 @@ module Tapioca
       ).returns(T::Array[ConfigError])
     end
     def validate_config_options(command_options, config_key, config_options)
-      config_options.map do |config_option_key, config_option_value|
+      config_options.filter_map do |config_option_key, config_option_value|
         command_option = command_options[config_option_key.to_sym]
         error_msg = "unknown option `#{config_option_key}` for key `#{config_key}`"
         next build_error(error_msg) unless command_option
@@ -135,7 +135,7 @@ module Tapioca
           all_strings = (config_option_value.keys + config_option_value.values).all? { |v| v.is_a?(String) }
           next build_error(error_msg) unless all_strings
         end
-      end.compact
+      end
     end
 
     class ConfigErrorMessagePart < T::Struct

data/lib/tapioca/helpers/rbi_helper.rb

@@ -8,6 +8,44 @@ module Tapioca
     extend SorbetHelper
     extend self
 
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          type: String,
+          variance: Symbol,
+          fixed: T.nilable(String),
+          upper: T.nilable(String),
+          lower: T.nilable(String)
+        ).returns(String)
+      end
+      def serialize_type_variable(type, variance, fixed, upper, lower)
+        variance = nil if variance == :invariant
+
+        bounds = []
+        bounds << "fixed: #{fixed}" if fixed
+        bounds << "lower: #{lower}" if lower
+        bounds << "upper: #{upper}" if upper
+
+        parameters = []
+        block = []
+
+        parameters << ":#{variance}" if variance
+
+        if sorbet_supports?(:type_variable_block_syntax)
+          block = bounds
+        else
+          parameters.concat(bounds)
+        end
+
+        serialized = type.dup
+        serialized << "(#{parameters.join(", ")})" unless parameters.empty?
+        serialized << " { { #{block.join(", ")} } }" unless block.empty?
+        serialized
+      end
+    end
+
     sig { params(name: String, type: String).returns(RBI::TypedParam) }
     def create_param(name, type:)
       create_typed_param(RBI::Param.new(name), type)
@@ -57,38 +95,13 @@ module Tapioca
         .gsub(".params()", "")
     end
 
-    sig do
-      params(
-        type: String,
-        variance: Symbol,
-        fixed: T.nilable(String),
-        upper: T.nilable(String),
-        lower: T.nilable(String)
-      ).returns(String)
-    end
-    def self.serialize_type_variable(type, variance, fixed, upper, lower)
-      variance = nil if variance == :invariant
-
-      bounds = []
-      bounds << "fixed: #{fixed}" if fixed
-      bounds << "lower: #{lower}" if lower
-      bounds << "upper: #{upper}" if upper
-
-      parameters = []
-      block = []
-
-      parameters << ":#{variance}" if variance
-
-      if sorbet_supports?(:type_variable_block_syntax)
-        block = bounds
+    sig { params(type: String).returns(String) }
+    def as_nilable_type(type)
+      if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
+        type
       else
-        parameters.concat(bounds)
+        "T.nilable(#{type})"
       end
-
-      serialized = type.dup
-      serialized << "(#{parameters.join(", ")})" unless parameters.empty?
-      serialized << " { { #{block.join(", ")} } }" unless block.empty?
-      serialized
     end
 
     sig { params(name: String).returns(T::Boolean) }

data/lib/tapioca/helpers/source_uri.rb

@@ -0,0 +1,77 @@
+# typed: true
+# frozen_string_literal: true
+
+require "uri/file"
+
+module URI
+  class Source < URI::File
+    extend T::Sig
+
+    COMPONENT = T.let([
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze, T::Array[Symbol])
+
+    alias_method(:gem_name, :host)
+    alias_method(:line_number, :fragment)
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :gem_version
+
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          gem_name: String,
+          gem_version: T.nilable(String),
+          path: String,
+          line_number: T.nilable(String)
+        ).returns(URI::Source)
+      end
+      def build(gem_name:, gem_version:, path:, line_number:)
+        super(
+          {
+            scheme: "source",
+            host: gem_name,
+            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            fragment: line_number,
+          }
+        )
+      end
+    end
+
+    sig { params(v: T.nilable(String)).void }
+    def set_path(v) # rubocop:disable Naming/AccessorMethodName
+      return if v.nil?
+
+      @gem_version, @path = v.split("/", 2)
+    end
+
+    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    def check_host(v)
+      return true unless v
+
+      if /[A-Za-z][A-Za-z0-9\-_]*/ !~ v
+        raise InvalidComponentError,
+          "bad component(expected gem name): #{v}"
+      end
+
+      true
+    end
+
+    sig { returns(String) }
+    def to_s
+      "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
+    end
+
+    if URI.respond_to?(:register_scheme)
+      URI.register_scheme("SOURCE", self)
+    else
+      @@schemes["SOURCE"] = self
+    end
+  end
+end

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

@@ -79,7 +79,7 @@ module Tapioca
 
           sig { returns(T::Array[String]) }
           def gathered_constants
-            compiler_class.processable_constants.map(&:name).compact.sort
+            compiler_class.processable_constants.filter_map(&:name).sort
           end
 
           sig { params(constant_name: T.any(Symbol, String)).returns(String) }

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

@@ -10,9 +10,13 @@ module Tapioca
         extend T::Sig
         require "thread"
 
-        sig { returns(T::Boolean) }
-        def self.forking_env?
-          !ENV["NO_FORK"] && Process.respond_to?(:fork)
+        class << self
+          extend T::Sig
+
+          sig { returns(T::Boolean) }
+          def forking_env?
+            !ENV["NO_FORK"] && Process.respond_to?(:fork)
+          end
         end
 
         def run

data/lib/tapioca/internal.rb

@@ -27,7 +27,6 @@ require "yard-sorbet"
 
 require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/helpers/gem_helper"
-require "tapioca/runtime/loader"
 
 require "tapioca/helpers/sorbet_helper"
 require "tapioca/helpers/rbi_helper"
@@ -37,6 +36,7 @@ require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"
 require "tapioca/runtime/generic_type_registry"
 
+require "tapioca/helpers/source_uri"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
 require "tapioca/helpers/rbi_files_helper"
@@ -50,6 +50,10 @@ require "tapioca/static/symbol_table_parser"
 require "tapioca/static/symbol_loader"
 require "tapioca/static/requires_compiler"
 
+require "tapioca/loaders/loader"
+require "tapioca/loaders/gem"
+require "tapioca/loaders/dsl"
+
 require "tapioca/gem"
 require "tapioca/dsl"
 require "tapioca/commands"

data/lib/tapioca/loaders/dsl.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Loaders
+    class Dsl < Loader
+      extend T::Sig
+
+      class << self
+        extend T::Sig
+
+        sig { params(tapioca_path: String, eager_load: T::Boolean).void }
+        def load_application(tapioca_path:, eager_load: true)
+          loader = new(tapioca_path: tapioca_path)
+          loader.load
+        end
+      end
+
+      sig { override.void }
+      def load
+        load_dsl_extensions
+        load_application
+        abort_if_pending_migrations!
+        load_dsl_compilers
+      end
+
+      protected
+
+      sig { params(tapioca_path: String, eager_load: T::Boolean).void }
+      def initialize(tapioca_path:, eager_load: true)
+        super()
+
+        @tapioca_path = tapioca_path
+        @eager_load = eager_load
+      end
+
+      sig { void }
+      def load_dsl_extensions
+        Dir["#{__dir__}/../dsl/extensions/*.rb"].sort.each { |f| require(f) }
+      end
+
+      sig { void }
+      def load_dsl_compilers
+        say("Loading DSL compiler classes... ")
+
+        Dir.glob([
+          "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
+          "#{@tapioca_path}/compilers/**/*.rb",
+        ]).each do |compiler|
+          require File.expand_path(compiler)
+        end
+
+        ::Gem.find_files("tapioca/dsl/compilers/*.rb").each do |compiler|
+          require File.expand_path(compiler)
+        end
+
+        say("Done", :green)
+      end
+
+      sig { void }
+      def load_application
+        say("Loading Rails application... ")
+
+        load_rails_application(
+          environment_load: true,
+          eager_load: @eager_load
+        )
+
+        say("Done", :green)
+      end
+
+      sig { void }
+      def abort_if_pending_migrations!
+        return unless File.exist?("config/application.rb")
+        return unless defined?(::Rake)
+
+        Rails.application.load_tasks
+        if Rake::Task.task_defined?("db:abort_if_pending_migrations")
+          Rake::Task["db:abort_if_pending_migrations"].invoke
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/loaders/gem.rb

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Loaders
+    class Gem < Loader
+      extend T::Sig
+
+      class << self
+        extend T::Sig
+
+        sig do
+          params(
+            bundle: Gemfile,
+            prerequire: T.nilable(String),
+            postrequire: String,
+            default_command: String
+          ).void
+        end
+        def load_application(bundle:, prerequire:, postrequire:, default_command:)
+          loader = new(bundle: bundle,
+            prerequire: prerequire,
+            postrequire: postrequire,
+            default_command: default_command)
+          loader.load
+        end
+      end
+
+      sig { override.void }
+      def load
+        require_gem_file
+      end
+
+      protected
+
+      sig do
+        params(
+          bundle: Gemfile,
+          prerequire: T.nilable(String),
+          postrequire: String,
+          default_command: String
+        ).void
+      end
+      def initialize(bundle:, prerequire:, postrequire:, default_command:)
+        super()
+
+        @bundle = bundle
+        @prerequire = prerequire
+        @postrequire = postrequire
+        @default_command = default_command
+      end
+
+      sig { void }
+      def require_gem_file
+        say("Requiring all gems to prepare for compiling... ")
+        begin
+          load_bundle(@bundle, @prerequire, @postrequire)
+        rescue LoadError => e
+          explain_failed_require(@postrequire, e)
+          exit(1)
+        end
+
+        Runtime::Trackers::Autoload.eager_load_all!
+
+        say(" Done", :green)
+        unless @bundle.missing_specs.empty?
+          say("  completed with missing specs: ")
+          say(@bundle.missing_specs.join(", "), :yellow)
+        end
+        puts
+      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}`", :bold, :blue)
+        say_error("you should probably review it and remove the faulty line.", :yellow)
+      end
+    end
+  end
+end

data/lib/tapioca/{runtime → loaders}/loader.rb

@@ -1,12 +1,22 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 module Tapioca
-  module Runtime
+  module Loaders
     class Loader
-      extend(T::Sig)
-      include Tapioca::GemHelper
+      extend T::Sig
+      extend T::Helpers
+
       include Thor::Base
+      include CliHelper
+      include Tapioca::GemHelper
+
+      abstract!
+
+      sig { abstract.void }
+      def load; end
+
+      private
 
       sig do
         params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void
@@ -43,16 +53,27 @@ module Tapioca
         say("Continuing RBI generation without loading the Rails application.")
       end
 
-      private
-
-      sig { params(file: T.nilable(String)).void }
-      def require_helper(file)
-        return unless file
+      sig { void }
+      def load_rails_engines
+        rails_engines.each do |engine|
+          errored_files = []
 
-        file = File.absolute_path(file)
-        return unless File.exist?(file)
+          engine.config.eager_load_paths.each do |load_path|
+            Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+              require(file)
+            rescue LoadError, StandardError
+              errored_files << file
+            end
+          end
 
-        require(file)
+          # Try files that have errored one more time
+          # It might have been a load order problem
+          errored_files.each do |file|
+            require(file)
+          rescue LoadError, StandardError
+            nil
+          end
+        end
       end
 
       sig { returns(T::Array[T.untyped]) }
@@ -110,27 +131,14 @@ module Tapioca
         end
       end
 
-      sig { void }
-      def load_rails_engines
-        rails_engines.each do |engine|
-          errored_files = []
+      sig { params(file: T.nilable(String)).void }
+      def require_helper(file)
+        return unless file
 
-          engine.config.eager_load_paths.each do |load_path|
-            Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-              require(file)
-            rescue LoadError, StandardError
-              errored_files << file
-            end
-          end
+        file = File.absolute_path(file)
+        return unless File.exist?(file)
 
-          # Try files that have errored one more time
-          # It might have been a load order problem
-          errored_files.each do |file|
-            require(file)
-          rescue LoadError, StandardError
-            nil
-          end
-        end
+        require(file)
       end
     end
   end

data/lib/tapioca/repo_index.rb

@@ -6,15 +6,19 @@ module Tapioca
     extend T::Sig
     extend T::Generic
 
-    sig { params(json: String).returns(RepoIndex) }
-    def self.from_json(json)
-      RepoIndex.from_hash(JSON.parse(json))
-    end
+    class << self
+      extend T::Sig
+
+      sig { params(json: String).returns(RepoIndex) }
+      def from_json(json)
+        RepoIndex.from_hash(JSON.parse(json))
+      end
 
-    sig { params(hash: T::Hash[String, T::Hash[T.untyped, T.untyped]]).returns(RepoIndex) }
-    def self.from_hash(hash)
-      hash.each_with_object(RepoIndex.new) do |(name, _), index|
-        index << name
+      sig { params(hash: T::Hash[String, T::Hash[T.untyped, T.untyped]]).returns(RepoIndex) }
+      def from_hash(hash)
+        hash.each_with_object(RepoIndex.new) do |(name, _), index|
+          index << name
+        end
       end
     end
 

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -178,7 +178,7 @@ module Tapioca
 
       sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
       def compile_mixes_in_class_methods(tree)
-        includes = dynamic_includes.map do |mod|
+        includes = dynamic_includes.filter_map do |mod|
           qname = qualified_name_of(mod)
 
           next if qname.nil? || qname.empty?
@@ -187,7 +187,7 @@ module Tapioca
           tree << RBI::Include.new(qname)
 
           mod
-        end.compact
+        end
 
         # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
         # constant itself

data/lib/tapioca/runtime/trackers/constant_definition.rb

@@ -49,22 +49,24 @@ module Tapioca
           (@class_files[key] ||= Set.new) << loc
         end
 
-        def self.build_constant_location(tp, locations)
-          file = resolve_loc(caller_locations)
-          lineno = file == File.realpath(tp.path) ? tp.lineno : 0
+        class << self
+          def build_constant_location(tp, locations)
+            file = resolve_loc(caller_locations)
+            lineno = file == File.realpath(tp.path) ? tp.lineno : 0
 
-          ConstantLocation.new(path: file, lineno: lineno)
-        end
+            ConstantLocation.new(path: file, lineno: lineno)
+          end
 
-        # 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 self.files_for(klass)
-          locations_for(klass).map(&:path).to_set
-        end
+          # 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)
+            locations_for(klass).map(&:path).to_set
+          end
 
-        def self.locations_for(klass)
-          @class_files.fetch(klass, Set.new)
+          def locations_for(klass)
+            @class_files.fetch(klass, Set.new)
+          end
         end
       end
     end