rbs_activesupport 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4db817778f6845f92163a0f4d14691e8b5126535c05b740027d8f9326f64d268
-  data.tar.gz: 51043ad364a80c5db2d59128c3a68eafbdd30cfe15cc0a6782bdc98c92755abd
+  metadata.gz: ccecb9129edd479a2f56c541fc90b0a6a2d97f72e757716767ff48c8d54b2400
+  data.tar.gz: df1a171c089788a1fd9e63c5cde999e92513973344943148baa39e8f29ea06ce
 SHA512:
-  metadata.gz: 33c9ccc927e7db87c937a82cc7b95919f39bdef2ba83c54dae7c8e20787f5e38f1c779a6914375cc47b2dbd9191a8dbec56f324e62e42ade0be19d57f7e383b3
-  data.tar.gz: 0f179597ae8b8ddd37f8ed42f912164a4aa16d3b0ef228a6c345070032e963d9d4e9e0b84287f42c0d2156f3d9775958b36ea91ebbae5f4e847391da192fef61
+  metadata.gz: f9f43ad74fe99dcff010b3beed25ffbf58e923ae5d7d0a4aeaa7777f167eb2a0bdcd2ad215cf6c7b593948f975e326007d8b03ce22472a0cb153119a56fb1a7b
+  data.tar.gz: 5bbaefec682d46203cda74d49bd6e9eab1c7461afc6d13448d0056f93da5d1cd485ac790a4e415790e11abd57532fdf0bf8fcb61a48cc6189146539118ac0038

data/.rubocop.yml

@@ -1,6 +1,9 @@
 AllCops:
   TargetRubyVersion: 2.7
 
+Layout/LeadingCommentSpace:
+  Enabled: false
+
 Metrics/AbcSize:
   Max: 25
   Exclude:
@@ -22,6 +25,12 @@ Metrics/MethodLength:
   Exclude:
     - "lib/rbs_activesupport/ast.rb"
 
+Style/AccessorGrouping:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
+
 Style/Documentation:
   Enabled: false
 

data/.vscode/settings.json

@@ -4,5 +4,7 @@
         "cattr",
         "Cyclomatic",
         "mattr"
-    ]
+    ],
+    "rbs-helper.rbs-inline-on-save": true,
+    "rbs-helper.rbs-inline-options": "--opt-out --output=sig/"
 }

data/README.md

@@ -14,6 +14,13 @@ After the installation, please run rake task generator:
 
     bundle exec rails g rbs_activesupport:install
 
+And then, please modify `lib/tasks/rbs_activesupport.rake` to fit your application.
+For example, set it up like this if you're using Rails configuration:
+
+    RbsActivesupport::RakeTask.new do |task|
+      task.target_directories = [Rails.root / "app", Rails.root / "lib"]
+    end
+
 ## Usage
 
 Run `rbs:activesupport:setup` task:

data/lib/generators/rbs_activesupport/install_generator.rb

@@ -12,6 +12,8 @@ module RbsActivesupport
           require 'rbs_activesupport/rake_task'
 
           RbsActivesupport::RakeTask.new do |task|
+            # The target directories
+            # task.target_directories = [Rails.root / "app"]
           end
         rescue LoadError
           # failed to load rbs_activesupport. Skip to load rbs_activesupport tasks.

data/lib/rbs_activesupport/ast.rb

@@ -2,13 +2,15 @@
 
 module RbsActivesupport
   module AST
-    def eval_args(node)
+    # @rbs node: Array[untyped]
+    def eval_args(node) #: Array[Array[Symbol?]]
       # @type var args: Array[Array[Symbol?]]
       *args, _ = eval_node(node)
       args
     end
 
-    def eval_args_with_options(node)
+    # @rbs node: Array[untyped]
+    def eval_args_with_options(node) #: [Array[Symbol], Hash[Symbol, untyped]]
       # @type var methods: Array[Symbol]
       # @type var options: Hash[Symbol, untyped]
       *args, _ = eval_node(node)

data/lib/rbs_activesupport/attribute_accessor.rb

@@ -2,14 +2,17 @@
 
 module RbsActivesupport
   class AttributeAccessor
-    attr_reader :name, :options
+    attr_reader :name #: Symbol
+    attr_reader :options #: Hash[untyped, untyped]
 
-    def initialize(name, options)
+    # @rbs name: Symbol
+    # @rbs options: Hash[untyped, untyped]
+    def initialize(name, options) #: void
       @name = name
       @options = options
     end
 
