tapioca 0.6.4 → 0.7.2

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

@@ -1,90 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "json"
-require "tempfile"
-
-module Tapioca
-  module Compilers
-    module SymbolTable
-      module SymbolLoader
-        class << self
-          extend(T::Sig)
-
-          sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
-          def list_from_paths(paths)
-            load_symbols(paths.map(&:to_s))
-          end
-
-          def ignore_symbol?(symbol)
-            symbol = symbol[2..-1] if symbol.start_with?("::")
-            ignored_symbols.include?(symbol)
-          end
-
-          private
-
-          sig { params(paths: T::Array[String]).returns(T::Set[String]) }
-          def load_symbols(paths)
-            output = T.cast(Tempfile.create("sorbet") do |file|
-              file.write(Array(paths).join("\n"))
-              file.flush
-
-              symbol_table_json_from("@#{file.path.shellescape}")
-            end, T.nilable(String))
-
-            return Set.new if output.nil? || output.empty?
-
-            json = JSON.parse(output)
-            SymbolTableParser.parse(json)
-          end
-
-          def ignored_symbols
-            unless @ignored_symbols
-              output = symbol_table_json_from("-e ''", table_type: "symbol-table-full-json")
-              json = JSON.parse(output)
-              @ignored_symbols = SymbolTableParser.parse(json)
-            end
-
-            @ignored_symbols
-          end
-
-          def symbol_table_json_from(input, table_type: "symbol-table-json")
-            Tapioca::Compilers::Sorbet.run("--no-config", "--print=#{table_type}", input)
-          end
-        end
-
-        class SymbolTableParser
-          def self.parse(object, parents = [])
-            symbols = Set.new
-
-            children = object.fetch("children", [])
-
-            children.each do |child|
-              kind = child.fetch("kind")
-              name = child.fetch("name")
-              name = name.fetch("name") if name.is_a?(Hash)
-
-              next if kind.nil? || name.nil?
-
-              # TODO: CLASS is removed since v0.4.4730 of Sorbet
-              # but keeping here for backward compatibility. Remove
-              # once the minimum version is moved past that.
-              next unless ["CLASS", "CLASS_OR_MODULE", "STATIC_FIELD"].include?(kind)
-              next if name =~ /[<>()$]/
-              next if name =~ /^[0-9]+$/
-              next if name == "T::Helpers"
-
-              parents << name
-
-              symbols.add(parents.join("::"))
-              symbols.merge(parse(child, parents))
-
-              parents.pop
-            end
-            symbols
-          end
-        end
-      end
-    end
-  end
-end

data/lib/tapioca/compilers/symbol_table_compiler.rb

@@ -1,17 +0,0 @@
-# typed: strong
-# frozen_string_literal: true
-
-module Tapioca
-  module Compilers
-    class SymbolTableCompiler
-      extend(T::Sig)
-
-      sig { params(gem: Gemfile::GemSpec, rbi: RBI::File, indent: Integer, include_docs: T::Boolean).void }
-      def compile(gem, rbi, indent = 0, include_docs = false)
-        Tapioca::Compilers::SymbolTable::SymbolGenerator
-          .new(gem, indent, include_docs)
-          .generate(rbi)
-      end
-    end
-  end
-end

data/lib/tapioca/compilers/todos_compiler.rb

@@ -1,32 +0,0 @@
-# typed: strong
-# frozen_string_literal: true
-
-module Tapioca
-  module Compilers
-    # Taken from https://github.com/sorbet/sorbet/blob/master/gems/sorbet/lib/todo-rbi.rb
-    class TodosCompiler
-      extend(T::Sig)
-
-      sig do
-        returns(String)
-      end
-      def compile
-        list_todos.each_line.map do |line|
-          next if line.include?("<") || line.include?("class_of")
-          "module #{line.strip.gsub("T.untyped::", "")}; end"
-        end.compact.join("\n")
-      end
-
-      private
-
-      sig { returns(String) }
-      def list_todos
-        Tapioca::Compilers::Sorbet.run(
-          "--print=missing-constants",
-          "--stdout-hup-hack",
-          "--no-error-count"
-        ).strip
-      end
-    end
-  end
-end

data/lib/tapioca/generators/todo.rb

@@ -1,76 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module Generators
-    class Todo < Base
-      sig do
-        params(
-          todo_file: String,
-          file_header: T::Boolean,
-          default_command: String,
-          file_writer: Thor::Actions
-        ).void
-      end
-      def initialize(todo_file:, file_header:, default_command:, file_writer: FileWriter.new)
-        @todo_file = todo_file
-        @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(@todo_file) if File.exist?(@todo_file)
-
-        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(@todo_file, content, verbose: false)
-
-        name = set_color(@todo_file, :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

@@ -1,9 +0,0 @@
-# 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/generic_type_registry.rb

@@ -1,164 +0,0 @@
-# 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(
-      {}.compare_by_identity,
-      T::Hash[Module, T::Array[TypeVariableModule]]
-    )
-
-    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 = "#{Reflection.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 { 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
-
-      # 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: TypeVariableModule,
-        ).void
-      end
-      def register_type_variable(constant, type_variable)
-        type_variables = lookup_or_initialize_type_variables(constant)
-
-        type_variables << type_variable
-      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_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 }
-
-        # 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
-
-      sig { params(constant: Class).returns(Class) }
-      def create_safe_subclass(constant)
-        # Lookup the "inherited" class method
-        inherited_method = constant.method(:inherited)
-        # and the module that defines it
-        owner = inherited_method.owner
-
-        # If no one has overriden the inherited method yet, just subclass
-        return Class.new(constant) if Class == owner
-
-        begin
-          # Otherwise, some inherited method could be preventing us
-          # from creating subclasses, so let's override it and rescue
-          owner.send(:define_method, :inherited) do |s|
-            inherited_method.call(s)
-          rescue
-            # Ignoring errors
-          end
-
-          # return a subclass
-          Class.new(constant)
-        ensure
-          # Reinstate the original inherited method back.
-          owner.send(:define_method, :inherited, inherited_method)
-        end
-      end
-
-      sig { params(constant: Module).returns(T::Array[TypeVariableModule]) }
-      def lookup_or_initialize_type_variables(constant)
-        @type_variables[constant] ||= []
-      end
-    end
-  end
-end

