tapioca 0.6.4 → 0.7.2

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

@@ -1,195 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "tapioca/rbi_ext/model"
-require "tapioca/compilers/dsl/param_helper"
-require "tapioca/compilers/dsl_compiler"
-
-module Tapioca
-  module Compilers
-    module Dsl
-      DSL_COMPILERS_DIR = T.let(File.expand_path("..", __FILE__).to_s, String)
-
-      class Base
-        extend T::Sig
-        extend T::Helpers
-
-        include Reflection
-
-        abstract!
-
-        sig { returns(T::Set[Module]) }
-        attr_reader :processable_constants
-
-        sig { returns(T::Array[String]) }
-        attr_reader :errors
-
-        sig { params(name: String).returns(T.nilable(T.class_of(Tapioca::Compilers::Dsl::Base))) }
-        def self.resolve(name)
-          # Try to find built-in tapioca generator first, then globally defined generator.
-          potentials = ["Tapioca::Compilers::Dsl::#{name}", name].map do |potential_name|
-            Object.const_get(potential_name)
-          rescue NameError
-            # Skip if we can't find generator by the potential name
-            nil
-          end
-
-          potentials.compact.first
-        end
-
-        sig { params(compiler: Tapioca::Compilers::DslCompiler).void }
-        def initialize(compiler)
-          @compiler = compiler
-          @processable_constants = T.let(Set.new(gather_constants), T::Set[Module])
-          @processable_constants.compare_by_identity
-          @errors = T.let([], T::Array[String])
-        end
-
-        sig { params(constant: Module).returns(T::Boolean) }
-        def handles?(constant)
-          processable_constants.include?(constant)
-        end
-
-        sig { params(generator_name: String).returns(T::Boolean) }
-        def generator_enabled?(generator_name)
-          @compiler.generator_enabled?(generator_name)
-        end
-
-        sig do
-          abstract
-            .type_parameters(:T)
-            .params(
-              tree: RBI::Tree,
-              constant: T.type_parameter(:T)
-            )
-            .void
-        end
-        def decorate(tree, constant); end
-
-        sig { abstract.returns(T::Enumerable[Module]) }
-        def gather_constants; end
-
-        # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
-        sig { params(error: String).void }
-        def add_error(error)
-          @errors << error
-        end
-
-        private
-
-        sig { returns(T::Enumerable[Class]) }
-        def all_classes
-          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[Class]))
-          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class]).each
-        end
-
-        sig { returns(T::Enumerable[Module]) }
-        def all_modules
-          @all_modules = T.let(@all_modules, T.nilable(T::Enumerable[Module]))
-          @all_modules ||= T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each
-        end
-
-        # Get the types of each parameter from a method signature
-        sig do
-          params(
-            method_def: T.any(Method, UnboundMethod),
-            signature: T.untyped # as `T::Private::Methods::Signature` is private
-          ).returns(T::Array[String])
-        end
-        def parameters_types_from_signature(method_def, signature)
-          params = T.let([], T::Array[String])
-
-          return method_def.parameters.map { "T.untyped" } unless signature
-
-          # parameters types
-          signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
-
-          # keyword parameters types
-          signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
-
-          # rest parameter type
-          params << signature.rest_type.to_s if signature.has_rest
-
-          # special case `.void` in a proc
-          unless signature.block_name.nil?
-            params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
-          end
-
-          params
-        end
-
-        sig { params(scope: RBI::Scope, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
-        def create_method_from_def(scope, method_def, class_method: false)
-          scope.create_method(
-            method_def.name.to_s,
-            parameters: compile_method_parameters_to_rbi(method_def),
-            return_type: compile_method_return_type_to_rbi(method_def),
-            class_method: class_method
-          )
-        end
-
-        include ParamHelper
-
-        sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
-        def compile_method_parameters_to_rbi(method_def)
-          signature = T::Private::Methods.signature_for_method(method_def)
-          method_def = signature.nil? ? method_def : signature.method
-          method_types = parameters_types_from_signature(method_def, signature)
-
-          parameters = T.let(method_def.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
-
-          parameters.each_with_index.map do |(type, name), index|
-            fallback_arg_name = "_arg#{index}"
-
-            name = name ? name.to_s : fallback_arg_name
-            name = fallback_arg_name unless valid_parameter_name?(name)
-            method_type = T.must(method_types[index])
-
-            case type
-            when :req
-              create_param(name, type: method_type)
-            when :opt
-              create_opt_param(name, type: method_type, default: "T.unsafe(nil)")
-            when :rest
-              create_rest_param(name, type: method_type)
-            when :keyreq
-              create_kw_param(name, type: method_type)
-            when :key
-              create_kw_opt_param(name, type: method_type, default: "T.unsafe(nil)")
-            when :keyrest
-              create_kw_rest_param(name, type: method_type)
-            when :block
-              create_block_param(name, type: method_type)
-            else
-              raise "Unknown type `#{type}`."
-            end
-          end
-        end
-
-        sig { params(method_def: T.any(Method, UnboundMethod)).returns(String) }
-        def compile_method_return_type_to_rbi(method_def)
-          signature = T::Private::Methods.signature_for_method(method_def)
-          return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
-          return_type = "void" if return_type == "<VOID>"
-          # Map <NOT-TYPED> to `T.untyped`
-          return_type = "T.untyped" if return_type == "<NOT-TYPED>"
-          return_type
-        end
-
-        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
-            "T.nilable(#{type})"
-          end
-        end
-
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_parameter_name?(name)
-          name.match?(/^[[[:alnum:]]_]+$/)
-        end
-      end
-    end
-  end
-end

data/lib/tapioca/compilers/dsl/helper/active_record_constants.rb

@@ -1,27 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module Compilers
-    module Dsl
-      module Helper
-        module ActiveRecordConstants
-          extend T::Sig
-
-          AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
-          AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
-
-          RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
-          AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)
-          CommonRelationMethodsModuleName = T.let("CommonRelationMethods", String)
-
-          RelationClassName = T.let("PrivateRelation", String)
-          RelationWhereChainClassName = T.let("PrivateRelationWhereChain", String)
-          AssociationRelationClassName = T.let("PrivateAssociationRelation", String)
-          AssociationRelationWhereChainClassName = T.let("PrivateAssociationRelationWhereChain", String)
-          AssociationsCollectionProxyClassName = T.let("PrivateCollectionProxy", String)
-        end
-      end
-    end
-  end
-end

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -1,134 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "tapioca/compilers/dsl/base"
-
-module Tapioca
-  module Compilers
-    class DslCompiler
-      extend T::Sig
-
-      sig { returns(T::Enumerable[Dsl::Base]) }
-      attr_reader :generators
-
-      sig { returns(T::Array[Module]) }
-      attr_reader :requested_constants
-
-      sig { returns(T.proc.params(error: String).void) }
-      attr_reader :error_handler
-
-      sig do
-        params(
-          requested_constants: T::Array[Module],
-          requested_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)],
-          error_handler: T.proc.params(error: String).void,
-          number_of_workers: T.nilable(Integer),
-        ).void
-      end
-      def initialize(
-        requested_constants:,
-        requested_generators: [],
-        excluded_generators: [],
-        error_handler: $stderr.method(:puts).to_proc,
-        number_of_workers: nil
-      )
-        @generators = T.let(
-          gather_generators(requested_generators, excluded_generators),
-          T::Enumerable[Dsl::Base]
-        )
-        @requested_constants = requested_constants
-        @error_handler = error_handler
-        @number_of_workers = number_of_workers
-      end
-
-      sig do
-        type_parameters(:T).params(
-          blk: T.proc.params(constant: Module, rbi: RBI::File).returns(T.type_parameter(:T))
-        ).returns(T::Array[T.type_parameter(:T)])
-      end
-      def run(&blk)
-        constants_to_process = gather_constants(requested_constants)
-          .select { |c| Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
-          .sort_by! { |c| T.must(Reflection.name_of(c)) }
-
-        if constants_to_process.empty?
-          report_error(<<~ERROR)
-            No classes/modules can be matched for RBI generation.
-            Please check that the requested classes/modules include processable DSL methods.
-          ERROR
-        end
-
-        result = Executor.new(
-          constants_to_process,
-          number_of_workers: @number_of_workers
-        ).run_in_parallel do |constant|
-          rbi = rbi_for_constant(constant)
-          next if rbi.nil?
-
-          blk.call(constant, rbi)
-        end
-
-        generators.flat_map(&:errors).each do |msg|
-          report_error(msg)
-        end
-
-        result.compact
-      end
-
-      sig { params(generator_name: String).returns(T::Boolean) }
-      def generator_enabled?(generator_name)
-        generator = Dsl::Base.resolve(generator_name)
-
-        return false unless generator
-
-        @generators.any?(generator)
-      end
-
-      private
-
-      sig do
-        params(
-          requested_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)]
-        ).returns(T::Enumerable[Dsl::Base])
-      end
-      def gather_generators(requested_generators, excluded_generators)
-        generator_klasses = ::Tapioca::Reflection.descendants_of(Dsl::Base).select do |klass|
-          (requested_generators.empty? || requested_generators.include?(klass)) &&
-            !excluded_generators.include?(klass)
-        end.sort_by { |klass| T.must(klass.name) }
-
-        generator_klasses.map { |generator_klass| generator_klass.new(self) }
-      end
-
-      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
-      def gather_constants(requested_constants)
-        constants = generators.map(&:processable_constants).reduce(Set.new, :union)
-        constants &= requested_constants unless requested_constants.empty?
-        constants
-      end
-
-      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
-      def rbi_for_constant(constant)
-        file = RBI::File.new(strictness: "true")
-
-        generators.each do |generator|
-          next unless generator.handles?(constant)
-          generator.decorate(file.root, constant)
-        end
-
-        return if file.root.empty?
-
-        file
-      end
-
-      sig { params(error: String).returns(T.noreturn) }
-      def report_error(error)
-        handler = error_handler
-        handler.call(error)
-        exit(1)
-      end
-    end
-  end
-end

