tapioca 0.11.8 → 0.11.10

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

@@ -0,0 +1,208 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "json_api_client"
+rescue LoadError
+  # means JsonApiClient is not installed,
+  # so let's not even define the compiler.
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::JsonApiClientResource` generates RBI files for classes that inherit
+      # [`JsonApiClient::Resource`](https://github.com/JsonApiClient/json_api_client).
+      #
+      # For example, with the following classes that inherits `JsonApiClient::Resource`:
+      #
+      # ~~~rb
+      # # user.rb
+      # class User < JsonApiClient::Resource
+      #   has_many :posts
+      #
+      #   property :name, type: :string
+      #   property :is_admin, type: :boolean, default: false
+      # end
+      #
+      # # post.rb
+      # class Post < JsonApiClient::Resource
+      #   belongs_to :user
+      #
+      #   property :title, type: :string
+      # end
+      # ~~~
+      #
+      # this compiler will produce RBI files with the following content:
+      #
+      # ~~~rbi
+      # # user.rbi
+      # # typed: strong
+      #
+      # class User
+      #   include JsonApiClientResourceGeneratedMethods
+      #
+      #   module JsonApiClientResourceGeneratedMethods
+      #     sig { returns(T::Boolean) }
+      #     def is_admin; end
+      #
+      #     sig { params(is_admin: T::Boolean).returns(T::Boolean) }
+      #     def is_admin=(is_admin); end
+      #
+      #     sig { returns(T.nilable(::String)) }
+      #     def name; end
+      #
+      #     sig { params(name: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def name=(name); end
+      #
+      #     sig { returns(T.nilable(T::Array[Post])) }
+      #     def posts; end
+      #
+      #     sig { params(posts: T.nilable(T::Array[Post])).returns(T.nilable(T::Array[Post])) }
+      #     def posts=(posts); end
+      #   end
+      # end
+      #
+      # # post.rbi
+      # # typed: strong
+      #
+      # class Post
+      #   include JsonApiClientResourceGeneratedMethods
+      #
+      #   module JsonApiClientResourceGeneratedMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
+      #
+      #     sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def title=(title); end
+      #
+      #     sig { returns(T.nilable(::String)) }
+      #     def user_id; end
+      #
+      #     sig { params(user_id: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def user_id=(user_id); end
+      #   end
+      # end
+      # ~~~
+      class JsonApiClientResource < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::JsonApiClient::Resource) } }
+
+        sig { override.void }
+        def decorate
+          schema = resource_schema
+          return if schema.nil? && constant.associations.empty?
+
+          root.create_path(constant) do |k|
+            module_name = "JsonApiClientResourceGeneratedMethods"
+            k.create_module(module_name) do |mod|
+              schema&.each_property do |property|
+                generate_methods_for_property(mod, property)
+              end
+
+              constant.associations.each do |association|
+                generate_methods_for_association(mod, association)
+              end
+            end
+
+            k.create_include(module_name)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_modules.select do |c|
+              name_of(c) && c < ::JsonApiClient::Resource
+            end
+          end
+        end
+
+        private
+
+        sig { returns(T.nilable(::JsonApiClient::Schema)) }
+        def resource_schema
+          schema = constant.schema
+
+          # empty? does not exist on JsonApiClient::Schema
+          schema if schema.size > 0 # rubocop:disable Style/ZeroLengthPredicate
+        end
+
+        sig do
+          params(
+            mod: RBI::Scope,
+            property: ::JsonApiClient::Schema::Property,
+          ).void
+        end
+        def generate_methods_for_property(mod, property)
+          type = type_for(property)
+
+          name = property.name.to_s
+
+          mod.create_method(name, return_type: type)
+          mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
+        end
+
+        sig { params(property: ::JsonApiClient::Schema::Property).returns(String) }
+        def type_for(property)
+          type = ::JsonApiClient::Schema::TypeFactory.type_for(property.type)
+          return "T.untyped" if type.nil?
+
+          sorbet_type = if type.respond_to?(:sorbet_type)
+            type.sorbet_type
+          elsif type == ::JsonApiClient::Schema::Types::Integer
+            "::Integer"
+          elsif type == ::JsonApiClient::Schema::Types::String
+            "::String"
+          elsif type == ::JsonApiClient::Schema::Types::Float
+            "::Float"
+          elsif type == ::JsonApiClient::Schema::Types::Time
+            "::Time"
+          elsif type == ::JsonApiClient::Schema::Types::Decimal
+            "::BigDecimal"
+          elsif type == ::JsonApiClient::Schema::Types::Boolean
+            "T::Boolean"
+          else
+            "T.untyped"
+          end
+
+          if property.default.nil?
+            as_nilable_type(sorbet_type)
+          else
+            sorbet_type
+          end
+        end
+
+        sig do
+          params(
+            mod: RBI::Scope,
+            association: JsonApiClient::Associations::BaseAssociation,
+          ).void
+        end
+        def generate_methods_for_association(mod, association)
+          # If the association is broken, it will raise a NameError when trying to access the association_class
+          klass = association.association_class
+
+          name, type = case association
+          when ::JsonApiClient::Associations::BelongsTo::Association
+            # id must be a string: # https://jsonapi.org/format/#document-resource-object-identification
+            [association.param.to_s, "T.nilable(::String)"]
+          when ::JsonApiClient::Associations::HasOne::Association
+            [association.attr_name.to_s, "T.nilable(#{klass})"]
+          when ::JsonApiClient::Associations::HasMany::Association
+            [association.attr_name.to_s, "T.nilable(T::Array[#{klass}])"]
+          else
+            return # Unsupported association type
+          end
+
+          mod.create_method(name, return_type: type)
+          mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/extensions/active_record.rb

@@ -30,6 +30,15 @@ module Tapioca
             super
           end
 
+          attr_reader :__tapioca_stored_attributes
+
+          def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
+            @__tapioca_stored_attributes ||= []
+            @__tapioca_stored_attributes << [store_attribute, keys, prefix, suffix]
+
+            super
+          end
+
           ::ActiveRecord::Base.singleton_class.prepend(self)
         end
       end

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

@@ -13,8 +13,26 @@ module Tapioca
           @constant = constant
         end
 
+        sig { params(attribute_name: String, column_name: String).returns([String, String]) }
+        def type_for(attribute_name, column_name = attribute_name)
+          return id_type if attribute_name == "id"
+
+          column_type_for(column_name)
+        end
+
+        private
+
+        sig { returns([String, String]) }
+        def id_type
+          if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
+            @constant.primary_key.map(&method(:column_type_for)).map { |tuple| "[#{tuple.join(", ")}]" }
+          else
+            column_type_for(@constant.primary_key)
+          end
+        end
+
         sig { params(column_name: String).returns([String, String]) }
-        def type_for(column_name)
+        def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(@constant)
 
           column = @constant.columns_hash[column_name]
@@ -33,7 +51,7 @@ module Tapioca
             return [getter_type, as_nilable_type(setter_type)]
           end
 
-          if column_name == @constant.primary_key ||
+          if Array(@constant.primary_key).include?(column_name) ||
               column_name == "created_at" ||
               column_name == "updated_at"
             getter_type = as_nilable_type(getter_type)
@@ -42,8 +60,6 @@ module Tapioca
           [getter_type, setter_type]
         end
 
-        private
-
         sig { params(column_type: T.untyped).returns(String) }
         def type_for_activerecord_value(column_type)
           case column_type
@@ -69,6 +85,9 @@ module Tapioca
             "::String"
           when ActiveRecord::Type::Serialized
             serialized_column_type(column_type)
+          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid
+            "::String"
           when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) &&
             ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore
             "T::Hash[::String, ::String]"

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

@@ -15,6 +15,7 @@ module Tapioca
         AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
         DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
         SecureTokensModuleName = T.let("GeneratedSecureTokenMethods", String)
+        StoredAttributesModuleName = T.let("GeneratedStoredAttributesMethods", String)
 
         RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
         AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)

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

@@ -9,8 +9,16 @@ module Tapioca
 
         extend T::Sig
 
-        sig { params(type: GraphQL::Schema::Wrapper).returns(String) }
-        def type_for(type)
+        sig { params(argument: GraphQL::Schema::Argument).returns(String) }
+        def type_for(argument)
+          type = if argument.loads
+            loads_type = ::GraphQL::Schema::Wrapper.new(argument.loads)
+            loads_type = loads_type.to_list_type if argument.type.list?
+            loads_type = loads_type.to_non_null_type if argument.type.non_null?
+            loads_type
+          else
+            argument.type
+          end
           unwrapped_type = type.unwrap
 
           parsed_type = case unwrapped_type
@@ -39,6 +47,8 @@ module Tapioca
             end
           when GraphQL::Schema::InputObject.singleton_class
             type_for_constant(unwrapped_type)
+          when Module
+            Runtime::Reflection.qualified_name_of(unwrapped_type) || "T.untyped"
           else
             "T.untyped"
           end
@@ -47,7 +57,7 @@ module Tapioca
             parsed_type = "T::Array[#{parsed_type}]"
           end
 
-          unless type.non_null?
+          unless type.non_null? || has_replaceable_default?(argument)
             parsed_type = RBIHelper.as_nilable_type(parsed_type)
           end
 
@@ -60,6 +70,11 @@ module Tapioca
         def type_for_constant(constant)
           Runtime::Reflection.qualified_name_of(constant) || "T.untyped"
         end
+
+        sig { params(argument: GraphQL::Schema::Argument).returns(T::Boolean) }
+        def has_replaceable_default?(argument)
+          !!argument.replace_null_with_default? && !argument.default_value.nil?
+        end
       end
     end
   end

data/lib/tapioca/dsl/pipeline.rb

@@ -105,10 +105,12 @@ module Tapioca
 
       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
+        @compilers ||= T.let(
+          Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
+            T.must(compiler.name)
+          end,
+          T.nilable(T::Array[T.class_of(Compiler)]),
+        )
       end
 
       private

data/lib/tapioca/gem/pipeline.rb

@@ -50,6 +50,8 @@ module Tapioca
         @root
       end
 
+      # Events handling
+
       sig { params(symbol: String).void }
       def push_symbol(symbol)
         @events << Gem::SymbolFound.new(symbol)
@@ -98,6 +100,8 @@ module Tapioca
         @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
 
+      # Constants and properties filtering
+
       sig { params(symbol_name: String).returns(T::Boolean) }
       def symbol_in_payload?(symbol_name)
         symbol_name = symbol_name[2..-1] if symbol_name.start_with?("::")
@@ -106,16 +110,27 @@ module Tapioca
         @payload_symbols.include?(symbol_name)
       end
 
+      # this looks something like:
+      # "(eval at /path/to/file.rb:123)"
+      # and we are just interested in the "/path/to/file.rb" part
+      EVAL_SOURCE_FILE_PATTERN = T.let(/\(eval at (.+):\d+\)/, Regexp)
+
       sig { params(name: T.any(String, Symbol)).returns(T::Boolean) }
       def constant_in_gem?(name)
         return true unless Object.respond_to?(:const_source_location)
 
-        source_location, _ = Object.const_source_location(name)
-        return true unless source_location
+        source_file, _ = Object.const_source_location(name)
+        return true unless source_file
         # If the source location of the constant is "(eval)", all bets are off.
-        return true if source_location == "(eval)"
+        return true if source_file == "(eval)"
 
-        gem.contains_path?(source_location)
+        # Ruby 3.3 adds automatic definition of source location for evals if
+        # `file` and `line` arguments are not provided. This results in the source
+        # file being something like `(eval at /path/to/file.rb:123)`. We try to parse
+        # this string to get the actual source file.
+        source_file = source_file.sub(EVAL_SOURCE_FILE_PATTERN, "\\1")
+
+        gem.contains_path?(source_file)
       end
 
       sig { params(method: UnboundMethod).returns(T::Boolean) }
@@ -126,6 +141,8 @@ module Tapioca
         @gem.contains_path?(source_location)
       end
 
+      # Helpers
+
       sig { params(constant: Module).returns(T.nilable(String)) }
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
@@ -149,6 +166,8 @@ module Tapioca
         gem_symbols.union(engine_symbols)
       end
 
+      # Events handling
+
       sig { returns(Gem::Event) }
       def next_event
         T.must(@events.shift)
@@ -171,7 +190,7 @@ module Tapioca
       sig { params(event: Gem::SymbolFound).void }
       def on_symbol(event)
         symbol = event.symbol.delete_prefix("::")
-        return if symbol_in_payload?(symbol) && !@bootstrap_symbols.include?(symbol)
+        return if skip_symbol?(symbol)
 
         constant = constantize(symbol)
         push_constant(symbol, constant) if Runtime::Reflection.constant_defined?(constant)
@@ -180,13 +199,7 @@ module Tapioca
       sig { params(event: Gem::ConstantFound).void.checked(:never) }
       def on_constant(event)
         name = event.symbol
-
-        return if name.strip.empty?
-        return if name.start_with?("#<")
-        return if name.downcase == name
-        return if alias_namespaced?(name)
-
-        return if T::Enum === event.constant # T::Enum instances are defined via `compile_enums`
+        return if skip_constant?(name, event.constant)
 
         if event.is_a?(Gem::ForeignConstantFound)
           compile_foreign_constant(name, event.constant)
@@ -200,11 +213,17 @@ module Tapioca
         @node_listeners.each { |listener| listener.dispatch(event) }
       end
 
-      # Compile
+      # Compiling
 
       sig { params(symbol: String, constant: Module).void }
       def compile_foreign_constant(symbol, constant)
-        compile_module(symbol, constant, foreign_constant: true)
+        return if skip_foreign_constant?(symbol, constant)
+        return if seen?(symbol)
+
+        seen!(symbol)
+
+        scope = compile_scope(symbol, constant)
+        push_foreign_scope(symbol, constant, scope)
       end
 
       sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
@@ -225,10 +244,9 @@ module Tapioca
       def compile_alias(name, constant)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        return if symbol_in_payload?(name)
-        return unless constant_in_gem?(name)
+        return if skip_alias?(name, constant)
 
         target = name_of(constant)
         # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
@@ -247,10 +265,9 @@ module Tapioca
       def compile_object(name, value)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        return if symbol_in_payload?(name)
-        return unless constant_in_gem?(name)
+        return if skip_object?(name, value)
 
         klass = class_of(value)
 
@@ -279,29 +296,29 @@ module Tapioca
         @root << node
       end
 
-      sig { params(name: String, constant: Module, foreign_constant: T::Boolean).void }
-      def compile_module(name, constant, foreign_constant: false)
-        return unless defined_in_gem?(constant, strict: false) || foreign_constant
-        return if Tapioca::TypeVariableModule === constant
+      sig { params(name: String, constant: Module).void }
+      def compile_module(name, constant)
+        return if skip_module?(name, constant)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        scope =
-          if constant.is_a?(Class)
-            superclass = compile_superclass(constant)
-            RBI::Class.new(name, superclass_name: superclass)
-          else
-            RBI::Module.new(name)
-          end
+        scope = compile_scope(name, constant)
+        push_scope(name, constant, scope)
+      end
 
-        if foreign_constant
-          push_foreign_scope(name, constant, scope)
+      sig { params(name: String, constant: Module).returns(RBI::Scope) }
+      def compile_scope(name, constant)
+        scope = if constant.is_a?(Class)
+          superclass = compile_superclass(constant)
+          RBI::Class.new(name, superclass_name: superclass)
         else
-          push_scope(name, constant, scope)
+          RBI::Module.new(name)
         end
 
         @root << scope
+
+        scope
       end
 
       sig { params(constant: T::Class[T.anything]).returns(T.nilable(String)) }
@@ -353,6 +370,54 @@ module Tapioca
         "::#{name}"
       end
 
+      # Constants and properties filtering
+
+      sig { params(name: String).returns(T::Boolean) }
+      def skip_symbol?(name)
+        symbol_in_payload?(name) && !@bootstrap_symbols.include?(name)
+      end
+
+      sig { params(name: String, constant: T.anything).returns(T::Boolean).checked(:never) }
+      def skip_constant?(name, constant)
+        return true if name.strip.empty?
+        return true if name.start_with?("#<")
+        return true if name.downcase == name
+        return true if alias_namespaced?(name)
+
+        return true if T::Enum === constant # T::Enum instances are defined via `compile_enums`
+
+        false
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_alias?(name, constant)
+        return true if symbol_in_payload?(name)
+        return true unless constant_in_gem?(name)
+
+        false
+      end
+
+      sig { params(name: String, constant: BasicObject).returns(T::Boolean).checked(:never) }
+      def skip_object?(name, constant)
+        return true if symbol_in_payload?(name)
+        return true unless constant_in_gem?(name)
+
+        false
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_foreign_constant?(name, constant)
+        Tapioca::TypeVariableModule === constant
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_module?(name, constant)
+        return true unless defined_in_gem?(constant, strict: false)
+        return true if Tapioca::TypeVariableModule === constant
+
+        false
+      end
+
       sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
       def defined_in_gem?(constant, strict: true)
         files = get_file_candidates(constant)
@@ -385,7 +450,7 @@ module Tapioca
       end
 
       sig { params(name: String).void }
-      def mark_seen(name)
+      def seen!(name)
         @seen.add(name)
       end
 
@@ -394,6 +459,8 @@ module Tapioca
         @seen.include?(name)
       end
 
+      # Helpers
+
       sig { params(constant: T.all(Module, T::Generic)).returns(String) }
       def generic_name_of(constant)
         type_name = T.must(constant.name)

data/lib/tapioca/gemfile.rb

@@ -156,6 +156,11 @@ module Tapioca
         @spec.name
       end
 
+      sig { returns(T::Array[::Gem::Dependency]) }
+      def dependencies
+        @spec.dependencies
+      end
+
       sig { returns(String) }
       def rbi_file_name
         "#{name}@#{version}.rbi"
@@ -230,13 +235,14 @@ module Tapioca
 
       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
+        @require_paths_prefix_matcher ||= T.let(
+          begin
+            require_paths = T.unsafe(@spec).require_paths
+            prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
+            Regexp.union(prefix_matchers)
+          end,
+          T.nilable(Regexp),
+        )
       end
 
       sig { params(file: String).returns(Pathname) }

data/lib/tapioca/helpers/git_attributes.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+class GitAttributes
+  class << self
+    extend T::Sig
+
+    sig { params(path: Pathname).void }
+    def create_generated_attribute_file(path)
+      create_gitattributes_file(path, <<~CONTENT)
+        **/*.rbi linguist-generated=true
+      CONTENT
+    end
+
+    sig { params(path: Pathname).void }
+    def create_vendored_attribute_file(path)
+      create_gitattributes_file(path, <<~CONTENT)
+        **/*.rbi linguist-vendored=true
+      CONTENT
+    end
+
+    private
+
+    sig { params(path: Pathname, content: String).void }
+    def create_gitattributes_file(path, content)
+      # We don't want to start creating folders, just to write
+      # the `.gitattributes` file. So, if the folder doesn't
+      # exist, we just return.
+      return unless path.exist?
+
+      File.write(path.join(".gitattributes"), content)
+    end
+  end
+end

data/lib/tapioca/helpers/test/template.rb

@@ -24,12 +24,12 @@ module Tapioca
           ::Gem::Requirement.new(selector).satisfied_by?(ActiveSupport.gem_version)
         end
 
-        sig { params(src: String).returns(String) }
-        def template(src)
+        sig { params(src: String, trim_mode: String).returns(String) }
+        def template(src, trim_mode: ">")
           erb = if ERB_SUPPORTS_KVARGS
-            ::ERB.new(src, trim_mode: ">")
+            ::ERB.new(src, trim_mode: trim_mode)
           else
-            ::ERB.new(src, nil, ">")
+            ::ERB.new(src, nil, trim_mode)
           end
 
           erb.result(binding)