rbs_rails 0.4.0 → 0.8.0

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
@@ -67,7 +92,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 +105,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 +120,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}
@@ -154,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
@@ -192,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
@@ -206,37 +233,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?
 
@@ -257,7 +289,7 @@ module RbsRails
       end
 
       private def relation_class_name
-        "#{klass.name}::ActiveRecord_Relation"
+        "ActiveRecord_Relation"
       end
 
       private def columns
@@ -301,29 +333,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,73 @@
+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
+        
+        # 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

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.4.0"
+  VERSION = "0.8.0"
 end

data/rbs_rails.gemspec

@@ -14,16 +14,17 @@ 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.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|gem_rbs)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'parser'
+  spec.add_runtime_dependency 'rbs', '>= 1'
 end

data/sig/fileutils.rbs

@@ -1,3 +1,4 @@
 module FileUtils
   def self.cp_r: (Pathname, Pathname) -> untyped
+  def self.mkdir_p: (String | Array[String], ?untyped) -> Array[String]
 end

data/sig/rake.rbs

@@ -0,0 +1,6 @@
+module Rake
+  class TaskLib
+    def desc: (String) -> void
+    def task: (Hash[Symbol, Symbol | Array[Symbol]]) ?{ () -> void } -> void
+  end
+end

data/sig/rbs_rails/active_record.rbs

@@ -1,11 +1,11 @@
 module RbsRails::ActiveRecord
-  def self.class_to_rbs: (untyped klass) -> untyped
+  def self.class_to_rbs: (untyped klass, ?dependencies: Array[String]) -> untyped
 end
 
 class RbsRails::ActiveRecord::Generator
   @parse_model_file: nil | Parser::AST::Node
 
-  def initialize: (singleton(ActiveRecord::Base) klass) -> untyped
+  def initialize: (singleton(ActiveRecord::Base) klass, dependencies: Array[String]) -> untyped
 
   def generate: () -> String
 
@@ -17,6 +17,8 @@ class RbsRails::ActiveRecord::Generator
 
   def header: () -> String
 
+  def footer: () -> String
+
   def associations: () -> String
 
   def has_many: () -> String
@@ -55,5 +57,9 @@ class RbsRails::ActiveRecord::Generator
 
   def optional: (String) -> String
 
+  private
+
   attr_reader klass: singleton(ActiveRecord::Base)
+
+  attr_reader klass_name: String
 end