data/lib/tapioca/compilers/dynamic_mixin_compiler.rb

@@ -1,223 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-class DynamicMixinCompiler
-  extend T::Sig
-  include Tapioca::Reflection
-
-  sig { returns(T::Array[Module]) }
-  attr_reader :dynamic_extends, :dynamic_includes
-
-  sig { returns(T::Array[Symbol]) }
-  attr_reader :class_attribute_readers, :class_attribute_writers, :class_attribute_predicates
-
-  sig { returns(T::Array[Symbol]) }
-  attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
-
-  sig { params(constant: Module).void }
-  def initialize(constant)
-    @constant = constant
-    mixins_from_modules = {}.compare_by_identity
-    class_attribute_readers = T.let([], T::Array[Symbol])
-    class_attribute_writers = T.let([], T::Array[Symbol])
-    class_attribute_predicates = T.let([], T::Array[Symbol])
-
-    instance_attribute_readers = T.let([], T::Array[Symbol])
-    instance_attribute_writers = T.let([], T::Array[Symbol])
-    instance_attribute_predicates = T.let([], T::Array[Symbol])
-
-    Class.new do
-      # Override the `self.include` method
-      define_singleton_method(:include) do |mod|
-        # Take a snapshot of the list of singleton class ancestors
-        # before the actual include
-        before = singleton_class.ancestors
-        # Call the actual `include` method with the supplied module
-        super(mod).tap do
-          # Take a snapshot of the list of singleton class ancestors
-          # after the actual include
-          after = singleton_class.ancestors
-          # The difference is the modules that are added to the list
-          # of ancestors of the singleton class. Those are all the
-          # modules that were `extend`ed due to the `include` call.
-          #
-          # We record those modules on our lookup table keyed by
-          # the included module with the values being all the modules
-          # that that module pulls into the singleton class.
-          #
-          # We need to reverse the order, since the extend order should
-          # be the inverse of the ancestor order. That is, earlier
-          # extended modules would be later in the ancestor chain.
-          mixins_from_modules[mod] = (after - before).reverse!
-        end
-      rescue Exception # rubocop:disable Lint/RescueException
-        # this is a best effort, bail if we can't perform this
-      end
-
-      define_singleton_method(:class_attribute) do |*attrs, **kwargs|
-        class_attribute_readers.concat(attrs)
-        class_attribute_writers.concat(attrs)
-
-        instance_predicate = kwargs.fetch(:instance_predicate, true)
-        instance_accessor = kwargs.fetch(:instance_accessor, true)
-        instance_reader = kwargs.fetch(:instance_reader, instance_accessor)
-        instance_writer = kwargs.fetch(:instance_writer, instance_accessor)
-
-        if instance_reader
-          instance_attribute_readers.concat(attrs)
-        end
-
-        if instance_writer
-          instance_attribute_writers.concat(attrs)
-        end
-
-        if instance_predicate
-          class_attribute_predicates.concat(attrs)
-
-          if instance_reader
-            instance_attribute_predicates.concat(attrs)
-          end
-        end
-
-        super(*attrs, **kwargs) if defined?(super)
-      end
-
-      # rubocop:disable Style/MissingRespondToMissing
-      T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
-      def method_missing(symbol, *args)
-        # We need this here so that we can handle any random instance
-        # method calls on the fake including class that may be done by
-        # the included module during the `self.included` hook.
-      end
-
-      class << self
-        extend T::Sig
-
-        T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
-        def method_missing(symbol, *args)
-          # Similarly, we need this here so that we can handle any
-          # random class method calls on the fake including class
-          # that may be done by the included module during the
-          # `self.included` hook.
-        end
-      end
-      # rubocop:enable Style/MissingRespondToMissing
-    end.include(constant)
-
-    # The value that corresponds to the original included constant
-    # is the list of all dynamically extended modules because of that
-    # constant. We grab that value by deleting the key for the original
-    # constant.
-    @dynamic_extends = T.let(mixins_from_modules.delete(constant) || [], T::Array[Module])
-
-    # Since we deleted the original constant from the list of keys, all
-    # the keys that remain are the ones that are dynamically included modules
-    # during the include of the original constant.
-    @dynamic_includes = T.let(mixins_from_modules.keys, T::Array[Module])
-
-    @class_attribute_readers = T.let(class_attribute_readers, T::Array[Symbol])
-    @class_attribute_writers = T.let(class_attribute_writers, T::Array[Symbol])
-    @class_attribute_predicates = T.let(class_attribute_predicates, T::Array[Symbol])
-
-    @instance_attribute_readers = T.let(instance_attribute_readers, T::Array[Symbol])
-    @instance_attribute_writers = T.let(instance_attribute_writers, T::Array[Symbol])
-    @instance_attribute_predicates = T.let(instance_attribute_predicates, T::Array[Symbol])
-  end
-
-  sig { returns(T::Boolean) }
-  def empty_attributes?
-    @class_attribute_readers.empty? && @class_attribute_writers.empty?
-  end
-
-  sig { params(tree: RBI::Tree).void }
-  def compile_class_attributes(tree)
-    return if empty_attributes?
-
-    # Create a synthetic module to hold the generated class methods
-    tree << RBI::Module.new("GeneratedClassMethods") do |mod|
-      class_attribute_readers.each do |attribute|
-        mod << RBI::Method.new(attribute.to_s)
-      end
-
-      class_attribute_writers.each do |attribute|
-        mod << RBI::Method.new("#{attribute}=") do |method|
-          method << RBI::Param.new("value")
-        end
-      end
-
-      class_attribute_predicates.each do |attribute|
-        mod << RBI::Method.new("#{attribute}?")
-      end
-    end
-
-    # Create a synthetic module to hold the generated instance methods
-    tree << RBI::Module.new("GeneratedInstanceMethods") do |mod|
-      instance_attribute_readers.each do |attribute|
-        mod << RBI::Method.new(attribute.to_s)
-      end
-
-      instance_attribute_writers.each do |attribute|
-        mod << RBI::Method.new("#{attribute}=") do |method|
-          method << RBI::Param.new("value")
-        end
-      end
-
-      instance_attribute_predicates.each do |attribute|
-        mod << RBI::Method.new("#{attribute}?")
-      end
-    end
-
-    # Add a mixes_in_class_methods and include for the generated modules
-    tree << RBI::MixesInClassMethods.new("GeneratedClassMethods")
-    tree << RBI::Include.new("GeneratedInstanceMethods")
-  end
-
-  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|
-      qname = qualified_name_of(mod)
-
-      next if qname.nil? || qname.empty?
-      next if filtered_mixin?(qname)
-
-      tree << RBI::Include.new(qname)
-
-      mod
-    end.compact
-
-    # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
-    # constant itself
-    mixed_in_class_methods = dynamic_extends.select do |mod|
-      mod != @constant && !module_included_by_another_dynamic_extend?(mod, dynamic_extends)
-    end
-
-    return [[], []] if mixed_in_class_methods.empty?
-
-    mixed_in_class_methods.each do |mod|
-      qualified_name = qualified_name_of(mod)
-
-      next if qualified_name.nil? || qualified_name.empty?
-      next if filtered_mixin?(qualified_name)
-
-      tree << RBI::MixesInClassMethods.new(qualified_name)
-    end
-
-    [mixed_in_class_methods, includes]
-  rescue
-    [[], []] # silence errors
-  end
-
-  sig { params(mod: Module, dynamic_extends: T::Array[Module]).returns(T::Boolean) }
-  def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
-    dynamic_extends.any? do |dynamic_extend|
-      mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)
-    end
-  end
-
-  sig { params(qualified_mixin_name: String).returns(T::Boolean) }
-  def filtered_mixin?(qualified_mixin_name)
-    # filter T:: namespace mixins that aren't T::Props
-    # T::Props and subconstants have semantic value
-    qualified_mixin_name.start_with?("::T::") && !qualified_mixin_name.start_with?("::T::Props")
-  end
-end

