tapioca 0.4.16 → 0.4.21

data/lib/tapioca/compilers/dsl/url_helpers.rb

@@ -89,7 +89,7 @@ module Tapioca
       class UrlHelpers < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def decorate(root, constant)
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
@@ -127,7 +127,7 @@ module Tapioca
 
         private
 
-        sig { params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
+        sig { params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -143,7 +143,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module), helper_module: Module).void }
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: Module, helper_module: Module).void }
         def create_mixins_for(mod, constant, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -74,9 +74,15 @@ module Tapioca
           compile(symbol, constant)
         end
 
-        sig { params(symbol: String, inherit: T::Boolean).returns(BasicObject).checked(:never) }
-        def resolve_constant(symbol, inherit: false)
-          Object.const_get(symbol, inherit)
+        sig do
+          params(
+            symbol: String,
+            inherit: T::Boolean,
+            namespace: Module
+          ).returns(BasicObject).checked(:never)
+        end
+        def resolve_constant(symbol, inherit: false, namespace: Object)
+          namespace.const_get(symbol, inherit)
         rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
           nil
         end
@@ -142,9 +148,11 @@ module Tapioca
         def compile_object(name, value)
           return if symbol_ignored?(name)
           klass = class_of(value)
-          return if name_of(klass)&.start_with?("T::Types::", "T::Private::")
+          klass_name = name_of(klass)
+
+          return if klass_name&.start_with?("T::Types::", "T::Private::")
 
-          type_name = public_module?(klass) && name_of(klass) || "T.untyped"
+          type_name = public_module?(klass) && klass_name || "T.untyped"
           indented("#{name} = T.let(T.unsafe(nil), #{type_name})")
         end
 
@@ -181,16 +189,17 @@ module Tapioca
 
             [
               compile_module_helpers(constant),
+              compile_type_variables(constant),
               compile_mixins(constant),
               compile_mixes_in_class_methods(constant),
               compile_props(constant),
               compile_enums(constant),
               methods,
-            ].select { |b| b != "" }.join("\n\n")
+            ].select { |b| b && !b.empty? }.join("\n\n")
           end
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_module_helpers(constant)
           abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type)
 
@@ -199,12 +208,14 @@ module Tapioca
           helpers << indented("final!") if T::Private::Final.final_module?(constant)
           helpers << indented("sealed!") if T::Private::Sealed.sealed_module?(constant)
 
+          return if helpers.empty?
+
           helpers.join("\n")
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_props(constant)
-          return "" unless T::Props::ClassMethods === constant
+          return unless T::Props::ClassMethods === constant
 
           constant.props.map do |name, prop|
             method = "prop"
@@ -219,11 +230,11 @@ module Tapioca
           end.join("\n")
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: Module).returns(T.nilable(String)) }
         def compile_enums(constant)
-          return "" unless constant < T::Enum
+          return unless T::Enum > constant
 
-          enums = T.cast(constant, T::Enum).values.map do |enum_type|
+          enums = T.unsafe(constant).values.map do |enum_type|
             enum_type.instance_variable_get(:@const_name).to_s
           end
 
@@ -250,11 +261,71 @@ module Tapioca
             compile(symbol, subconstant)
           end.compact
 
-          return "" if output.empty?
+          return if output.empty?
 
           "\n" + output.join("\n\n")
         end
 
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variables(constant)
+          type_variables = compile_type_variable_declarations(constant)
+          singleton_class_type_variables = compile_type_variable_declarations(singleton_class_of(constant))
+
+          return if !type_variables && !singleton_class_type_variables
+
+          type_variables += "\n" if type_variables
+          singleton_class_type_variables += "\n" if singleton_class_type_variables
+
+          [
+            type_variables,
+            singleton_class_type_variables,
+          ].compact.join("\n").rstrip
+        end
+
+        sig { params(constant: Module).returns(T.nilable(String)) }
+        def compile_type_variable_declarations(constant)
+          with_indentation_for_constant(constant) do
+            # Try to find the type variables defined on this constant, bail if we can't
+            type_variables = GenericTypeRegistry.lookup_type_variables(constant)
+            return unless type_variables
+
+            # Create a map of subconstants (via their object ids) to their names.
+            # We need this later when we want to lookup the name of the registered type
+            # variable via the value of the type variable constant.
+            subconstant_to_name_lookup = constants_of(constant).map do |constant_name|
+              [
+                object_id_of(resolve_constant(constant_name.to_s, namespace: constant)),
+                constant_name,
+              ]
+            end.to_h
+
+            # Map each type variable to its string representation.
+            #
+            # Each entry of `type_variables` maps an object_id to a String,
+            # and the order they are inserted into the hash is the order they should be
+            # defined in the source code.
+            #
+            # By looping over these entries and then getting the actual constant name
+            # from the `subconstant_to_name_lookup` we defined above, gives us all the
+            # information we need to serialize type variable definitions.
+            type_variable_declarations = type_variables.map do |type_variable_id, serialized_type_variable|
+              constant_name = subconstant_to_name_lookup[type_variable_id]
+              # Here, we know that constant_value will be an instance of
+              # T::Types::CustomTypeVariable, which knows how to serialize
+              # itself to a type_member/type_template
+              indented("#{constant_name} = #{serialized_type_variable}")
+            end.compact
+
+            return if type_variable_declarations.empty?
+
+            [
+              indented("extend T::Generic"),
+              "",
+              *type_variable_declarations,
+            ].compact.join("\n")
+          end
+        end
+
         sig { params(constant: Class).returns(String) }
         def compile_superclass(constant)
           superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
