rbs_activerecord 1.2.1 → 1.4.0

data/lib/rbs_activerecord/generator/attributes.rb

@@ -6,16 +6,19 @@ module RbsActiverecord
       include Utils
 
       attr_reader :model #: RbsActiverecord::Model
+      attr_reader :pure_accessors #: bool
 
       # @rbs model: RbsActiverecord::Model
-      def initialize(model) #: void
+      # @rbs pure_accessors: bool
+      def initialize(model, pure_accessors:) #: void
         @model = model
+        @pure_accessors = pure_accessors
       end
 
       def generate #: String
         <<~RBS
           module GeneratedAttributeMethods
-            #{model.columns.map { |c| column(c) }.join("\n")}
+            #{model.columns.map { column(_1) }.join("\n")}
             #{attributes.map { |name, type| attribute(name, type) }.join("\n")}
             #{model.attribute_aliases.map { |from, to| alias_method(from, to) }.join("\n")}
           end
@@ -24,14 +27,17 @@ module RbsActiverecord
 
       private
 
+      # @rbs col: untyped
       def column(col) #: String  # rubocop:disable Metrics/AbcSize
         type = sql_type_to_class(col.type)
         optional = "#{type}?"
         column_type = col.null ? optional : type
+        writer_type = writer_type_for(col.type, nullable: col.null)
 
         <<~RBS
+          #{"%a{pure}" if pure_accessors}
           def #{col.name}: () -> #{column_type}
-          def #{col.name}=: (#{column_type}) -> #{column_type}
+          def #{col.name}=: (#{writer_type}) -> #{writer_type}
           def #{col.name}?: () -> bool
           def #{col.name}_changed?: () -> bool
           def #{col.name}_change: () -> [#{optional}, #{optional}]
@@ -53,7 +59,7 @@ module RbsActiverecord
 
       def attributes #: Hash[String, untyped]
         model.attribute_types.filter_map do |name, type|
-          [name, type] if model.columns.none? { |col| col.name == name }
+          [name, type] if model.columns.none? { _1.name == name }
         end.to_h
       end
 
@@ -61,13 +67,32 @@ module RbsActiverecord
       # @rbs type: untyped
       def attribute(name, type) #: String
         column_type = sql_type_to_class(type.type)
+        writer_type = writer_type_for(type.type, nullable: false)
 
         <<~RBS
           def #{name}: () -> #{column_type}
-          def #{name}=: (#{column_type}) -> #{column_type}
+          def #{name}=: (#{writer_type}) -> #{writer_type}
         RBS
       end
 
+      # The type accepted by the attribute writer.
+      # It is wider than the reader type for the types ActiveRecord casts on assignment.
+      #
+      # @rbs type: Symbol
+      # @rbs nullable: bool
+      def writer_type_for(type, nullable:) #: String
+        writer_type = case type
+                      when :datetime
+                        # A datetime attribute also accepts ::Time and converts it to ::ActiveSupport::TimeWithZone
+                        "(::ActiveSupport::TimeWithZone | ::Time)"
+                      else
+                        sql_type_to_class(type)
+                      end
+        nullable ? "#{writer_type}?" : writer_type
+      end
+
+      # @rbs from: untyped
+      # @rbs to: untyped
       def alias_method(from, to) #: String
         <<~RBS
           alias #{from} #{to}

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

@@ -19,7 +19,7 @@ module RbsActiverecord
         def generate #: String
           <<~RBS.strip
             module GeneratedDelegatedTypeInstanceMethods
-              #{delegated_types.map { |node| delegated_type(node) }.join("\n")}
+              #{delegated_types.map { delegated_type(_1) }.join("\n")}
             end
           RBS
         end
@@ -27,18 +27,18 @@ module RbsActiverecord
         private
 
         def delegated_types #: Array[Prism::CallNode]
-          declarations.select { |node| node.name == :delegated_type }
+          declarations.select { _1.name == :delegated_type }
         end
 
         # @rbs node: Prism::CallNode
-        def delegated_type(node) #: String  # rubocop:disable Metrics/AbcSize
+        def delegated_type(node) #: String
           arguments = node.arguments&.arguments || []
-          name, options = arguments.map { |arg| Parser.eval_node(arg) } #: [String?, Hash[Symbol, untyped]]
+          name, options = arguments.map { Parser.eval_node(_1) } #: [String?, Hash[Symbol, untyped]]
           return "" unless name
 
           types = options[:types]
           role_methods = <<~RBS
