orthoses-rails 0.2.0 → 0.5.0

data/examples/rails/tasks/active_support.rake

@@ -0,0 +1,92 @@
+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
+
+        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_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/lib/orthoses/active_model/has_secure_password.rb

@@ -13,19 +13,26 @@ module Orthoses
       end
 
       def call
-        target_method = ::ActiveModel::SecurePassword::ClassMethods.instance_method(:has_secure_password)
+        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
 
         store = call_tracer.trace(target_method) do
           @loader.call
         end
 
-        call_tracer.result.each do |method, argument|
-          next unless method.receiver.kind_of?(Class)
-          base_name = Utils.module_name(method.receiver)
+        call_tracer.captures.each do |capture|
+          next unless capture.method.receiver.kind_of?(Class)
+          base_name = Utils.module_name(capture.method.receiver)
           next unless base_name
 
-          attribute = argument[:attribute] || :password
+          attribute = capture.argument[:attribute] || :password
           full_name = if ::ActiveModel::VERSION::MAJOR < 6
             "ActiveModel::SecurePassword::InstanceMethodsOnActivation"
           else

data/lib/orthoses/active_model.rb

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

data/lib/orthoses/active_record/query_methods.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    class QueryMethods
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          content = store["ActiveRecord::QueryMethods"]
+
+          ::ActiveRecord::Relation::VALUE_METHODS.each do |name|
+            method_name, type =
+              case name
+              when *::ActiveRecord::Relation::MULTI_VALUE_METHODS
+                ["#{name}_values", "::Array[untyped]"]
+              when *::ActiveRecord::Relation::SINGLE_VALUE_METHODS
+                ["#{name}_value", name == :create_with ? "::Hash[untyped, untyped]?" : "untyped"]
+              when *::ActiveRecord::Relation::CLAUSE_METHODS
+                ["#{name}_clause", name == :from ? "::ActiveRecord::Relation::FromClause" : "::ActiveRecord::Relation::WhereClause"]
+              end
+
+            content << "def #{method_name}: () -> #{type}"
+            content << "def #{method_name}=: (#{type} value) -> #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'active_record/belongs_to'
+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'

data/lib/orthoses/active_support/class_attribute.rb

@@ -15,26 +15,35 @@ module Orthoses
       end
 
       def call
-        target_method = ::Class.instance_method(:class_attribute)
+        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
 
         store = call_tracer.trace(target_method) do
           @loader.call
         end
 
-        call_tracer.result.each do |method, argument|
-          receiver_name = Orthoses::Utils.module_name(method.receiver)
+        call_tracer.captures.each do |capture|
+          receiver_name = Orthoses::Utils.module_name(capture.method.receiver)
           next unless receiver_name
 
           methods = []
           if ::ActiveSupport::VERSION::MAJOR < 6
-            options = argument[:attrs].extract_options!
-            argument[:instance_reader]    = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
-            argument[:instance_writer]    = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
-            argument[:instance_predicate] = options.fetch(:instance_predicate, true)
-            argument[:default_value]      = options.fetch(:default, nil)
+            options = capture.argument[:attrs].extract_options!
+            capture.argument[:instance_reader]    = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+            capture.argument[:instance_writer]    = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+            capture.argument[:instance_predicate] = options.fetch(:instance_predicate, true)
+            capture.argument[:default_value]      = options.fetch(:default, nil)
           end
-          argument[:attrs].each do |name|
+
+          content = store[receiver_name]
+
+          capture.argument[:attrs].each do |name|
             next unless @if.nil? || @if.call(method, name)
 
             # skip internal attribute
@@ -43,15 +52,17 @@ module Orthoses
             next if name == :attributes_to_define_after_schema_loads
 
             methods << "def self.#{name}: () -> untyped"
-            methods << "def self.#{name}?: () -> bool" if argument[:instance_predicate]
+            methods << "def self.#{name}?: () -> bool" if capture.argument[:instance_predicate]
             methods << "def self.#{name}=: (untyped value) -> untyped"
-            methods << "def #{name}: () -> untyped" if argument[:instance_reader]
-            methods << "def #{name}?: () -> bool" if argument[:instance_predicate] && argument[:instance_reader]
-            methods << "attr_writer #{name}: untyped" if argument[:instance_writer]
+            methods << "def #{name}: () -> untyped" if capture.argument[:instance_reader]
+            methods << "def #{name}?: () -> bool" if capture.argument[:instance_predicate] && capture.argument[:instance_reader]
+            methods << "def #{name}=: (untyped value) -> untyped" if capture.argument[:instance_writer]
+            # In RBS, `foo=` and attr_writer :foo cannot live together.
+            content.body.delete_if { |line| line.start_with?("attr_writer #{name}:") }
           end
           next if methods.empty?
 
-          store[receiver_name].concat(methods)
+          content.concat(methods)
         end
 
         store

