rbs_rails 0.5.0 → 0.8.2

data/bin/setup

@@ -4,5 +4,6 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
+bin/gem_rbs
 
 # Do any other automated setup that you need to do here

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,97 @@
 module RbsRails
   module ActiveRecord
-    def self.class_to_rbs(klass)
-      Generator.new(klass).generate
+
+    def self.generatable?(klass)
+      return false if klass.abstract_class?
+
+      klass.connection.table_exists?(klass.table_name)
+    end
+
+    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}, #{pk_type}]
 
-          #{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 pk_type
+        pk = klass.primary_key
+        col = klass.columns.find {|col| col.name == pk }
+        sql_type_to_class(col.type)
+      end
+
       private def relation_decl
         <<~RBS
           class #{relation_class_name} < ActiveRecord::Relation
-            include _ActiveRecord_Relation[#{klass.name}]
-            include Enumerable[#{klass.name}]
-          #{enum_scope_methods(singleton: false).indent(2)}
-          #{scopes(singleton: false).indent(2)}
+            include _ActiveRecord_Relation[#{klass_name}, #{pk_type}]
+            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
@@ -67,7 +105,7 @@ module RbsRails
       private def has_many
         klass.reflect_on_all_associations(:has_many).map do |a|
           singular_name = a.name.to_s.singularize
-          type = a.klass.name
+          type = Util.module_name(a.klass)
           collection_type = "#{type}::ActiveRecord_Associations_CollectionProxy"
           <<~RUBY.chomp
             def #{a.name}: () -> #{collection_type}
@@ -80,7 +118,7 @@ module RbsRails
 
       private def has_one
         klass.reflect_on_all_associations(:has_one).map do |a|
-          type = a.polymorphic? ? 'untyped' : a.klass.name
+          type = a.polymorphic? ? 'untyped' : Util.module_name(a.klass)
           type_optional = optional(type)
           <<~RUBY.chomp
             def #{a.name}: () -> #{type}
@@ -95,7 +133,7 @@ module RbsRails
 
       private def belongs_to
         klass.reflect_on_all_associations(:belongs_to).map do |a|
-          type = a.polymorphic? ? 'untyped' : a.klass.name
+          type = a.polymorphic? ? 'untyped' : Util.module_name(a.klass)
           type_optional = optional(type)
           <<~RUBY.chomp
             def #{a.name}: () -> #{type}
@@ -208,37 +246,42 @@ module RbsRails
           next unless body_node.type == :block
 
           args = args_to_type(body_node.children[1])
-          "def #{singleton ? 'self.' : ''}#{name}: (#{args}) -> #{relation_class_name}"
+          "def #{singleton ? 'self.' : ''}#{name}: #{args} -> #{relation_class_name}"
         end.compact.join("\n")
       end
 
       private def args_to_type(args_node)
         # @type var res: Array[String]
         res = []
+        # @type var block: String?
+        block = nil
         args_node.children.each do |node|
           case node.type
           when :arg
-            res << "untyped"
+            res << "untyped #{node.children[0]}"
           when :optarg
-            res << "?untyped"
+            res << "?untyped #{node.children[0]}"
           when :kwarg
             res << "#{node.children[0]}: untyped"
           when :kwoptarg
             res << "?#{node.children[0]}: untyped"
+          when :restarg
+            res << "*untyped #{node.children[0]}"
+          when :kwrestarg
+            res << "**untyped #{node.children[0]}"
+          when :blockarg
+            block = " { (*untyped) -> untyped }"
           else
             raise "unexpected: #{node}"
           end
         end
-        res.join(", ")
+        "(#{res.join(", ")})#{block}"
       end
 
       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?
 
@@ -259,7 +302,7 @@ module RbsRails
       end
 
       private def relation_class_name
-        "#{klass.name}::ActiveRecord_Relation"
+        "ActiveRecord_Relation"
       end
 
       private def columns
@@ -280,6 +323,12 @@ module RbsRails
             def #{col.name}_previously_changed?: () -> bool
             def #{col.name}_previous_change: () -> Array[#{class_name_opt}]?
             def #{col.name}_previously_was: () -> #{class_name_opt}
+            def #{col.name}_before_last_save: () -> #{class_name_opt}
+            def #{col.name}_change_to_be_saved: () -> Array[#{class_name_opt}]?
+            def #{col.name}_in_database: () -> #{class_name_opt}
+            def saved_change_to_#{col.name}: () -> Array[#{class_name_opt}]?
+            def saved_change_to_#{col.name}?: () -> bool
+            def will_save_change_to_#{col.name}?: () -> bool
             def restore_#{col.name}!: () -> void
             def clear_#{col.name}_change: () -> void
           EOS
@@ -303,29 +352,25 @@ module RbsRails
         when :string, :text, :citext, :uuid, :binary
           'String'
         when :datetime
-          # TODO
-          # ActiveSupport::TimeWithZone.name
-          'Time'
+          'ActiveSupport::TimeWithZone'
         when :boolean
-          "TrueClass | FalseClass"
+          "bool"
         when :jsonb, :json
           "untyped"
         when :date
-          # TODO
-          # Date.name
-          'untyped'
+          'Date'
         when :time
           '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,72 @@
+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_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}:generate_rbs_for_models", :"#{name}:generate_rbs_for_path_helpers"]
+      task("#{name}:all": deps)
+    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
+        
+        ::ActiveRecord::Base.descendants.each do |klass|
+          next unless RbsRails::ActiveRecord.generatable?(klass)
+          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

data/lib/rbs_rails/util.rb

@@ -0,0 +1,25 @@
+module RbsRails
+  module Util
+    MODULE_NAME = Module.instance_method(:name)
+
+    extend self
+
+    if '2.7' <= RUBY_VERSION
+      def module_name(mod)
+        # HACK: RBS doesn't have UnboundMethod#bind_call
+        (_ = MODULE_NAME).bind_call(mod)
+      end
+    else
+      def module_name(mod)
+        MODULE_NAME.bind(mod).call
+      end
+    end
+
+    def format_rbs(rbs)
+      decls = RBS::Parser.parse_signature(rbs)
+      StringIO.new.tap do |io|
+        RBS::Writer.new(out: io).write(decls)
+      end.string
+    end
+  end
+end

data/lib/rbs_rails/version.rb

@@ -2,5 +2,5 @@ module RbsRails
   # Because of copy_signatures is defined by lib/rbs_rails.rb
   # @dynamic self.copy_signatures
 
-  VERSION = "0.5.0"
+  VERSION = "0.8.2"
 end

data/rbs_rails.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["changelog_uri"] = "https://github.com/pocke/rbs_rails/blob/master/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -26,5 +26,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'parser'
-  spec.add_runtime_dependency 'rbs', '>= 0.17'
+  spec.add_runtime_dependency 'rbs', '>= 1'
 end

data/sig/activerecord.rbs

@@ -0,0 +1,4 @@
+# TODO: Define it in gem_rbs_collection repository
+class ActiveRecord::Base
+  def self.primary_key: () -> String
+end