rbs_activesupport 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15aaf2bfe1439cdfd04de74b02a684b4dd81be4a076378f8746b6f65fef6eae2
-  data.tar.gz: b8f442d762f030c4f7eec6f36de7be7ff90f027968b056e1d996c1da47c7ad0e
+  metadata.gz: 2e77fa40a7a5219ebb44f4f61f46e6191d57fdbb484ee21bf56482e1e39f15be
+  data.tar.gz: e357c7dcb7a169e1fb4134bb3f86fdfe7651a79ce705de666c0d131defc632e0
 SHA512:
-  metadata.gz: 60d85781b44efb807e298c2dc5c261fd135553ba36d08460a99cfc67688616da7171d472fd4d1744c06700ad6caf006433fc70d612ae9c38cde932990e85bdc8
-  data.tar.gz: 8ee761e2ce8f2ee1b4e18a90501ee6250ac618351e937abcef5a3cb2e9141e3f128f046d7329ca3174d8f88c6297f9ad832e6fc42ff8f83522c6aedd41b53f17
+  metadata.gz: fc3430776bd189fa7af3ba83d205328adb8222cc26061fa3f3069e0ad0ea9ffa6140a9f2d6dcfa19720eec0970b2f9f16d16ef11d8c0e1de72d749d0c8572298
+  data.tar.gz: 3a9f7bc7e633726b9928db97d93937c3b753b6bfbe2a796b161cb11dc8acd66360a654d274bd7cfa9d91209bc062bc6b348e9470125ebd5ac4ca2f47bfa95b79

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