-    def type
+    def type #: String
       # @type var trailng_comment: String?
       trailing_comment = options[:trailing_comment]
       if trailing_comment&.start_with?("#:")
@@ -19,31 +22,31 @@ module RbsActivesupport
       end
     end
 
-    def singleton_reader?
+    def singleton_reader? #: bool
       options.fetch(:singleton_reader, true)
     end
 
-    def singleton_writer?
+    def singleton_writer? #: bool
       options.fetch(:singleton_writer, true)
     end
 
-    def instance_accessor?
+    def instance_accessor? #: bool
       options.fetch(:instance_accessor, true)
     end
 
-    def instance_reader?
+    def instance_reader? #: bool
       options.fetch(:instance_reader, instance_accessor?)
     end
 
-    def instance_writer?
+    def instance_writer? #: bool
       options.fetch(:instance_writer, instance_accessor?)
     end
 
-    def public?
+    def public? #: bool
       !private?
     end
 
-    def private?
+    def private? #: bool
       options.fetch(:private, false)
     end
   end

data/lib/rbs_activesupport/class_attribute.rb

@@ -2,14 +2,17 @@
 
 module RbsActivesupport
   class ClassAttribute
-    attr_reader :name, :options
+    attr_reader :name #: Symbol
+    attr_reader :options #: Hash[untyped, untyped]
 
-    def initialize(name, options)
+    # @rbs name: Symbol
+    # @rbs options: Hash[untyped, untyped]
+    def initialize(name, options) #: void
       @name = name
       @options = options
     end
 
-    def type
+    def type #: String
       # @type var trailng_comment: String?
       trailing_comment = options[:trailing_comment]
       if trailing_comment&.start_with?("#:")
@@ -19,27 +22,27 @@ module RbsActivesupport
       end
     end
 
-    def instance_accessor?
+    def instance_accessor? #: bool
       options.fetch(:instance_accessor, true)
     end
 
-    def instance_reader?
+    def instance_reader? #: bool
       options.fetch(:instance_reader, instance_accessor?)
     end
 
-    def instance_writer?
+    def instance_writer? #: bool
       options.fetch(:instance_writer, instance_accessor?)
     end
 
-    def instance_predicate?
+    def instance_predicate? #: bool
       options.fetch(:instance_predicate, true)
     end
 
-    def public?
+    def public? #: bool
       !private?
     end
 
-    def private?
+    def private? #: bool
       options.fetch(:private, false)
     end
   end

data/lib/rbs_activesupport/declaration_builder.rb

@@ -2,15 +2,20 @@
 
 module RbsActivesupport
   class DeclarationBuilder
+    # @rbs! type t = AttributeAccessor | ClassAttribute | Delegate | Include
+
     include AST
 
-    attr_reader :method_searcher
+    attr_reader :method_searcher #: MethodSearcher
 
-    def initialize(method_searcher)
+    # @rbs method_searcher: MethodSearcher
+    def initialize(method_searcher) #: void
       @method_searcher = method_searcher
     end
 
-    def build(namespace, method_calls)
+    # @rbs namespace: RBS::Namespace
+    # @rbs method_calls: Array[Parser::MethodCall]
+    def build(namespace, method_calls) #: [Array[String], Array[String]]
       public_decls, private_decls = build_method_calls(namespace, method_calls).partition(&:public?)
       [public_decls.map(&method(:render)).compact, # steep:ignore BlockTypeMismatch
        private_decls.map(&method(:render)).compact] # steep:ignore BlockTypeMismatch
@@ -18,7 +23,9 @@ module RbsActivesupport
 
     private
 
-    def build_method_calls(namespace, method_calls)
+    # @rbs namespace: RBS::Namespace
+    # @rbs method_calls: Array[Parser::MethodCall]
+    def build_method_calls(namespace, method_calls) #: Array[t]
       method_calls.flat_map do |method_call|
         case method_call.name
         when :class_attribute
@@ -36,7 +43,8 @@ module RbsActivesupport
       end.compact
     end
 
-    def build_attribute_accessor(method_call)
+    # @rbs method_call: Parser::MethodCall
+    def build_attribute_accessor(method_call) #: Array[AttributeAccessor]
       methods, options = eval_args_with_options(method_call.args)
       options[:singleton_reader] = false if %i[cattr_writer mattr_writer].include?(method_call.name)
       options[:singleton_writer] = false if %i[cattr_reader mattr_reader].include?(method_call.name)
@@ -49,7 +57,8 @@ module RbsActivesupport
       end
     end
 
