tapioca 0.4.15 → 0.4.20

data/lib/tapioca/config.rb

@@ -8,7 +8,6 @@ module Tapioca
     const(:outdir, String)
     const(:prerequire, T.nilable(String))
     const(:postrequire, String)
-    const(:generate_command, String)
     const(:exclude, T::Array[String])
     const(:typed_overrides, T::Hash[String, String])
     const(:todos_path, String)
@@ -27,6 +26,7 @@ module Tapioca
     TAPIOCA_PATH = T.let("#{SORBET_PATH}/tapioca", String)
     TAPIOCA_CONFIG = T.let("#{TAPIOCA_PATH}/config.yml", String)
 
+    DEFAULT_COMMAND = T.let("bin/tapioca", String)
     DEFAULT_POSTREQUIRE = T.let("#{TAPIOCA_PATH}/require.rb", String)
     DEFAULT_RBIDIR = T.let("#{SORBET_PATH}/rbi", String)
     DEFAULT_DSLDIR = T.let("#{DEFAULT_RBIDIR}/dsl", String)

data/lib/tapioca/config_builder.rb

@@ -10,9 +10,13 @@ module Tapioca
 
       sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Config) }
       def from_options(command, options)
-        Config.from_hash(
-          merge_options(default_options(command), config_options, options)
-        )
+        merged_options = merge_options(default_options(command), config_options, options)
+
+        puts(<<~MSG) if merged_options.include?("generate_command")
+          DEPRECATION: The `-c` and `--cmd` flags will be removed in a future release.
+        MSG
+
+        Config.from_hash(merged_options)
       end
 
       private
@@ -40,14 +44,6 @@ module Tapioca
         DEFAULT_OPTIONS.merge("outdir" => default_outdir)
       end
 
-      sig { returns(String) }
-      def default_command
-        command = File.basename($PROGRAM_NAME)
-        args = ARGV.join(" ")
-
-        "#{command} #{args}".strip
-      end
-
       sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
       def merge_options(*options)
         options.each_with_object({}) do |option, result|
@@ -65,7 +61,6 @@ module Tapioca
     DEFAULT_OPTIONS = T.let({
       "postrequire" => Config::DEFAULT_POSTREQUIRE,
       "outdir" => nil,
-      "generate_command" => default_command,
       "exclude" => [],
       "typed_overrides" => Config::DEFAULT_OVERRIDES,
       "todos_path" => Config::DEFAULT_TODOSPATH,

data/lib/tapioca/generator.rb

@@ -63,7 +63,7 @@ module Tapioca
 
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} require",
         reason: "explicit gem requires",
         strictness: "false"
       )
@@ -76,8 +76,8 @@ module Tapioca
       say("Done", :green)
 
       say("All requires from this application have been written to #{name}.", [:green, :bold])
-      cmd = set_color("tapioca sync", :yellow, :bold)
-      say("Please review changes and commit them, then run #{cmd}.", [:green, :bold])
+      cmd = set_color("#{Config::DEFAULT_COMMAND} sync", :yellow, :bold)
+      say("Please review changes and commit them, then run `#{cmd}`.", [:green, :bold])
     end
 
     sig { void }
@@ -99,7 +99,7 @@ module Tapioca
 
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} todo",
         reason: "unresolved constants",
         strictness: "false"
       )
@@ -116,14 +116,27 @@ module Tapioca
       say("Please review changes and commit them.", [:green, :bold])
     end
 
-    sig { params(requested_constants: T::Array[String]).void }
-    def build_dsl(requested_constants)
+    sig do
+      params(
+        requested_constants: T::Array[String],
+        should_verify: T::Boolean,
+        quiet: T::Boolean
+      ).void
+    end
+    def build_dsl(requested_constants, should_verify: false, quiet: false)
       load_application(eager_load: requested_constants.empty?)
       load_dsl_generators
 
-      say("Compiling DSL RBI files...")
+      if should_verify
+        say("Checking for out-of-date RBIs...")
+      else
+        say("Compiling DSL RBI files...")
+      end
       say("")
 
+      outpath = should_verify ? Pathname.new(Dir.mktmpdir) : config.outpath
+      rbi_files_to_purge = existing_rbi_filenames(requested_constants)
+
       compiler = Compilers::DslCompiler.new(
         requested_constants: constantize(requested_constants),
         requested_generators: config.generators,
@@ -132,15 +145,35 @@ module Tapioca
         }
       )
 
+      constant_lookup = {}
+
       compiler.run do |constant, contents|