data/lib/tapioca/helpers/active_record_column_type_helper.rb

@@ -1,108 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-class ActiveRecordColumnTypeHelper
-  extend T::Sig
-
-  sig { params(constant: T.class_of(ActiveRecord::Base)).void }
-  def initialize(constant)
-    @constant = constant
-  end
-
-  sig { params(column_name: String).returns([String, String]) }
-  def type_for(column_name)
-    return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(@constant)
-
-    column_type = @constant.attribute_types[column_name]
-
-    getter_type =
-      case column_type
-      when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
-        "::Money"
-      when ActiveRecord::Type::Integer
-        "::Integer"
-      when ActiveRecord::Type::String
-        "::String"
-      when ActiveRecord::Type::Date
-        "::Date"
-      when ActiveRecord::Type::Decimal
-        "::BigDecimal"
-      when ActiveRecord::Type::Float
-        "::Float"
-      when ActiveRecord::Type::Boolean
-        "T::Boolean"
-      when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-        "::DateTime"
-      when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-        "::ActiveSupport::TimeWithZone"
-      else
-        handle_unknown_type(column_type)
-      end
-
-    column = @constant.columns_hash[column_name]
-    setter_type = getter_type
-
-    if column&.null
-      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 = as_nilable_type(getter_type)
-    end
-
-    [getter_type, setter_type]
-  end
-
-  private
-
-  sig { params(constant: Module).returns(T::Boolean) }
-  def do_not_generate_strong_types?(constant)
-    Object.const_defined?(:StrongTypeGeneration) &&
-        !(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) ||
-      lookup_arg_type_of_method(column_type, :serialize) ||
-      "T.untyped"
-  end
-
-  sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-  def lookup_return_type_of_method(column_type, method)
-    signature = T::Private::Methods.signature_for_method(column_type.method(method))
-    return unless signature
-
-    return_type = signature.return_type
-    return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
-
-    return_type.to_s
-  end
-
-  sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-  def lookup_arg_type_of_method(column_type, method)
-    signature = T::Private::Methods.signature_for_method(column_type.method(method))
-    return unless signature
-
-    # Arg types is an array [name, type] entries, so we desctructure the type of
-    # first argument to get the first argument type
-    _, first_argument_type = signature.arg_types.first
-
-    first_argument_type.to_s
-  end
-end

data/lib/tapioca/loader.rb

@@ -1,119 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  class Loader
-    extend(T::Sig)
-
-    sig { params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
-    def load_bundle(gemfile, initialize_file, require_file)
-      require_helper(initialize_file)
-
-      load_rails_application
-
-      gemfile.require_bundle
-
-      require_helper(require_file)
-
-      load_rails_engines
-    end
-
-    sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-    def load_rails_application(environment_load: false, eager_load: false)
-      return unless File.exist?("config/application.rb")
-
-      silence_deprecations
-
-      if environment_load
-        safe_require("./config/environment")
-      else
-        safe_require("./config/application")
-      end
-
-      eager_load_rails_app if eager_load
-    end
-
-    private
-
-    sig { params(file: T.nilable(String)).void }
-    def require_helper(file)
-      return unless file
-      file = File.absolute_path(file)
-      return unless File.exist?(file)
-
-      require(file)
-    end
-
-    sig { returns(T::Array[T.untyped]) }
-    def rails_engines
-      return [] unless Object.const_defined?("Rails::Engine")
-
-      # We can use `Class#descendants` here, since we know Rails is loaded
-      Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
-    end
-
-    sig { params(path: String).void }
-    def safe_require(path)
-      require path
-    rescue LoadError
-      nil
-    end
-
-    sig { void }
-    def silence_deprecations
-      # Stop any ActiveSupport Deprecations from being reported
-      Object.const_get("ActiveSupport::Deprecation").silenced = true
-    rescue NameError
-      nil
-    end
-
-    sig { void }
-    def eager_load_rails_app
-      rails = Object.const_get("Rails")
-      application = rails.application
-
-      if Object.const_defined?("ActiveSupport")
-        Object.const_get("ActiveSupport").run_load_hooks(
-          :before_eager_load,
-          application
-        )
-      end
-
-      if Object.const_defined?("Zeitwerk::Loader")
-        zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
-        zeitwerk_loader.eager_load_all
-      end
-
-      if rails.respond_to?(:autoloaders) && rails.autoloaders.zeitwerk_enabled?
-        rails.autoloaders.each(&:eager_load)
-      end
-
-      if application.config.respond_to?(:eager_load_namespaces)
-        application.config.eager_load_namespaces.each(&:eager_load!)
-      end
-    end
-
-    sig { void }
-    def load_rails_engines
-      rails_engines.each do |engine|
-        errored_files = []
-
-        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
-
-        # 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
-  end
-end