rbs_rails 0.2.0 → 0.6.0

data/bin/postprocess.rb

@@ -0,0 +1,137 @@
+#!ruby
+
+# TODO: Expose me to user
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'rbs', '1.0.0'
+end
+
+require 'rbs'
+require 'rbs/cli'
+require 'optparse'
+
+def env(options:)
+  loader = options.loader
+  RBS::Environment.from_loader(loader).resolve_type_names
+end
+
+def parse_option(argv)
+  opt = OptionParser.new
+  options = RBS::CLI::LibraryOptions.new
+  options.setup_library_options(opt)
+
+  return opt.parse(argv), options
+end
+
+class FileMatcher
+  def initialize(targets:)
+    base_dir = Dir.pwd
+    @targets = targets + targets.map { |t| File.expand_path(t, base_dir) }
+  end
+
+  def match?(fname)
+    @targets.any? { |t| fname.start_with?(t) }
+  end
+end
+
+def class_method_name(concern)
+  RBS::TypeName.new(namespace: concern.name.to_namespace, name: :ClassMethods)
+end
+
+def process(decl, env:, builder:, update_targets:)
+  concerns = decl.members.select do |m|
+    next false unless m.is_a?(RBS::AST::Members::Include)
+    next false unless m.name.kind == :class
+
+    mod_entry = env.class_decls[m.name]
+    unless mod_entry
+      warn "unknown type: #{m.name}"
+      next false
+    end
+
+    a = builder.singleton_ancestors(m.name)
+    a.ancestors.any? { |ancestor| ancestor.name.to_s == '::ActiveSupport::Concern' }
+  end
+
+  concerns.each do |concern|
+    class_methods_name = class_method_name(concern)
+    class_methods_type = env.class_decls[class_methods_name]
+    next unless class_methods_type
+
+    # Skip if the decl already extend ClassMethods
+    a = builder.singleton_ancestors(decl.name)
+    next if a.ancestors.any? { |ancestor| ancestor.name == class_methods_name }
+
+    # TODO: Insert `extend class_methods_name` to decl
+    update_targets << [decl, concern]
+  end
+end
+
+def each_decl_descendant(decl:, path: [], &block)
+  return unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
+
+  block.call(decl: decl, path: path)
+  path = [*path, decl]
+  decl.each_decl do |child|
+    each_decl_descendant(decl: child, path: path, &block)
+  end
+end
+
+def may_eql_member?(a, b)
+  a.name.to_s.split('::').last == b.name.to_s.split('::').last
+end
+
+def update!(update_targets:, only:)
+  update_targets.group_by { |decl, _concern| decl.location.name }.each do |fname, target_decls|
+    next unless only.match?(fname)
+
+    tree = RBS::Parser.parse_signature(File.read(fname))
+    target_decls.each do |target_decl, concern|
+      catch(:break) do
+        tree.each do |node|
+          each_decl_descendant(decl: node) do |decl:, path:|
+            next unless [relative = [*path, decl].map { |p| p.name.to_s }.join('::'), '::' + relative].include?(target_decl.name.to_s)
+
+            idx = decl.members.index { |m| may_eql_member?(m, concern) } || -1
+            extend = RBS::AST::Members::Extend.new(name: class_method_name(concern), args: [], annotations: [], location: nil, comment: nil)
+            decl.members.insert(idx + 1, extend)
+            throw :break
+          end
+        end
+      end
+    end
+
+    File.open(fname, 'w') do |f|
+      RBS::Writer.new(out: f).write(tree)
+    end
+  end
+end
+
+def run(argv)
+  targets, options = parse_option(argv)
+  env = env(options: options)
+  builder = RBS::DefinitionBuilder.new(env: env)
+  matcher = FileMatcher.new(targets: targets)
+
+  only = ENV['ONLY']&.then { Regexp.new(_1) } || //
+
+  update_targets = []
+
+  env.class_decls.each do |_name, entry|
+    entry.decls.each do |d|
+      decl = d.decl
+      loc = decl.location
+      fname = loc.name
+      next unless matcher.match?(fname)
+
+      process(decl, env: env, builder: builder, update_targets: update_targets)
+    end
+  end
+
+  update!(update_targets: update_targets, only: only)
+end
+
+run(ARGV)

data/bin/rbs

@@ -0,0 +1,30 @@
+#!ruby
+
+require 'pathname'
+root = Pathname(__dir__) / '../'
+
+def v(require)
+  if v = ENV['RAILS_VERSION']
+    "#{require}:#{v}"
+  else
+    require
+  end
+end
+
+def repo
+  ENV['RBS_REPO_DIR'] || Pathname(__dir__).join('../gem_rbs/gems').to_s
+end
+
+exec(
+  'rbs',
+  # Require stdlibs
+  '-rlogger', '-rpathname', '-rmutex_m', '-rdate',
+  "--repo=#{repo}",
+  # Require Rails libraries
+  v('-ractivesupport'), v('-ractionpack'), v('-ractivejob'), v('-ractivemodel'), v('-ractionview'), v('-ractiverecord'), v('-rrailties'),
+  # Load signatures that are bundled in rbs_rails
+  '-I' + root.join('sig').to_s, '-I' + root.join('assets/sig').to_s,
+  # Expand arguments
+  *ARGV,
+)
+