-            def #{name}_class: () -> (#{types.map { |type| "::#{type}" }.join(" | ")})
+            def #{name}_class: () -> (#{types.map { "::#{_1}" }.join(" | ")})
             def #{name}_name: () -> ::String
           RBS
 

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

@@ -17,7 +17,7 @@ module RbsActiverecord
         def generate #: String
           <<~RBS.strip
             module GeneratedDelegatedTypeScopeMethods[Relation]
-              #{delegated_types.map { |node| delegated_type(node) }.join("\n")}
+              #{delegated_types.map { delegated_type(_1) }.join("\n")}
             end
           RBS
         end
@@ -25,13 +25,13 @@ module RbsActiverecord
         private
 
         def delegated_types #: Array[Prism::CallNode]
-          declarations.select { |node| node.name == :delegated_type }
+          declarations.select { _1.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]]
+          name, options = arguments.map { Parser.eval_node(_1) } #: [String?, Hash[Symbol, untyped]]
           return "" unless name
 
           options[:types].map do |type|

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

@@ -7,9 +7,9 @@ module RbsActiverecord
         private
 
         # @rbs node: Prism::CallNode
-        def parse_arguments(node) #: [String?, Array[String | Symbol], Hash[Symbol, untyped]] # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def parse_arguments(node) #: [String?, Array[String | Symbol], Hash[Symbol, untyped]] # rubocop:disable Metrics/CyclomaticComplexity
           arguments = node.arguments&.arguments || []
-          args = arguments.map { |arg| Parser.eval_node(arg) }
+          args = arguments.map { Parser.eval_node(_1) }
           return nil, [], {} if args.empty?
 
           name = args[0] #: String?

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

@@ -21,7 +21,7 @@ module RbsActiverecord
         def generate #: String
           <<~RBS.strip
             module GeneratedEnumInstanceMethods
-              #{enums.map { |node| enum(node) }.join("\n")}
+              #{enums.map { enum(_1) }.join("\n")}
             end
           RBS
         end
@@ -29,7 +29,7 @@ module RbsActiverecord
         private
 
         def enums #: Array[Prism::CallNode]
-          declarations.select { |node| node.name == :enum }
+          declarations.select { _1.name == :enum }
         end
 
         # @rbs node: Prism::CallNode
@@ -58,7 +58,7 @@ module RbsActiverecord
 
         # @rbs name: String
         def column_type(name) #: String
-          col = model.columns.find { |c| c.name == name.to_s }
+          col = model.columns.find { _1.name == name.to_s }
           if col
             sql_type_to_class(col.type)
           else

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

@@ -19,7 +19,7 @@ module RbsActiverecord
         def generate #: String
           <<~RBS.strip
             module GeneratedEnumMappingMethods
-              #{enums.map { |node| enum(node) }.join("\n")}
+              #{enums.map { enum(_1) }.join("\n")}
             end
           RBS
         end
@@ -27,7 +27,7 @@ module RbsActiverecord
         private
 
         def enums #: Array[Prism::CallNode]
-          declarations.select { |node| node.name == :enum }
+          declarations.select { _1.name == :enum }
         end
 
         # @rbs node: Prism::CallNode

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

@@ -19,7 +19,7 @@ module RbsActiverecord
         def generate #: String
           <<~RBS.strip
             module GeneratedEnumScopeMethods[Relation]
-              #{enums.map { |node| enum(node) }.join("\n")}
+              #{enums.map { enum(_1) }.join("\n")}
             end
           RBS
         end
@@ -27,7 +27,7 @@ module RbsActiverecord
         private
 
         def enums #: Array[Prism::CallNode]
-          declarations.select { |node| node.name == :enum }
+          declarations.select { _1.name == :enum }
         end
 
         # @rbs node: Prism::CallNode

data/lib/rbs_activerecord/generator/scopes.rb

@@ -16,7 +16,7 @@ module RbsActiverecord
       def generate #: String
         <<~RBS.strip
           module GeneratedScopeMethods[Relation]
-            #{scopes.map { |node| scope(node) }.join("\n")}
+            #{scopes.map { scope(_1) }.join("\n")}
           end
         RBS
       end
@@ -24,7 +24,7 @@ module RbsActiverecord
       private
 
       def scopes #: Array[Prism::CallNode]
-        declarations.select { |node| node.name == :scope }
+        declarations.select { _1.name == :scope }
       end
 
       # @rbs node: Prism::CallNode

data/lib/rbs_activerecord/generator/secure_password.rb

@@ -40,7 +40,7 @@ module RbsActiverecord
         return [] unless secure_password?
 
         model.klass.instance_methods.grep(/authenticate_/).filter_map do |method|
