orthoses-rails 0.4.0 → 0.7.0

data/examples/rails/tasks/active_storage.rake

@@ -0,0 +1,94 @@
+require 'rbs'
+
+stdlib_dependencies = %w[time monitor singleton logger mutex_m json date benchmark digest forwardable did_you_mean openssl socket minitest]
+gem_dependencies = %w[nokogiri]
+rails_dependencies = %w[activesupport activemodel activejob activerecord]
+
+VERSIONS.each do |version|
+  namespace version do
+    namespace :active_storage do
+      export = "export/activestorage/#{version}"
+
+      desc "export to #{export}"
+      task :export do
+        sh "rm -fr #{export}"
+        sh "mkdir -p #{export}"
+
+        # base
+        sh "cp -a out/#{version}/active_storage.rbs #{export}"
+        sh "cp -a out/#{version}/active_storage #{export}"
+        sh "rm #{export}/active_storage/engine.rbs"
+        decls = RBS::Parser.parse_signature(RBS::Buffer.new(
+          content: File.read("out/#{version}/active_record/base.rbs"),
+          name: "out/#{version}/active_record/base.rbs"
+        )).map do |decl|
+          decl.members.select! do |member|
+            case member
+            when RBS::AST::Members::Mixin
+              # Remove ActiveStorage
+              member.name.to_s.include?("ActiveStorage")
+            end
+          end
+          decl
+        end
+        File.open("#{export}/active_record_base.rbs", "w+") do |f|
+          RBS::Writer.new(out: f).write(decls)
+        end
+
+        # TODO: remove after support action_controller
+        sh "rm -fr #{export}/active_storage/blobs"
+        sh "rm -fr #{export}/active_storage/representations"
+        Dir.glob("#{export}/active_storage/*_controller.rbs").each do |controller|
+          sh "rm -f #{controller}"
+        end
+        sh "rm -f #{export}/active_storage/streaming.rbs"
+
+        generate_test_script(
+          gem: :activestorage,
+          version: version,
+          export: export,
+          stdlib_dependencies: stdlib_dependencies,
+          gem_dependencies: gem_dependencies,
+          rails_dependencies: rails_dependencies,
+        )
+
+        Pathname(export).join('_test').join('test.rb').write(<<~RUBY)
+          # !!! GENERATED CODE !!!
+          # Please see generators/rails-generator
+
+          class User < ActiveRecord::Base
+            has_one_attached :one_image
+            has_many_attached :many_image
+          end
+
+          user = User.new
+          one = ActiveStorage::Attached::One.new("one_image", user)
+          one.url
+        RUBY
+
+        Pathname(export).join('_test').join('test.rbs').write(<<~RBS)
+          # !!! GENERATED CODE !!!
+          # Please see generators/rails-generator
+
+          class User < ActiveRecord::Base
+          end
+        RBS
+      end
+
+      desc "validate version=#{version} gem=active_storage"
+      task :validate do
+        stdlib_opt = stdlib_dependencies.map{"-r #{_1}"}.join(" ")
+        gem_opt = gem_dependencies.map{"-I ../../.gem_rbs_collection/#{_1}"}.join(" ")
+        rails_opt = rails_dependencies.map{"-I export/#{_1}/#{version}"}.join(" ")
+        sh "rbs #{stdlib_opt} #{gem_opt} #{rails_opt} -I #{export} validate --silent"
+      end
+
+      desc "install to ../../../gems/activestorage/#{version}"
+      task :install do
+        install_to = File.expand_path("../../../gems/activestorage/#{version}", __dir__)
+        sh "rm -fr #{install_to}"
+        sh "cp -a #{export} #{install_to}"
+      end
+    end
+  end
+end

data/examples/rails/tasks/active_support.rake

