rbs_rails 0.11.0 → 0.12.1

data/lib/rbs_rails/active_record.rb

@@ -12,12 +12,14 @@ module RbsRails
     end
 
     class Generator
+      IGNORED_ENUM_KEYS = %i[_prefix _suffix _default _scopes]
+
       def initialize(klass, dependencies:)
         @klass = klass
         @dependencies = dependencies
-        @klass_name = Util.module_name(klass)
+        @klass_name = Util.module_name(klass, abs: false)
 
-        namespaces = klass_name.split('::').tap{ |names| names.pop }
+        namespaces = klass_name(abs: false).split('::').tap{ |names| names.pop }
         @dependencies << namespaces.join('::') unless namespaces.empty?
       end
 
@@ -28,7 +30,7 @@ module RbsRails
       private def klass_decl
         <<~RBS
           #{header}
-            extend _ActiveRecord_Relation_ClassMethods[#{klass_name}, #{relation_class_name}, #{pk_type}]
+            extend ::_ActiveRecord_Relation_ClassMethods[#{klass_name}, #{relation_class_name}, #{pk_type}]
 
           #{columns}
           #{associations}
@@ -60,7 +62,7 @@ module RbsRails
 
       private def generated_relation_methods_decl
         <<~RBS
-          module GeneratedRelationMethods
+          module #{generated_relation_methods_name(abs: false)}
             #{enum_scope_methods(singleton: false)}
             #{scopes(singleton: false)}
             #{delegated_type_scope(singleton: false)}
@@ -70,10 +72,10 @@ module RbsRails
 
       private def relation_decl
         <<~RBS
-          class #{relation_class_name} < ::ActiveRecord::Relation
-            include GeneratedRelationMethods
-            include _ActiveRecord_Relation[#{klass_name}, #{pk_type}]
-            include Enumerable[#{klass_name}]
+          class #{relation_class_name(abs: false)} < ::ActiveRecord::Relation
+            include #{generated_relation_methods_name}
+            include ::_ActiveRecord_Relation[#{klass_name}, #{pk_type}]
+            include ::Enumerable[#{klass_name}]
           end
         RBS
       end
@@ -81,22 +83,22 @@ module RbsRails
       private def collection_proxy_decl
         <<~RBS
           class ActiveRecord_Associations_CollectionProxy < ::ActiveRecord::Associations::CollectionProxy
-            include GeneratedRelationMethods
-            include _ActiveRecord_Relation[#{klass_name}, #{pk_type}]
+            include #{generated_relation_methods_name}
+            include ::_ActiveRecord_Relation[#{klass_name}, #{pk_type}]
           end
         RBS
       end
 
       private def header
         namespace = +''
-        klass_name.split('::').map do |mod_name|
+        klass_name(abs: false).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)
+            superclass_name = Util.module_name(superclass, abs: false)
             @dependencies << superclass_name
 
             "class #{mod_name} < ::#{superclass_name}"
@@ -109,7 +111,7 @@ module RbsRails
       end
 
       private def footer
-        "end\n" * klass_name.split('::').size
+        "end\n" * klass_name(abs: false).split('::').size
       end
 
       private def associations
@@ -131,9 +133,9 @@ module RbsRails
 
           <<~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]
+            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
@@ -147,7 +149,7 @@ module RbsRails
           <<~RUBY.chomp
             def #{a.name}: () -> #{type_optional}
             def #{a.name}=: (#{type_optional}) -> #{type_optional}
-            def build_#{a.name}: (untyped) -> #{type}
+            def build_#{a.name}: (?untyped) -> #{type}
             def create_#{a.name}: (untyped) -> #{type}
             def create_#{a.name}!: (untyped) -> #{type}
             def reload_#{a.name}: () -> #{type_optional}
@@ -159,11 +161,13 @@ module RbsRails
         klass.reflect_on_all_associations(:belongs_to).map do |a|
           @dependencies << a.klass.name unless a.polymorphic?
 
+          is_optional = a.options[:optional]
+
           type = a.polymorphic? ? 'untyped' : Util.module_name(a.klass)
           type_optional = optional(type)
           # @type var methods: Array[String]
           methods = []
-          methods << "def #{a.name}: () -> #{type}"
+          methods << "def #{a.name}: () -> #{is_optional ? type_optional : type}"
           methods << "def #{a.name}=: (#{type_optional}) -> #{type_optional}"
           methods << "def reload_#{a.name}: () -> #{type_optional}"
           if !a.polymorphic?
@@ -186,21 +190,21 @@ module RbsRails
             case reflection.macro
             when :has_one_attached
               <<~EOS
-                def #{name}: () -> ActiveStorage::Attached::One
-                def #{name}=: (ActionDispatch::Http::UploadedFile) -> ActionDispatch::Http::UploadedFile
-                            | (Rack::Test::UploadedFile) -> Rack::Test::UploadedFile
-                            | (ActiveStorage::Blob) -> ActiveStorage::Blob
-                            | (String) -> String
-                            | ({ io: IO, filename: String, content_type: String? }) -> { io: IO, filename: String, content_type: String? }
+                def #{name}: () -> ::ActiveStorage::Attached::One
+                def #{name}=: (::ActionDispatch::Http::UploadedFile) -> ::ActionDispatch::Http::UploadedFile
+                            | (::Rack::Test::UploadedFile) -> ::Rack::Test::UploadedFile
+                            | (::ActiveStorage::Blob) -> ::ActiveStorage::Blob
+                            | (::String) -> ::String
+                            | ({ io: ::IO, filename: ::String, content_type: ::String? }) -> { io: ::IO, filename: ::String, content_type: ::String? }
                             | (nil) -> nil
               EOS
             when :has_many_attached
               <<~EOS
-                def #{name}: () -> ActiveStorage::Attached::Many
+                def #{name}: () -> ::ActiveStorage::Attached::Many
                 def #{name}=: (untyped) -> untyped
               EOS
             else
-              raise
+              raise "unknown macro: #{reflection.macro}"
             end
           end.join("\n")
           sigs << "end"
@@ -316,7 +320,7 @@ module RbsRails
         methods = []
         enum_definitions.each do |hash|
           hash.each do |name, values|
-            next if name == :_prefix || name == :_suffix || name == :_default
+            next if IGNORED_ENUM_KEYS.include?(name)
 
             values.each do |label, value|
               value_method_name = enum_method_name(hash, name, label)
@@ -334,7 +338,7 @@ module RbsRails
         methods = []
         enum_definitions.each do |hash|
           hash.each do |name, values|
-            next if name == :_prefix || name == :_suffix || name == :_default
+            next if IGNORED_ENUM_KEYS.include?(name)
 
             values.each do |label, value|
               value_method_name = enum_method_name(hash, name, label)
@@ -456,7 +460,7 @@ module RbsRails
       private def parse_model_file
         return @parse_model_file if defined?(@parse_model_file)
 
-        path = Rails.root.join('app/models/', klass_name.underscore + '.rb')
+        path = Rails.root.join('app/models/', klass_name(abs: false).underscore + '.rb')
         return @parse_model_file = nil unless path.exist?
         return [] unless path.exist?
 
@@ -467,24 +471,32 @@ module RbsRails
       end
 
       private def traverse(node, &block)
-        return to_enum(__method__ || raise, node) unless block_given?
+        return to_enum(__method__ || raise, node) unless block
 
-        # @type var block: ^(Parser::AST::Node) -> untyped
         block.call node
         node.children.each do |child|
           traverse(child, &block) if child.is_a?(Parser::AST::Node)
         end
       end
 
-      private def relation_class_name
-        "ActiveRecord_Relation"
+      private def relation_class_name(abs: true)
+        abs ? "#{klass_name}::ActiveRecord_Relation" : "ActiveRecord_Relation"
+      end
+
+      private def klass_name(abs: true)
+        abs ? "::#{@klass_name}" : @klass_name
       end
 
+      private def generated_relation_methods_name(abs: true)
+        abs ? "#{klass_name}::GeneratedRelationMethods" : "GeneratedRelationMethods"
+      end
+
+
       private def columns
         mod_sig = +"module GeneratedAttributeMethods\n"
         mod_sig << klass.columns.map do |col|
           class_name = if enum_definitions.any? { |hash| hash.key?(col.name) || hash.key?(col.name.to_sym) }
-                         'String'
+                         '::String'
                        else
                          sql_type_to_class(col.type)
                        end
@@ -499,12 +511,12 @@ module RbsRails
             def #{col.name}_will_change!: () -> void
             def #{col.name}_was: () -> #{class_name_opt}
             def #{col.name}_previously_changed?: () -> bool
-            def #{col.name}_previous_change: () -> Array[#{class_name_opt}]?
+            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}_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}: () -> ::Array[#{class_name_opt}]?
             def saved_change_to_#{col.name}?: () -> bool
             def will_save_change_to_#{col.name}?: () -> bool
             def restore_#{col.name}!: () -> void
@@ -525,25 +537,25 @@ module RbsRails
       private def sql_type_to_class(t)
         case t
         when :integer
-          'Integer'
+          '::Integer'
         when :float
-          'Float'
+          '::Float'
         when :decimal
-          'BigDecimal'
+          '::BigDecimal'
         when :string, :text, :citext, :uuid, :binary
-          'String'
+          '::String'
         when :datetime
-          'ActiveSupport::TimeWithZone'
+          '::ActiveSupport::TimeWithZone'
         when :boolean
           "bool"
         when :jsonb, :json
           "untyped"
         when :date
-          'Date'
+          '::Date'
         when :time
-          'Time'
+          '::Time'
         when :inet
-          "IPAddr"
+          "::IPAddr"
         else
           # Unknown column type, give up
           'untyped'
@@ -551,7 +563,7 @@ module RbsRails
       end
 
       private
-      attr_reader :klass, :klass_name
+      attr_reader :klass
     end
   end
 end

data/lib/rbs_rails/dependency_builder.rb

@@ -10,7 +10,7 @@ module RbsRails
     def build
       dep_rbs = +""
       deps.uniq!
-      while dep = deps.shift
+      while dep = shift
         next unless done.add?(dep)
 
         case dep_object = Object.const_get(dep)
@@ -39,5 +39,9 @@ module RbsRails
         Util.format_rbs(dep_rbs)
       end
     end
+
+    private def shift
+      deps.shift&.sub(/^::/, '')
+    end
   end
 end

data/lib/rbs_rails/rake_task.rb

@@ -3,17 +3,17 @@ require 'rake/tasklib'
 
 module RbsRails
   class RakeTask < Rake::TaskLib
-    attr_accessor :ignore_model_if, :name, :signature_root_dir
+    attr_accessor :ignore_model_if, :name
+    attr_writer :signature_root_dir
 
     def initialize(name = :rbs_rails, &block)
       super()
 
       @name = name
+      @signature_root_dir = Rails.root / 'sig/rbs_rails'
 
       block.call(self) if block
 
-      setup_signature_root_dir!
-
       def_generate_rbs_for_models
       def_generate_rbs_for_path_helpers
       def_all
@@ -64,10 +64,10 @@ module RbsRails
       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(@signature_root_dir).tap do |dir|
+        dir.mkpath
+      end
     end
   end
 end

data/lib/rbs_rails/util.rb

@@ -4,19 +4,23 @@ module RbsRails
 
     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
+    def module_name(mod, abs: true)
+      name = MODULE_NAME.bind_call(mod)
+      name ="::#{name}" if abs
+      name
     end
 
     def format_rbs(rbs)
-      decls = RBS::Parser.parse_signature(rbs)
+      decls =
+        if Gem::Version.new('3') <= Gem::Version.new(RBS::VERSION) 
+          parsed = _ = RBS::Parser.parse_signature(rbs)
+          parsed[1] + parsed[2]
+        else
+          # 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|
         RBS::Writer.new(out: io).write(decls)
       end.string

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.11.0"
+  VERSION = "0.12.1"
 end