-    def build_class_attribute(method_call)
+    # @rbs method_call: Parser::MethodCall
+    def build_class_attribute(method_call) #: Array[ClassAttribute]
       methods, options = eval_args_with_options(method_call.args)
       options[:private] = true if method_call.private?
       options[:trailing_comment] = method_call.trailing_comment
@@ -58,7 +67,9 @@ module RbsActivesupport
       end
     end
 
-    def build_delegate(namespace, method_call)
+    # @rbs namespace: RBS::Namespace
+    # @rbs method_call: Parser::MethodCall
+    def build_delegate(namespace, method_call) #: Array[Delegate]
       methods, options = eval_args_with_options(method_call.args)
       options[:private] = true if method_call.private?
       methods.map do |method|
@@ -66,14 +77,17 @@ module RbsActivesupport
       end
     end
 
-    def build_include(namespace, method_call)
+    # @rbs namespace: RBS::Namespace
+    # @rbs method_call: Parser::MethodCall
+    def build_include(namespace, method_call) #: Array[Include]
       module_paths = eval_args(method_call.args)
       module_paths.map do |module_path|
         Include.new(namespace, module_path, { private: method_call.private? })
       end
     end
 
-    def render(decl)
+    # @rbs decl: t
+    def render(decl) #: String?
       case decl
       when AttributeAccessor
         render_attribute_accessor(decl)
@@ -86,7 +100,8 @@ module RbsActivesupport
       end
     end
 
-    def render_attribute_accessor(decl)
+    # @rbs decl: AttributeAccessor
+    def render_attribute_accessor(decl) #: String
       methods = []
       methods << "def self.#{decl.name}: () -> (#{decl.type})" if decl.singleton_reader?
       methods << "def self.#{decl.name}=: (#{decl.type}) -> (#{decl.type})" if decl.singleton_writer?
@@ -95,7 +110,8 @@ module RbsActivesupport
       methods.join("\n")
     end
 
-    def render_class_attribute(decl)
+    # @rbs decl: ClassAttribute
+    def render_class_attribute(decl) #: String
       methods = []
       methods << "def self.#{decl.name}: () -> (#{decl.type})"
       methods << "def self.#{decl.name}=: (#{decl.type}) -> (#{decl.type})"
@@ -106,13 +122,15 @@ module RbsActivesupport
       methods.join("\n")
     end
 
-    def render_delegate(decl)
+    # @rbs decl: Delegate
+    def render_delegate(decl) #: String
       method_types = method_searcher.method_types_for(decl)
 
       "def #{decl.method_name}: #{method_types.join(" | ")}"
     end
 
-    def render_include(decl)
+    # @rbs decl: Include
+    def render_include(decl) #: String?
       return unless decl.concern? && decl.classmethods?
 
       <<~RBS

data/lib/rbs_activesupport/delegate.rb

@@ -2,19 +2,24 @@
 
 module RbsActivesupport
   class Delegate
-    attr_reader :namespace, :method, :options
+    attr_reader :namespace #: RBS::Namespace
+    attr_reader :method #: Symbol
+    attr_reader :options #: Hash[Symbol, untyped]
 
-    def initialize(namespace, method, options)
+    # @rbs namespace: RBS::Namespace
+    # @rbs method: Symbol
+    # @rbs options: Hash[Symbol, untyped]
+    def initialize(namespace, method, options) #: void
       @namespace = namespace
       @method = method
       @options = options
     end
 
-    def to
+    def to #: Symbol
       options[:to]
     end
 
-    def method_name
+    def method_name #: Symbol
       case options[:prefix]
       when true
         :"#{to}_#{method}"
@@ -25,11 +30,11 @@ module RbsActivesupport
       end
     end
 
-    def public?
+    def public? #: bool
       !private?
     end
 
-    def private?
+    def private? #: bool
       options.fetch(:private, false)
     end
   end

data/lib/rbs_activesupport/generator.rb

@@ -2,20 +2,27 @@
 
 module RbsActivesupport
   class Generator
-    def self.generate(pathname, rbs_builder)
+    # @rbs pathname: Pathname
+    # @rbs rbs_builder: RBS::DefinitionBuilder
+    def self.generate(pathname, rbs_builder) #: String?
       new(pathname, rbs_builder).generate
     end
 
-    attr_reader :pathname, :declaration_builder
+    include AST
 
