tapioca 0.9.4 → 0.10.0

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

@@ -0,0 +1,81 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "graphql"
+rescue LoadError
+  return
+end
+
+require "tapioca/dsl/helpers/graphql_type_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::GraphqlMutation` generates RBI files for subclasses of
+      # [`GraphQL::Schema::Mutation`](https://graphql-ruby.org/api-doc/2.0.11/GraphQL/Schema/Mutation).
+      #
+      # For example, with the following `GraphQL::Schema::Mutation` subclass:
+      #
+      # ~~~rb
+      # class CreateComment < GraphQL::Schema::Mutation
+      #   argument :body, String, required: true
+      #   argument :post_id, ID, required: true
+      #
+      #   def resolve(body:, post_id:)
+      #     # ...
+      #   end
+      # end
+      # ~~~
+      #
+      # this compiler will produce the RBI file `notify_user_job.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # create_comment.rbi
+      # # typed: true
+      # class CreateComment
+      #   sig { params(body: String, post_id: String).returns(T.untyped) }
+      #   def resolve(body:, post_id:); end
+      # end
+      # ~~~
+      class GraphqlMutation < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::InputObject) } }
+
+        sig { override.void }
+        def decorate
+          return unless constant.method_defined?(:resolve)
+
+          method_def = constant.instance_method(:resolve)
+          return if signature_of(method_def) # Skip if the mutation already has an inline sig
+
+          arguments = constant.all_argument_definitions
+          return if arguments.empty?
+
+          arguments_by_name = arguments.to_h { |a| [a.keyword.to_s, a] }
+          graphql_type_helper = Helpers::GraphqlTypeHelper.new
+
+          params = compile_method_parameters_to_rbi(method_def).map do |param|
+            name = param.param.name
+            argument = arguments_by_name.fetch(name, nil)
+            create_typed_param(param.param, argument ? graphql_type_helper.type_for(argument.type) : "T.untyped")
+          end
+
+          root.create_path(constant) do |mutation|
+            mutation.create_method("resolve", parameters: params, return_type: "T.untyped")
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |c| c < GraphQL::Schema::Mutation && c != GraphQL::Schema::RelayClassicMutation }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -100,10 +100,14 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          descendants_of(::ActiveRecord::Base).select do |klass|
-            klass < ::IdentityCache::WithoutPrimaryIndex
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).select do |klass|
+              klass < ::IdentityCache::WithoutPrimaryIndex
+            end
           end
         end
 

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

@@ -63,11 +63,15 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          # Select all non-anonymous modules that have overridden Module.included
-          all_modules.select do |mod|
-            !mod.is_a?(Class) && name_of(mod) && Runtime::Reflection.method_of(mod, :included).owner != Module
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            # Select all non-anonymous modules that have overridden Module.included
+            all_modules.select do |mod|
+              !mod.is_a?(Class) && name_of(mod) && Runtime::Reflection.method_of(mod, :included).owner != Module
+            end
           end
         end
       end

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

@@ -90,33 +90,70 @@ module Tapioca
             elsif constant == Google::Protobuf::Map
               create_type_members(klass, "Key", "Value")
             else
-              descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
-              descriptor.each_oneof { |oneof| create_oneof_method(klass, oneof) }
-              fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
-              fields.sort_by!(&:name)
+              descriptor = T.unsafe(constant).descriptor
 
-              parameters = fields.map do |field|
-                create_kw_opt_param(field.name, type: field.init_type, default: field.default)
-              end
+              case descriptor
+              when Google::Protobuf::EnumDescriptor
+                descriptor.to_h.each do |sym, val|
+                  klass.create_constant(sym.to_s, value: val.to_s)
+                end
+
+                klass.create_method(
+                  "lookup",
+                  parameters: [create_param("number", type: "Integer")],
+                  return_type: "T.nilable(Symbol)",
+                  class_method: true,
+                )
+                klass.create_method(
+                  "resolve",
+                  parameters: [create_param("symbol", type: "Symbol")],
+                  return_type: "T.nilable(Integer)",
+                  class_method: true,
+                )
+                klass.create_method(
+                  "descriptor",
+                  return_type: "Google::Protobuf::EnumDescriptor",
+                  class_method: true,
+                )
+              when Google::Protobuf::Descriptor
+                descriptor.each_oneof { |oneof| create_oneof_method(klass, oneof) }
+                fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
+                fields.sort_by!(&:name)
+
+                parameters = fields.map do |field|
+                  create_kw_opt_param(field.name, type: field.init_type, default: field.default)
+                end
 
