rbs_activesupport 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 15aaf2bfe1439cdfd04de74b02a684b4dd81be4a076378f8746b6f65fef6eae2
+  data.tar.gz: b8f442d762f030c4f7eec6f36de7be7ff90f027968b056e1d996c1da47c7ad0e
+SHA512:
+  metadata.gz: 60d85781b44efb807e298c2dc5c261fd135553ba36d08460a99cfc67688616da7171d472fd4d1744c06700ad6caf006433fc70d612ae9c38cde932990e85bdc8
+  data.tar.gz: 8ee761e2ce8f2ee1b4e18a90501ee6250ac618351e937abcef5a3cb2e9141e3f128f046d7329ca3174d8f88c6297f9ad832e6fc42ff8f83522c6aedd41b53f17

data/.rubocop.yml

@@ -0,0 +1,32 @@
+AllCops:
+  TargetRubyVersion: 2.7
+
+Metrics/AbcSize:
+  Max: 25
+  Exclude:
+    - "lib/rbs_activesupport/ast.rb"
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*.rb"
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/rbs_activesupport/ast.rb"
+
+Metrics/MethodLength:
+  Max: 30
+  Exclude:
+    - "lib/rbs_activesupport/ast.rb"
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "shopify.ruby-lsp",
+        "soutaro.steep-vscode",
+        "tk0miya.rbs-helper"
+    ]
+}

