tapioca 0.6.0 → 0.6.4

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

@@ -141,7 +141,6 @@ module Tapioca
           return if symbol_ignored?(name)
 
           klass = class_of(value)
-          return if klass == TypeMember || klass == TypeTemplate
 
           klass_name = if klass == ObjectSpace::WeakMap
             # WeakMap is an implicit generic with one type variable
@@ -172,6 +171,7 @@ module Tapioca
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_module(tree, name, constant)
           return unless defined_in_gem?(constant, strict: false)
+          return if Tapioca::TypeVariableModule === constant
 
           comments = documentation_comments(name)
           scope =
@@ -282,30 +282,16 @@ module Tapioca
           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)
-            .each_with_object({}.compare_by_identity) do |constant_name, table|
-            table[constantize(constant_name.to_s, namespace: constant)] = constant_name.to_s
-          end
-
           # Map each type variable to its string representation.
           #
-          # Each entry of `type_variables` maps an object_id to a String,
+          # Each entry of `type_variables` maps a Module 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, serialized_type_variable|
-            constant_name = subconstant_to_name_lookup[type_variable]
-            type_variable.name = constant_name
-            # 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
-            tree << RBI::TypeMember.new(constant_name, serialized_type_variable)
+          type_variable_declarations = type_variables.map do |type_variable|
+            type_variable_name = type_variable.name
+            next unless type_variable_name
+
+            tree << RBI::TypeMember.new(type_variable_name, type_variable.serialize)
           end
 
           return if type_variable_declarations.empty?
@@ -392,7 +378,7 @@ module Tapioca
             .select do |mod|
               name = name_of(mod)
 
-              name && !name.start_with?("T::")
+              name && !filtered_mixin?(name)
             end
             .map do |mod|
               add_to_symbol_queue(name_of(mod))
@@ -496,7 +482,9 @@ module Tapioca
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            unless name
+            name = if name
+              name.to_s
+            else
               # For attr_writer methods, Sorbet signatures have the name
               # of the method (without the trailing = sign) as the name of
               # the only parameter. So, if the parameter does not have a name
@@ -512,15 +500,15 @@ module Tapioca
                 method_name[-1] == "="
               )
 
-              name = if writer_method_with_sig
-                T.must(method_name[0...-1]).to_sym
+              if writer_method_with_sig
+                method_name.delete_suffix("=")
               else
                 fallback_arg_name
               end
             end
 
             # Sanitize param names
-            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, fallback_arg_name)
+            name = fallback_arg_name unless valid_parameter_name?(name)
 
             [type, name]
           end
@@ -613,6 +601,13 @@ module Tapioca
           SymbolLoader.ignore_symbol?(symbol_name)
         end
 