data/lib/orthoses/active_support/configurable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveSupport
+    # <= 6.1
+    #   def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true)
+    # >= 7
+    #   def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
+    class Configurable
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        config_accessor = CallTracer.new
+        store = config_accessor.trace(::ActiveSupport::Configurable::ClassMethods.instance_method(:config_accessor)) do
+          @loader.call
+        end
+        config_accessor.captures.each do |capture|
+          mod_name = Utils.module_name(capture.method.receiver) or next
+          content = store[mod_name]
+          capture.argument[:names].each do |name|
+            content << "def self.#{name}: () -> untyped"
+            content << "def self.#{name}=: (untyped value) -> untyped"
+            if capture.argument[:instance_accessor]
+              content << "def #{name}: () -> untyped" if capture.argument[:instance_reader]
+              content << "def #{name}=: (untyped value) -> untyped" if capture.argument[:instance_writer]
+            end
+          end
+        end
+
+        store
+      end
+    end
+  end
+end

data/lib/orthoses/active_support/delegation.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveSupport
+    class Delegation
+      def initialize(loader)
+        @loader = loader
+      end
+
+      # 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
+          @loader.call
+        end
+
+        resource = Resource.new(store)
+
+        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
+            capture.argument[:methods].each do |arg|
+              if sig = resource.build_signature(to_module_name, arg, :singleton, false)
+                receiver_content << "# defined by `delegate` to: #{to_module_name}"
+                receiver_content << sig
+              else
+                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 since missing type for #{receiver_name}##{to_name.inspect} in #{capture.argument.inspect}")
+              next
+            end
+            if to_return_type.instance_of?(RBS::Types::Bases::Any)
+              capture.argument[:methods].each do |method|
+                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_return_type}##{to_name}"
+                  receiver_content << sig
+                else
+                  Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore since missing type for #{to_typename}##{method.inspect} in #{capture.argument.inspect}")
+                end
+              end
+            end
+          end
+        end
+
+        store
+      end
+
+      private
+
+      class Resource
+        def initialize(store)
+          @store = store
+          env = Orthoses::Utils.rbs_environment(collection: true)
+          @definition_builder = RBS::DefinitionBuilder.new(env: env)
+        end
+
+        def find(mod_name, name, kind, argument)
+          typename = TypeName(mod_name).absolute!
+
+          if definition_method = build_definition(typename, kind)&.methods&.[](name)
+            return [:multi, definition_method.defs.map(&:type)]
+          end
+          resolve_type_by_name(@store[mod_name].to_decl.members, name, kind, argument)
+        end
+
+        def build_definition(typename, kind)
+          case kind
+          when :instance
+            @definition_builder.build_instance(typename)
+          when :singleton
+            @definition_builder.build_singleton(typename)
+          else
+            raise "big"
+          end
+        rescue RuntimeError => e
+          if e.message.match?(/\AUnknown name for/)
+            nil
+          else
+            raise
+          end
+        end
+
+        def build_signature(mod_name, name, kind, argument)
+          tag, type = find(mod_name, name, kind, argument)
+          case tag
+          when :single
+            "def #{name}: () -> #{type}"
+          when :multi
+            "def #{name}: #{type.join(' | ')}"
+          else
+            nil
+          end
+        end
+
+        private
+
+        def resolve_type_by_name(members, name, kind, argument)
+          members.each do |member|
+            case member
+            when RBS::AST::Members::MethodDefinition
+              next unless member.name == name && member.kind == kind
+              if argument
+                return [:multi, member.types]
+              else
+                type = member.types.find do |method_type|
+                  method_type.type.required_positionals.empty? && method_type.type.required_keywords.empty?
+                end
+                next unless type
+                return [:single, type.type.return_type]
+              end
+            when RBS::AST::Members::Var
+              next unless member.name == name
+              return [:single, member.type]
+            when RBS::AST::Declarations::Constant
+              next unless member.name.to_s.to_sym == name
+              return [:single, member.type]
+            when RBS::AST::Members::Attribute
+              next unless member.name == name && member.kind == kind
+              return [:single, member.type]
+            when RBS::AST::Members::Alias
+              next unless member.new_name == name && member.kind == kind
+              return resolve_type_by_name(members, member.old_name, kind, argument)
+            when RBS::AST::Members::Mixin, RBS::AST::Members::LocationOnly
+              next
+            else
+              raise "bug: #{member.class} is not supported yet"
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_support/mattr_accessor.rb

@@ -16,20 +16,20 @@ module Orthoses
         mattr_reader = Orthoses::CallTracer.new
         mattr_writer = Orthoses::CallTracer.new
 
-        store = mattr_reader.trace(::Module.instance_method(:mattr_reader)) do
-          mattr_writer.trace(::Module.instance_method(:mattr_writer)) do
+        store = mattr_reader.trace(target_method(:mattr_reader)) do
+          mattr_writer.trace(target_method(:mattr_writer)) do
             @loader.call
           end
         end
 