@@ -0,0 +1,99 @@
+stdlib_dependencies = %w[benchmark date digest json logger monitor mutex_m pathname singleton time minitest]
+gem_dependencies = %w[nokogiri]
+rails_dependencies = %w[]
+
+VERSIONS.each do |version|
+  namespace version do
+    namespace :active_support do
+      export = "export/activesupport/#{version}"
+
+      desc "export to #{export}"
+      task :export do
+        sh "rm -fr #{export}"
+        sh "mkdir -p #{export}"
+
+        # minimum
+        sh "cp -a out/#{version}/active_support.rbs #{export}"
+        sh "cp -a out/#{version}/active_support #{export}"
+        sh "rm #{export}/active_support/railtie.rbs"
+
+        # core_ext
+        %w[
+          array benchmark big_decimal class date date_and_time date_time digest
+          enumerable file hash integer kernel load_error marshal module name_error numeric
+          object pathname range regexp securerandom string symbol time uri
+        ].each do |lib|
+          out = "out/#{version}/#{lib}"
+          sh "cp -a #{out} #{export}" if File.exist?(out)
+          sh "cp -a #{out}.rbs #{export}" if File.exist?("#{out}.rbs")
+        end
+
+        # 5.2
+        sh "cp -a out/#{version}/logger_silence.rbs #{export}" if File.exist?("out/#{version}/logger_silence.rbs")
+
+        Pathname(export).join("EXTERNAL_TODO.rbs").write(<<~RBS)
+          # !!! GENERATED CODE !!!
+          # Please see generators/rails-generator
+
+          module DRb
+            module DRbUndumped
+            end
+          end
+          module Concurrent
+            class Map
+            end
+          end
+        RBS
+
+        case version
+        when "6.0", "6.1"
+          sh "rm -fr #{export}/uri"
+        when "7.0"
+          # deprecated
+          sh "rm -fr #{export}/uri{,.rbs}"
+        end
+
+        generate_manifest(
+          export: export,
+          stdlib_dependencies: stdlib_dependencies
+        )
+        generate_test_script(
+          gem: :activesupport,
+          version: version,
+          export: export,
+          stdlib_dependencies: stdlib_dependencies,
+          gem_dependencies: gem_dependencies,
+          rails_dependencies: rails_dependencies,
+        )
+
+        Pathname(export).join('_test').join('test.rb').write(<<~'RUBY')
+          # !!! GENERATED CODE !!!
+          # Please see generators/rails-generator
+
+          require 'active_support/all'
+
+          # Test ActiveSupport::NumericWithFormat
+          42.to_s
+          42.to_s(:phone)
+
+          3.days.ago + 1.minute
+        RUBY
+      end
+
+      desc "validate version=#{version} gem=active_support"
+      task :validate do
+        stdlib_opt = stdlib_dependencies.map{"-r #{_1}"}.join(" ")
+        gem_opt = gem_dependencies.map{"-I ../../.gem_rbs_collection/#{_1}"}.join(" ")
+        rails_opt = rails_dependencies.map{"-I export/#{_1}/#{version}"}.join(" ")
+        sh "rbs #{stdlib_opt} #{gem_opt} #{rails_opt} -I #{export} validate --silent"
+      end
+
+      desc "install to ../../../gems/activesupport/#{version}"
+      task :install do
+        install_to = File.expand_path("../../../gems/activesupport/#{version}", __dir__)
+        sh "rm -fr #{install_to}"
+        sh "cp -a #{export} #{install_to}"
+      end
+    end
+  end
+end

data/examples/rails/tasks/railties.rake