@@ -431,29 +502,19 @@ module Tapioca
           instance_methods = compile_directly_owned_methods(name, constant)
           singleton_methods = compile_directly_owned_methods(name, singleton_class_of(constant))
 
-          return if symbol_ignored?(name) && instance_methods.empty? && singleton_methods.empty?
+          return if symbol_ignored?(name) && !instance_methods && !singleton_methods
 
           [
-            initialize_method || "",
+            initialize_method,
             instance_methods,
             singleton_methods,
-          ].select { |b| b.strip != "" }.join("\n\n")
+          ].select { |b| b && !b.strip.empty? }.join("\n\n")
         end
 
-        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(String) }
+        sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(T.nilable(String)) }
         def compile_directly_owned_methods(module_name, mod, for_visibility = [:public, :protected, :private])
-          indent_step = 0
-          preamble = nil
-          postamble = nil
-
-          if mod.singleton_class?
-            indent_step = 1
-            preamble = indented("class << self")
-            postamble = indented("end")
-          end
-
-          methods = with_indentation(indent_step) do
-            method_names_by_visibility(mod)
+          with_indentation_for_constant(mod) do
+            methods = method_names_by_visibility(mod)
               .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
               .flat_map do |visibility, method_list|
                 compiled = method_list.sort!.map do |name|
@@ -470,16 +531,11 @@ module Tapioca
                 compiled
               end
               .compact
-              .join("\n")
-          end
 
-          return "" if methods.strip == ""
+            return if methods.empty?
 
-          [
-            preamble,
-            methods,
-            postamble,
-          ].compact.join("\n")
+            methods.join("\n")
+          end
         end
 
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
@@ -659,6 +715,33 @@ module Tapioca
           @indent -= 2 * step
         end
 
+        sig do
+          params(
+            constant: Module,
+            blk: T.proc
+              .returns(T.nilable(String))
+          )
+            .returns(T.nilable(String))
+        end
+        def with_indentation_for_constant(constant, &blk)
+          step = if constant.singleton_class?
+            1
+          else
+            0
+          end
+
+          result = with_indentation(step, &blk)
+
+          return result unless result
+          return result unless constant.singleton_class?
+
+          [
+            indented("class << self"),
+            result,
+            indented("end"),
+          ].compact.join("\n")
+        end
+
         sig { params(str: String).returns(String) }
         def indented(str)
           " " * @indent + str
@@ -859,12 +942,12 @@ module Tapioca
           nil
         end
 
-        sig { params(constant: Module).returns(String) }
+        sig { params(constant: T::Types::Base).returns(String) }
         def type_of(constant)
           constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
         end
 
-        sig { params(object: Object).returns(T::Boolean).checked(:never) }
+        sig { params(object: BasicObject).returns(Integer).checked(:never) }
         def object_id_of(object)
           Object.instance_method(:object_id).bind(object).call
         end

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,16 +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
 
-      rbi_files_to_purge = existing_rbi_filenames(requested_constants)
-
-      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,
@@ -135,24 +146,31 @@ module Tapioca
       )
 
       compiler.run do |constant, contents|
-        filename = compile_dsl_rbi(constant, contents)
-        rbi_files_to_purge.delete(filename) if filename
-      end
+        constant_name = Module.instance_method(:name).bind(constant).call
 
-      unless rbi_files_to_purge.empty?
-        say("")
-        say("Removing stale RBI files...")
+        filename = compile_dsl_rbi(
+          constant_name,
+          contents,
+          outpath: outpath,
+          quiet: should_verify || quiet
+        )
 
-        rbi_files_to_purge.sort.each do |filename|
-          remove(filename)
+        if filename
+          rbi_files_to_purge.delete(filename)
         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)
+      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 }
@@ -218,7 +236,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
 
@@ -286,10 +304,10 @@ module Tapioca
       constant_map.values
     end
 
-    sig { params(requested_constants: T::Array[String]).returns(T::Set[Pathname]) }
-    def existing_rbi_filenames(requested_constants)
+    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(config.outpath / "**/*.rbi")
+        Pathname.glob(path / "**/*.rbi")
       else
         requested_constants.map do |constant_name|
           dsl_rbi_filename(constant_name)
@@ -477,7 +495,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
       )
@@ -494,33 +512,120 @@ 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).returns(T.nilable(Pathname)) }
-    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).void }
+    def perform_dsl_verification(dir)
+      diff = verify_dsl_rbi(tmp_dir: dir)
+
+      if diff.empty?
+        say("Nothing to do, all RBIs are up-to-date.")
+      else
+        say("RBI files are out-of-date, please run:")
+        say("  `#{Config::DEFAULT_COMMAND} dsl`")
+
+        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