Merge pull request #335 from tk0miya/cli

feat: Add command line interface for rbs_rails

Author: tk0miya

Gemfile

@@ -8,6 +8,6 @@ gemspec
 gem "rake", "~> 13.0"
 gem 'rails', '>= 7.0'
 gem 'rbs', '>= 3'
-gem 'rbs-inline'
+gem 'rbs-inline', require: false
 gem 'steep', '>= 1.4'
 gem 'minitest'

README.md

@@ -26,18 +26,23 @@ Run the following command. It generates `lib/tasks/rbs.rake`.
 $ bin/rails g rbs_rails:install
 ```
 
-Then, the following four tasks are available.
+Then, the following three tasks are available.
 
-* `rbs_rails:prepare`: Install inspector modules for Active Record models.  This task is required to run before loading Rails application.
 * `rbs_rails:generate_rbs_for_models`: Generate RBS files for Active Record models
 * `rbs_rails:generate_rbs_for_path_helpers`: Generate RBS files for path helpers
 * `rbs_rails:all`: Execute all tasks of RBS Rails
 
-
-If you invoke multiple tasks, please run `rbs_rails:prepare` first.
+You can also run rbs_rails from command line:
 
 ```console
-$ bin/rails rbs_rails:prepare some_task another_task rbs_rails:generate_rbs_for_models
+# Generate all RBS files
+$ bundle exec rbs_rails all
+
+# Generate RBS files for models
+$ bundle exec rbs_rails models
+
+# Generate RBS files for path helpers
+$ bundle exec rbs_rails path_helpers
 ```
 
 ### Install RBS for `rails` gem
@@ -52,6 +57,31 @@ You need to install `rails` gem's RBS files. I highly recommend using `rbs colle
    $ bundle exec rbs collection install
    ```
 
+### Configuration
+
+You can customize the behavior of rbs_rails via configuration file. Place one of the following files in your project:
+
+* `.rbs_rails.rb` (in the project root)
+* `config/rbs_rails.rb`
+
+```ruby
+RbsRails.configure do |config|
+  # Specify the directory where RBS signatures will be generated
+  # Default: Rails.root.join("sig/rbs_rails")
+  config.signature_root_dir = "sig/rbs_rails"
+
+  # Define which models should be ignored during generation
+  config.ignore_model_if do |klass|
+    # Example: Ignore test models
+    klass.name.start_with?("Test") ||
+    # Example: Ignore models in specific namespaces
+    klass.name.start_with?("Admin::") ||
+    # Example: Ignore models without database tables
+    !klass.table_exists?
+  end
+end
+```
+
 ### Steep integration
 
 Put the following code as `Steepfile`.

example/rbs_rails.rb

@@ -0,0 +1,22 @@
+# Example configuration file for rbs_rails
+#
+# Place this file in the root of your Rails project or in config/rbs_rails.rb
+
+RbsRails.configure do |config|
+  # Specify the directory where RBS signatures will be generated
+  # Default: Rails.root.join("sig/rbs_rails")
+  config.signature_root_dir = "sig/rbs_rails"
+
+  # Define a proc to determine which models should be ignored during generation
+  # The proc receives a model class and should return true if the model should be ignored
+  config.ignore_model_if do |klass|
+    # Example: Ignore test models
+    klass.name.start_with?("Test") ||
+    # Example: Ignore models in the Admin namespace
+    klass.name.start_with?("Admin::") ||
+    # Example: Ignore models that are not backed by a database table
+    !klass.table_exists? ||
+    # Example: Ignore anonymous classes
+    klass.name.blank?
+  end
+end

exe/rbs_rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "rbs_rails"
+require "rbs_rails/cli"
+
+exit RbsRails::CLI.new().run(ARGV)

lib/generators/rbs_rails/install_generator.rb

@@ -8,18 +8,9 @@ def create_raketask #: void
           require 'rbs_rails/rake_task'
 
           RbsRails::RakeTask.new do |task|
-            # If you want to avoid generating RBS for some classes, comment in it.
-            # default: nil
-            #
-            # task.ignore_model_if = -> (klass) { klass == MyClass }
-
             # If you want to change the rake task namespace, comment in it.
             # default: :rbs_rails
             # task.name = :cool_rbs_rails
-
-            # If you want to change where RBS Rails writes RBSs into, comment in it.
-            # default: Rails.root / 'sig/rbs_rails'
-            # task.signature_root_dir = Rails.root / 'my_sig/rbs_rails'
           end
         rescue LoadError
           # failed to load rbs_rails. Skip to load rbs_rails tasks.

lib/rbs_rails/cli.rb

@@ -0,0 +1,168 @@
+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
+      Rails.application.eager_load!
+
+      dep_builder = DependencyBuilder.new
+
+      ::ActiveRecord::Base.descendants.each do |klass|
+        generate_single_model(klass, dep_builder)
+      rescue => e
+        puts "Error generating RBS for #{klass.name} model"
+        raise e
+      end
+
+      if dep_rbs = dep_builder.build
+        config.signature_root_dir.join('model_dependencies.rbs').write(dep_rbs)
+      end
+    end
+
+    # @rbs klass: singleton(ActiveRecord::Base)
+    # @rbs dep_builder: DependencyBuilder
+    def generate_single_model(klass, dep_builder) #: 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, dependencies: dep_builder.deps)
+      path.write sig
+      dep_builder.done << klass.name
+
+      true
+    end
+
+    def generate_path_helpers #: void
+      path = config.signature_root_dir.join 'path_helpers.rbs'
+      path.dirname.mkpath
+
+      sig = RbsRails::PathHelpers.generate
+      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

lib/rbs_rails/cli/configuration.rb

@@ -0,0 +1,63 @@
+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)?
+
+      def initialize #: void
+        @signature_root_dir = nil
+        @ignore_model_if = nil
+      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