rbs_activerecord 1.0.0

data/lib/rbs_activerecord/generator/delegated_type/scopes.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module DelegatedType
+      class Scopes
+        attr_reader :model #: RbsActiverecord::Model
+        attr_reader :declarations #: Array[Prism::CallNode]
+
+        # @rbs model: RbsActiverecord::Model
+        # @rbs declarations: Hash[String, Array[Prism::CallNode]]
+        def initialize(model, declarations) #: void
+          @model = model
+          @declarations = declarations.fetch(model.klass.name.to_s, [])
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedDelegatedTypeScopeMethods[Relation]
+              #{delegated_types.map { |node| delegated_type(node) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def delegated_types #: Array[Prism::CallNode]
+          declarations.select { |node| node.name == :delegated_type }
+        end
+
+        # @rbs node: Prism::CallNode
+        def delegated_type(node) #: String
+          arguments = node.arguments&.arguments || []
+          name, options = arguments.map { |arg| Parser.eval_node(arg) } #: [String?, Hash[Symbol, untyped]]
+          return "" unless name
+
+          options[:types].map do |type|
+            "def #{type.tableize}: () -> Relation"
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/enum/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module Enum
+      class Base
+        private
+
+        # @rbs node: Prism::CallNode
+        def parse_arguments(node) #: [String?, Array[String | Symbol], Hash[Symbol, untyped]] # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+          arguments = node.arguments&.arguments || []
+          args = arguments.map { |arg| Parser.eval_node(arg) }
+          return nil, [], {} if args.empty?
+
+          name = args[0] #: String?
+
+          case args[1]
+          when Array
+            values = args[1]
+            options = args[2] || {}
+          when Hash
+            values = args[1].keys
+            options = args[2] || {}
+          else
+            values = []
+            options = {}
+          end
+
+          [name, values, options]
+        end
+
+        # @rbs name: String
+        # @rbs value: untyped
+        # @rbs options: Hash[Symbol, untyped]
+        def enum_method_name(name, value, options) #: String
+          components = [] #: Array[String | Symbol]
+
+          case options[:prefix]
+          when true
+            components << name
+          when String, Symbol
+            components << options[:prefix]
+          end
+
+          components << value
+
+          case options[:suffix]
+          when true
+            components << name
+          when String, Symbol
+            components << options[:suffix]
+          end
+
+          enum_method_name = components.join("_")
+
+          # Make enum methods friendly
+          # refs: https://github.com/rails/rails/blob/v8.0.0/activerecord/lib/active_record/enum.rb#L270
+          enum_method_name.gsub(/[\W&&[:ascii:]]+/, "_")
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/enum/instance_methods.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module Enum
+      class InstanceMethods < Base
+        attr_reader :model #: RbsActiverecord::Model
+        attr_reader :declarations #: Array[Prism::CallNode]
+
+        # @rbs model: RbsActiverecord::Model
+        # @rbs declarations: Hash[String, Array[Prism::CallNode]]
+        def initialize(model, declarations) #: void
+          @model = model
+          @declarations = declarations.fetch(model.klass.name.to_s, [])
+
+          super()
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedEnumInstanceMethods
+              #{enums.map { |node| enum(node) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def enums #: Array[Prism::CallNode]
+          declarations.select { |node| node.name == :enum }
+        end
+
+        # @rbs node: Prism::CallNode
+        def enum(node) #: String
+          name, values, options = parse_arguments(node)
+
+          return "" unless name
+          return "" unless options.fetch(:instance_methods, true)
+
+          values.map do |value|
+            method_name = enum_method_name(name, value, options)
+            <<~RBS
+              def #{method_name}!: () -> void
+              def #{method_name}?: () -> bool
+            RBS
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/enum/scopes.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module Enum
+      class Scopes < Base
+        attr_reader :model #: RbsActiverecord::Model
+        attr_reader :declarations #: Array[Prism::CallNode]
+
+        # @rbs model: RbsActiverecord::Model
+        # @rbs declarations: Hash[String, Array[Prism::CallNode]]
+        def initialize(model, declarations) #: void
+          @model = model
+          @declarations = declarations.fetch(model.klass.name.to_s, [])
+
+          super()
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedEnumScopeMethods[Relation]
+              #{enums.map { |node| enum(node) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def enums #: Array[Prism::CallNode]
+          declarations.select { |node| node.name == :enum }
+        end
+
+        # @rbs node: Prism::CallNode
+        def enum(node) #: String
+          name, values, options = parse_arguments(node)
+
+          return "" unless name
+          return "" unless options.fetch(:scopes, true)
+
+          values.map do |value|
+            method_name = enum_method_name(name, value, options)
+            <<~RBS
+              def #{method_name}: () -> Relation
+              def not_#{method_name}: () -> Relation
+            RBS
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/pluck_overloads.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    class PluckOverloads
+      include Utils
+
+      attr_reader :model #: RbsActiverecord::Model
+
+      # @rbs model: RbsActiverecord::Model
+      def initialize(model) #: void
+        @model = model
+      end
+
+      def generate #: String
+        <<~RBS.strip
+          module GeneratedPluckOverloads
+            def pluck: #{overloads.join(" | ")}
+                     | (::Symbol | ::String | ::Arel::Nodes::t column) -> ::Array[untyped]
+                     | (*::Symbol | ::String | ::Arel::Nodes::t columns) -> ::Array[::Array[untyped]]
+          end
+        RBS
+      end
+
+      private
+
+      def overloads #: Array[String]
+        model.columns.map do |col|
+          base_type = enum?(col) ? "::String" : sql_type_to_class(col.type)
+          column_type = col.null ? "#{base_type}?" : base_type
+          "(:#{col.name} | \"#{col.name}\") -> ::Array[#{column_type}]"
+        end
+      end
+
+      # @rbs column: untyped
+      def enum?(column) #: bool
+        model.defined_enums.key? column.name
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/scopes.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    class Scopes
+      attr_reader :model #: RbsActiverecord::Model
+      attr_reader :declarations #: Array[Prism::CallNode]
+
+      # @rbs model: RbsActiverecord::Model
+      # @rbs delarations: Hash[String, Array[Prism::CallNode]]
+      def initialize(model, declarations) #: void
+        @model = model
+        @declarations = declarations.fetch(model.klass.name, [])
+      end
+
+      def generate #: String
+        <<~RBS.strip
+          module GeneratedScopeMethods[Relation]
+            #{scopes.map { |node| scope(node) }.join("\n")}
+          end
+        RBS
+      end
+
+      private
+
+      def scopes #: Array[Prism::CallNode]
+        declarations.select { |node| node.name == :scope }
+      end
+
+      # @rbs node: Prism::CallNode
+      def scope(node) #: String # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        args = node.arguments&.arguments
+        return "" unless args
+
+        name = args[0] #: Prism::SymbolNode
+        body = args[1]
+
+        case body
+        when Prism::LambdaNode
+          params = lambda_params(body)
+          "def #{name.value}: (#{params}) -> Relation"
+        when Prism::CallNode
+          if (body.name == :lambda || body.name == :proc) && body.block
+            block = body.block #: Prism::BlockNode
+            params = lambda_params(block)
+            "def #{name.value}: (#{params}) -> Relation"
+          else
+            "def #{name.value}: (?) -> Relation"
+          end
+        else
+          "def #{name.value}: (?) -> Relation"
+        end
+      end
+
+      # @rbs node: Prism::LambdaNode | Prism::BlockNode
+      def lambda_params(node) #: String  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # @type var params: Prism::ParametersNode?
+        params = node.parameters&.parameters # steep:ignore
+        return "" unless params
+
+        args = [] #: Array[String]
+
+        params.requireds.each do |required|
+          case required
+          when Prism::RequiredParameterNode
+            args << "untyped #{required.name}"
+          when Prism::MultiTargetNode
+            args << "untyped"
+          end
+        end
+        params.optionals.each do |optional|
+          args << "?untyped #{optional.name}"
+        end
+        case params.rest
+        when Prism::RestParameterNode
+          args << "*untyped #{params.rest.name}"
+        when Prism::ImplicitRestNode
+          args << "*untyped"
+        end
+        params.keywords.each do |keyword|
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            args << "#{keyword.name}: untyped"
+          when Prism::OptionalKeywordParameterNode
+            args << "?#{keyword.name}: untyped"
+          end
+        end
+        case params.keyword_rest
+        when Prism::KeywordRestParameterNode
+          args << "**untyped #{params.keyword_rest.name}"
+        when Prism::NoKeywordsParameterNode
+          args << "**untyped"
+        end
+
+        args.join(", ")
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/secure_password.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    class SecurePassword
+      attr_reader :model #: RbsActiverecord::Model
+
+      # @rbs model: RbsActiverecord::Model
+      def initialize(model) #: void
+        @model = model
+      end
+
+      def generate #: String
+        <<~RBS
+          module GeneratedSecurePasswordMethods
+            #{methods}
+          end
+        RBS
+      end
+
+      private
+
+      def methods #: String
+        secure_password_attributes.map do |name|
+          <<~RBS
+            attr_reader #{name}: String?
+            attr_accessor #{name}_confirmation: String
+            attr_accessor #{name}_challenge: String
+
+            def #{name}=: (String) -> String
+            def #{name}_salt: () -> String
+            def authenticate_#{name}: (String) -> (instance | false)
+
+            #{"alias authenticate authenticate_password" if name == "password"}
+          RBS
+        end.join("\n")
+      end
+
+      def secure_password_attributes #: Array[String]
+        return [] unless secure_password?
+
+        model.klass.instance_methods.grep(/authenticate_/).filter_map do |method|
+          next if model.klass.instance_methods.include?(:"#{method}_confirmation")
+
+          method.to_s.split("_", 2).last
+        end
+      end
+
+      def secure_password? #: bool
+        model.klass.ancestors.any?(::ActiveModel::SecurePassword::InstanceMethodsOnActivation)
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module RbsActiverecord
+  class Generator
+    include Utils
+
+    attr_reader :klass #: singleton(ActiveRecord::Base)
+    attr_reader :klass_name #: String
+    attr_reader :model #: RbsActiverecord::Model
+
+    # @rbs klass: singleton(ActiveRecord::Base)
+    def initialize(klass) #: void
+      @klass = klass
+      @klass_name = klass.name || ""
+      @model = Model.new(klass)
+    end
+
+    def generate #: String  # rubocop:disable Metrics/AbcSize
+      format <<~RBS
+        #{header}
+          #{Attributes.new(model).generate}
+          #{Associations.new(model).generate}
+
+          #{ActiveStorage::InstanceMethods.new(model).generate}
+          #{ActiveStorage::Scopes.new(model).generate}
+          #{PluckOverloads.new(model).generate}
+          #{SecurePassword.new(model).generate}
+
+          #{DelegatedType::InstanceMethods.new(model, declarations).generate}
+          #{DelegatedType::Scopes.new(model, declarations).generate}
+          #{Enum::InstanceMethods.new(model, declarations).generate}
+          #{Enum::Scopes.new(model, declarations).generate}
+          #{Scopes.new(model, declarations).generate}
+
+          class ActiveRecord_Relation < ::ActiveRecord::Relation
+            include ::Enumerable[#{klass_name}]
+            include ::ActiveRecord::Relation::Methods[#{klass_name}, #{primary_key_type}]
+            #{relation_methods}
+            include GeneratedPluckOverloads
+          end
+
+          class ActiveRecord_Associations_CollectionProxy < ::ActiveRecord::Associations::CollectionProxy
+            include ::Enumerable[#{klass_name}]
+            include ::ActiveRecord::Relation::Methods[#{klass_name}, #{primary_key_type}]
+            #{relation_methods}
+            include GeneratedPluckOverloads
+          end
+
+          extend ::ActiveRecord::Base::ClassMethods[#{klass_name}, #{klass_name}::ActiveRecord_Relation, #{primary_key_type}]
+          #{scope_class_methods}
+          extend GeneratedPluckOverloads
+
+          include GeneratedActiveStorageInstanceMethods
+          include GeneratedAttributeMethods
+          include GeneratedAssociationMethods
+          include GeneratedDelegatedTypeInstanceMethods
+          include GeneratedEnumInstanceMethods
+          include GeneratedSecurePasswordMethods
+        #{footer}
+      RBS
+    end
+
+    private
+
+    def primary_key_type #: String
+      primary_key_type_for(klass)
+    end
+
+    # @rbs @declarations: Hash[String, Array[Prism::CallNode]]
+
+    def declarations #: Hash[String, Array[Prism::CallNode]]
+      @declarations ||= begin
+        filename = Rails.root.join(model.filename)
+        if filename.exist?
+          Parser.parse(filename.to_s)
+        else
+          {}
+        end
+      end
+    end
+
+    def header #: String
+      namespace = +""
+      klass_name.split("::").map do |mod_name|
+        namespace += "::#{mod_name}"
+        mod_object = Object.const_get(namespace)
+        case mod_object
+        when Class
+          superclass = mod_object.superclass
+          superclass_name = superclass&.name || "Object"
+
+          "class #{mod_name} < ::#{superclass_name}"
+        when Module
+          "module #{mod_name}"
+        else
+          raise "unreachable"
+        end
+      end.join("\n")
+    end
+
+    def footer #: String
+      "end\n" * klass.module_parents.size
+    end
+
+    def relation_methods #: String
+      methods = <<~RBS
+        include GeneratedActiveStorageScopeMethods[ActiveRecord_Relation]
+        include GeneratedDelegatedTypeScopeMethods[ActiveRecord_Relation]
+        include GeneratedEnumScopeMethods[ActiveRecord_Relation]
+        include GeneratedScopeMethods[ActiveRecord_Relation]
+      RBS
+      model.parents.each do |cls|
+        methods += <<~RBS.strip
+          include ::#{cls.name}::GeneratedActiveStorageScopeMethods[ActiveRecord_Relation]
+          include ::#{cls.name}::GeneratedDelegatedTypeScopeMethods[ActiveRecord_Relation]
+          include ::#{cls.name}::GeneratedEnumScopeMethods[ActiveRecord_Relation]
+          include ::#{cls.name}::GeneratedScopeMethods[ActiveRecord_Relation]
+        RBS
+      end
+      methods
+    end
+
+    def scope_class_methods #: String
+      methods = <<~RBS
+        extend GeneratedActiveStorageScopeMethods[ActiveRecord_Relation]
+        extend GeneratedDelegatedTypeScopeMethods[ActiveRecord_Relation]
+        extend GeneratedEnumScopeMethods[ActiveRecord_Relation]
+        extend GeneratedScopeMethods[ActiveRecord_Relation]
+      RBS
+      model.parents.each do |cls|
+        methods += <<~RBS.strip
+          extend ::#{cls.name}::GeneratedActiveStorageScopeMethods[ActiveRecord_Relation]
+          extend ::#{cls.name}::GeneratedDelegatedTypeScopeMethods[ActiveRecord_Relation]
+          extend ::#{cls.name}::GeneratedEnumScopeMethods[ActiveRecord_Relation]
+          extend ::#{cls.name}::GeneratedScopeMethods[ActiveRecord_Relation]
+        RBS
+      end
+      methods
+    end
+  end
+end

data/lib/rbs_activerecord/model.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module RbsActiverecord
+  class Model
+    extend Forwardable
+
+    attr_reader :klass #: singleton(ActiveRecord::Base)
+
+    # @rbs!
+    #   def attribute_types: () -> Hash[String, untyped]
+    #   def attribute_aliases: () -> Hash[String, String]
+    #   def columns: () -> Array[untyped]
+    #   def defined_enums: () -> Hash[String, untyped]
+    #   def reflect_on_all_associations: (Symbol) -> Array[untyped]
+    def_delegators :klass, :attribute_aliases, :attribute_types, :columns, :defined_enums, :reflect_on_all_associations
+
+    # @rbs klass: singleton(ActiveRecord::Base)
+    def initialize(klass) #: void
+      @klass = klass
+    end
+
+    def filename #: String
+      "app/models/#{klass.name.to_s.underscore}.rb"
+    end
+
+    def parents #: Array[singleton(ActiveRecord::Base)]
+      ancestors = klass.ancestors #: Array[singleton(ActiveRecord::Base)]
+      ancestors.select { |cls| cls < ActiveRecord::Base && cls != klass && !cls.abstract_class? }
+    end
+  end
+end

data/lib/rbs_activerecord/parser/evaluator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  module Parser
+    module Evaluator
+      # @rbs! def self.eval_node: (Prism::Node node) -> untyped
+
+      # @rbs node: Prism::Node
+      def eval_node(node) #: untyped # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        case node
+        when Prism::NilNode
+          nil
+        when Prism::TrueNode
+          true
+        when Prism::FalseNode
+          false
+        when Prism::SymbolNode
+          node.value.to_s.to_sym
+        when Prism::IntegerNode
+          node.value
+        when Prism::StringNode
+          node.unescaped
+        when Prism::ArrayNode
+          node.elements.map { |e| eval_node(e) }
+        when Prism::HashNode
+          node.elements.filter_map do |assoc|
+            case assoc
+            when Prism::AssocNode
+              key = eval_node(assoc.key)
+              value = eval_node(assoc.value)
+              [key, value]
+            end
+          end.to_h
+        when Prism::KeywordHashNode
+          node.elements.filter_map do |assoc|
+            case assoc
+            when Prism::AssocNode
+              key = eval_node(assoc.key)
+              value = eval_node(assoc.value)
+              [key, value]
+            end
+          end.to_h
+        end
+      end
+      module_function :eval_node
+    end
+  end
+end

data/lib/rbs_activerecord/parser/visitor.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  module Parser
+    class Visitor < Prism::Visitor
+      attr_reader :context #: Array[Prism::ClassNode | Prism::ModuleNode]
+      attr_reader :decls   #: Hash[String, Array[Prism::CallNode]]
+
+      def initialize #: void
+        super
+
+        @context = []
+        @decls = {}
+      end
+
+      def current_namespace #: String
+        context.flat_map do |node|
+          namespace = [] #: Array[Symbol?]
+          path = node.constant_path #: Prism::Node?
+          loop do
+            case path
+            when Prism::ConstantPathNode
+              namespace << path.name
+              path = path.parent
+            when Prism::ConstantReadNode
+              namespace << path.name
+              break
+            end
+          end
+
+          namespace.compact.reverse
+        end.join("::")
+      end
+
+      # @rbs override
+      def visit_module_node(node)
+        context << node
+        begin
+          super
+        ensure
+          context.pop
+        end
+      end
+
+      # @rbs override
+      def visit_class_node(node)
+        context << node
+        begin
+          super
+        ensure
+          context.pop
+        end
+      end
+
+      # @rbs override
+      def visit_call_node(node)
+        decls[current_namespace] ||= []
+        decls[current_namespace] << node
+      end
+
+      # @rbs override
+      def visit_def_node(node)
+        # ignore
+      end
+    end
+  end
+end