-              if fields.all? { |field| FIELD_RE.match?(field.name) }
-                klass.create_method("initialize", parameters: parameters, return_type: "void")
+                if fields.all? { |field| FIELD_RE.match?(field.name) }
+                  klass.create_method("initialize", parameters: parameters, return_type: "void")
+                else
+                  # One of the fields has an incorrect name for a named parameter so creating the default initialize for
+                  # it would create a RBI with a syntax error.
+                  # The workaround is to create an initialize that takes a **kwargs instead.
+                  kwargs_parameter = create_kw_rest_param("fields", type: "T.untyped")
+                  klass.create_method("initialize", parameters: [kwargs_parameter], return_type: "void")
+                end
               else
-                # One of the fields has an incorrect name for a named parameter so creating the default initialize for
-                # it would create a RBI with a syntax error.
-                # The workaround is to create an initialize that takes a **kwargs instead.
-                kwargs_parameter = create_kw_rest_param("fields", type: "T.untyped")
-                klass.create_method("initialize", parameters: [kwargs_parameter], return_type: "void")
+                raise TypeError, "Unexpected descriptor class: #{descriptor.class.name}"
               end
             end
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          marker = Google::Protobuf::MessageExts::ClassMethods
-          results = T.cast(ObjectSpace.each_object(marker).to_a, T::Array[Module])
-          results.any? ? results + [Google::Protobuf::RepeatedField, Google::Protobuf::Map] : []
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            marker = Google::Protobuf::MessageExts::ClassMethods
+
+            enum_modules = ObjectSpace.each_object(Google::Protobuf::EnumDescriptor).map do |desc|
+              T.cast(desc, Google::Protobuf::EnumDescriptor).enummodule
+            end
+
+            results = T.cast(ObjectSpace.each_object(marker).to_a, T::Array[Module]).concat(enum_modules)
+            results.any? ? results + [Google::Protobuf::RepeatedField, Google::Protobuf::Map] : []
+          end
         end
 
         private
@@ -138,7 +175,13 @@ module Tapioca
         def type_of(descriptor)
           case descriptor.type
           when :enum
-            descriptor.subtype.enummodule.name
+            # According to https://developers.google.com/protocol-buffers/docs/reference/ruby-generated#enum
+            # > You may assign either a number or a symbol to an enum field.
+            # > When reading the value back, it will be a symbol if the enum
+            # > value is known, or a number if it is unknown. Since proto3 uses
+            # > open enum semantics, any number may be assigned to an enum
+            # > field, even if it was not defined in the enum.
+            "T.any(Symbol, Integer)"
           when :message
             descriptor.subtype.msgclass.name
           when :int32, :int64, :uint32, :uint64
@@ -179,7 +222,7 @@ module Tapioca
               Field.new(
                 name: descriptor.name,
                 type: type,
-                init_type: "T.any(#{type}, T::Hash[#{key_type}, #{value_type}])",
+                init_type: "T.nilable(T.any(#{type}, T::Hash[#{key_type}, #{value_type}]))",
                 default: "Google::Protobuf::Map.new(#{default_args.join(", ")})"
               )
             else
@@ -192,18 +235,19 @@ module Tapioca
               Field.new(
                 name: descriptor.name,
                 type: type,
-                init_type: "T.any(#{type}, T::Array[#{elem_type}])",
+                init_type: "T.nilable(T.any(#{type}, T::Array[#{elem_type}]))",
                 default: "Google::Protobuf::RepeatedField.new(#{default_args.join(", ")})"
               )
             end
           else
             type = type_of(descriptor)
-            type = as_nilable_type(type) if nilable_descriptor?(descriptor)
+            nilable_type = as_nilable_type(type)
+            type = nilable_type if nilable_descriptor?(descriptor)
 
             Field.new(
               name: descriptor.name,
               type: type,
-              init_type: type,
+              init_type: nilable_type,
               default: "nil"
             )
           end
@@ -226,7 +270,7 @@ module Tapioca
           klass.create_method(
             "#{field.name}=",
             parameters: [create_param("value", type: field.type)],
-            return_type: field.type
+            return_type: "void"
           )
 
           field

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

@@ -64,14 +64,18 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          all_classes.select do |const|
-            name = qualified_name_of(const)
-
-            name &&
-              !name.match?(BUILT_IN_MATCHER) &&
-              ::Rails::Generators::Base > const
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select do |const|
+              name = qualified_name_of(const)
+
+              name &&
+                !name.match?(BUILT_IN_MATCHER) &&
+                ::Rails::Generators::Base > const
+            end
           end
         end
 

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

@@ -72,9 +72,13 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          all_classes.select { |c| c < Sidekiq::Worker }
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |c| c < Sidekiq::Worker }
+          end
         end
 
         private

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

@@ -85,12 +85,16 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          all_modules.select do |c|
-            name_of(c) &&
-              c != ::SmartProperties::Validations::Ancestor &&
-              c < ::SmartProperties && ::SmartProperties::ClassMethods === c
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_modules.select do |c|
+              name_of(c) &&
+                c != ::SmartProperties::Validations::Ancestor &&
+                c < ::SmartProperties && ::SmartProperties::ClassMethods === c
+            end
           end
         end
 

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

