rbs_activerecord 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b4083cdfd1907ddd9ba845bf3535ed264504753c6fe80c08ac723891a0c990aa
+  data.tar.gz: 8825d942ba46a8b35cd4aa3d57ef723aa7fbc51333d7fe30bdca1b143ed73693
+SHA512:
+  metadata.gz: '07838fda26b2d56872fa91f7d3d9a89b2eb89c5c93591722547ca27af65d65ff72ae1703c8366d4c556559d18cbcc8668930c8c4e2bbb7c89aaaa3e1b7ec84a3'
+  data.tar.gz: 605694bc6458aa4f6076d89add3a162c66edceefd357f2402e989a093f898b853f1d363cf7d121a4e5e49befa4747bd99c2ae9a52f2a89502f25361ee1865ccf

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Layout/LeadingCommentSpace:
+  AllowRBSInlineAnnotation: true
+  AllowSteepAnnotation: true
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*.rb"
+
+Metrics/MethodLength:
+  Max: 30
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/.vscode/extensions.json

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

data/.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+    "[ruby]": {
+        "editor.defaultFormatter": "Shopify.ruby-lsp"
+    },
+    "rbs-helper.rbs-inline-signature-directory": "sig/",
+    "rbs-helper.rbs-inline-on-save": true,
+    "cSpell.words": [
+        "activerecord",
+        "codebases",
+        "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_activerecord
+
+rbs_activerecord is a RBSGenerator for models built with ActiveRecord.
+
+## Installation
+
+Add a new entry to your Gemfile and run `bundle install`:
+
+  group :development do
+    gem 'rbs_activerecord', require: false
+  end
+
+After the installation, please run rake task generator:
+
+  bundle exec rails g rbs_activerecord:install
+
+## Usage
+
+Run `rbs:activerecord:setup` task:
+
+  bundle exec rake rbs:activerecord:setup
+
+Then rbs_activerecord will scan your code and generate RBS files into
+`sig/activerecord` 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_activerecord.
+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_activerecord/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_activerecord project's codebases, issue trackers is expected to
+follow the [code of conduct](https://github.com/tk0miya/rbs_activerecord/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop
+
+namespace :rbs do
+  task :generate do
+    sh "rbs-inline", "--opt-out", "--output=sig", "lib"
+  end
+end

data/Steepfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+end

data/lib/generators/rbs_activerecord/install_generator.rb

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

data/lib/rbs_activerecord/generator/active_storage/instance_methods.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module ActiveStorage
+      class InstanceMethods
+        attr_reader :model #: RbsActiverecord::Model
+
+        # @rbs model: RbsActiverecord::Model
+        def initialize(model) #: void
+          @model = model
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedActiveStorageInstanceMethods
+              #{attachments.map { |name, reflection| attachment(name, reflection) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def attachments #: Hash[String, untyped]
+          if model.klass.respond_to?(:attachment_reflections)
+            model.klass.attachment_reflections # steep:ignore
+          else
+            {}
+          end
+        end
+
+        # @rbs name: String
+        def attachment(name, reflection) #: String
+          case reflection.macro
+          when :has_one_attached
+            <<~RBS
+              def #{name}: () -> ::ActiveStorage::Attached::One
+              def #{name}=: (::ActionDispatch::Http::UploadedFile) -> ::ActionDispatch::Http::UploadedFile
+                          | (::Rack::Test::UploadedFile) -> ::Rack::Test::UploadedFile
+                          | (::ActiveStorage::Blob) -> ::ActiveStorage::Blob
+                          | (::String) -> ::String
+                          | ({ io: ::IO, filename: ::String, content_type: ::String? }) -> { io: ::IO, filename: ::String, content_type: ::String? }
+                          | (nil) -> nil
+            RBS
+          when :has_many_attached
+            <<~RBS
+              def #{name}: () -> ::ActiveStroage::Attached::Many
+              def #{name}=: (untyped) -> untyped
+            RBS
+          else
+            raise "unknown macro: #{reflection.macro}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/active_storage/scopes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module ActiveStorage
+      class Scopes
+        attr_reader :model #: RbsActiverecord::Model
+
+        # @rbs model: RbsActiverecord::Model
+        def initialize(model) #: void
+          @model = model
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedActiveStorageScopeMethods[Relation]
+              #{attachments.map { |name, _| attachment(name) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def attachments #: Hash[String, untyped]
+          if model.klass.respond_to?(:attachment_reflections)
+            model.klass.attachment_reflections # steep:ignore
+          else
+            {}
+          end
+        end
+
+        # @rbs name: String
+        def attachment(name) #: String
+          "def with_attached_#{name}: () -> Relation"
+        end
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/associations.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    class Associations
+      include Utils
+
+      attr_reader :model #: RbsActiverecord::Model
+
+      # @rbs model: RbsActiverecord::Model
+      def initialize(model) #: void
+        @model = model
+      end
+
+      def generate #: String
+        <<~RBS.strip
+          module GeneratedAssociationMethods
+            #{has_many}
+            #{has_one}
+            #{belongs_to}
+            #{has_and_belongs_to_many}
+          end
+        RBS
+      end
+
+      private
+
+      def has_many #: String  # rubocop:disable Naming/PredicateName
+        model.reflect_on_all_associations(:has_many).map do |assoc|
+          assoc_name = assoc.name.to_s
+          klass_name = assoc.klass.name
+          collection = "#{klass_name}::ActiveRecord_Associations_CollectionProxy"
+          primary_key_type = primary_key_type_for(assoc.klass)
+
+          <<~RBS
+            def #{assoc_name}: () -> #{collection}
+            def #{assoc_name}=: (#{collection} | Array[::#{klass_name}]) -> (#{collection} | Array[::#{klass_name}])
+            def #{assoc_name.singularize}_ids: () -> Array[#{primary_key_type}]
+            def #{assoc_name.singularize}_ids=: (Array[#{primary_key_type}]) -> Array[#{primary_key_type}]
+          RBS
+        end.join("\n")
+      end
+
+      def has_one #: String  # rubocop:disable Naming/PredicateName
+        model.reflect_on_all_associations(:has_one).map do |assoc|
+          type = assoc.klass.name
+          optional = "#{type}?"
+
+          <<~RBS
+            def #{assoc.name}: () -> #{optional}
+            def #{assoc.name}=: (#{optional}) -> #{optional}
+            def build_#{assoc.name}: (?untyped) -> #{type}
+            def create_#{assoc.name}: (untyped) -> #{type}
+            def create_#{assoc.name}!: (untyped) -> #{type}
+            def reload_#{assoc.name}: () -> #{optional}
+            def reset_#{assoc.name}: () -> void
+            def #{assoc.name}_changed?: () -> bool
+            def #{assoc.name}_previously_changed?: () -> bool
+          RBS
+        end.join("\n")
+      end
+
+      def belongs_to #: String  # rubocop:disable Metrics/AbcSize
+        model.reflect_on_all_associations(:belongs_to).map do |assoc|
+          is_optional = assoc.options[:optional]
+          type = assoc.polymorphic? ? polymorphic_owner_types(assoc) : assoc.klass.name
+          optional = "#{type}?"
+
+          # @type var methods: Array[String]
+          methods = []
+          methods << "def #{assoc.name}: () -> #{is_optional ? optional : type}"
+          methods << "def #{assoc.name}=: (#{optional}) -> #{optional}"
+          unless assoc.polymorphic?
+            methods << "def build_#{assoc.name}: (untyped) -> #{type}"
+            methods << "def create_#{assoc.name}: (untyped) -> #{type}"
+            methods << "def create_#{assoc.name}!: (untyped) -> #{type}"
+          end
+          methods << "def reload_#{assoc.name}: () -> #{optional}"
+          methods << "def reset_#{assoc.name}: () -> void"
+          methods.join("\n")
+        end.join("\n")
+      end
+
+      # @rbs assoc: untyped
+      def polymorphic_owner_types(assoc) #: String  # rubocop:disable Metrics/AbcSize
+        table_name = model.klass.name.to_s.tableize.to_sym
+        owners = ActiveRecord::Base.descendants.select do |klass|
+          klass.reflect_on_all_associations.any? { |a| a.name == table_name && a.options[:as] == assoc.name }
+        end
+
+        if owners.empty?
+          "untyped"
+        elsif owners.size == 1
+          owners.first.name
+        else
+          names = owners.map(&:name).sort.join(" | ")
+          "(#{names})"
+        end
+      end
+
+      def has_and_belongs_to_many #: String  # rubocop:disable Naming/PredicateName
+        model.reflect_on_all_associations(:has_and_belongs_to_many).map do |assoc|
+          assoc_name = assoc.name.to_s
+          klass_name = assoc.klass.name
+          collection = "#{klass_name}::ActiveRecord_Associations_CollectionProxy"
+          primary_key_type = primary_key_type_for(assoc.klass)
+
+          <<~RBS
+            def #{assoc_name}: () -> #{collection}
+            def #{assoc_name}=: (#{collection} | Array[::#{klass_name}]) -> (#{collection} | Array[::#{klass_name}])
+            def #{assoc_name.singularize}_ids: () -> Array[#{primary_key_type}]
+            def #{assoc_name.singularize}_ids=: (Array[#{primary_key_type}]) -> Array[#{primary_key_type}]
+          RBS
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/attributes.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    class Attributes
+      include Utils
+
+      attr_reader :model #: RbsActiverecord::Model
+
+      # @rbs model: RbsActiverecord::Model
+      def initialize(model) #: void
+        @model = model
+      end
+
+      def generate #: String
+        <<~RBS
+          module GeneratedAttributeMethods
+            #{model.columns.map { |c| column(c) }.join("\n")}
+            #{attributes.map { |name, type| attribute(name, type) }.join("\n")}
+            #{model.attribute_aliases.map { |from, to| alias_method(from, to) }.join("\n")}
+          end
+        RBS
+      end
+
+      private
+
+      def column(col) #: String  # rubocop:disable Metrics/AbcSize
+        type = sql_type_to_class(col.type)
+        optional = "#{type}?"
+        column_type = col.null ? optional : type
+
+        <<~RBS
+          def #{col.name}: () -> #{column_type}
+          def #{col.name}=: (#{column_type}) -> #{column_type}
+          def #{col.name}?: () -> bool
+          def #{col.name}_changed?: () -> bool
+          def #{col.name}_change: () -> [#{optional}, #{optional}]
+          def #{col.name}_will_change!: () -> void
+          def #{col.name}_was: () -> #{optional}
+          def #{col.name}_previously_changed?: () -> bool
+          def #{col.name}_previous_change: () -> ::Array[#{optional}]?
+          def #{col.name}_previously_was: () -> #{optional}
+          def #{col.name}_before_last_save: () -> #{optional}
+          def #{col.name}_change_to_be_saved: () -> ::Array[#{optional}]?
+          def #{col.name}_in_database: () -> #{optional}
+          def saved_change_to_#{col.name}: () -> ::Array[#{optional}]?
+          def saved_change_to_#{col.name}?: () -> bool
+          def will_save_change_to_#{col.name}?: () -> bool
+          def restore_#{col.name}!: () -> void
+          def clear_#{col.name}_change: () -> void
+        RBS
+      end
+
+      def attributes #: Hash[String, untyped]
+        model.attribute_types.filter_map do |name, type|
+          [name, type] if model.columns.none? { |col| col.name == name }
+        end.to_h
+      end
+
+      # @rbs name: String
+      # @rbs type: untyped
+      def attribute(name, type) #: String
+        column_type = sql_type_to_class(type.type)
+
+        <<~RBS
+          def #{name}: () -> #{column_type}
+          def #{name}=: (#{column_type}) -> #{column_type}
+        RBS
+      end
+
+      def alias_method(from, to) #: String
+        <<~RBS
+          alias #{from} #{to}
+          alias #{from}= #{to}=
+          alias #{from}? #{to}?
+          alias #{from}_changed? #{to}_changed?
+          alias #{from}_change #{to}_change
+          alias #{from}_will_change! #{to}_will_change!
+          alias #{from}_was #{to}_was
+          alias #{from}_previously_changed? #{to}_previously_changed?
+          alias #{from}_previous_change #{to}_previous_change
+          alias #{from}_previously_was #{to}_previously_was
+          alias #{from}_before_last_save #{to}_before_last_save
+          alias #{from}_change_to_be_saved #{to}_change_to_be_saved
+          alias #{from}_in_database #{to}_in_database
+          alias saved_change_to_#{from} saved_change_to_#{to}
+          alias saved_change_to_#{from}? saved_change_to_#{to}?
+          alias will_save_change_to_#{from}? will_save_change_to_#{to}?
+          alias restore_#{from}! restore_#{to}!
+          alias clear_#{from}_change clear_#{to}_change
+        RBS
+      end
+    end
+  end
+end

data/lib/rbs_activerecord/generator/delegated_type/instance_methods.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RbsActiverecord
+  class Generator
+    module DelegatedType
+      class InstanceMethods
+        include Utils
+
+        attr_reader :model #: RbsActiverecord::Model
+        attr_reader :declarations #: Array[Prism::CallNode]
+
+        # @rbs model: RbsActiverecord::Model
+        # @rbs declarations: Hash[String, Array[Prism::CallNode]]
+        def initialize(model, declarations) #: void
+          @model = model
+          @declarations = declarations.fetch(model.klass.name.to_s, [])
+        end
+
+        def generate #: String
+          <<~RBS.strip
+            module GeneratedDelegatedTypeInstanceMethods
+              #{delegated_types.map { |node| delegated_type(node) }.join("\n")}
+            end
+          RBS
+        end
+
+        private
+
+        def delegated_types #: Array[Prism::CallNode]
+          declarations.select { |node| node.name == :delegated_type }
+        end
+
+        # @rbs node: Prism::CallNode
+        def delegated_type(node) #: String
+          arguments = node.arguments&.arguments || []
+          name, options = arguments.map { |arg| Parser.eval_node(arg) } #: [String?, Hash[Symbol, untyped]]
+          return "" unless name
+
+          types = options[:types]
+          role_methods = <<~RBS
+            def #{name}_class: () -> (#{types.join(" | ")})
+            def #{name}_name: () -> String
+          RBS
+
+          type_methods = types.map do |type|
+            <<~RBS
+              def #{type.underscore}?: () -> bool
+              def #{type.underscore}: () -> #{type}?
+              def #{type.underscore}_id: () -> #{primary_key_type_for(type)}?
+            RBS
+          end.join("\n")
+
+          role_methods + type_methods
+        end
+
+        # @rbs klass_name: String
+        def primary_key_type_for(klass_name) #: String
+          klass = Object.const_get(klass_name)
+          super(klass)
+        rescue NameError
+          "::Integer"
+        end
+      end
+    end
+  end
+end