-    def initialize(pathname, rbs_builder)
+    attr_reader :pathname #: Pathname
+    attr_reader :declaration_builder #: DeclarationBuilder
+
+    # @rbs pathname: Pathname
+    # @rbs rbs_builder: RBS::DefinitionBuilder
+    def initialize(pathname, rbs_builder) #: void
       @pathname = pathname
 
       method_searcher = MethodSearcher.new(rbs_builder)
       @declaration_builder = DeclarationBuilder.new(method_searcher)
     end
 
-    def generate
+    def generate #: String?
       declarations = parse_source_code
       return if declarations.empty?
 
@@ -42,20 +49,22 @@ module RbsActivesupport
 
     private
 
-    def format(rbs)
+    # @rbs rbs: String
+    def format(rbs) #: String
       parsed = RBS::Parser.parse_signature(rbs)
       StringIO.new.tap do |out|
         RBS::Writer.new(out: out).write(parsed[1] + parsed[2])
       end.string
     end
 
-    def parse_source_code
+    def parse_source_code #: Hash[RBS::Namespace, Array[Parser::MethodCall]]
       parser = Parser.new
       parser.parse(pathname.read)
       parser.method_calls
     end
 
-    def header(namespace)
+    # @rbs namespace: RBS::Namespace
+    def header(namespace) #: String
       context = +""
       namespace.path.map do |mod_name|
         context += "::#{mod_name}"
@@ -75,7 +84,8 @@ module RbsActivesupport
       end.join("\n")
     end
 
-    def footer(namespace)
+    # @rbs namespace: RBS::Namespace
+    def footer(namespace) #: String
       "end\n" * namespace.path.size
     end
   end

data/lib/rbs_activesupport/include.rb

@@ -4,15 +4,20 @@ require "active_support/concern"
 
 module RbsActivesupport
   class Include
-    attr_reader :context, :module_path, :options
+    attr_reader :context #: RBS::Namespace
+    attr_reader :module_path #: Array[Symbol?]
+    attr_reader :options #: Hash[Symbol, untyped]
 
-    def initialize(context, module_path, options)
+    # @rbs context: RBS::Namespace
+    # @rbs module_path: Array[Symbol?]
+    # @rbs options: Hash[Symbol, untyped]
+    def initialize(context, module_path, options) #: void
       @context = context
       @module_path = module_path
       @options = options
     end
 
-    def argument
+    def argument #: RBS::Namespace
       if module_path.first.nil?
         RBS::Namespace.new(path: module_path[1...], absolute: true) # steep:ignore ArgumentTypeMismatch
       else
@@ -20,7 +25,8 @@ module RbsActivesupport
       end
     end
 
-    def module_name
+    # @rbs %a{pure}
+    def module_name #: RBS::Namespace?
       namespace = @context
 
       loop do
@@ -33,7 +39,7 @@ module RbsActivesupport
       end
     end
 
-    def concern?
+    def concern? #: bool
       return false unless module_name
 
       modname = module_name.to_s.delete_suffix("::")
@@ -43,18 +49,18 @@ module RbsActivesupport
       mod&.singleton_class&.include?(ActiveSupport::Concern)
     end
 
-    def classmethods?
+    def classmethods? #: bool
       return false unless module_name
 
       modname = module_name.append(:ClassMethods).to_s.delete_suffix("::")
       Object.const_defined?(modname)
     end
 
-    def public?
+    def public? #: bool
       !private?
     end
 
-    def private?
+    def private? #: bool
       options.fetch(:private, false)
     end
   end

data/lib/rbs_activesupport/method_searcher.rb

@@ -4,28 +4,47 @@ require "rbs"
 
 module RbsActivesupport
   class MethodSearcher
-    attr_reader :rbs_builder
+    attr_reader :rbs_builder #: RBS::DefinitionBuilder
 
-    def initialize(rbs_builder)
+    # @rbs rbs_builder: RBS::DefinitionBuilder
+    def initialize(rbs_builder) #: void
       @rbs_builder = rbs_builder
     end
 
-    def method_types_for(delegate)
+    # @rbs delegate: Delegate
+    def method_types_for(delegate) #: Array[String]
       delegate_to = lookup_method_types(delegate.namespace.to_type_name, delegate.to)
       return ["() -> untyped"] if delegate_to.any? { |t| t.type.return_type.is_a?(RBS::Types::Bases::Any) }
 
-      return_types = delegate_to
-                     .filter_map { |t| t.type.return_type.name } # steep:ignore NoMethod
-                     .uniq
-                     .flat_map { |t| lookup_method_types(t, delegate.method) }
-                     .map(&:to_s)
+      return_types = return_type_names_for(delegate_to).uniq
+                                                       .flat_map { |t| lookup_method_types(t, delegate.method) }
+                                                       .map(&:to_s)
       return_types << "() -> untyped" if return_types.empty?
       return_types
     end
 
     private
 
