rbs_rails 0.2.0 → 0.3.0

data/assets/sig/i18n.rbs

@@ -0,0 +1,4 @@
+module I18n
+  class Config
+  end
+end

data/assets/sig/minitest.rbs

@@ -1,2 +1,13 @@
-class Minitest::Test
+module Minitest
+  class Test
+  end
+
+  class SummaryReporter
+  end
+
+  class StatisticsReporter
+  end
+
+  module Assertions
+  end
 end

data/assets/sig/racc.rbs

@@ -0,0 +1,4 @@
+module Racc
+  class Parser
+  end
+end

data/assets/sig/rack-test.rbs

@@ -0,0 +1,6 @@
+module Rack
+  module Test
+    class UploadedFile
+    end
+  end
+end

data/assets/sig/rack.rbs

@@ -0,0 +1,46 @@
+module Rack
+  class Server
+  end
+
+  class Response
+    module Helpers
+    end
+  end
+
+  class Request
+    module Helpers
+    end
+
+    module Env
+    end
+  end
+
+  module Session
+    module Abstract
+      class SessionHash
+      end
+
+      class PersistedSecure
+        class SecureSessionHash
+        end
+      end
+
+      class Persisted
+      end
+    end
+
+    class SessionId
+    end
+
+    class Dalli
+    end
+  end
+
+  module Cache
+    class MetaStore
+    end
+
+    class EntityStore
+    end
+  end
+end

data/assets/sig/rails.rbs

@@ -1,11 +1,14 @@
 module Rails
-  def self.root: () -> Pathname
-  def self.application: () -> Rails::Application
+  overload def self.env: () -> ActiveSupport::StringInquirer
+
+  module Dom
+    module Testing
+      module Assertions
+      end
+    end
+  end
 end
 
 class Rails::Application
   def routes: () -> untyped
 end
-
-class Rails::Railtie
-end

data/assets/sig/rdoc.rbs

@@ -0,0 +1,9 @@
+module RDoc
+  module Generator
+    class SDoc
+    end
+  end
+
+  class Task
+  end
+end

data/assets/sig/stdlib.rbs

@@ -1,14 +1,24 @@
-class Logger
+module DRb
 end
 
-class Logger::Formatter
+module DRb::DRbUndumped
 end
 
-module Mutex_m
+module TSort
 end
 
-module DRb
+class SimpleDelegator
 end
 
-module DRb::DRbUndumped
+module Gem
+  class Version
+  end
+end
+
+module OpenSSL
+  class Cipher
+  end
+end
+
+module FileUtils
 end

data/assets/sig/thor.rbs

@@ -0,0 +1,12 @@
+class Thor
+  class Group
+  end
+
+  module Actions
+    class CreateFile
+    end
+  end
+
+  class Error
+  end
+end

data/assets/sig/tzinfo.rbs

@@ -0,0 +1,4 @@
+module TZInfo
+  class Timezone
+  end
+end

data/bin/add-type-params.rb

@@ -1,15 +1,15 @@
+#!ruby
+
 require 'rbs'
-rbs = ARGF.read
-decls = RBS::Parser.parse_signature(rbs)
 
 def args(n)
   (:T..).take(n)
 end
 
 def env
-  @env ||= RBS::Environment.new.tap do |env|
+  @env ||= begin
     loader = RBS::EnvironmentLoader.new()
-    loader.load(env: env)
+    RBS::Environment.from_loader(loader).resolve_type_names
   end
 end
 
@@ -17,7 +17,7 @@ def apply_to_superclass(decl)
   return unless decl.super_class
 
   name = decl.super_class.name
-  type = env.find_class(name) || env.find_class(name.absolute!)
+  type = env.class_decls[name] || env.class_decls[name.absolute!]
   return unless type
   return if type.type_params.empty?
 
@@ -32,12 +32,21 @@ def apply_to_superclass(decl)
   decl.instance_variable_set(:@type_params, type_params)
 end
 
+def apply_to_itself(decl)
+  name = decl.name
+  type = env.class_decls[name] || env.class_decls[name.absolute!]
+  return unless type
+  return if type.type_params.empty?
+
+  decl.instance_variable_set(:@type_params, type.type_params.dup)
+end
+
 def apply_to_includes(decl)
   decl.members.each do |member|
     next unless member.is_a?(RBS::AST::Members::Mixin)
 
     name = member.name
-    type = env.find_class(name) || env.find_class(name.absolute!)
+    type = env.class_decls[name] || env.class_decls[name.absolute!]
     next unless type
     next if type.type_params.empty?
 
@@ -46,14 +55,24 @@ def apply_to_includes(decl)
   end
 end
 
-decls.each do |decl|
-  case decl
-  when RBS::AST::Declarations::Class
-    apply_to_superclass(decl)
-    apply_to_includes(decl)
-  when RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface, RBS::AST::Declarations::Extension
-    apply_to_includes(decl)
+def analyze(decls)
+  decls.each do |decl|
+    case decl
+    when RBS::AST::Declarations::Class
+      apply_to_itself(decl)
+      apply_to_superclass(decl)
+      apply_to_includes(decl)
+      analyze(decl.members)
+    when RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface
+      apply_to_itself(decl)
+      apply_to_includes(decl)
+      analyze(decl.members)
+    end
   end
 end
 
+rbs = ARGF.read
+decls = RBS::Parser.parse_signature(rbs)
+analyze(decls)
+
 puts RBS::Writer.new(out: $stdout).write(decls)

data/bin/postprocess.rb

@@ -0,0 +1,128 @@
+#!ruby
+
+# TODO: Expose me to user
+
+require 'rbs'
+require 'rbs/cli'
+require 'optparse'
+
+def env(options:)
+  loader = RBS::EnvironmentLoader.new()
+  options.setup(loader)
+  RBS::Environment.from_loader(loader).resolve_type_names
+end
+
+def parse_option(argv)
+  opt = OptionParser.new
+  options = RBS::CLI::LibraryOptions.new
+  cli = RBS::CLI.new(stdout: nil, stderr: nil)
+  cli.library_parse(opt, options: options)
+
+  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:)
+  update_targets.group_by { |decl, _concern| decl.location.name }.each do |fname, target_decls|
+    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)
+
+  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)
+end
+
+run(ARGV)

data/bin/rbs

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+rbs -rlogger -rpathname -rmutex_m -Isig -Iassets/sig $@

data/bin/rbs-prototype-rb.rb

@@ -0,0 +1,142 @@
+#!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:, singleton:)
+      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, singleton: false
+      end
+
+      true
+    end
+
+    def process_struct_new(node, decls:, comments:, singleton:)
+      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,
+            ivar_name: false,
+            annotations: [],
+            location: nil,
+            comment: nil,
+          )
+        end
+      end
+
+      if body
+        each_node [body] do |child|
+          process child, decls: kls.members, comments: comments, singleton: false
+        end
+      end
+
+      true
+    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'])
+    end
+  end
+}
+
+module PrototypeExt
+  def process(...)
+    process_class_methods(...) || process_struct_new(...) || 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)