data/lib/tapioca/compilers/sorbet.rb

@@ -1,59 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "pathname"
-require "shellwords"
-
-module Tapioca
-  module Compilers
-    module Sorbet
-      SORBET_GEM_SPEC = T.let(
-        Gem::Specification.find_by_name("sorbet-static"),
-        Gem::Specification
-      )
-      SORBET = T.let(
-        Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
-        Pathname
-      )
-      EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
-
-      FEATURE_REQUIREMENTS = T.let({
-        # First tag that includes https://github.com/sorbet/sorbet/pull/4706
-        to_ary_nil_support: Gem::Requirement.new(">= 0.5.9220"),
-      }.freeze, T::Hash[Symbol, Gem::Requirement])
-
-      class << self
-        extend(T::Sig)
-
-        sig { params(args: String).returns(String) }
-        def run(*args)
-          IO.popen(
-            [
-              sorbet_path,
-              "--quiet",
-              *args,
-            ].join(" "),
-            err: "/dev/null"
-          ).read
-        end
-
-        sig { returns(String) }
-        def sorbet_path
-          sorbet_path = ENV.fetch(EXE_PATH_ENV_VAR, SORBET)
-          sorbet_path = SORBET if sorbet_path.empty?
-          sorbet_path.to_s.shellescape
-        end
-
-        sig { params(feature: Symbol, version: T.nilable(Gem::Version)).returns(T::Boolean) }
-        def supports?(feature, version: nil)
-          version = SORBET_GEM_SPEC.version unless version
-          requirement = FEATURE_REQUIREMENTS[feature]
-
-          raise "Invalid Sorbet feature #{feature}" unless requirement
-
-          requirement.satisfied_by?(version)
-        end
-      end
-    end
-  end
-end