@@ -0,0 +1,37 @@
+stdlib_dependencies = %w[benchmark date digest json logger monitor mutex_m pathname singleton time minitest securerandom ipaddr did_you_mean forwardable openssl socket]
+gem_dependencies = %w[nokogiri i18n rack rails-dom-testing]
+rails_dependencies = %w[actionpack actionview activejob activemodel activerecord activestorage activesupport]
+
+VERSIONS.each do |version|
+  namespace version do
+    namespace :railties do
+      export = "export/railties/#{version}"
+
+      desc "export to #{export}"
+      task :export do
+        sh "rm -fr #{export}"
+        sh "mkdir -p #{export}"
+
+        if File.exist?("out/#{version}/active_record/destroy_association_async_job.rbs")
+          sh "mkdir -p #{export}/active_record"
+          sh "cp out/#{version}/active_record/destroy_association_async_job.rbs #{export}/active_record/destroy_association_async_job.rbs"
+        end
+      end
+
+      desc "validate version=#{version} gem=railties"
+      task :validate do
+        stdlib_opt = stdlib_dependencies.map{"-r #{_1}"}.join(" ")
+        gem_opt = gem_dependencies.map{"-I ../../.gem_rbs_collection/#{_1}"}.join(" ")
+        rails_opt = rails_dependencies.map{"-I export/#{_1}/#{version}"}.join(" ")
+        sh "rbs #{stdlib_opt} #{gem_opt} #{rails_opt} -I #{export} validate --silent"
+      end
+
+      desc "install to ../../../gems/railties/#{version}"
+      task :install do
+        install_to = File.expand_path("../../../gems/railties/#{version}", __dir__)
+        sh "rm -fr #{install_to}"
+        sh "cp -a #{export} #{install_to}"
+      end
+    end
+  end
+end

data/lib/orthoses/active_model/has_secure_password.rb

@@ -13,17 +13,9 @@ module Orthoses
       end
 
       def call
-        target_method = begin
-          ::ActiveModel::SecurePassword::ClassMethods.instance_method(:has_secure_password)
-        rescue NameError => err
-          Orthoses.logger.warn("Run `require 'active_support/concern'; require 'active_model/secure_password'` and retry because #{err}")
-          require 'active_support/concern'
-          require 'active_model/secure_password'
-          retry
-        end
-        call_tracer = Orthoses::CallTracer.new
+        call_tracer = CallTracer::Lazy.new
 
-        store = call_tracer.trace(target_method) do
+        store = call_tracer.trace('ActiveModel::SecurePassword::ClassMethods#has_secure_password') do
           @loader.call
         end
 

data/lib/orthoses/active_model.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
 require_relative 'active_model/has_secure_password'
-require_relative 'active_model/known_sig'

data/lib/orthoses/active_record/delegated_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    # <= 6.0
+    #   not implemented
+    # >= 6.1
+    #   def delegated_type(role, types:, **options)
+    class DelegatedType
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        delegated_type = CallTracer::Lazy.new
+        store = delegated_type.trace('ActiveRecord::DelegatedType#delegated_type') do
+          @loader.call
+        end
+
+        delegated_type.captures.each do |capture|
+          base_name = Utils.module_name(capture.method.receiver) or next
+          role = capture.argument[:role]
+          types = capture.argument[:types]
+          options = capture.argument[:options]
+          primary_key = options[:primary_key] || "id"
+
+          content = store[base_name]
+          content << "def #{role}_class: () -> (#{types.join(' | ')})"
+          content << "def #{role}_name: () -> String"
+          content << "def build_#{role}: () -> (#{types.join(' | ')})"
+          types.each do |type|
+            scope_name = type.tableize.gsub("/", "_")
+            singular = scope_name.singularize
+            content << "def #{singular}?: () -> bool"
+            content << "def #{singular}: () -> #{type}?"
+            content << "def #{singular}_#{primary_key}: () -> Integer?"
+          end
+        end
+
+        store
+      end
+    end
+  end
+end