-    def lookup_method_types(type_name, method)
+    # @rbs delegate_to: Array[RBS::MethodType]
+    def return_type_names_for(delegate_to) #: Array[RBS::TypeName]
+      delegate_to.filter_map do |t|
+        type_name_for(t.type.return_type)
+      end
+    end
+
+    # @rbs type: RBS::Types::t
+    def type_name_for(type) #: RBS::TypeName?
+      case type
+      when RBS::Types::Optional
+        type_name_for(type.type)
+      when RBS::Types::ClassSingleton, RBS::Types::ClassInstance, RBS::Types::Interface, RBS::Types::Alias
+        type.name
+      end
+    end
+
+    # @rbs type_name: RBS::TypeName
+    # @rbs method: Symbol
+    def lookup_method_types(type_name, method) #: Array[RBS::MethodType]
       instance = rbs_builder.build_instance(type_name)
       method_def = instance.methods[method]
       return [] unless method_def

data/lib/rbs_activesupport/parser/comment_parser.rb

@@ -3,14 +3,16 @@
 module RbsActivesupport
   class Parser
     class CommentParser
-      attr_reader :line_comments, :trailing_comments
+      attr_reader :line_comments #: Hash[Integer, String]
+      attr_reader :trailing_comments #: Hash[Integer, String]
 
-      def initialize
+      def initialize #: void
         @line_comments = {}
         @trailing_comments = {}
       end
 
-      def parse(string)
+      # @rbs string: String
+      def parse(string) #: self
         # @type var code_lines: Hash[Integer, bool]
         code_lines = {}
         Ripper.lex(string).each do |(line, _), type, token, _|

data/lib/rbs_activesupport/parser.rb

@@ -8,39 +8,54 @@ require "rbs/prototype/rb"
 module RbsActivesupport
   class Parser < ::RBS::Prototype::RB
     class MethodCall
-      attr_reader :name, :args, :trailing_comment
+      attr_reader :name #: t
+      attr_reader :args #: Array[RubyVM::AbstractSyntaxTree::Node]
+      attr_reader :trailing_comment #: String?
 
-      def initialize(name, args, private, trailing_comment: nil)
+      # @rbs @private: bool
+
+      # @rbs name: t
+      # @rbs args: Array[RubyVM::AbstractSyntaxTree::Node]
+      # @rbs private: bool
+      # @rbs trailing_comment: String?
+      def initialize(name, args, private, trailing_comment: nil) #: void
         @name = name
         @args = args
         @private = private
         @trailing_comment = trailing_comment
       end
 
-      def private?
+      def private? #: bool
         @private
       end
     end
 
+    # @rbs!
+    #   type t = :class_attribute | :delegate | :cattr_accessor | :mattr_accessor | :cattr_reader | :mattr_reader |
+    #            :cattr_writer | :mattr_writer | :include
+
     METHODS = %i[
       class_attribute delegate cattr_accessor mattr_accessor cattr_reader mattr_reader cattr_writer mattr_writer include
-    ].freeze # steep:ignore IncompatibleAssignment
+    ].freeze #: Array[t] # steep:ignore IncompatibleAssignment
 
     alias process_orig process
 
-    attr_reader :comment_parser, :method_calls
+    attr_reader :comment_parser #: CommentParser
+    attr_reader :method_calls #: Hash[RBS::Namespace, Array[MethodCall]]
 
-    def initialize
+    def initialize #: void
       super
       @comment_parser = CommentParser.new
       @method_calls = Hash.new { |hash, key| hash[key] = [] }
     end
 
-    def parse(string)
+    # @rbs string: String
+    def parse(string) #: void
       comment_parser.parse(string)
       super
     end
 
+    # @rbs override
     def process(node, decls:, comments:, context:)
       case node.type
       when :FCALL, :VCALL
@@ -57,11 +72,13 @@ module RbsActivesupport
       end
     end
 
-    def trailing_comment_for(node)
+    # @rbs node: RubyVM::AbstractSyntaxTree::Node
+    def trailing_comment_for(node) #: String?
       comment_parser.trailing_comments[node.last_lineno]
     end
 
-    def private?(decls)
+    # @rbs decls: Array[RBS::AST::Declarations::t | RBS::AST::Members::t]
+    def private?(decls) #: bool
       current_accessibility(decls) == private
     end
   end