orthoses-rails 0.9.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a43ce53af9e7aec6ef02751c5649146d817e76770a9b15bb2fb5a24fa1b0447b
-  data.tar.gz: 83c78756ff7794059a1001902f887509d8be7b42f116a2ce30b1cdb27d75ff6a
+  metadata.gz: ec337b1da4ecda39f953797824239ede59c536c74da48cc1dbd01e46eed1d2b0
+  data.tar.gz: b146481d3fda9b3568a1593fd05608f09c811e1181356f2e36d2b010c30dd130
 SHA512:
-  metadata.gz: bce1abdf1faf93222005ba51aa4c74675fc98edef98a546faecd52280bf03ce11dc896379ab7269c3c7bda3be43eddae81cf01ab6fc701e8a2e96d4f841dd7b8
-  data.tar.gz: be065396c52d757e110c2668e5eb90ada5f58275376bc93f0e9e4d25be4968735bccae5ace6d2ad7e08c8642b75b1ff5f5bd63b93c4019faba66101f1de34757
+  metadata.gz: 2bec23dc332048a010d10a2dc01754b969f76d2dd19bfa4b50393c1a764b3de496a35d018560aca04fe43630de497e900bb580774698bda3073ea33dcbf44bb5
+  data.tar.gz: e2dac22ee12a3bf049a73e5609d4a3ca1693c2dbc851c3bb06256e4566e9adad6c991fa9a60b0aaa7b22d6ea19e0c7cbc65c403cd136669d4c98b58deb7d90e7

data/README.md