data/lib/orthoses/active_record/enum.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    # <= 6.1
+    #   def enum(definitions)
+    # >= 7.0
+    #   def enum(name = nil, values = nil, **options)
+    class Enum
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        enum = CallTracer::Lazy.new
+        store = enum.trace('ActiveRecord::Enum#enum') do
+          @loader.call
+        end
+
+        enum.captures.each do |capture|
+          base_name = Utils.module_name(capture.method.receiver) or next
+
+          if capture.argument[:definitions]
+            # on rails 6
+            definitions = capture.argument[:definitions].slice!(:_prefix, :_suffix, :_scopes, :_default)
+            options = capture.argument[:definitions].transform_keys { |key| :"#{key[1..-1]}" }
+            definitions.each { |name, values| _enum(store, base_name, name, values, **options) }
+          else
+            # on rails 7
+            name = capture.argument[:name]
+            values = capture.argument[:values]
+            options = capture.argument[:options]
+            if name
+              # rails 7 style
+              values, options = options, {} unless values
+              _enum(store, base_name, name, values, **options)
+            else
+              # rails 6 style
+              definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default)
+              options.transform_keys! { |key| :"#{key[1..-1]}" }
+
+              definitions.each { |name, values| _enum(store, base_name, name, values, **options) }
+            end
+          end
+        end
+
+        store
+      end
+
+      private
+
+      def _enum(store, base_name, name, values, prefix: nil, suffix: nil, **_options)
+        name = name.to_s
+
+        prefix = if prefix
+          prefix == true ? "#{name}_" : "#{prefix}_"
+        end
+
+        suffix = if suffix
+          suffix == true ? "_#{name}" : "_#{suffix}"
+        end
+
+        return_type_param = Hash === values ? "[String, String]" : "[String, Integer]"
+        store[base_name] << "def self.#{name.pluralize}: () -> ActiveSupport::HashWithIndifferentAccess#{return_type_param}"
+
+        pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+        pairs.each do |label, value|
+          value_method_name = "#{prefix}#{label}#{suffix}"
+          enum_methods_content = store["#{base_name}::ActiveRecord_Enum_EnumMethods"]
+          enum_methods_content.header = "module #{base_name}::ActiveRecord_Enum_EnumMethods"
+          enum_methods_content << "def #{value_method_name}?: () -> bool"
+          enum_methods_content << "def #{value_method_name}!: () -> bool"
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_record/generated_attribute_methods.rb

@@ -42,6 +42,7 @@ module Orthoses
             generated_attribute_methods = "#{name}::AttributeMethods::GeneratedAttributeMethods"
             store[name] << "include #{generated_attribute_methods}"
 
+            store["#{name}::AttributeMethods"].header = "module #{name}::AttributeMethods"
             store[generated_attribute_methods].header = "module #{generated_attribute_methods}"
             store[generated_attribute_methods].concat(lines)
           end

data/lib/orthoses/active_record/scope.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    # def scope(name, body, &block)
+    class Scope
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        scope = CallTracer::Lazy.new
+        store = scope.trace('ActiveRecord::Scoping::Named::ClassMethods#scope') do
+          @loader.call
+        end
+
+        scope.captures.each do |capture|
+          base_name = Utils.module_name(capture.method.receiver) or next
+
+          name = capture.argument[:name]
+          body = capture.argument[:body]
+
+          definition = "#{name}: #{parameters_to_type(body.parameters)} -> #{base_name}::ActiveRecord_Relation"
+          store[base_name] << "def self.#{definition}"
+          store["#{base_name}::GeneratedRelationMethods"].header = "module #{base_name}::GeneratedRelationMethods"
+          store["#{base_name}::GeneratedRelationMethods"] << "def #{definition}"
+        end
+
+        store
+      end
+
+      private
+
+      def parameters_to_type(parameters)
+        # @type var res: Array[String]
+        res = []
+        # @type var block: String?
+        block = nil
+        parameters.each do |(type, name)|
+          case type
+          when :req
+            res << "untyped #{name}"
+          when :opt
+            res << "?untyped #{name}"
+          when :keyreq
+            res << "#{name}: untyped"
+          when :key
+            res << "?#{name}: untyped"
+          when :rest
+            res << "*untyped #{name}"
+          when :keyrest
+            res << "**untyped #{name}"
+          when :block
+            block = " { (*untyped) -> untyped }"
+          else
+            raise "unexpected: #{type}"
+          end
+        end
+        "(#{res.join(", ")})#{block}"
+      end
+    end
+  end
+end

