rbs_rails 0.12.0 → 0.13.0

data/lib/rbs_rails/cli/configuration.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'singleton'
+
+module RbsRails
+  class CLI
+    class Configuration
+      include Singleton
+
+      # @rbs!
+      #   def self.instance: () -> Configuration
+      #   def self.configure: () { (Configuration) -> void } -> void
+
+      class << self
+        extend Forwardable
+
+        def_delegator :instance, :configure  # steep:ignore
+      end
+
+      # @rbs!
+      #   @signature_root_dir: Pathname?
+      #   @ignore_model_if: (^(singleton(ActiveRecord::Base)) -> bool)?
+
+      attr_reader :check_db_migrations  #: bool
+
+      def initialize #: void
+        @signature_root_dir = nil
+        @ignore_model_if = nil
+        @check_db_migrations = true
+      end
+
+      # @rbs &block: (Configuration) -> void
+      def configure(&block) #: void
+        block.call(self)
+      end
+
+      def signature_root_dir #: Pathname
+        @signature_root_dir || Rails.root.join("sig/rbs_rails")
+      end
+
+      # @rbs dir: String | Pathname
+      def signature_root_dir=(dir) #: Pathname
+        @signature_root_dir = case dir
+                            when String
+                              Pathname.new(dir)
+                            when Pathname
+                              dir
+                            else
+                              raise ArgumentError, "signature_root_dir must be String or Pathname"
+                            end
+      end
+
+      # @rbs &block: (singleton(ActiveRecord::Base)) -> bool
+      def ignore_model_if(&block) #: void
+        @ignore_model_if = block
+      end
+
+      # @rbs klass: singleton(ActiveRecord::Base)
+      def ignored_model?(klass) #: bool
+        ignore_model_if = @ignore_model_if
+        return false unless ignore_model_if
+
+        ignore_model_if.call(klass)
+      end
+    end
+  end
+end

data/lib/rbs_rails/cli.rb

@@ -0,0 +1,173 @@
+require "optparse"
+require "rbs_rails/cli/configuration"
+
+module RbsRails
+  # @rbs &block: (CLI::Configuration) -> void
+  def self.configure(&block) #: void
+    CLI::Configuration.configure(&block)
+  end
+
+  class CLI
+    attr_reader :config_file #: String?
+
+    # @rbs argv: Array[String]
+    def run(argv) #: Integer
+      parser = create_option_parser
+
+      begin
+        args = parser.parse(argv)
+        subcommand = args.shift || "help"
+
+        case subcommand
+        when "help"
+          $stdout.puts parser.help
+          0
+        when "version"
+          $stdout.puts "rbs_rails #{RbsRails::VERSION}"
+          0
+        when "all"
+          load_application
+          load_config
+          generate_models
+          generate_path_helpers
+          0
+        when "models"
+          load_application
+          load_config
+          generate_models
+          0
+        when "path_helpers"
+          load_application
+          load_config
+          generate_path_helpers
+          0
+        else
+          $stdout.puts "Unknown command: #{subcommand}"
+          $stdout.puts parser.help
+          1
+        end
+      rescue OptionParser::InvalidOption => e
+        $stderr.puts "Error: #{e.message}"
+        $stdout.puts parser.help
+        1
+      end
+    rescue StandardError => e
+      $stderr.puts "Error: #{e.message}"
+      1
+    end
+
+    private
+
+    def config #: Configuration
+      Configuration.instance
+    end
+
+    def load_config #: void
+      if config_file
+        load config_file
+      else
+        if File.exist?(".rbs_rails.rb")
+          load ".rbs_rails.rb"
+        elsif Rails.root.join("config/rbs_rails.rb").exist?
+          load Rails.root.join("config/rbs_rails.rb").to_s
+        end
+      end
+    end
+
+    def load_application #: void
+      require_relative "#{Dir.getwd}/config/application"
+
+      install_hooks
+
+      Rails.application.initialize!
+    rescue LoadError => e
+      raise "Failed to load Rails application: #{e.message}"
+    end
+
+    def install_hooks #: void
+      # Load inspectors.  This is necessary to load earlier than Rails application.
+      require 'rbs_rails/active_record/enum'
+    end
+
+    def generate_models #: void
+      check_db_migrations!
+      Rails.application.eager_load!
+
+      ::ActiveRecord::Base.descendants.each do |klass|
+        generate_single_model(klass)
+      rescue => e
+        puts "Error generating RBS for #{klass.name} model"
+        raise e
+      end
+    end
+
+    # Raise an error if database is not migrated to the latest version
+    def check_db_migrations! #: void
+      return unless config.check_db_migrations
+
+      if ::ActiveRecord::Migration.respond_to? :check_all_pending!
+        # Rails 7.1 or later
+        ::ActiveRecord::Migration.check_all_pending!  # steep:ignore NoMethod
+      else
+        ::ActiveRecord::Migration.check_pending!
+      end
+    end
+
+    # @rbs klass: singleton(ActiveRecord::Base)
+    def generate_single_model(klass) #: bool
+      return false if config.ignored_model?(klass)
+      return false unless RbsRails::ActiveRecord.generatable?(klass)
+
+      original_path, _line = Object.const_source_location(klass.name) rescue nil
+
+      rbs_relative_path = if original_path && Pathname.new(original_path).fnmatch?("#{Rails.root}/**")
+                            Pathname.new(original_path)
+                                    .relative_path_from(Rails.root)
+                                    .sub_ext('.rbs')
+                          else
+                            "app/models/#{klass.name.underscore}.rbs"
+                          end
+
+      path = config.signature_root_dir / rbs_relative_path
+      path.dirname.mkpath
+
+      sig = RbsRails::ActiveRecord.class_to_rbs(klass)
+      Util::FileWriter.new(path).write sig
+
+      true
+    end
+
+    def generate_path_helpers #: void
+      path = config.signature_root_dir.join 'path_helpers.rbs'
+      path.dirname.mkpath
+
+      sig = RbsRails::PathHelpers.generate
+      Util::FileWriter.new(path).write sig
+    end
+
+    def create_option_parser #: OptionParser
+      OptionParser.new do |opts|
+        opts.banner = <<~BANNER
+          Usage: rbs_rails [command] [options]
+
+          Commands:
+                  help           Show this help message
+                  version        Show version
+                  all            Generate all RBS files
+                  models         Generate RBS files for models
+                  path_helpers   Generate RBS for Rails path helpers
+
+          Options:
+        BANNER
+
+        opts.on("--signature-root-dir=DIR", "Specify the root directory for RBS signatures") do |dir|
+          config.signature_root_dir = Pathname.new(dir)
+        end
+
+        opts.on("--config=FILE", "Load configuration from FILE") do |file|
+          @config_file = file
+        end
+      end
+    end
+  end
+end