@@ -160,9 +160,13 @@ module Tapioca
           end
         end
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
+          end
         end
 
         private

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

@@ -107,23 +107,39 @@ module Tapioca
           ActionView::Helpers,
         ], T::Array[Module])
 
-        sig { override.returns(T::Enumerable[Module]) }
-        def self.gather_constants
-          return [] unless Rails.application
+        class << self
+          extend T::Sig
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            return [] unless Rails.application
+
+            Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
+            Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
+
+            constants = all_modules.select do |mod|
+              next unless name_of(mod)
+
+              includes_helper?(mod, GeneratedUrlHelpersModule) ||
+                includes_helper?(mod, GeneratedPathHelpersModule) ||
+                includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
+                includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
+            end
 
-          Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
-          Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
+            constants.concat(NON_DISCOVERABLE_INCLUDERS)
+          end
 
-          constants = all_modules.select do |mod|
-            next unless name_of(mod)
+          sig { params(mod: Module, helper: Module).returns(T::Boolean) }
+          private def includes_helper?(mod, helper)
+            superclass_ancestors = []
 
-            includes_helper?(mod, GeneratedUrlHelpersModule) ||
-              includes_helper?(mod, GeneratedPathHelpersModule) ||
-              includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
-              includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
-          end
+            if Class === mod
+              superclass = superclass_of(mod)
+              superclass_ancestors = ancestors_of(superclass) if superclass
+            end
 
-          constants.concat(NON_DISCOVERABLE_INCLUDERS)
+            ancestors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
+            ancestors.any? { |ancestor| helper == ancestor }
+          end
         end
 
         private
@@ -152,19 +168,6 @@ module Tapioca
           mod.create_include(T.must(helper_module.name)) if include_helper
           mod.create_extend(T.must(helper_module.name)) if extend_helper
         end
-
-        sig { params(mod: Module, helper: Module).returns(T::Boolean) }
-        private_class_method def self.includes_helper?(mod, helper)
-          superclass_ancestors = []
-
-          if Class === mod
-            superclass = superclass_of(mod)
-            superclass_ancestors = ancestors_of(superclass) if superclass
-          end
-
-          ancestors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
-          ancestors.any? { |ancestor| helper == ancestor }
-        end
       end
     end
   end

data/lib/tapioca/dsl/compilers.rb

@@ -4,11 +4,6 @@
 module Tapioca
   module Dsl
     module Compilers
-      DIRECTORY = T.let(
-        File.expand_path("compilers", __dir__),
-        String
-      )
-
       # DSL compilers are either built-in to Tapioca and live under the
       # `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
       # can be referred to by just using the class name, or they live in

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -6,6 +6,7 @@ module Tapioca
     module Helpers
       class ActiveRecordColumnTypeHelper
         extend T::Sig
+        include RBIHelper
 
         sig { params(constant: T.class_of(ActiveRecord::Base)).void }
         def initialize(constant)
@@ -74,15 +75,6 @@ module Tapioca
             !(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: BasicObject).returns(String) }
         def handle_unknown_type(column_type)
           return "T.untyped" unless ActiveModel::Type::Value === column_type

data/lib/tapioca/dsl/helpers/graphql_type_helper.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      class GraphqlTypeHelper
+        extend T::Sig
+        include RBIHelper
+        include Runtime::Reflection
+
+        sig { params(type: GraphQL::Schema::Wrapper).returns(String) }
+        def type_for(type)
+          unwrapped_type = type.unwrap
+
+          parsed_type = case unwrapped_type
+          when GraphQL::Types::Boolean.singleton_class
+            "T::Boolean"
+          when GraphQL::Types::Float.singleton_class
+            qualified_name_of(Float)
+          when GraphQL::Types::ID.singleton_class
+            qualified_name_of(String)
+          when GraphQL::Types::Int.singleton_class
+            qualified_name_of(Integer)
+          when GraphQL::Types::ISO8601Date.singleton_class
+            qualified_name_of(Date)
+          when GraphQL::Types::ISO8601DateTime.singleton_class
+            qualified_name_of(DateTime)
+          when GraphQL::Types::JSON.singleton_class
+            "T::Hash[::String, T.untyped]"
+          when GraphQL::Types::String.singleton_class
+            qualified_name_of(String)
+          when GraphQL::Schema::Enum.singleton_class
+            enum_values = T.cast(unwrapped_type.enum_values, T::Array[GraphQL::Schema::EnumValue])
+            value_types = enum_values.map { |v| qualified_name_of(v.value.class) }.uniq
+            if value_types.size == 1
+              value_types.first
+            else
+              "T.any(#{value_types.join(", ")})"
+            end
+          when GraphQL::Schema::InputObject.singleton_class
+            qualified_name_of(unwrapped_type)
+          else
+            "T.untyped"
+          end
+
+          parsed_type = T.must(parsed_type)
+
+          if type.list?
+            parsed_type = "T::Array[#{parsed_type}]"
+          end
+
+          unless type.non_null?
+            parsed_type = as_nilable_type(parsed_type)
+          end
+
+          parsed_type
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/pipeline.rb