data/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "rbs-helper.signature-directory": "sig/",
+    "cSpell.words": [
+        "Cyclomatic"
+    ]
+}

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Takeshi KOMIYA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# rbs_activesupport
+
+rbs_activesupport is a RBS generator for Active Support.
+
+## Installation
+
+Add a new entry to your Gemfile and run `bundle install`:
+
+    group :development do
+      gem 'rbs_activesupport', require: false
+    end
+
+After the installation, please run rake task generator:
+
+    bundle exec rails g rbs_activesupport:install
+
+## Usage
+
+Run `rbs:activesupport:setup` task:
+
+    bundle exec rake rbs:activesupport:setup
+
+Then rbs_activesupport will scan your source code and generate RBS file into `sig/activesupport` directory.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also
+run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version, update the version number in `version.rb`, and then put
+a git tag (ex. `git tag v1.0.0`) and push it to the GitHub. Then GitHub Actions
+will release a new package to [rubygems.org](https://rubygems.org) automatically.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tk0miya/rbs_activesupport.
+This project is intended to be a safe, welcoming space for collaboration, and contributors are
+expected to adhere to the [code of conduct](https://github.com/tk0miya/rbs_activesupport/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the rbs_activesupport project's codebases, issue trackers is expected to
+follow the [code of conduct](https://github.com/tk0miya/rbs_activesupport/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/Steepfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  configure_code_diagnostics(D::Ruby.lenient)
+end

data/lib/generators/rbs_activesupport/install_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module RbsActivesupport
+  class InstallGenerator < Rails::Generators::Base
+    def create_raketask
+      create_file "lib/tasks/rbs_activesupport.rake", <<~RUBY
+        # frozen_string_literal: true
+
+        begin
+          require 'rbs_activesupport/rake_task'
+
+          RbsActivesupport::RakeTask.new do |task|
+          end
+        rescue LoadError
+          # failed to load rbs_activesupport. Skip to load rbs_activesupport tasks.
+        end
+      RUBY
+    end
+  end
+end

data/lib/rbs_activesupport/ast.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  module AST
+    def eval_args(node)
+      # @type var args: Array[Array[Symbol?]]
+      *args, _ = eval_node(node)
+      args
+    end
+
+    def eval_args_with_options(node)
+      # @type var methods: Array[Symbol]
+      # @type var options: Hash[Symbol, untyped]
+      *args, _ = eval_node(node)
+      if args.last.is_a?(Hash)
+        options = args.pop
+        [args, options]
+      else
+        [args, {}]
+      end
+    end
+
+    def eval_node(node)
+      case node
+      when nil
+        nil
+      when Symbol, Hash # Only for debug use
+        node
+      when Array
+        node.map { |e| eval_node(e) }
+      when RubyVM::AbstractSyntaxTree::Node
+        case node.type
+        when :LIT
+          node.children.first
+        when :HASH
+          elem = node.children.first.children.compact.map { |e| eval_node(e) }
+          Hash[*elem]
+        when :TRUE
+          true
+        when :FALSE
+          false
+        when :NIL
+          nil
+        when :CONST
+          node.children
+        when :COLON2
+          eval_node(node.children.first) + [node.children.last]
+        when :COLON3
+          [nil, node.children.first]
+        else
+          p node # for debug
+          raise
+        end
+      else
+        p node # for debug
+        raise
+      end
+    end
+  end
+end

data/lib/rbs_activesupport/attribute_accessor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class AttributeAccessor
+    attr_reader :name, :options
+
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+
+    def singleton_reader?
+      options.fetch(:singleton_reader, true)
+    end
+
+    def singleton_writer?
+      options.fetch(:singleton_writer, true)
+    end
+
+    def instance_accessor?
+      options.fetch(:instance_accessor, true)
+    end
+
+    def instance_reader?
+      options.fetch(:instance_reader, instance_accessor?)
+    end
+
+    def instance_writer?
+      options.fetch(:instance_writer, instance_accessor?)
+    end
+
+    def public?
+      !private?
+    end
+
+    def private?
+      options.fetch(:private, false)
+    end
+  end
+end

data/lib/rbs_activesupport/class_attribute.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class ClassAttribute
+    attr_reader :name, :options
+
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+
+    def instance_accessor?
+      options.fetch(:instance_accessor, true)
+    end
+
+    def instance_reader?
+      options.fetch(:instance_reader, instance_accessor?)
+    end
+
+    def instance_writer?
+      options.fetch(:instance_writer, instance_accessor?)
+    end
+
+    def instance_predicate?
+      options.fetch(:instance_predicate, true)
+    end
+
+    def public?
+      !private?
+    end
+
+    def private?
+      options.fetch(:private, false)
+    end
+  end
+end

data/lib/rbs_activesupport/declaration_builder.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class DeclarationBuilder
+    include AST
+
+    attr_reader :method_searcher
+
+    def initialize(method_searcher)
+      @method_searcher = method_searcher
+    end
+
+    def build(namespace, method_calls)
+      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
+    end
+
+    private
+
+    def build_method_calls(namespace, method_calls)
+      method_calls.flat_map do |method_call|
+        case method_call.name
+        when :class_attribute
+          build_class_attribute(method_call)
+        when :delegate
+          build_delegate(namespace, method_call)
+        when :cattr_accessor, :mattr_accessor, :cattr_reader, :mattr_reader, :cattr_writer, :mattr_writer
+          build_attribute_accessor(method_call)
+        when :include
+          build_include(namespace, method_call)
+        end
+      rescue StandardError => e
+        puts "ERROR: #{namespace}:#{method_call.name}: Failed to build method calls: #{e}"
+        nil
+      end.compact
+    end
+
+    def build_attribute_accessor(method_call)
+      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?
+      methods.map do |method|
+        AttributeAccessor.new(method, options)
+      end
+    end
+
+    def build_class_attribute(method_call)
+      methods, options = eval_args_with_options(method_call.args)
+      options[:private] = true if method_call.private?
+      methods.map do |method|
+        ClassAttribute.new(method, options)
+      end
+    end
+
+    def build_delegate(namespace, method_call)
+      methods, options = eval_args_with_options(method_call.args)
+      options[:private] = true if method_call.private?
+      methods.map do |method|
+        Delegate.new(namespace, method, options)
+      end
+    end
+
+    def build_include(namespace, method_call)
+      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)
+      case decl
+      when AttributeAccessor
+        render_attribute_accessor(decl)
+      when ClassAttribute
+        render_class_attribute(decl)
+      when Delegate
+        render_delegate(decl)
+      when Include
+        render_include(decl)
+      end
+    end
+
+    def render_attribute_accessor(decl)
+      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.join("\n")
+    end
+
+    def render_class_attribute(decl)
+      methods = []
+      methods << "def self.#{decl.name}: () -> untyped"
+      methods << "def self.#{decl.name}=: (untyped) -> untyped"
+      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}?: () -> bool" if decl.instance_predicate? && decl.instance_reader?
+      methods.join("\n")
+    end
+
+    def render_delegate(decl)
+      method_types = method_searcher.method_types_for(decl)
+
+      "def #{decl.method_name}: #{method_types.join(" | ")}"
+    end
+
+    def render_include(decl)
+      return unless decl.concern? && decl.classmethods?
+
+      <<~RBS
+        include #{decl.argument.to_s.delete_suffix("::")}
+        extend #{decl.argument}ClassMethods
+      RBS
+    end
+  end
+end

data/lib/rbs_activesupport/delegate.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class Delegate
+    attr_reader :namespace, :method, :options
+
+    def initialize(namespace, method, options)
+      @namespace = namespace
+      @method = method
+      @options = options
+    end
+
+    def to
+      options[:to]
+    end
+
+    def method_name
+      case options[:prefix]
+      when true
+        :"#{to}_#{method}"
+      when String, Symbol
+        :"#{options[:prefix]}_#{method}"
+      else
+        method
+      end
+    end
+
+    def public?
+      !private?
+    end
+
+    def private?
+      options.fetch(:private, false)
+    end
+  end
+end

data/lib/rbs_activesupport/generator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RbsActivesupport
+  class Generator
+    def self.generate(pathname, rbs_builder)
+      new(pathname, rbs_builder).generate
+    end
+
+    attr_reader :pathname, :declaration_builder
+
+    def initialize(pathname, rbs_builder)
+      @pathname = pathname
+
+      method_searcher = MethodSearcher.new(rbs_builder)
+      @declaration_builder = DeclarationBuilder.new(method_searcher)
+    end
+
+    def generate
+      declarations = parse_source_code
+      return if declarations.empty?
+
+      definition = declarations.map do |namespace, method_calls|
+        public_decls, private_decls = declaration_builder.build(namespace, method_calls)
+        next if public_decls.empty? && private_decls.empty?
+
+        <<~RBS
+          #{header(namespace)}
+          #{public_decls.join("\n")}
+
+          #{"private" if private_decls.any?}
+
+          #{private_decls.join("\n")}
+
+          #{footer(namespace)}
+        RBS
+      end.compact.join("\n")
+
+      return if definition.empty?
+
+      format(definition)
+    end
+
+    private
+
+    def format(rbs)
+      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
+      parser = Parser.new
+      parser.parse(pathname.read)
+      parser.method_calls
+    end
+
+    def header(namespace)
+      context = +""
+      namespace.path.map do |mod_name|
+        context += "::#{mod_name}"
+        mod_object = Object.const_get(context)
+        case mod_object
+        when Class
+          # @type var superclass: Class
+          superclass = _ = mod_object.superclass
+          superclass_name = superclass.name || "Object"
+
+          "class #{mod_name} < ::#{superclass_name}"
+        when Module
+          "module #{mod_name}"
+        else
+          raise "unreachable"
+        end
+      end.join("\n")
+    end
+
+    def footer(namespace)
+      "end\n" * namespace.path.size
+    end
+  end
+end