data/lib/rbs_rails/dependency_builder.rb

@@ -1,26 +1,43 @@
 module RbsRails
   class DependencyBuilder
-    attr_reader :deps, :done
+    attr_reader :deps #: Array[String]
+    attr_reader :done #: Set[String]
 
-    def initialize
+    def initialize #: void
       @deps = []
-      @done = Set.new(['ActiveRecord::Base', 'ActiveRecord', 'Object'])
+      @done = Set.new([
+        'ActiveRecord',
+        'ActiveRecord::Associations',
+        'ActiveRecord::Associations::CollectionProxy',
+        'ActiveRecord::Base',
+        'ActiveRecord::Relation',
+        'ActiveStorage',
+        'ActiveStorage::Attachment',
+        'ActiveStorage::Blob',
+        'ActiveStorage::Record',
+        'Object'
+      ])
     end
 
-    def build
+    # @rbs name: String
+    def <<(name) #: Array[String]
+      deps << name
+    end
+
+    def build #: String | nil
       dep_rbs = +""
       deps.uniq!
-      while dep = deps.shift
+      while dep = 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)
+          super_name = Util.module_name(superclass, abs: false)
           deps << super_name
-          dep_rbs << "class #{dep} < #{super_name} end\n"
+          dep_rbs << "class ::#{dep} < ::#{super_name} end\n"
         when Module
-          dep_rbs << "module #{dep} end\n"
+          dep_rbs << "module ::#{dep} end\n"
         else
           raise
         end
@@ -39,5 +56,9 @@ module RbsRails
         Util.format_rbs(dep_rbs)
       end
     end
+
+    private def shift #: String | nil
+      deps.shift&.sub(/^::/, '')
+    end
   end
 end

data/lib/rbs_rails/path_helpers.rb

@@ -1,6 +1,10 @@
 module RbsRails
   class PathHelpers
     def self.generate(routes: Rails.application.routes)
+      # Since Rails 8.0, route drawing has been deferred to the first request.
+      # This forcedly loads routes before generating path_helpers.
+      Rails.application.routes.eager_load!
+
       new(routes: Rails.application.routes).generate
     end
 
@@ -11,13 +15,21 @@ module RbsRails
     def generate
       methods = helpers.map do |helper|
         # TODO: More restrict argument types
-        "def #{helper}: (*untyped) -> String"
+        "def #{helper}: (*untyped) -> ::String"
       end
 
       <<~RBS
-        interface _RbsRailsPathHelpers
+        # resolve-type-names: false
+
+        interface ::_RbsRailsPathHelpers
         #{methods.join("\n").indent(2)}
         end
+
+        module ::ActionController
+          class ::ActionController::Base
+            include ::_RbsRailsPathHelpers
+          end
+        end
       RBS
     end
 

data/lib/rbs_rails/rake_task.rb

@@ -3,71 +3,69 @@ require 'rake/tasklib'
 
 module RbsRails
   class RakeTask < Rake::TaskLib