@@ -7,7 +7,7 @@ module Tapioca
       extend T::Sig
 
       sig { returns(T::Enumerable[T.class_of(Compiler)]) }
-      attr_reader :compilers
+      attr_reader :active_compilers
 
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
@@ -34,8 +34,8 @@ module Tapioca
         error_handler: $stderr.method(:puts).to_proc,
         number_of_workers: nil
       )
-        @compilers = T.let(
-          gather_compilers(requested_compilers, excluded_compilers),
+        @active_compilers = T.let(
+          gather_active_compilers(requested_compilers, excluded_compilers),
           T::Enumerable[T.class_of(Compiler)]
         )
         @requested_constants = requested_constants
@@ -87,11 +87,19 @@ module Tapioca
       def compiler_enabled?(compiler_name)
         potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
 
-        @compilers.any? do |compiler|
+        active_compilers.any? do |compiler|
           potential_names.any?(compiler.name)
         end
       end
 
+      sig { returns(T::Array[T.class_of(Compiler)]) }
+      def compilers
+        @compilers = T.let(@compilers, T.nilable(T::Array[T.class_of(Compiler)]))
+        @compilers ||= Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
+          T.must(compiler.name)
+        end
+      end
+
       private
 
       sig do
@@ -100,16 +108,16 @@ module Tapioca
           excluded_compilers: T::Array[T.class_of(Compiler)]
         ).returns(T::Enumerable[T.class_of(Compiler)])
       end
-      def gather_compilers(requested_compilers, excluded_compilers)
-        Runtime::Reflection.descendants_of(Compiler).select do |klass|
-          (requested_compilers.empty? || requested_compilers.include?(klass)) &&
-            !excluded_compilers.include?(klass)
-        end.sort_by { |klass| T.must(klass.name) }
+      def gather_active_compilers(requested_compilers, excluded_compilers)
+        active_compilers = compilers
+        active_compilers -= excluded_compilers
+        active_compilers &= requested_compilers unless requested_compilers.empty?
+        active_compilers
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
       def gather_constants(requested_constants)
-        constants = compilers.map(&:processable_constants).reduce(Set.new, :union)
+        constants = active_compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants = filter_anonymous_and_reloaded_constants(constants)
 
         constants &= requested_constants unless requested_constants.empty?
@@ -145,7 +153,7 @@ module Tapioca
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
-        compilers.each do |compiler_class|
+        active_compilers.each do |compiler_class|
           next unless compiler_class.handles?(constant)
 
           compiler = compiler_class.new(self, file.root, constant)

data/lib/tapioca/gem/listeners/source_location.rb

@@ -41,7 +41,6 @@ module Tapioca
         def add_source_location_comment(node, file, line)
           return unless file && line
 
-          gem = @pipeline.gem
           path = Pathname.new(file)
           return unless File.exist?(path)
 
@@ -49,17 +48,25 @@ module Tapioca
           # use for jump to definition. Only add source comments on Ruby files
           return unless path.extname == ".rb"
 
-          path = if path.realpath.to_s.start_with?(gem.full_gem_path)
-            "#{gem.name}-#{gem.version}/#{path.realpath.relative_path_from(gem.full_gem_path)}"
-          else
-            path.sub("#{Bundler.bundle_path}/gems/", "").to_s
-          end
+          realpath = path.realpath.to_s
+          gem = Gemfile::GemSpec.spec_lookup_by_file_path[realpath]
+          return if gem.nil?
 
-          # Strip out the RUBY_ROOT prefix, which is different for each user
-          path = path.sub(RbConfig::CONFIG["rubylibdir"], "RUBY_ROOT")
+          path = gem.relative_path_for(path)
+          version = gem.version
+          # we can clear the gem version if the gem is the same one we are processing
+          version = "" if gem == @pipeline.gem
 
+          uri = URI::Source.build(
+            gem_name: gem.name,
+            gem_version: version,
+            path: path.to_s,
+            line_number: line.to_s
+          )
           node.comments << RBI::Comment.new("") if node.comments.any?
-          node.comments << RBI::Comment.new("source://#{path}:#{line}")
+          node.comments << RBI::Comment.new(uri.to_s)
+        rescue URI::InvalidComponentError, URI::InvalidURIError
+          # Bad uri
         end
       end
     end