+        sig { params(mixin_name: String).returns(T::Boolean) }
+        def filtered_mixin?(mixin_name)
+          # filter T:: namespace mixins that aren't T::Props
+          # T::Props and subconstants have semantic value
+          mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
+        end
+
         SPECIAL_METHOD_NAMES = T.let([
           "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
           "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"
@@ -624,6 +619,11 @@ module Tapioca
           !!name.match(/^[[:word:]]+[?!=]?$/)
         end
 
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
+
         sig { params(method: UnboundMethod).returns(T::Boolean) }
         def method_in_gem?(method)
           source_location = method.source_location&.first

data/lib/tapioca/gemfile.rb

@@ -99,6 +99,9 @@ module Tapioca
       sig { returns(String) }
       attr_reader :full_gem_path, :version
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :files
+
       sig { params(spec: Spec).void }
       def initialize(spec)
         @spec = T.let(spec, Tapioca::Gemfile::Spec)
@@ -106,6 +109,7 @@ module Tapioca
         @full_gem_path = T.let(real_gem_path, String)
         @version = T.let(version_string, String)
         @exported_rbi_files = T.let(nil, T.nilable(T::Array[String]))
+        @files = T.let(collect_files, T::Array[Pathname])
       end
 
       sig { params(gemfile_dir: String).returns(T::Boolean) }
@@ -113,21 +117,6 @@ module Tapioca
         gem_ignored? || gem_in_app_dir?(gemfile_dir)
       end
 
-      sig { returns(T::Array[Pathname]) }
-      def files
-        if default_gem?
-          # `Bundler::RemoteSpecification` delegates missing methods to
-          # `Gem::Specification`, so `files` actually always exists on spec.
-          T.unsafe(@spec).files.map do |file|
-            ruby_lib_dir.join(file)
-          end
-        else
-          @spec.full_require_paths.flat_map do |path|
-            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
-          end
-        end
-      end
-
       sig { returns(String) }
       def name
         @spec.name
@@ -154,7 +143,7 @@ module Tapioca
 
       sig { returns(T::Array[String]) }
       def exported_rbi_files
-        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi")
+        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi").sort
       end
 
       sig { returns(T::Boolean) }
@@ -176,14 +165,49 @@ module Tapioca
 
       private
 
-      sig { returns(T::Boolean) }
+      sig { returns(T::Array[Pathname]) }
+      def collect_files
+        if default_gem?
+          # `Bundler::RemoteSpecification` delegates missing methods to
+          # `Gem::Specification`, so `files` actually always exists on spec.
+          T.unsafe(@spec).files.map do |file|
+            resolve_to_ruby_lib_dir(file)
+          end
+        else
+          @spec.full_require_paths.flat_map do |path|
+            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
+          end
+        end
+      end
+
+      sig { returns(T.nilable(T::Boolean)) }
       def default_gem?
         @spec.respond_to?(:default_gem?) && @spec.default_gem?
       end
 
-      sig { returns(Pathname) }
-      def ruby_lib_dir
-        Pathname.new(RbConfig::CONFIG["rubylibdir"])
+      sig { returns(Regexp) }
+      def require_paths_prefix_matcher
+        @require_paths_prefix_matcher = T.let(@require_paths_prefix_matcher, T.nilable(Regexp))
+
+        @require_paths_prefix_matcher ||= begin
+          require_paths = T.unsafe(@spec).require_paths
+          prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
+          Regexp.union(prefix_matchers)
+        end
+      end
+
+      sig { params(file: String).returns(Pathname) }
+      def resolve_to_ruby_lib_dir(file)
+        # We want to match require prefixes but fallback to an empty match
+        # if none of the require prefixes actually match. This is so that
+        # we can always replace the match with the Ruby lib directory and
+        # we would have properly resolved the file under the Ruby lib dir.
+        prefix_matcher = Regexp.union(require_paths_prefix_matcher, //)
+
+        ruby_lib_dir = RbConfig::CONFIG["rubylibdir"]
+        file = file.sub(prefix_matcher, "#{ruby_lib_dir}/")
+
+        Pathname.new(file).expand_path
       end
 
       sig { returns(String) }

data/lib/tapioca/generators/base.rb

@@ -11,8 +11,8 @@ module Tapioca
         include Thor::Actions
       end
 
-      include CliHelper
       include Thor::Base
+      include CliHelper
 
       abstract!
 

data/lib/tapioca/generic_type_registry.rb

@@ -20,7 +20,6 @@ module Tapioca
   # variable to type variable serializers. This allows us to associate type variables
   # to the constant names that represent them, easily.
   module GenericTypeRegistry
-    TypeVariable = T.type_alias { T.any(TypeMember, TypeTemplate) }
     @generic_instances = T.let(
       {},
       T::Hash[String, Module]
@@ -28,7 +27,7 @@ module Tapioca
 
     @type_variables = T.let(
       {}.compare_by_identity,
-      T::Hash[Module, T::Hash[TypeVariable, String]]
+      T::Hash[Module, T::Array[TypeVariableModule]]
     )
 
     class << self
@@ -60,7 +59,12 @@ module Tapioca
         @generic_instances[name] ||= create_generic_type(constant, name)
       end
 
-      sig { params(constant: Module).returns(T.nilable(T::Hash[TypeVariable, String])) }
+      sig { params(instance: Object).returns(T::Boolean) }
+      def generic_type_instance?(instance)
+        @generic_instances.values.any? { |generic_type| generic_type === instance }
+      end
+
+      sig { params(constant: Module).returns(T.nilable(T::Array[TypeVariableModule])) }
       def lookup_type_variables(constant)
         @type_variables[constant]
       end
@@ -77,13 +81,13 @@ module Tapioca
       sig do
         params(
           constant: T.untyped,
-          type_variable: TypeVariable,
+          type_variable: TypeVariableModule,
         ).void
       end
       def register_type_variable(constant, type_variable)
         type_variables = lookup_or_initialize_type_variables(constant)
 
-        type_variables[type_variable] = type_variable.serialize
+        type_variables << type_variable
       end
 
       private
@@ -109,6 +113,17 @@ module Tapioca
         # Let's set the `name` method to return the proper generic name
         generic_type.define_singleton_method(:name) { name }
 
+        # We need to define a `<=` method on the cloned constant, so that Sorbet
+        # can do covariance/contravariance checks on the type variables.
+        #
+        # Normally, we would be doing proper covariance/contravariance checks here, but
+        # that is not necessary, since we are not implementing a runtime type checker
+        # here. It is just enough for the checks to pass, so that we can serialize the
+        # signatures, assuming the sigs were well-formed.
+        #
+        # So we act like all subtype checks pass.
+        generic_type.define_singleton_method(:<=) { |_| true }
+
         # Return the generic type we created
         generic_type
       end
@@ -140,9 +155,9 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Hash[TypeVariable, String]) }
+      sig { params(constant: Module).returns(T::Array[TypeVariableModule]) }
       def lookup_or_initialize_type_variables(constant)
-        @type_variables[constant] ||= {}.compare_by_identity
+        @type_variables[constant] ||= []
       end
     end
   end

data/lib/tapioca/helpers/active_record_column_type_helper.rb

@@ -43,13 +43,13 @@ class ActiveRecordColumnTypeHelper
     setter_type = getter_type
 
     if column&.null
-      return ["T.nilable(#{getter_type})", "T.nilable(#{setter_type})"]
+      return [as_nilable_type(getter_type), as_nilable_type(setter_type)]
     end
 
     if column_name == @constant.primary_key ||
         column_name == "created_at" ||
         column_name == "updated_at"
-      getter_type = "T.nilable(#{getter_type})"
+      getter_type = as_nilable_type(getter_type)
     end
 
     [getter_type, setter_type]
@@ -63,9 +63,19 @@ class ActiveRecordColumnTypeHelper
         !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
   end
 
+  sig { params(type: String).returns(String) }
+  def as_nilable_type(type)
+    if type.start_with?("T.nilable(") || type == "T.untyped"
+      type
+    else
+      "T.nilable(#{type})"
+    end
+  end
+
   sig { params(column_type: Object).returns(String) }
   def handle_unknown_type(column_type)
     return "T.untyped" unless ActiveModel::Type::Value === column_type
+    return "T.untyped" if Tapioca::GenericTypeRegistry.generic_type_instance?(column_type)
 
     lookup_return_type_of_method(column_type, :deserialize) ||
       lookup_return_type_of_method(column_type, :cast) ||

data/lib/tapioca/helpers/cli_helper.rb

@@ -12,15 +12,16 @@ module Tapioca
 
     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
+      # Thor has its own `say_error` now, but it has two problems:
+      # 1. it adds the padding around all the messages, even if they continue on
+      #    the same line, and
+      # 2. it accepts a last parameter which breaks the ability to pass color values
+      #    as splats.
+      #
+      # So we implement our own version here to work around those problems.
+      shell.indent(-shell.padding) do
+        super(message, color)
+      end
     end
   end
 end

data/lib/tapioca/helpers/config_helper.rb

@@ -6,6 +6,9 @@ require "yaml"
 module Tapioca
   module ConfigHelper
     extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor }
 
     sig { returns(String) }
     attr_reader :command_name
@@ -60,9 +63,122 @@ module Tapioca
         config = YAML.load_file(config_file, fallback: {})
       end
 
+      validate_config!(config_file, config)
+
       Thor::CoreExt::HashWithIndifferentAccess.new(config[command_name] || {})
     end
 
+    sig { params(config_file: String, config: T::Hash[T.untyped, T.untyped]).void }
+    def validate_config!(config_file, config)
+      # To ensure that this is not re-entered, we mark during validation
+      return if @validating_config
+      @validating_config = T.let(true, T.nilable(T::Boolean))
+
+      commands = T.cast(self, Thor).class.commands
+
+      errors = config.flat_map do |config_key, config_options|
+        command = commands[config_key.to_s]
+
+        unless command
+          next build_error("unknown key `#{config_key}`")
+        end
+
+        validate_config_options(command.options, config_key, config_options || {})
+      end.compact
+
+      unless errors.empty?
+        print_errors(config_file, errors)
+        exit(1)
+      end
+    ensure
+      @validating_config = false
+    end
+
+    sig do
+      params(
+        command_options: T::Hash[Symbol, Thor::Option],
+        config_key: String,
+        config_options: T::Hash[T.untyped, T.untyped]
+      ).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|
+        command_option = command_options[config_option_key.to_sym]
+
+        unless command_option
+          next build_error("unknown option `#{config_option_key}` for key `#{config_key}`")
+        end
+
+        config_option_value_type = case config_option_value
+        when FalseClass, TrueClass
+          :boolean
+        when Numeric
+          :numeric
+        when Hash
+          :hash
+        when Array
+          :array
+        when String
+          :string
+        else
+          :object
+        end
+
+        unless config_option_value_type == command_option.type
+          next build_error("invalid value for option `#{config_option_key}` for key `#{config_key}` " \
+            "- expected `#{command_option.type.capitalize}` but found #{config_option_value_type.capitalize}")
+        end
+      end.compact
+    end
+
+    class ConfigErrorMessagePart < T::Struct
+      const :message, String
+      const :colors, T::Array[Symbol]
+    end
+
+    class ConfigError < T::Struct
+      const :message_parts, T::Array[ConfigErrorMessagePart]
+    end
+
+    sig { params(msg: String).returns(ConfigError) }
+    def build_error(msg)
+      parts = msg.split(/(`[^`]+` ?)/)
+
+      message_parts = parts.map do |part|
+        match = part.match(/`([^`]+)`( ?)/)
+
+        if match
+          ConfigErrorMessagePart.new(
+            message: "#{match[1]}#{match[2]}",
+            colors: [:bold, :blue]
+          )
+        else
+          ConfigErrorMessagePart.new(
+            message: part,
+            colors: [:yellow]
+          )
+        end
+      end
+
+      ConfigError.new(
+        message_parts: message_parts
+      )
+    end
+
+    sig { params(config_file: String, errors: T::Array[ConfigError]).void }
+    def print_errors(config_file, errors)
+      say_error("\nConfiguration file ", :red)
+      say_error("#{config_file} ", :blue, :bold)
+      say_error("has the following errors:\n\n", :red)
+
+      errors.each do |error|
+        say_error("- ")
+        error.message_parts.each do |part|
+          T.unsafe(self).say_error(part.message, *part.colors)
+        end
+      end
+    end
+
     sig do
       params(options: T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
         .returns(Thor::CoreExt::HashWithIndifferentAccess)