@@ -3,38 +3,26 @@
 [Orthoses](https://github.com/ksss/orthoses) extension for Ruby on Rails.
 Orthoses::Rails automatically generates RBS for methods added by Rails.
 
-## Features
-
-### Orthoses::ActiveModel
-
-- `HasSecurePassword`
-  - Add signatures that generated form `has_secure_password`.
-
-### Orthoses::ActiveRecord
-
-- `BelongsTo`
-  - Add signatures that generated form `belongs_to`.
-- `DelegatedType`
-  - Add signatures that generated from `delegated_type`
-- `Enum`
-  - Add signatures that generated from `enum`
-- `HasMany`
-  - Add signatures that generated form `has_many`.
-- `HasOne`
-  - Add signatures that generated form `has_one`.
-- `Scope`
-  - Add signatures that generated form `scope`.
-
-### Orthoses::ActiveSupport
-
-- `ClassAttribute`
-  - Add signatures that generated form `class_attribute`.
-- `Configurable`
-  - Add signatures that generated from `config_accessor`
-- `Delegation`
-  - Add signatures that generated from `delegate`. The type definition of the method or instance variable specified by `to` is required.
-- `MattrAccessor`
-  - Add signatures that generated form `mattr_accessor`, `cattr_accessor`, `mattr_reader`, `cattr_reader`, `mattr_writer` and `cattr_writer`.
+## Usage
+
+If you have never performed rbs collection initialization, you need to do it.
+
+```
+$ bundle exec rbs collection init
+$ bundle exec rbs collection install
+```
+
+Build your Rake task for RBS generation.
+
+```
+$ bin/rails generate orthoses:rails:install
+```
+
+Then run the rake task.
+
+```
+$ bin/rails orthoses:rails
+```
 
 ## Installation
 
@@ -46,39 +34,6 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install orthoses-rails
 
-## Usage
-
-Build your Rake task for RBS generation.
-
-```rb
-task :rbs_generate => :environment do
-  Orthoses::Builder.new do
-    use Orthoses::CreateFileByName
-      base_dir: Rails.root.join("sig/out"),
-      header: "# !!! GENERATED CODE !!!"
-    use Orthoses::Filter do |name, _content|
-      path, _lineno = Object.const_source_location(name)
-      return false unless path
-      %r{app/models}.match?(path)
-    end
-    use YourCustom::Middleware
-    use Orthoses::ActiveModel::HasSecurePassword
-    use Orthoses::ActiveRecord::BelongsTo
-    use Orthoses::ActiveRecord::HasMany
-    use Orthoses::ActiveRecord::HasOne
-    use Orthoses::ActiveSupport::ClassAttribute
-    use Orthoses::ActiveSupport::MattrAccessor
-    use Orthoses::Mixin
-    use Orthoses::Constant, strict: false
-    use Orthoses::ObjectSpaceAll
-    use Orthoses::Autoload
-    run -> {
-      Rails.application.eager_load!
-    }
-  end.call
-end
-```
-
 ## 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.

data/lib/generators/orthoses/rails/install_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+require 'orthoses/rails'
+
+module Orthoses
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+
+        def copy_rake_task_file
+          copy_file "rails.rake", "lib/tasks/orthoses/rails.rake"
+        end
+      end
+    end
+  end
+end

data/lib/generators/orthoses/rails/templates/rails.rake

@@ -0,0 +1,31 @@
+namespace :orthoses do
+  task :rails do
+    # Phase to load libraries
+    require Rails.root / "config/application"
+    require 'orthoses/rails'
+
+    # You can choose logger level
+    Orthoses.logger.level = :warn
+
+    # DSL for Orthoses.
+    Orthoses::Builder.new do
+      use Orthoses::CreateFileByName,
+        to: 'sig/orthoses', # Write to this dir. (require)
+        depth: 1,           # Group files by module name path depth. (default: nil)
+        rmtree: true        # Remove all `to` dir before generation. (default: false)
+
+      # Complement missing const name.
+      use Orthoses::MissingName
+
+      # You can load hand written RBS.
+      # use Orthoses::LoadRBS,
+      #   paths: Dir.glob(Rails.root / "sig/hand-written/**/*.rbs")
+
+      # Middleware package for rails application.
+      use Orthoses::Rails::Application
+
+      # Application code loaded here is the target of the analysis.
+      run Orthoses::Rails::Application::Loader.new
+    end.call
+  end
+end

data/lib/orthoses/active_record/belongs_to.rb

@@ -15,7 +15,19 @@ module Orthoses
 
             lines = base.reflect_on_all_associations(:belongs_to).flat_map do |ref|
               # FIXME: Can I get list of class for polymorphic?
-              type = ref.polymorphic? ? 'untyped' : ref.klass.to_s
+              type = if ref.polymorphic?
+                'untyped'
+              else
+                begin
+                  Utils.module_name(ref.klass) or next
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
+              end
               opt = "#{type}?"
 
               [
@@ -38,9 +50,8 @@ module Orthoses
               content.concat(lines)
             end
 
-            store[base_name].tap do |content|
-              store[base_name] << "include #{generated_association_methods}"
-            end
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/enum.rb

@@ -20,6 +20,11 @@ module Orthoses
         enum.captures.each do |capture|
           base_name = Utils.module_name(capture.method.receiver) or next
 
+          sig = "include #{base_name}::ActiveRecord_Enum_EnumMethods"
+          if !store[base_name].body.include?(sig)
+            store[base_name] << sig
+          end
+
           if capture.argument[:definitions]
             # on rails 6
             definitions = capture.argument[:definitions].slice!(:_prefix, :_suffix, :_scopes, :_default)

data/lib/orthoses/active_record/generated_attribute_methods.rb

@@ -3,6 +3,30 @@
 module Orthoses
   module ActiveRecord
     class GeneratedAttributeMethods
+      TARGET_TYPE_MAP = {
+        "attribute" => "() -> %<type>s",
+        "attribute=" => "(%<type>s) -> %<type>s",
+        "attribute?" => "() -> bool",
+        "attribute_before_last_save" => "() -> %<opt>s",
+        "attribute_before_type_cast" => "() -> %<type>s",
+        "attribute_came_from_user?" => "() -> bool",
+        "attribute_change" => "() -> [%<opt>s, %<opt>s]",
+        "attribute_change_to_be_saved" => "() -> Array[%<opt>s]?",
+        "attribute_changed?" => "() -> bool",
+        "attribute_for_database" => "() -> %<type>s",
+        "attribute_in_database" => "() -> %<opt>s",
+        "attribute_previous_change" => "() -> Array[%<opt>s]?",
+        "attribute_previously_changed?" => "() -> bool",
+        "attribute_previously_was" => "() -> %<opt>s",
+        "attribute_was" => "() -> %<opt>s",
+        "attribute_will_change!" => "() -> void",
+        "clear_attribute_change" => "() -> void",
+        "restore_attribute!" => "() -> void",
+        "saved_change_to_attribute" => "() -> Array[%<opt>s]?",
+        "saved_change_to_attribute?" => "() -> bool",
+        "will_save_change_to_attribute?" => "() -> bool",
+      }
+
       def initialize(loader)
         @loader = loader
       end
@@ -12,71 +36,39 @@ module Orthoses
           ::ActiveRecord::Base.descendants.each do |klass|
             next if klass.abstract_class?
 
-            name = Utils.module_name(klass) || next
-            lines = klass.columns.flat_map do |col|
-              req = sql_type_to_rbs(col.type)
+            base_klass_name = Utils.module_name(klass) || next
+            begin
+              klass.columns
+            rescue ::ActiveRecord::StatementInvalid => e
+              Orthoses.logger.warn(e.to_s)
+              next
+            end
+
+            lines = []
+            klass.columns_hash.each do |name, col|
+              req = ActiveRecord.sql_type_to_rbs(col.type)
               opt = "#{req}?"
               type = col.null ? opt : req
 
-              [
-                "def #{col.name}: () -> #{type}",
-                "def #{col.name}=: (#{type}) -> #{type}",
-                "def #{col.name}?: () -> bool",
-                "def #{col.name}_changed?: () -> bool",
-                "def #{col.name}_change: () -> [#{opt}, #{opt}]",
-                "def #{col.name}_will_change!: () -> void",
-                "def #{col.name}_was: () -> #{opt}",
-                "def #{col.name}_previously_changed?: () -> bool",
-                "def #{col.name}_previous_change: () -> Array[#{opt}]?",
-                "def #{col.name}_previously_was: () -> #{opt}",
-                "def #{col.name}_before_last_save: () -> #{opt}",
-                "def #{col.name}_change_to_be_saved: () -> Array[#{opt}]?",
-                "def #{col.name}_in_database: () -> #{opt}",
-                "def saved_change_to_#{col.name}: () -> Array[#{opt}]?",
-                "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",
-              ]
+              ::ActiveRecord::Base.attribute_method_matchers.each do |matcher|
+                tmpl = TARGET_TYPE_MAP[matcher.target]
+                lines << "def #{matcher.method_name(name)}: #{tmpl % {type: type, opt: opt}}"
+              end
+            end
+            klass.attribute_aliases.each do |alias_name, column_name|
+              ::ActiveRecord::Base.attribute_method_matchers.each do |matcher|
+                lines << "alias #{matcher.method_name(alias_name)} #{matcher.method_name(column_name)}"
+              end
             end
-            generated_attribute_methods = "#{name}::AttributeMethods::GeneratedAttributeMethods"
-            store[name] << "include #{generated_attribute_methods}"
 
-            store["#{name}::AttributeMethods"].header = "module #{name}::AttributeMethods"
+            generated_attribute_methods = "#{base_klass_name}::GeneratedAttributeMethods"
+            store[base_klass_name] << "include #{generated_attribute_methods}"
+
             store[generated_attribute_methods].header = "module #{generated_attribute_methods}"
             store[generated_attribute_methods].concat(lines)
           end
         end
       end
-
-      # Thanks https://github.com/pocke/rbs_rails/blob/8a128a8d29f0861aa2c25aa4110ff7c2ea674865/lib/rbs_rails/active_record.rb#L525-L551
-      def sql_type_to_rbs(t)
-        case t
-        when :integer
-          'Integer'
-        when :float
-          'Float'
-        when :decimal
-          'BigDecimal'
-        when :string, :text, :citext, :uuid, :binary
-          'String'
-        when :datetime
-          'ActiveSupport::TimeWithZone'
-        when :boolean
-          "bool"
-        when :jsonb, :json
-          "untyped"
-        when :date
-          'Date'
-        when :time
-          'Time'
-        when :inet
-          "IPAddr"
-        else
-          # Unknown column type, give up
-          'untyped'
-        end
-      end
     end
   end
 end

data/lib/orthoses/active_record/has_many.rb

@@ -13,14 +13,23 @@ module Orthoses
             next if base.abstract_class?
             base_name = Utils.module_name(base) || next
 
-            collection_proxy = "#{base_name}::ActiveRecord_Associations_CollectionProxy"
-
             lines = base.reflect_on_all_associations(:has_many).flat_map do |ref|
               singular_name = ref.name.to_s.singularize
+              type =
+                begin
+                  Utils.module_name(ref.klass)
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
 
+              collection_proxy = "::#{type}::ActiveRecord_Associations_CollectionProxy"
               [
                 "def #{ref.name}: () -> #{collection_proxy}",
-                "def #{ref.name}=: (#{collection_proxy} | Array[#{ref.klass}]) -> (#{collection_proxy} | Array[#{ref.klass}])",
+                "def #{ref.name}=: (#{collection_proxy} | Array[#{type}]) -> (#{collection_proxy} | Array[#{type}])",
                 "def #{singular_name}_ids: () -> Array[Integer]",
                 "def #{singular_name}_ids=: (Array[Integer]) -> Array[Integer]",
               ]
@@ -29,7 +38,9 @@ module Orthoses
             generated_association_methods = "#{base_name}::GeneratedAssociationMethods"
             store[generated_association_methods].header = "module #{generated_association_methods}"
             store[generated_association_methods].concat(lines)
-            store[base_name] << "include #{generated_association_methods}"
+
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/has_one.rb

@@ -14,7 +14,16 @@ module Orthoses
             base_name = Utils.module_name(base) || next
 
             lines = base.reflect_on_all_associations(:has_one).flat_map do |ref|
-              type = ref.klass.to_s
+              type =
+                begin
+                  Utils.module_name(ref.klass) or next
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
               opt = "#{type}?"
 
               [
@@ -31,7 +40,8 @@ module Orthoses
             store[generated_association_methods].header = "module #{generated_association_methods}"
             store[generated_association_methods].concat(lines)
 
-            store[base_name] << "include #{generated_association_methods}"
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/relation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    class Relation
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          ::ActiveRecord::Base.descendants.each do |klass|
+            next if klass.abstract_class?
+
+            primary_key = fetch_primary_key(klass)
+
+            model_name = Utils.module_name(klass) or next
+            class_specific_relation = "#{model_name}::ActiveRecord_Relation"
+            class_specific_proxy = "#{model_name}::ActiveRecord_Associations_CollectionProxy"
+            class_specific_generated_relation_methods = "#{model_name}::GeneratedRelationMethods"
+
+            store[class_specific_generated_relation_methods].tap do |c|
+            end
+
+            store[class_specific_relation].tap do |c|
+              c.header = "class #{class_specific_relation} < ::ActiveRecord::Relation"
+              c << "include #{class_specific_generated_relation_methods}"
+              c << "include _ActiveRecord_Relation[#{model_name}, #{primary_key}]"
+              c << "include Enumerable[#{model_name}]"
+            end
+
+            store[class_specific_proxy].tap do |c|
+              c.header = "class #{class_specific_proxy} < ::ActiveRecord::Associations::CollectionProxy"
+              c << "include _ActiveRecord_Relation[#{model_name}, #{primary_key}]"
+            end
+
+            store[model_name].tap do |c|
+              c << "extend _ActiveRecord_Relation_ClassMethods[#{model_name}, #{class_specific_relation}, #{primary_key}]"
+            end
+          end
+        end
+      end
+
+      private
+
+      def fetch_primary_key(klass)
+        type = klass.type_for_attribute(klass.primary_key).type
+        ActiveRecord.sql_type_to_rbs(type)
+      rescue ::ActiveRecord::StatementInvalid => e
+        Orthoses.logger.warn(e.to_s)
+        "untyped"
+      end
+    end
+  end
+end
+

data/lib/orthoses/active_record/secure_token.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    # def has_secure_token(attribute = :token, length: MINIMUM_TOKEN_LENGTH)
+    class SecureToken
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        has_secure_token = CallTracer::Lazy.new
+        store = has_secure_token.trace('ActiveRecord::SecureToken::ClassMethods#has_secure_token') do
+          @loader.call
+        end
+
+        has_secure_token.captures.each do |capture|
+          base_name = Utils.module_name(capture.method.receiver) or next
+          attribute = capture.argument[:attribute]
+
+          store[base_name] << "def regenerate_#{attribute}: () -> bool"
+        end
+
+        store
+      end
+    end
+  end
+end

data/lib/orthoses/active_record.rb

@@ -7,4 +7,41 @@ require_relative 'active_record/generated_attribute_methods'
 require_relative 'active_record/has_many'
 require_relative 'active_record/has_one'
 require_relative 'active_record/query_methods'
+require_relative 'active_record/relation'
 require_relative 'active_record/scope'
+require_relative 'active_record/secure_token'
+
+module Orthoses
+  module ActiveRecord
+    # Thanks https://github.com/pocke/rbs_rails/blob/8a128a8d29f0861aa2c25aa4110ff7c2ea674865/lib/rbs_rails/active_record.rb#L525-L551
+    def self.sql_type_to_rbs(t)
+      case t
+      when :integer, :big_integer
+        '::Integer'
+      when :float
+        '::Float'
+      when :decimal
+        '::BigDecimal'
+      when :string, :text, :citext, :uuid, :binary, :immutable_string
+        '::String'
+      when :datetime
+        '::ActiveSupport::TimeWithZone'
+      when :boolean
+        "bool"
+      when :date
+        '::Date'
+      when :time
+        '::Time'
+      when :cidr, :inet
+        "::IPAddr"
+      when :bit, :bit_varying, :enum, :hstore,
+           :interval, :jsonb, :json, :legacy_point, :money, :point, :vector, :xml
+        # FIXME
+        'untyped'
+      else
+        # Unknown column type, give up
+        'untyped'
+      end
+    end
+  end
+end

data/lib/orthoses/active_storage/attached/model.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveStorage
+    module Attached
+      # <= 6.0
+      #   def has_one_attached(name, dependent: :purge_later)
+      # >= 6.1
+      #   def has_one_attached(name, dependent: :purge_later, service: nil, strict_loading: false)
+      class Model
+        def initialize(loader)
+          @loader = loader
+        end
+
+        def call
+          store = @loader.call
+
+          ::ActiveRecord::Base.descendants.each do |base|
+            next if base.abstract_class?
+            next if base.reflect_on_all_attachments.empty?
+
+            base_name = Utils.module_name(base) or next
+            base.reflect_on_all_attachments.each do |reflection|
+              type =
+                case reflection
+                when ::ActiveStorage::Reflection::HasOneAttachedReflection
+                  "ActiveStorage::Attached::One"
+                when ::ActiveStorage::Reflection::HasManyAttachedReflection
+                  "ActiveStorage::Attached::Many"
+                else
+                  "untyped"
+                end
+              name = reflection.name
+
+              store[base_name].tap do |content|
+                content << "def #{name}: () -> #{type}"
+                content << "def #{name}=: (untyped attachable) -> untyped"
+              end
+            end
+          end
+
+          store
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_storage.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'active_storage/attached/model'

data/lib/orthoses/active_support/aliasing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveSupport
+    # def alias_attribute(new_name, old_name)
+    class Aliasing
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        alias_attribute = CallTracer::Lazy.new
+
+        store =
+          alias_attribute.trace('Module#alias_attribute') do
+            @loader.call
+          end
+
+        alias_attribute.captures.each do |capture|
+          base_mod_name = Utils.module_name(capture.method.receiver) or next
+          new_name = capture.argument[:new_name]
+
+          content = store[base_mod_name]
+          # TODO: Shold use alias? But, it has risc of undefined method
+          content << "def #{new_name}: () -> untyped"
+          content << "def #{new_name}?: () -> bool"
+          content << "def #{new_name}=: (untyped) -> untyped"
+        end
+
+        store
+      end
+    end
+  end
+end