-    attr_accessor :ignore_model_if, :name, :signature_root_dir
-
-    def initialize(name = :rbs_rails, &block)
+    # @rbs!
+    #   interface _Filter
+    #     def call: (Class) -> boolish
+    #   end
+
+    attr_accessor :ignore_model_if #: _Filter | nil
+    attr_accessor :name #: Symbol
+    attr_writer :signature_root_dir #: Pathname?
+
+    # @rbs name: ::Symbol
+    # @rbs &block: (RbsRails::RakeTask) -> void
+    def initialize(name = :rbs_rails, &block) #: void
       super()
 
       @name = name
+      @signature_root_dir = nil
 
       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
+    def def_all #: void
       desc 'Run all tasks of rbs_rails'
-
-      deps = [:"#{name}:generate_rbs_for_models", :"#{name}:generate_rbs_for_path_helpers"]
-      task("#{name}:all": deps)
+      task :"#{name}:all" do
+        if signature_root_dir
+          sh "rbs_rails", "all", "--signature-root-dir=#{signature_root_dir}"
+        else
+          sh "rbs_rails", "all"
+        end
+      end
     end
 
-    def def_generate_rbs_for_models
+    def def_generate_rbs_for_models #: void
       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)
+      task :"#{name}:generate_rbs_for_models" do
+        warn "ignore_model_if is deprecated." if ignore_model_if
 
-          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
-          dep_builder.done << klass.name
-        end
-
-        if dep_rbs = dep_builder.build
-          signature_root_dir.join('model_dependencies.rbs').write(dep_rbs)
+        if signature_root_dir
+          sh "rbs_rails", "models", "--signature-root-dir=#{signature_root_dir}"
+        else
+          sh "rbs_rails", "models"
         end
       end
     end
 
-    def def_generate_rbs_for_path_helpers
+    def def_generate_rbs_for_path_helpers #: void
       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
+      task :"#{name}:generate_rbs_for_path_helpers" do
+        if signature_root_dir
+          sh "rbs_rails", "path_helpers", "--signature-root-dir=#{signature_root_dir}"
+        else
+          sh "rbs_rails", "path_helpers"
+        end
       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
+    private def signature_root_dir #: Pathname?
+      if path = @signature_root_dir
+        Pathname(path)
+      end
     end
   end
 end

data/lib/rbs_rails/util/file_writer.rb

@@ -0,0 +1,22 @@
+module RbsRails
+  module Util
+    # To avoid unnecessary type reloading by type checkers and other utilities,
+    # FileWriter modifies the target file only if its content has been changed.
+    class FileWriter
+      attr_reader :path  #: Pathname
+
+      # @rbs path: Pathname
+      def initialize(path) #: void
+        @path = path
+      end
+
+      def write(content) #: void
+        original_content = path.read rescue nil
+
+        if original_content != content
+          path.write(content)
+        end
+      end
+    end
+  end
+end

data/lib/rbs_rails/util.rb

@@ -1,29 +1,31 @@
+require_relative 'util/file_writer'
+
 module RbsRails
   module Util
-    MODULE_NAME = Module.instance_method(:name)
+    MODULE_NAME = Module.instance_method(:name) #: UnboundMethod
+
+    # @rbs! extend Util
 
     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
+    # @rbs mod: Module
+    # @rbs abs: boolish
+    def module_name(mod, abs: true) #: String
+      name = MODULE_NAME.bind_call(mod)
+      name ="::#{name}" if abs
+      name
     end
 
-    def format_rbs(rbs)
+    # @rbs rbs: String
+    def format_rbs(rbs) #: String
       decls =
-        if Gem::Version.new('3') <= Gem::Version.new(RBS::VERSION) 
-          # TODO: Remove this type annotation when rbs_rails depends on RBS v3
-          # @type var parsed: [RBS::Buffer, untyped, RBS::Declarations::t]
+        if Gem::Version.new('3') <= Gem::Version.new(RBS::VERSION)
           parsed = _ = RBS::Parser.parse_signature(rbs)
           parsed[1] + parsed[2]
         else
-          RBS::Parser.parse_signature(rbs)
+          # TODO: Remove this type annotation when rbs_rails drops support of RBS 2.x.
+          # @type var parsed: [RBS::Declarations::t]
+          parsed = _ = RBS::Parser.parse_signature(rbs)
         end
 
       StringIO.new.tap do |io|

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.12.0"
+  VERSION = "0.13.0" #: String
 end

data/lib/rbs_rails.rb

@@ -1,17 +1,20 @@
-require 'parser/current'
+require 'parser'
+require 'prism'
 require 'rbs'
 require 'stringio'
 
 require_relative "rbs_rails/version"
 require_relative "rbs_rails/util"
 require_relative 'rbs_rails/active_record'
+require_relative 'rbs_rails/active_record/enum'
 require_relative 'rbs_rails/path_helpers'
 require_relative 'rbs_rails/dependency_builder'
 
 module RbsRails
   class Error < StandardError; end
 
-  def self.copy_signatures(to:)
+  # @rbs to: untyped
+  def self.copy_signatures(to:) #: untyped
     from = Pathname(_ = __dir__) / '../assets/sig/'
     to = Pathname(to)
     FileUtils.cp_r(from, to)