-        compile_dsl_rbi(constant, contents)
+        constant_name = Module.instance_method(:name).bind(constant).call
+
+        filename = compile_dsl_rbi(
+          constant_name,
+          contents,
+          outpath: outpath,
+          quiet: should_verify || quiet
+        )
+
+        if filename
+          rbi_files_to_purge.delete(filename)
+          constant_lookup[filename.relative_path_from(outpath)] = constant_name
+        end
       end
-
       say("")
-      say("Done", :green)
 
-      say("All operations performed in working directory.", [:green, :bold])
-      say("Please review changes and commit them.", [:green, :bold])
+      if should_verify
+        perform_dsl_verification(outpath, constant_lookup)
+      else
+        purge_stale_dsl_rbi_files(rbi_files_to_purge)
+
+        say("Done", :green)
+
+        say("All operations performed in working directory.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
     end
 
     sig { void }
@@ -206,7 +239,7 @@ module Tapioca
       say_error("If you populated ", :yellow)
       say_error("#{file} ", :bold, :blue)
       say_error("with ", :yellow)
-      say_error("tapioca require", :bold, :blue)
+      say_error("`#{Config::DEFAULT_COMMAND} require`", :bold, :blue)
       say_error("you should probably review it and remove the faulty line.", :yellow)
     end
 
@@ -253,13 +286,38 @@ module Tapioca
 
     sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
     def constantize(constant_names)
-      constant_names.map do |name|
+      constant_map = constant_names.map do |name|
         begin
-          name.constantize
+          [name, name.constantize]
         rescue NameError
-          nil
+          [name, nil]
         end
-      end.compact
+      end.to_h
+
+      unprocessable_constants = constant_map.select { |_, v| v.nil? }
+      unless unprocessable_constants.empty?
+        unprocessable_constants.each do |name, _|
+          say("Error: Cannot find constant '#{name}'", :red)
+          remove(dsl_rbi_filename(name))
+        end
+
+        exit(1)
+      end
+
+      constant_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?
+        Pathname.glob(path / "**/*.rbi")
+      else
+        requested_constants.map do |constant_name|
+          dsl_rbi_filename(constant_name)
+        end
+      end
+
+      filenames.to_set
     end
 
     sig { returns(T::Hash[String, String]) }
@@ -277,6 +335,11 @@ module Tapioca
         .to_h
     end
 
+    sig { params(constant_name: String).returns(Pathname) }
+    def dsl_rbi_filename(constant_name)
+      config.outpath / "#{constant_name.underscore}.rbi"
+    end
+
     sig { params(gem_name: String, version: String).returns(Pathname) }
     def gem_rbi_filename(gem_name, version)
       config.outpath / "#{gem_name}@#{version}.rbi"
@@ -316,6 +379,7 @@ module Tapioca
 
     sig { params(filename: Pathname).void }
     def remove(filename)
+      return unless filename.exist?
       say("-- Removing: #{filename}")
       filename.unlink
     end
@@ -434,7 +498,7 @@ module Tapioca
       rbi_body_content = compiler.compile(gem)
       content = String.new
       content << rbi_header(
-        config.generate_command,
+        "#{Config::DEFAULT_COMMAND} sync",
         reason: "types exported from the `#{gem.name}` gem",
         strictness: strictness
       )
@@ -451,31 +515,122 @@ module Tapioca
       end
       File.write(filename.to_s, content)
 
-      Pathname.glob((config.outpath / "#{gem.name}@*.rbi").to_s) do |file|
+      T.unsafe(Pathname).glob((config.outpath / "#{gem.name}@*.rbi").to_s) do |file|
         remove(file) unless file.basename.to_s == gem.rbi_file_name
       end
     end
 
-    sig { params(constant: Module, contents: String).void }
-    def compile_dsl_rbi(constant, contents)
+    sig do
+      params(constant_name: String, contents: String, outpath: Pathname, quiet: T::Boolean)
+        .returns(T.nilable(Pathname))
+    end
+    def compile_dsl_rbi(constant_name, contents, outpath: config.outpath, quiet: false)
       return if contents.nil?
 
-      command = format(config.generate_command, constant.name)
-      constant_name = Module.instance_method(:name).bind(constant).call
       rbi_name = constant_name.underscore + ".rbi"
-      filename = config.outpath / rbi_name
+      filename = outpath / rbi_name
 
       out = String.new
       out << rbi_header(
-        command,
-        reason: "dynamic methods in `#{constant.name}`"
+        "#{Config::DEFAULT_COMMAND} dsl #{constant_name}",
+        reason: "dynamic methods in `#{constant_name}`"
       )
       out << contents
 
       FileUtils.mkdir_p(File.dirname(filename))
       File.write(filename, out)
-      say("Wrote: ", [:green])
-      say(filename)
+
+      unless quiet
+        say("Wrote: ", [:green])
+        say(filename)
+      end
+
+      filename
+    end
+
+    sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+    def verify_dsl_rbi(tmp_dir:)
+      diff = {}
+
+      existing_rbis = rbi_files_in(config.outpath)
+      new_rbis = rbi_files_in(tmp_dir)
+
+      added_files = (new_rbis - existing_rbis)
+
+      added_files.each do |file|
+        diff[file] = :added
+      end
+
+      removed_files = (existing_rbis - new_rbis)
+
+      removed_files.each do |file|
+        diff[file] = :removed
+      end
+
+      common_files = (existing_rbis & new_rbis)
+
+      changed_files = common_files.map do |filename|
+        filename unless FileUtils.identical?(config.outpath / filename, tmp_dir / filename)
+      end.compact
+
+      changed_files.each do |file|
+        diff[file] = :changed
+      end
+
+      diff
+    end
+
+    sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+    def build_error_for_files(cause, files)
+      filenames = files.map do |file|
+        config.outpath / file
+      end.join("\n  - ")
+
+      "  File(s) #{cause}:\n  - #{filenames}"
+    end
+
+    sig { params(path: Pathname).returns(T::Array[Pathname]) }
+    def rbi_files_in(path)
+      Pathname.glob(path / "**/*.rbi").map do |file|
+        file.relative_path_from(path)
+      end.sort
+    end
+
+    sig { params(dir: Pathname, constant_lookup: T::Hash[String, String]).void }
+    def perform_dsl_verification(dir, constant_lookup)
+      diff = verify_dsl_rbi(tmp_dir: dir)
+
+      if diff.empty?
+        say("Nothing to do, all RBIs are up-to-date.")
+      else
+        constants = T.unsafe(constant_lookup).values_at(*diff.keys).join(" ")
+
+        say("RBI files are out-of-date, please run:")
+        say("  `#{Config::DEFAULT_COMMAND} dsl #{constants}`")
+
+        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
+    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
   end
 end

data/lib/tapioca/generic_type_registry.rb

@@ -0,0 +1,219 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  # This class is responsible for storing and looking up information related to generic types.
+  #
+  # The class stores 2 different kinds of data, in two separate lookup tables:
+  #   1. a lookup of generic type instances by name: `@generic_instances`
+  #   2. a lookup of type variable serializer by constant and type variable
+  #      instance: `@type_variables`
+  #
+  # By storing the above data, we can cheaply query each constant against this registry
+  # to see if it declares any generic type variables. This becomes a simple lookup in the
+  # `@type_variables` hash table with the given constant.
+  #
+  # If there is no entry, then we can cheaply know that we can skip generic type
+  # information generation for this type.
+  #
+  # On the other hand, if we get a result, then the result will be a hash of type
+  # variable to type variable serializers. This allows us to associate type variables
+  # to the constant names that represent them, easily.
+  module GenericTypeRegistry
+    @generic_instances = T.let(
+      {},
+      T::Hash[String, Module]
+    )
+
+    @type_variables = T.let(
+      {},
+      T::Hash[Integer, T::Hash[Integer, String]]
+    )
+
+    class << self
+      extend T::Sig
+
+      # This method is responsible for building the name of the instantiated concrete type
+      # and cloning the given constant so that we can return a type that is the same
+      # as the current type but is a different instance and has a different name method.
+      #
+      # We cache those cloned instances by their name in `@generic_instances`, so that
+      # we don't keep instantiating a new type every single time it is referenced.
+      # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+      # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+      # 2 hash lookups (for the other two `Foo[Integer]`s).
+      #
+      # This method returns the created or cached clone of the constant.
+      sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
+      def register_type(constant, types)
+        # Build the name of the instantiated generic type,
+        # something like `"Foo[X, Y, Z]"`
+        type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
+        name = "#{name_of(constant)}[#{type_list}]"
+
+        # Create a generic type with an overridden `name`
+        # method that returns the name we constructed above.
+        #
+        # Also, we try to memoize the generic type based on the name, so that
+        # we don't have to keep recreating them all the time.
+        @generic_instances[name] ||= create_generic_type(constant, name)
+      end
+
+      sig do
+        params(
+          constant: T.untyped,
+          type_member: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      def register_type_member(constant, type_member, fixed, lower, upper)
+        register_type_variable(constant, :type_member, type_member, fixed, lower, upper)
+      end
+
+      sig do
+        params(
+          constant: T.untyped,
+          type_template: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      def register_type_template(constant, type_template, fixed, lower, upper)
+        register_type_variable(constant, :type_template, type_template, fixed, lower, upper)
+      end
+
+      sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
+      def lookup_type_variables(constant)
+        @type_variables[object_id_of(constant)]
+      end
+
+      private
+
+      sig { params(constant: Module, name: String).returns(Module) }
+      def create_generic_type(constant, name)
+        generic_type = case constant
+        when Class
+          # For classes, we want to create a subclass, so that an instance of
+          # the generic class `Foo[Bar]` is still a `Foo`. That is:
+          # `Foo[Bar].new.is_a?(Foo)` should be true, which isn't the case
+          # if we just clone the class. But subclassing works just fine.
+          create_sealed_safe_subclass(constant)
+        else
+          # This can only be a module and it is fine to just clone modules
+          # since they can't have instances and will not have `is_a?` relationships.
+          # Moreover, we never `include`/`extend` any generic modules into the
+          # ancestor tree, so this doesn't become a problem with checking the
+          # instance of a class being `is_a?` of a module type.
+          constant.clone
+        end
+
+        # Let's set the `name` method to return the proper generic name
+        generic_type.define_singleton_method(:name) { name }
+
+        # Return the generic type we created
+        generic_type
+      end
+
+      # This method is called from intercepted calls to `type_member` and `type_template`.
+      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+      #
+      # This method creates a `String` with that data and stores it in the
+      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+      #
+      # Finally, the original `type_variable` is returned from this method, so that the caller
+      # can return it from the original methods as well.
+      sig do
+        params(
+          constant: T.untyped,
+          type_variable_type: T.enum([:type_member, :type_template]),
+          type_variable: T::Types::TypeVariable,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).void
+      end
+      # rubocop:disable Metrics/ParameterLists
+      def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper)
+        # rubocop:enable Metrics/ParameterLists
+        type_variables = lookup_or_initialize_type_variables(constant)
+
+        type_variables[object_id_of(type_variable)] = serialize_type_variable(
+          type_variable_type,
+          type_variable.variance,
+          fixed,
+          lower,
+          upper
+        )
+      end
+
+      sig { params(constant: Class).returns(Class) }
+      def create_sealed_safe_subclass(constant)
+        # If the constant is not sealed let's just bail early.
+        # We just return a subclass of the constant.
+        return Class.new(constant) unless T::Private::Sealed.sealed_module?(constant)
+
+        # Since sealed classes can normally not be subclassed, we need to trick
+        # sealed classes into thinking that the generic type we are
+        # creating by subclassing is actually safe for sealed types.
+        #
+        # Get the filename the sealed class was declared in
+        decl_file = constant.instance_variable_get(:@sorbet_sealed_module_decl_file)
+        begin
+          # Clear the current declaration filename on the class
+          constant.remove_instance_variable(:@sorbet_sealed_module_decl_file)
+          # Make this file be the declaration filename so that Sorbet runtime
+          # does not shout at us for an invalid subclassing.
+          T.cast(constant, T::Helpers).sealed!
+          # return a subclass
+          Class.new(constant)
+        ensure
+          # Reinstate the original declaration filename
+          constant.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+        end
+      end
+
+      sig { params(constant: Module).returns(T::Hash[Integer, String]) }
+      def lookup_or_initialize_type_variables(constant)
+        @type_variables[object_id_of(constant)] ||= {}
+      end
+
+      sig do
+        params(
+          type_variable_type: Symbol,
+          variance: Symbol,
+          fixed: T.untyped,
+          lower: T.untyped,
+          upper: T.untyped
+        ).returns(String)
+      end
+      def serialize_type_variable(type_variable_type, variance, fixed, lower, upper)
+        parts = []
+        parts << ":#{variance}" unless variance == :invariant
+        parts << "fixed: #{fixed}" if fixed
+        parts << "lower: #{lower}" unless lower == T.untyped
+        parts << "upper: #{upper}" unless upper == BasicObject
+
+        parameters = parts.join(", ")
+
+        serialized = T.let(type_variable_type.to_s, String)
+        serialized += "(#{parameters})" unless parameters.empty?
+
+        serialized
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def name_of(constant)
+        Module.instance_method(:name).bind(constant).call
+      end
+
+      sig { params(object: BasicObject).returns(Integer) }
+      def object_id_of(object)
+        Object.instance_method(:object_id).bind(object).call
+      end
+    end
+  end
+end