rbs_rails 0.3.0 → 0.7.0

data/bin/rbs-prototype-rb.rb

@@ -17,7 +17,7 @@ using Module.new {
       end
     end
 
-    def process_class_methods(node, decls:, comments:, singleton:)
+    def process_class_methods(node, decls:, comments:, context:)
       return false unless node.type == :ITER
 
       fcall = node.children[0]
@@ -37,13 +37,13 @@ using Module.new {
       decls.push mod
 
       each_node [node.children[1]] do |child|
-        process child, decls: mod.members, comments: comments, singleton: false
+        process child, decls: mod.members, comments: comments, context: RBS::Prototype::RB::Context.initial
       end
 
       true
     end
 
-    def process_struct_new(node, decls:, comments:, singleton:)
+    def process_struct_new(node, decls:, comments:, context:)
       return unless node.type == :CDECL
 
       name, *_, rhs = node.children
@@ -68,6 +68,7 @@ using Module.new {
           kls.members << RBS::AST::Members::AttrAccessor.new(
             name: f.children.first,
             type: untyped,
+            kind: :instance,
             ivar_name: false,
             annotations: [],
             location: nil,
@@ -78,13 +79,65 @@ using Module.new {
 
       if body
         each_node [body] do |child|
-          process child, decls: kls.members, comments: comments, singleton: false
+          process child, decls: kls.members, comments: comments, context: RBS::Prototype::RB::Context.initial
         end
       end
 
       true
     end
 
+    def process_attr_internal(node, decls:, comments:, context:)
+      case node.type
+      when :FCALL, :VCALL
+        args = node.children[1]&.children || []
+
+        case node.children[0]
+        when :attr_internal_reader
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrReader.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        when :attr_internal_writer
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrWriter.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        when :attr_internal_accessor, :attr_internal
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrAccessor.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        end
+      end
+    end
+
     def class_new_method_to_type(node)
       case node.type
       when :CALL
@@ -122,14 +175,14 @@ using Module.new {
 
     def struct_as_superclass
       name = RBS::TypeName.new(name: 'Struct', namespace: RBS::Namespace.root)
-      RBS::AST::Declarations::Class::Super.new(name: name, args: ['untyped'])
+      RBS::AST::Declarations::Class::Super.new(name: name, args: ['untyped'], location: nil)
     end
   end
 }
 
 module PrototypeExt
   def process(...)
-    process_class_methods(...) || process_struct_new(...) || super
+    process_class_methods(...) || process_struct_new(...) || process_attr_internal(...) || super
   end
 
   def literal_to_type(node)

data/lib/rbs_rails.rb

@@ -1,8 +1,12 @@
 require 'parser/current'
+require 'rbs'
+require 'stringio'
 
 require_relative "rbs_rails/version"
+require_relative "rbs_rails/util"
 require_relative 'rbs_rails/active_record'
 require_relative 'rbs_rails/path_helpers'
+require_relative 'rbs_rails/dependency_builder'
 
 module RbsRails
   class Error < StandardError; end

data/lib/rbs_rails/active_record.rb

@@ -1,59 +1,84 @@
 module RbsRails
   module ActiveRecord
-    def self.class_to_rbs(klass)
-      Generator.new(klass).generate
+
+    def self.class_to_rbs(klass, dependencies: [])
+      Generator.new(klass, dependencies: dependencies).generate
     end
 
     class Generator
-      def initialize(klass)
+      def initialize(klass, dependencies:)
         @klass = klass
+        @dependencies = dependencies
+        @klass_name = Util.module_name(klass)
+
+        namespaces = klass_name.split('::').tap{ |names| names.pop }
+        @dependencies << namespaces.join('::') unless namespaces.empty?
       end
 
       def generate
-        [
-          klass_decl,
-          relation_decl,
-          collection_proxy_decl,
-        ].join("\n")
+        Util.format_rbs klass_decl
       end
 
       private def klass_decl
         <<~RBS
           #{header}
-            extend _ActiveRecord_Relation_ClassMethods[#{klass.name}, #{relation_class_name}]
+            extend _ActiveRecord_Relation_ClassMethods[#{klass_name}, #{relation_class_name}]
 
-          #{columns.indent(2)}
-          #{associations.indent(2)}
-          #{enum_instance_methods.indent(2)}
-          #{enum_scope_methods(singleton: true).indent(2)}
-          #{scopes(singleton: true).indent(2)}
-          end
+          #{columns}
+          #{associations}
+          #{enum_instance_methods}
+          #{enum_scope_methods(singleton: true)}
+          #{scopes(singleton: true)}
+
+          #{relation_decl}
+
+          #{collection_proxy_decl}
+
+          #{footer}
         RBS
       end
 
       private def relation_decl
         <<~RBS
           class #{relation_class_name} < ActiveRecord::Relation
-            include _ActiveRecord_Relation[#{klass.name}]
-            include Enumerable[#{klass.name}, self]
-          #{enum_scope_methods(singleton: false).indent(2)}
-          #{scopes(singleton: false).indent(2)}
+            include _ActiveRecord_Relation[#{klass_name}]
+            include Enumerable[#{klass_name}]
+          #{enum_scope_methods(singleton: false)}
+          #{scopes(singleton: false)}
           end
         RBS
       end
 
       private def collection_proxy_decl
         <<~RBS
-          class #{klass.name}::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
+          class ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
           end
         RBS
       end
 
-
       private def header
-        # @type var superclass: Class
-        superclass = _ = klass.superclass
-        "class #{klass.name} < #{superclass.name}"
+        namespace = +''
+        klass_name.split('::').map do |mod_name|
+          namespace += "::#{mod_name}"
+          mod_object = Object.const_get(namespace)
+          case mod_object
+          when Class
+            # @type var superclass: Class
+            superclass = _ = mod_object.superclass
+            superclass_name = Util.module_name(superclass)
+            @dependencies << superclass_name
+
+            "class #{mod_name} < #{superclass_name}"
+          when Module
+            "module #{mod_name}"
+          else
+            raise 'unreachable'
+          end
+        end.join("\n")
+      end
+
+      private def footer
+        "end\n" * klass_name.split('::').size
       end
 
       private def associations
@@ -66,21 +91,45 @@ module RbsRails
 
       private def has_many
         klass.reflect_on_all_associations(:has_many).map do |a|
-          "def #{a.name}: () -> #{a.klass.name}::ActiveRecord_Associations_CollectionProxy"
+          singular_name = a.name.to_s.singularize
+          type = Util.module_name(a.klass)
+          collection_type = "#{type}::ActiveRecord_Associations_CollectionProxy"
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{collection_type}
+            def #{a.name}=: (#{collection_type} | Array[#{type}]) -> (#{collection_type} | Array[#{type}])
+            def #{singular_name}_ids: () -> Array[Integer]
+            def #{singular_name}_ids=: (Array[Integer]) -> Array[Integer]
+          RUBY
         end.join("\n")
       end
 
       private def has_one
         klass.reflect_on_all_associations(:has_one).map do |a|
-          type = a.polymorphic? ? 'untyped' : a.klass.name
-          "def #{a.name}: () -> #{type}"
+          type = a.polymorphic? ? 'untyped' : Util.module_name(a.klass)
+          type_optional = optional(type)
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{type}
+            def #{a.name}=: (#{type_optional}) -> #{type_optional}
+            def build_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}!: (untyped) -> #{type}
+            def reload_#{a.name}: () -> #{type_optional}
+          RUBY
         end.join("\n")
       end
 
       private def belongs_to
         klass.reflect_on_all_associations(:belongs_to).map do |a|
-          type = a.polymorphic? ? 'untyped' : a.klass.name
-          "def #{a.name}: () -> #{type}"
+          type = a.polymorphic? ? 'untyped' : Util.module_name(a.klass)
+          type_optional = optional(type)
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{type}
+            def #{a.name}=: (#{type_optional}) -> #{type_optional}
+            def build_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}!: (untyped) -> #{type}
+            def reload_#{a.name}: () -> #{type_optional}
+          RUBY
         end.join("\n")
       end
 
@@ -130,6 +179,7 @@ module RbsRails
         return [] unless ast
 
         traverse(ast).map do |node|
+          # @type block: nil | Hash[untyped, untyped]
           next unless node.type == :send
           next unless node.children[0].nil?
           next unless node.children[1] == :enum
@@ -168,6 +218,7 @@ module RbsRails
         return '' unless ast
 
         traverse(ast).map do |node|
+          # @type block: nil | String
           next unless node.type == :send
           next unless node.children[0].nil?
           next unless node.children[1] == :scope
@@ -209,10 +260,7 @@ module RbsRails
       private def parse_model_file
         return @parse_model_file if defined?(@parse_model_file)
 
-
-        # @type var class_name: String
-        class_name = _ = klass.name
-        path = Rails.root.join('app/models/', class_name.underscore + '.rb')
+        path = Rails.root.join('app/models/', klass_name.underscore + '.rb')
         return @parse_model_file = nil unless path.exist?
         return [] unless path.exist?
 
@@ -233,12 +281,16 @@ module RbsRails
       end
 
       private def relation_class_name
-        "#{klass.name}::ActiveRecord_Relation"
+        "ActiveRecord_Relation"
       end
 
       private def columns
         klass.columns.map do |col|
-          class_name = sql_type_to_class(col.type)
+          class_name = if enum_definitions.any? { |hash| hash.key?(col.name) || hash.key?(col.name.to_sym) }
+                         'String'
+                       else
+                         sql_type_to_class(col.type)
+                       end
           class_name_opt = optional(class_name)
           column_type = col.null ? class_name_opt : class_name
           sig = <<~EOS
@@ -265,35 +317,33 @@ module RbsRails
       private def sql_type_to_class(t)
         case t
         when :integer
-          Integer.name
+          'Integer'
         when :float
-          Float.name
-        when :string, :text, :uuid, :binary
-          String.name
+          'Float'
+        when :decimal
+          'BigDecimal'
+        when :string, :text, :citext, :uuid, :binary
+          'String'
         when :datetime
-          # TODO
-          # ActiveSupport::TimeWithZone.name
-          Time.name
+          'ActiveSupport::TimeWithZone'
         when :boolean
-          "TrueClass | FalseClass"
+          "bool"
         when :jsonb, :json
           "untyped"
         when :date
-          # TODO
-          # Date.name
-          'untyped'
+          'Date'
         when :time
-          Time.name
+          'Time'
         when :inet
           "IPAddr"
         else
-          raise "unexpected: #{t.inspect}"
+          # Unknown column type, give up
+          'untyped'
         end
       end
 
       private
-      # @dynamic klass
-      attr_reader :klass
+      attr_reader :klass, :klass_name
     end
   end
 end

data/lib/rbs_rails/dependency_builder.rb

@@ -0,0 +1,43 @@
+module RbsRails
+  class DependencyBuilder
+    attr_reader :deps
+
+    def initialize
+      @deps = []
+    end
+
+    def build
+      dep_rbs = +""
+      done = Set.new(['ActiveRecord::Base', 'ActiveRecord', 'Object'])
+      deps.uniq!
+      while dep = deps.shift
+        next unless done.add?(dep)
+
+        case dep_object = Object.const_get(dep)
+        when Class
+          superclass = dep_object.superclass or raise
+          super_name = Util.module_name(superclass)
+          deps << super_name
+          dep_rbs << "class #{dep} < #{super_name} end\n"
+        when Module
+          dep_rbs << "module #{dep} end\n"
+        else
+          raise
+        end
+
+        # push namespaces
+        namespaces = dep.split('::')
+        namespaces.pop
+        namespaces.inject('') do |base, name|
+          full_name = base.empty? ? name : [base, name].join('::')
+          deps << full_name
+          full_name
+        end
+      end
+
+      unless dep_rbs.empty?
+        Util.format_rbs(dep_rbs)
+      end
+    end
+  end
+end

data/lib/rbs_rails/rake_task.rb

@@ -0,0 +1,83 @@
+require 'rake'
+require 'rake/tasklib'
+
+module RbsRails
+  class RakeTask < Rake::TaskLib
+    attr_accessor :ignore_model_if, :name, :signature_root_dir
+
+    def initialize(name = :rbs_rails, &block)
+      super()
+
+      @name = name
+
+      block.call(self) if block
+
+      setup_signature_root_dir!
+
+      def_copy_signature_files
+      def_generate_rbs_for_models
+      def_generate_rbs_for_path_helpers
+      def_all
+    end
+
+    def def_all
+      desc 'Run all tasks of rbs_rails'
+
+      deps = [:"#{name}:copy_signature_files", :"#{name}:generate_rbs_for_models", :"#{name}:generate_rbs_for_path_helpers"]
+      task("#{name}:all": deps)
+    end
+
+    def def_copy_signature_files
+      desc 'Copy RBS files for rbs_rails'
+      task("#{name}:copy_signature_files": :environment) do
+        require 'rbs_rails'
+
+        RbsRails.copy_signatures(to: signature_root_dir)
+      end
+    end
+
+    def def_generate_rbs_for_models
+      desc 'Generate RBS files for Active Record models'
+      task("#{name}:generate_rbs_for_models": :environment) do
+        require 'rbs_rails'
+
+        Rails.application.eager_load!
+
+        dep_builder = DependencyBuilder.new
+        
+        # HACK: for steep
+        (_ = ::ActiveRecord::Base).descendants.each do |klass|
+          next if klass.abstract_class?
+          next if ignore_model_if&.call(klass)
+
+          path = signature_root_dir / "app/models/#{klass.name.underscore}.rbs"
+          path.dirname.mkpath
+
+          sig = RbsRails::ActiveRecord.class_to_rbs(klass, dependencies: dep_builder.deps)
+          path.write sig
+        end
+
+        if dep_rbs = dep_builder.build
+          signature_root_dir.join('model_dependencies.rbs').write(dep_rbs)
+        end
+      end
+    end
+
+    def def_generate_rbs_for_path_helpers
+      desc 'Generate RBS files for path helpers'
+      task("#{name}:generate_rbs_for_path_helpers": :environment) do
+        require 'rbs_rails'
+
+        out_path = signature_root_dir.join 'path_helpers.rbs'
+        rbs = RbsRails::PathHelpers.generate
+        out_path.write rbs
+      end
+    end
+
+    private def setup_signature_root_dir!
+      @signature_root_dir ||= Rails.root / 'sig/rbs_rails'
+      @signature_root_dir = Pathname(@signature_root_dir)
+      @signature_root_dir.mkpath
+    end
+  end
+end