-          next if model.klass.instance_methods.include?(:"#{method}_confirmation")
+          next if model.klass.method_defined?(:"#{method}_confirmation")
 
           method.to_s.split("_", 2).last
         end

data/lib/rbs_activerecord/generator.rb

@@ -3,18 +3,21 @@
 require "rails"
 
 module RbsActiverecord
-  class Generator # rubocop:disable Metrics/ClassLength
+  class Generator
     include Utils
 
     attr_reader :klass #: singleton(ActiveRecord::Base)
     attr_reader :klass_name #: String
     attr_reader :model #: RbsActiverecord::Model
+    attr_reader :pure_accessors #: bool
 
     # @rbs klass: singleton(ActiveRecord::Base)
-    def initialize(klass) #: void
+    # @rbs pure_accessors: bool
+    def initialize(klass, pure_accessors: false) #: void
       @klass = klass
       @klass_name = klass.name || ""
       @model = Model.new(klass)
+      @pure_accessors = pure_accessors
     end
 
     def generate #: String  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -22,7 +25,7 @@ module RbsActiverecord
         # resolve-type-names: false
 
         #{header}
-          #{Attributes.new(model).generate}
+          #{Attributes.new(model, pure_accessors:).generate}
           #{Associations.new(model).generate}
 
           #{ActiveStorage::InstanceMethods.new(model).generate}

data/lib/rbs_activerecord/model.rb

@@ -14,6 +14,7 @@ module RbsActiverecord
     #   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)
@@ -27,7 +28,7 @@ module RbsActiverecord
 
     def parents #: Array[singleton(ActiveRecord::Base)]
       ancestors = klass.ancestors #: Array[singleton(ActiveRecord::Base)]
-      ancestors.select { |cls| cls < ActiveRecord::Base && cls != klass && !cls.abstract_class? }
+      ancestors.select { _1 < ActiveRecord::Base && _1 != klass && !_1.abstract_class? }
     end
   end
 end

data/lib/rbs_activerecord/parser/evaluator.rb

@@ -4,7 +4,7 @@ module RbsActiverecord
   module Parser
     module Evaluator
       # @rbs node: Prism::Node
-      def eval_node(node) #: untyped # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def eval_node(node) #: untyped # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         case node
         when Prism::NilNode
           nil
@@ -19,8 +19,8 @@ module RbsActiverecord
         when Prism::StringNode
           node.unescaped
         when Prism::ArrayNode
-          node.elements.map { |e| eval_node(e) }
-        when Prism::HashNode
+          node.elements.map { eval_node(_1) }
+        when Prism::HashNode, Prism::KeywordHashNode
           node.elements.filter_map do |assoc|
             case assoc
             when Prism::AssocNode
@@ -34,15 +34,6 @@ module RbsActiverecord
         when Prism::ConstantPathNode
           parent = node.parent ? eval_node(node.parent) : nil
           "#{parent}::#{node.name}"
-        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

data/lib/rbs_activerecord/parser/include_expander/module.rb

@@ -21,7 +21,7 @@ module RbsActiverecord
         def included_blocks #: Array[Prism::CallNode]
           return [] unless concern?
 
-          declarations.select { |node| node.name == :included }
+          declarations.select { _1.name == :included }
         end
 
         private
@@ -31,10 +31,12 @@ module RbsActiverecord
         def declarations #: Array[Prism::CallNode]
           @declarations ||= begin
             path = source_location
-            return [] unless path && File.exist?(path)
-
-            declarations = Parser.parse_file(path)
-            declarations.fetch(name, [])
+            if path && File.exist?(path)
+              declarations = Parser.parse_file(path)
+              declarations.fetch(name, [])
+            else
+              []
+            end
           end
         end
 

data/lib/rbs_activerecord/parser/include_expander.rb

@@ -22,7 +22,7 @@ module RbsActiverecord
       def expand #: void
         declarations.each_value do |decls|
           loop do
-            index = decls.index { |node| node.name == :include }
+            index = decls.index { _1.name == :include }
             break unless index
 
             included_module = decls.delete_at(index) || raise
@@ -39,8 +39,8 @@ module RbsActiverecord
       # @rbs node: Prism::CallNode
       def included_blocks_for(node) #: Array[Prism::CallNode]
         modules = node.arguments&.arguments.to_a
-                      .map { |arg| Parser.eval_node(arg) }
-                      .select { |mod| mod.is_a?(String) }
+                      .map { Parser.eval_node(_1) }
+                      .grep(String)
         modules.flat_map do |modname|
           mod = const_get(modname)
           next [] unless mod