data/bin/rbs-prototype-rb.rb

@@ -0,0 +1,195 @@
+#!ruby
+
+require 'rbs'
+require 'rbs/cli'
+
+using Module.new {
+  refine(Object) do
+    def const_name(node)
+      case node.type
+      when :CONST
+        node.children[0]
+      when :COLON2
+        base, name = node.children
+        base = const_name(base)
+        return unless base
+        "#{base}::#{name}"
+      end
+    end
+
+    def process_class_methods(node, decls:, comments:, context:)
+      return false unless node.type == :ITER
+
+      fcall = node.children[0]
+      return false unless fcall.children[0] == :class_methods
+
+      name = RBS::TypeName.new(name: :ClassMethods, namespace: RBS::Namespace.empty)
+      mod = RBS::AST::Declarations::Module.new(
+        name: name,
+        type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+        self_types: [],
+        members: [],
+        annotations: [],
+        location: nil,
+        comment: comments[node.first_lineno - 1]
+      )
+
+      decls.push mod
+
+      each_node [node.children[1]] do |child|
+        process child, decls: mod.members, comments: comments, context: RBS::Prototype::RB::Context.initial
+      end
+
+      true
+    end
+
+    def process_struct_new(node, decls:, comments:, context:)
+      return unless node.type == :CDECL
+
+      name, *_, rhs = node.children
+      fields, body = struct_new(rhs)
+      return unless fields
+
+      type_name = RBS::TypeName.new(name: name, namespace: RBS::Namespace.empty)
+      kls = RBS::AST::Declarations::Class.new(
+        name: type_name,
+        super_class: struct_as_superclass,
+        type_params: RBS::AST::Declarations::ModuleTypeParams.empty,
+        members: [],
+        annotations: [],
+        location: nil,
+        comment: comments[node.first_lineno - 1],
+      )
+      decls.push kls
+
+      fields.children.compact.each do |f|
+        case f.type
+        when :LIT, :STR
+          kls.members << RBS::AST::Members::AttrAccessor.new(
+            name: f.children.first,
+            type: untyped,
+            kind: :instance,
+            ivar_name: false,
+            annotations: [],
+            location: nil,
+            comment: nil,
+          )
+        end
+      end
+
+      if body
+        each_node [body] do |child|
+          process child, decls: kls.members, comments: comments, context: RBS::Prototype::RB::Context.initial
+        end
+      end
+
+      true
+    end
+
+    def process_attr_internal(node, decls:, comments:, context:)
+      case node.type
+      when :FCALL, :VCALL
+        args = node.children[1]&.children || []
+
+        case node.children[0]
+        when :attr_internal_reader
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrReader.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        when :attr_internal_writer
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrWriter.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        when :attr_internal_accessor, :attr_internal
+          args.each do |arg|
+            if arg && (name = literal_to_symbol(arg))
+              decls << RBS::AST::Members::AttrAccessor.new(
+                name: name,
+                ivar_name: :"@_#{name}",
+                type: RBS::Types::Bases::Any.new(location: nil),
+                kind: context.attribute_kind,
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+                annotations: []
+              )
+            end
+          end
+        end
+      end
+    end
+
+    def class_new_method_to_type(node)
+      case node.type
+      when :CALL
+        recv, name, _args = node.children
+        return unless name == :new
+
+        klass = const_name(recv)
+        return unless klass
+
+        type_name = RBS::TypeName.new(name: klass, namespace: RBS::Namespace.empty)
+        RBS::Types::ClassInstance.new(name: type_name, args: [], location: nil)
+      end
+    end
+
+    def struct_new(node)
+      case node.type
+      when :CALL
+        # ok
+      when :ITER
+        call, block = node.children
+        return struct_new(call)&.tap do |r|
+          r << block
+        end
+      else
+        return
+      end
+
+      recv, method_name, args = node.children
+      return unless method_name == :new
+      return unless recv.type == :CONST || recv.type == :COLON3
+      return unless recv.children.first == :Struct
+
+      [args]
+    end
+
+    def struct_as_superclass
+      name = RBS::TypeName.new(name: 'Struct', namespace: RBS::Namespace.root)
+      RBS::AST::Declarations::Class::Super.new(name: name, args: ['untyped'], location: nil)
+    end
+  end
+}
+
+module PrototypeExt
+  def process(...)
+    process_class_methods(...) || process_struct_new(...) || process_attr_internal(...) || super
+  end
+
+  def literal_to_type(node)
+    class_new_method_to_type(node) || super
+  end
+end
+
+RBS::Prototype::RB.prepend PrototypeExt
+
+RBS::CLI.new(stdout: STDOUT, stderr: STDERR).run(ARGV.dup)

data/bin/to-ascii.rb