data/lib/orthoses/active_record.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'active_record/belongs_to'
+require_relative 'active_record/delegated_type'
+require_relative 'active_record/enum'
 require_relative 'active_record/generated_attribute_methods'
 require_relative 'active_record/has_many'
 require_relative 'active_record/has_one'
-require_relative 'active_record/known_sig'
 require_relative 'active_record/query_methods'
+require_relative 'active_record/scope'

data/lib/orthoses/active_support/class_attribute.rb

@@ -15,20 +15,13 @@ module Orthoses
       end
 
       def call
-        target_method = begin
-          ::Class.instance_method(:class_attribute)
-        rescue NameError => err
-          Orthoses.logger.warn("Run `require 'active_support/core_ext/class/attribute'` and retry because #{err}")
-          require 'active_support/core_ext/class/attribute'
-          retry
-        end
-        call_tracer = Orthoses::CallTracer.new
+        lazy_tracer = Orthoses::CallTracer::Lazy.new
 
-        store = call_tracer.trace(target_method) do
+        store = lazy_tracer.trace('Class#class_attribute') do
           @loader.call
         end
 
-        call_tracer.captures.each do |capture|
+        lazy_tracer.captures.each do |capture|
           receiver_name = Orthoses::Utils.module_name(capture.method.receiver)
           next unless receiver_name
 

data/lib/orthoses/active_support/configurable.rb

@@ -12,8 +12,9 @@ module Orthoses
       end
 
       def call
-        config_accessor = CallTracer.new
-        store = config_accessor.trace(::ActiveSupport::Configurable::ClassMethods.instance_method(:config_accessor)) do
+        config_accessor = CallTracer::Lazy.new
+
+        store = config_accessor.trace('ActiveSupport::Configurable::ClassMethods#config_accessor') do
           @loader.call
         end
         config_accessor.captures.each do |capture|

data/lib/orthoses/active_support/delegation.rb

@@ -10,15 +10,8 @@ module Orthoses
       # def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
       # def delegate_missing_to(target, allow_nil: nil)
       def call
-        target_method = begin
-          ::Module.method(:delegate)
-        rescue NameError => err
-          Orthoses.logger.warn("Run `require 'active_support/core_ext/module/delegation'` and retry because #{err}")
-          require 'active_support/core_ext/module/delegation'
-          retry
-        end
-        delegate = CallTracer.new
-        store = delegate.trace(target_method) do
+        delegate = CallTracer::Lazy.new
+        store = delegate.trace('Module#delegate') do
           @loader.call
         end
 
@@ -27,6 +20,7 @@ module Orthoses
         delegate.captures.each do |capture|
           receiver_name = Utils.module_name(capture.method.receiver) or next
           receiver_content = store[receiver_name]
+
           case capture.argument[:to]
           when Module
             to_module_name = Utils.module_name(capture.argument[:to]) or next
@@ -35,30 +29,28 @@ module Orthoses
                 receiver_content << "# defined by `delegate` to: #{to_module_name}"
                 receiver_content << sig
               else
-                Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore #{arg.inspect}")
+                Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore since missing type for #{to_module_name}.#{arg.inspect} in #{capture.argument.inspect}")
               end
             end
           else
             to_name = capture.argument[:to].to_s.to_sym
             tag, to_return_type = resource.find(receiver_name, to_name, :instance, false)
             raise "bug" if tag == :multi
-            if to_return_type.nil?
-              Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore #{capture.argument.inspect}")
-              next
-            end
-            if to_return_type.instance_of?(RBS::Types::Bases::Any)
+
+            case to_return_type
+            when nil, RBS::Types::Bases::Any
               capture.argument[:methods].each do |method|