-        mattr_reader.result.each do |method, argument|
-          base = Orthoses::Utils.module_name(method.receiver) || next
+        mattr_reader.captures.each do |capture|
+          base = Orthoses::Utils.module_name(capture.method.receiver) || next
           methods = []
-          argument[:syms].each do |sym|
+          capture.argument[:syms].each do |sym|
             next unless @if.nil? || @if.call(method, sym)
 
             methods << "def self.#{sym}: () -> untyped"
-            if argument[:instance_reader] && argument[:instance_accessor]
+            if capture.argument[:instance_reader] && capture.argument[:instance_accessor]
               methods << "def #{sym}: () -> untyped"
             end
           end
@@ -38,14 +38,14 @@ module Orthoses
           store[base].concat(methods)
         end
 
-        mattr_writer.result.each do |method, argument|
-          base = Orthoses::Utils.module_name(method.receiver) || next
+        mattr_writer.captures.each do |capture|
+          base = Orthoses::Utils.module_name(capture.method.receiver) || next
           methods = []
-          argument[:syms].each do |sym|
+          capture.argument[:syms].each do |sym|
             next unless @if.nil? || @if.call(method, sym)
 
             methods << "def self.#{sym}=: (untyped val) -> untyped"
-            if argument[:instance_writer] && argument[:instance_accessor]
+            if capture.argument[:instance_writer] && capture.argument[:instance_accessor]
               methods << "def #{sym}=: (untyped val) -> untyped"
             end
           end
@@ -56,6 +56,14 @@ 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

@@ -7,18 +7,13 @@ module Orthoses
         @loader = loader
       end
 
-      LOAD_PATHS = [
-        File.expand_path("known_sig/time.rbs", __dir__),
-        File.expand_path("known_sig/active_support/time_with_zone.rbs", __dir__),
-      ]
-
       # Time <= (known Time)
       # TimeWithZone <= (known TimeWithZone, known Time, core Time)
       def call
-        store = Orthoses::LoadRBS.new(@loader, paths: LOAD_PATHS).call
+        store = @loader.call
 
         time_with_zone_store = store["ActiveSupport::TimeWithZone"]
-        each_line_from_core_time_definition do |line|
+        each_line_from_core_time_definition(store) do |line|
           time_with_zone_store << line
         end
 
@@ -27,29 +22,39 @@ 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
+      def each_line_from_core_time_definition(store)
         type_name_time = TypeName("::Time")
-        loader = RBS::EnvironmentLoader.new
-        env = RBS::Environment.from_loader(loader)
-        LOAD_PATHS.each do |path|
-          RBS::Parser.parse_signature(File.read(path)).each do |decl|
-            env << decl
-          end
-        end
+        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
+        env << store["DateAndTime::Zones"].to_decl
+        env << store["DateAndTime::Calculations"].to_decl
+        env << store["DateAndTime::Compatibility"].to_decl
+        env << store["ActiveSupport"].to_decl
+        env << store["ActiveSupport::TimeZone"].to_decl
+        env << store["ActiveSupport::Duration"].to_decl
+        env << store["ActiveSupport::TimeWithZone"].to_decl
 
         builder = RBS::DefinitionBuilder.new(env: env.resolve_type_names)
         one_ancestors = builder.ancestor_builder.one_instance_ancestors(type_name_time)
         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|
@@ -67,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

data/lib/orthoses/active_support.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'active_support/class_attribute'
+require_relative 'active_support/configurable'
+require_relative 'active_support/delegation'
+require_relative 'active_support/mattr_accessor'
+require_relative 'active_support/time_with_zone'
+
+module Orthoses
+  module ActiveSupport
+    # Interface for adding middleware in bulk.
+    #     Orthoses::ActiveSupport.each do |middleware, **args|
+    #       use middleware, **args
+    #     end
+    def self.each
+      yield ClassAttribute
+      yield Delegation
+      yield MattrAccessor
+      yield TimeWithZone
+    end
+  end
+end

data/lib/orthoses/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Orthoses
   module Rails
-    VERSION = "0.2.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/orthoses/rails.rb

@@ -4,14 +4,6 @@ require 'orthoses'
 
 require_relative "rails/version"
 
-require_relative 'active_model/has_secure_password'
-
-require_relative 'active_record/generated_attribute_methods'
-require_relative 'active_record/has_many'
-require_relative 'active_record/has_one'
-require_relative 'active_record/belongs_to'
-
-require_relative 'active_support/class_attribute'
-require_relative 'active_support/concern'
-require_relative 'active_support/mattr_accessor'
-require_relative 'active_support/time_with_zone'
+require_relative 'active_model'
+require_relative 'active_record'
+require_relative 'active_support'

data/orthoses-rails.gemspec

@@ -32,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "orthoses"
+  spec.add_dependency "orthoses", ">= 0.10"
 end