@@ -0,0 +1,5 @@
+#!ruby
+
+ARGV.each do |p|
+  File.write p, File.read(p).gsub(/[^[:ascii:]]+/, '(trim non-ascii characters)')
+end

data/lib/rbs_rails/active_record.rb

@@ -1,13 +1,12 @@
 module RbsRails
   module ActiveRecord
-    def self.class_to_rbs(klass, mode:)
-      Generator.new(klass, mode: mode).generate
+    def self.class_to_rbs(klass)
+      Generator.new(klass).generate
     end
 
     class Generator
-      def initialize(klass, mode:)
+      def initialize(klass)
         @klass = klass
-        @mode = mode
       end
 
       def generate
@@ -36,7 +35,7 @@ module RbsRails
         <<~RBS
           class #{relation_class_name} < ActiveRecord::Relation
             include _ActiveRecord_Relation[#{klass.name}]
-            include Enumerable[#{klass.name}, self]
+            include Enumerable[#{klass.name}]
           #{enum_scope_methods(singleton: false).indent(2)}
           #{scopes(singleton: false).indent(2)}
           end
@@ -52,16 +51,9 @@ module RbsRails
 
 
       private def header
-        case mode
-        when :extension
-          "extension #{klass.name} (RbsRails)"
-        when :class
-          # @type var superclass: Class
-          superclass = _ = klass.superclass
-          "class #{klass.name} < #{superclass.name}"
-        else
-          raise "unexpected mode: #{mode}"
-        end
+        # @type var superclass: Class
+        superclass = _ = klass.superclass
+        "class #{klass.name} < #{superclass.name}"
       end
 
       private def associations
@@ -74,21 +66,45 @@ module RbsRails
 
       private def has_many
         klass.reflect_on_all_associations(:has_many).map do |a|
-          "def #{a.name}: () -> #{a.klass.name}::ActiveRecord_Associations_CollectionProxy"
+          singular_name = a.name.to_s.singularize
+          type = a.klass.name
+          collection_type = "#{type}::ActiveRecord_Associations_CollectionProxy"
+          <<~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]
+          RUBY
         end.join("\n")
       end
 
       private def has_one
         klass.reflect_on_all_associations(:has_one).map do |a|
           type = a.polymorphic? ? 'untyped' : a.klass.name
-          "def #{a.name}: () -> #{type}"
+          type_optional = optional(type)
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{type}
+            def #{a.name}=: (#{type_optional}) -> #{type_optional}
+            def build_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}!: (untyped) -> #{type}
+            def reload_#{a.name}: () -> #{type_optional}
+          RUBY
         end.join("\n")
       end
 
       private def belongs_to
         klass.reflect_on_all_associations(:belongs_to).map do |a|
           type = a.polymorphic? ? 'untyped' : a.klass.name
-          "def #{a.name}: () -> #{type}"
+          type_optional = optional(type)
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{type}
+            def #{a.name}=: (#{type_optional}) -> #{type_optional}
+            def build_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}: (untyped) -> #{type}
+            def create_#{a.name}!: (untyped) -> #{type}
+            def reload_#{a.name}: () -> #{type_optional}
+          RUBY
         end.join("\n")
       end
 
@@ -138,6 +154,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
@@ -176,6 +193,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
@@ -246,38 +264,65 @@ module RbsRails
 
       private def columns
         klass.columns.map do |col|
-          "attr_accessor #{col.name} (): #{sql_type_to_class(col.type)}"
+          class_name = if enum_definitions.any? { |hash| hash.key?(col.name) || hash.key?(col.name.to_sym) }
+                         'String'
+                       else
+                         sql_type_to_class(col.type)
+                       end
+          class_name_opt = optional(class_name)
+          column_type = col.null ? class_name_opt : class_name
+          sig = <<~EOS
+            attr_accessor #{col.name} (): #{column_type}
+            def #{col.name}_changed?: () -> bool
+            def #{col.name}_change: () -> [#{class_name_opt}, #{class_name_opt}]
+            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}_previously_was: () -> #{class_name_opt}
+            def restore_#{col.name}!: () -> void
+            def clear_#{col.name}_change: () -> void
+          EOS
+          sig << "attr_accessor #{col.name}? (): #{class_name}\n" if col.type == :boolean
+          sig
         end.join("\n")
       end
 
+      private def optional(class_name)
+        class_name.include?("|") ? "(#{class_name})?" : "#{class_name}?"
+      end
+
       private def sql_type_to_class(t)
         case t
         when :integer
-          Integer.name
+          'Integer'
         when :float
-          Float.name
-        when :string, :text, :uuid, :binary
-          String.name
+          'Float'
+        when :decimal
+          'BigDecimal'
+        when :string, :text, :citext, :uuid, :binary
+          'String'
         when :datetime
-          # TODO
-          # ActiveSupport::TimeWithZone.name
-          Time.name
+          '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, mode
-      attr_reader :klass, :mode
+      # @dynamic klass
+      attr_reader :klass
     end
   end
 end