-                receiver_content << "# defined by `delegate` to: :#{to_name}(#{to_return_type})"
+                receiver_content << "# defined by `delegate` to: #{to_return_type}##{to_name}"
                 receiver_content << "def #{method}: (*untyped, **untyped) -> untyped"
               end
             else
               to_typename = to_return_type.name.relative!.to_s
               capture.argument[:methods].each do |method|
                 if sig = resource.build_signature(to_typename, method, :instance, true)
-                  receiver_content << "# defined by `delegate` to: :#{to_name}(#{to_return_type})"
+                  receiver_content << "# defined by `delegate` to #{to_return_type}##{to_name}"
                   receiver_content << sig
                 else
-                  Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore #{method.inspect}")
+                  Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore since missing type for #{to_typename}##{method.inspect} in #{capture.argument.inspect}")
                 end
               end
             end
@@ -146,7 +138,7 @@ module Orthoses
             when RBS::AST::Members::Mixin, RBS::AST::Members::LocationOnly
               next
             else
-              binding.irb
+              raise "bug: #{member.class} is not supported yet"
             end
           end
 

data/lib/orthoses/active_support/mattr_accessor.rb

@@ -13,11 +13,11 @@ module Orthoses
       end
 
       def call
-        mattr_reader = Orthoses::CallTracer.new
-        mattr_writer = Orthoses::CallTracer.new
+        mattr_reader = CallTracer::Lazy.new
+        mattr_writer = CallTracer::Lazy.new
 
-        store = mattr_reader.trace(target_method(:mattr_reader)) do
-          mattr_writer.trace(target_method(:mattr_writer)) do
+        store = mattr_reader.trace('Module#mattr_reader') do
+          mattr_writer.trace('Module#mattr_writer') do
             @loader.call
           end
         end
@@ -56,14 +56,6 @@ module Orthoses
 
         store
       end
-
-      def target_method(name)
-        ::Module.instance_method(name)
-      rescue NameError => err
-        Orthoses.logger.warn("Run `require 'active_support/core_ext/module/attribute_accessors'` and retry because #{err}")
-        require 'active_support/core_ext/module/attribute_accessors'
-        retry
-      end
     end
   end
 end

data/lib/orthoses/active_support/time_with_zone.rb

@@ -22,16 +22,22 @@ module Orthoses
 
       private
 
-      NOT_DELEGATE_METHODS = %i[
+      NOT_DELEGATE_METHODS = Set.new(%i[
         utc
         getgm
         getutc
         gmtime
         localtime
-      ]
+      ])
+
+      TYPE_MERGE_METHODS = Set.new(%i[
+        +
+        -
+      ])
 
       def each_line_from_core_time_definition(store)
         type_name_time = TypeName("::Time")
+        type_name_time_with_zone = TypeName("::ActiveSupport::TimeWithZone")
         env = Utils.rbs_environment(collection: true, cache: false)
         env << store["Time"].to_decl
         env << store["DateAndTime"].to_decl
@@ -48,6 +54,7 @@ module Orthoses
         one_ancestors.included_modules.each do |included_module|
           yield "include #{included_module.source.name}"
         end
+        twz_methods = builder.build_instance(type_name_time_with_zone).methods
         builder.build_instance(type_name_time).methods.each do |sym, definition_method|
           next if !definition_method.public?
           definition_method.defs.reject! do |type_def|
@@ -65,7 +72,18 @@ module Orthoses
           end
 
           if definition_method.alias_of.nil?
-            yield "def #{sym}: #{definition_method.method_types.join(" | ")}"
+            method_types = definition_method.method_types
+
+            if TYPE_MERGE_METHODS.include?(sym)
+              if twz_definition_method = twz_methods[sym]
+                twz_definition_method.defs.each do |type_def|
+                  if type_def.implemented_in == type_name_time_with_zone
+                    method_types << type_def.type
+                  end
+                end
+              end
+            end
+            yield "def #{sym}: #{method_types.join(" | ")}"
           else
             yield "alias #{sym} #{definition_method.alias_of.defs.first.member.name}"
           end