@@ -1,6 +1,10 @@
 {
     "rbs-helper.signature-directory": "sig/",
     "cSpell.words": [
-        "Cyclomatic"
-    ]
+        "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:
@@ -22,6 +29,68 @@ Run `rbs:activesupport:setup` task:
 
 Then rbs_activesupport will scan your source code and generate RBS file into `sig/activesupport` directory.
 
+rbs_activesupport will generate types for the following code:
+
+* auto-extend on including ActiveSupport::Concern module
+* delegate
+* class_attribute, cattr_* and mattr_*
+
+
+### auto-extend on including ActiveSupport::Concern module
+
+The concern modules using `ActiveSupport::Concern` can provide the sub module named
+`ClassMethods`.  It is useful to define class methods to the including class.
+
+Extending the `ClassMethods` on including the concern module goes automatically and
+silently.  So developers who uses the concern modules don't know the concern modules
+automatically call "extend" in the background.
+
+On the other hand, in the Type World, Steep and RBS does not support auto-extending.
+Therefore we need to define the "extend" call manually.
+
+For example, we need to write the "extend" call like the following:
+
+```ruby
+# user.rbs
+class User
+  include ActiveModel::Attribute
+  extend ActiveModel::Attribute::ClassMethods
+end
+```
+
+rbs_activesupport detects the including concern modules and generates the "extend"
+call automatically if the concern modules have `ClassMethods` module.
+
+### delegate
+
+ActiveSupport provides `delegate` method to delegate the method calls to the other
+objects.  It's very useful and powerful.
+
+But RBS generators like `rbs prototype rb` and `rbs-inline` does not support it.
+As a result, the delegation methods are missing in the RBS files.
+
+rbs_activesupport detects the `delegate` method call and generates the types for
+them automatically.
+
+### class_attribute, cattr_* and mattr_*
+
+ActiveSupport provides some methods to define class attributes and accessors:
+
+* `class_attribute`
+* `cattr_accessor`, `cattr_reader`, `cattr_writer`
+* `mattr_accessor`, `mattr_reader`, `mattr_writer`
+
+rbs_activesupport detects the calls of these methods and generates the types
+for them.
+
+Additionally, rbs_activesupport also supports the type annotation comment like RBS::Inline.
+
+```ruby
+class User
+  class_attribute :name  #: String
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also

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,38 +2,51 @@
 
 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 singleton_reader?
+    def type #: String
+      # @type var trailng_comment: String?
+      trailing_comment = options[:trailing_comment]
+      if trailing_comment&.start_with?("#:")
+        trailing_comment[2..].strip
+      else
+        "untyped"
+      end
+    end
+
+    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,34 +2,47 @@
 
 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 instance_accessor?
+    def type #: String
+      # @type var trailng_comment: String?
+      trailing_comment = options[:trailing_comment]
+      if trailing_comment&.start_with?("#:")
+        trailing_comment[2..].strip
+      else
+        "untyped"
+      end
+    end
+
+    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,27 +43,33 @@ 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)
       options[:instance_reader] = false if %i[cattr_writer mattr_writer].include?(method_call.name)
       options[:instance_writer] = false if %i[cattr_reader mattr_reader].include?(method_call.name)
       options[:private] = true if method_call.private?
+      options[:trailing_comment] = method_call.trailing_comment
       methods.map do |method|
         AttributeAccessor.new(method, options)
       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
       methods.map do |method|
         ClassAttribute.new(method, options)
       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|
@@ -64,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)
@@ -84,33 +100,37 @@ module RbsActivesupport
       end
     end
 
-    def render_attribute_accessor(decl)
+    # @rbs decl: AttributeAccessor
+    def render_attribute_accessor(decl) #: String
       methods = []
-      methods << "def self.#{decl.name}: () -> untyped" if decl.singleton_reader?
-      methods << "def self.#{decl.name}=: (untyped) -> untyped" if decl.singleton_writer?
-      methods << "def #{decl.name}: () -> untyped" if decl.instance_reader?
-      methods << "def #{decl.name}=: (untyped) -> untyped" if decl.instance_writer?
+      methods << "def self.#{decl.name}: () -> (#{decl.type})" if decl.singleton_reader?
+      methods << "def self.#{decl.name}=: (#{decl.type}) -> (#{decl.type})" if decl.singleton_writer?
+      methods << "def #{decl.name}: () -> (#{decl.type})" if decl.instance_reader?
+      methods << "def #{decl.name}=: (#{decl.type}) -> (#{decl.type})" if decl.instance_writer?
       methods.join("\n")
     end
 
-    def render_class_attribute(decl)
+    # @rbs decl: ClassAttribute
+    def render_class_attribute(decl) #: String
       methods = []
-      methods << "def self.#{decl.name}: () -> untyped"
-      methods << "def self.#{decl.name}=: (untyped) -> untyped"
+      methods << "def self.#{decl.name}: () -> (#{decl.type})"
+      methods << "def self.#{decl.name}=: (#{decl.type}) -> (#{decl.type})"
       methods << "def self.#{decl.name}?: () -> bool" if decl.instance_predicate?
-      methods << "def #{decl.name}: () -> untyped" if decl.instance_reader?
-      methods << "def #{decl.name}=: (untyped) -> untyped" if decl.instance_writer?
+      methods << "def #{decl.name}: () -> (#{decl.type})" if decl.instance_reader?
+      methods << "def #{decl.name}=: (#{decl.type}) -> (#{decl.type})" if decl.instance_writer?
       methods << "def #{decl.name}?: () -> bool" if decl.instance_predicate? && decl.instance_reader?
       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,13 +4,15 @@ 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) }
 
@@ -25,7 +27,9 @@ module RbsActivesupport
 
     private
 
-    def lookup_method_types(type_name, method)
+    # @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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class Parser
+    class CommentParser
+      attr_reader :line_comments #: Hash[Integer, String]
+      attr_reader :trailing_comments #: Hash[Integer, String]
+
+      def initialize #: void
+        @line_comments = {}
+        @trailing_comments = {}
+      end
+
+      # @rbs string: String
+      def parse(string) #: self
+        # @type var code_lines: Hash[Integer, bool]
+        code_lines = {}
+        Ripper.lex(string).each do |(line, _), type, token, _|
+          case type
+          when :on_sp, :on_ignored_nl
+            # ignore
+          when :on_comment
+            if code_lines[line]
+              trailing_comments[line] = token.chomp
+            else
+              line_comments[line] = token.chomp
+            end
+            :here
+          else
+            code_lines[line] = true
+          end
+        end
+
+        self
+      end
+    end
+  end
+end