@@ -69,7 +69,7 @@ module RbsActiverecord
           case node.block.body
           when Prism::StatementsNode
             body = node.block.body.body #: Array[Prism::CallNode]
-            body.select { |n| n.is_a?(Prism::CallNode) }
+            body.grep(Prism::CallNode)
           else
             []
           end

data/lib/rbs_activerecord/parser/visitor.rb

@@ -14,7 +14,7 @@ module RbsActiverecord
       end
 
       def current_namespace #: String
-        context.map { |node| Parser.eval_node(node.constant_path) }.join("::")
+        context.map { Parser.eval_node(_1.constant_path) }.join("::")
       end
 
       # @rbs override

data/lib/rbs_activerecord/parser.rb

@@ -14,8 +14,9 @@ module RbsActiverecord
     end
     module_function :parse
 
+    # @rbs filename: String
     def parse_file(filename) #: Hash[String, Array[Prism::CallNode]]
-      File.open(filename) { |f| parse(f.read) }
+      File.open(filename) { parse(_1.read) }
     end
     module_function :parse_file
 

data/lib/rbs_activerecord/rake_task.rb

@@ -4,14 +4,17 @@ require "rake/tasklib"
 
 module RbsActiverecord
   class RakeTask < Rake::TaskLib
-    attr_accessor :name, :signature_root_dir
+    attr_accessor :name #: Symbol
+    attr_accessor :pure_accessors #: bool
+    attr_accessor :signature_root_dir #: Pathname
 
     # @rbs name: Symbol
     # @rbs &block: (RakeTask) -> void
-    def initialize(name = :'rbs:activerecord', &block) #: void
+    def initialize(name = :"rbs:activerecord", &block) #: void
       super()
 
       @name = name
+      @pure_accessors = false
       @signature_root_dir = Rails.root / "sig/activerecord"
 
       block&.call(self)
@@ -48,7 +51,7 @@ module RbsActiverecord
           next if klass.abstract_class?
           next unless klass.connection.table_exists?(klass.table_name)
 
-          rbs = Generator.new(klass).generate
+          rbs = Generator.new(klass, pure_accessors:).generate
 
           path = signature_root_dir / "app/models/#{klass.name.underscore}.rbs"
           path.dirname.mkpath

data/lib/rbs_activerecord/utils.rb

@@ -8,11 +8,11 @@ module RbsActiverecord
     def format(str) #: String
       parsed = RBS::Parser.parse_signature(str)
       StringIO.new.tap do |out|
-        RBS::Writer.new(out: out).write(parsed[1] + parsed[2])
+        RBS::Writer.new(out:).write(parsed[1] + parsed[2])
       end.string
     end
 
-    # @rbs klass_name: singleton(Object)
+    # @rbs klass: singleton(Object)
     def klass_to_names(klass) #: Array[RBS::TypeName]
       type_name = RBS::TypeName.parse("::#{klass.name}")
 
@@ -26,22 +26,22 @@ module RbsActiverecord
     end
 
     # @rbs klass: singleton(ActiveRecord::Base)
-    def primary_key_type_for(klass) #: String  # rubocop:disable Metrics/AbcSize
+    def primary_key_type_for(klass) #: String
       case klass.primary_key
       when Array
         primary_keys = klass.primary_key.map(&:to_s)
         types = klass.columns
-                     .select { |column| primary_keys.include?(column.name) }
-                     .map { |pk| sql_type_to_class(pk.type) }
+                     .select { primary_keys.include?(_1.name) }
+                     .map { sql_type_to_class(_1.type) }
         "[#{types.join(" | ")}]"
       else
-        primary_key = klass.columns.find { |column| column.name == klass.primary_key }
+        primary_key = klass.columns.find { _1.name == klass.primary_key }
         sql_type_to_class(primary_key.type)
       end
     end
 
     # @rbs type: Symbol
-    def sql_type_to_class(type) #: String  # rubocop:disable Metris/CyclomaticComplexity
+    def sql_type_to_class(type) #: String  # rubocop:disable Metrics/CyclomaticComplexity
       case type
       when :integer
         "::Integer"
@@ -63,7 +63,7 @@ module RbsActiverecord
         "untyped"
       when :inet
         "::IPAddr"
-      else
+      else # rubocop:disable Lint/DuplicateBranch
         "untyped"
       end
     end

data/lib/rbs_activerecord/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbsActiverecord
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
 end