orthoses-rails 0.2.0 → 0.3.0

data/examples/rails/patch/pg/simple_decoder.rbs

@@ -0,0 +1,4 @@
+module PG
+  class SimpleDecoder
+  end
+end

data/examples/rails/patch/pg.rbs

@@ -0,0 +1,2 @@
+module PG
+end

data/examples/rails/patch/qc/queue.rbs

@@ -0,0 +1,2 @@
+class QC::Queue
+end

data/examples/rails/patch/qc.rbs

@@ -0,0 +1,2 @@
+class QC
+end

data/examples/rails/patch/que/job.rbs

@@ -0,0 +1,2 @@
+class Que::Job
+end

data/examples/rails/patch/que.rbs

@@ -0,0 +1,2 @@
+module Que
+end

data/examples/rails/patch/rack/cache/entity_store.rbs

@@ -0,0 +1,2 @@
+class Rack::Cache::EntityStore
+end

data/examples/rails/patch/rack/cache/meta_store.rbs

@@ -0,0 +1,2 @@
+class Rack::Cache::MetaStore
+end

data/examples/rails/patch/rack/cache.rbs

@@ -0,0 +1,2 @@
+module Rack::Cache
+end

data/examples/rails/patch/rack/session/dalli.rbs

@@ -0,0 +1,2 @@
+class Rack::Session::Dalli
+end

data/examples/rails/patch/rack/session.rbs

@@ -0,0 +1,2 @@
+module Rack::Session
+end

data/examples/rails/patch/rboc.rbs

@@ -0,0 +1,2 @@
+module RDoc
+end

data/examples/rails/patch/rdoc/generator/sdoc.rbs

@@ -0,0 +1,3 @@
+# defined in sdoc gem
+class RDoc::Generator::SDoc
+end

data/examples/rails/patch/rdoc/generator.rbs

@@ -0,0 +1,2 @@
+module RDoc::Generator
+end

data/examples/rails/patch/rdoc/task.rbs

@@ -0,0 +1,2 @@
+class RDoc::Task
+end

data/examples/rails/patch/ripper.rbs

@@ -0,0 +1,2 @@
+class Ripper
+end

data/examples/rails/patch/sidekiq/worker.rbs

@@ -0,0 +1,2 @@
+module Sidekiq::Worker
+end

data/examples/rails/patch/sidekiq.rbs

@@ -0,0 +1,2 @@
+module Sidekiq
+end

data/examples/rails/patch/sneakers/worker.rbs

@@ -0,0 +1,2 @@
+module Sneakers::Worker
+end

data/examples/rails/patch/sneakers.rbs

@@ -0,0 +1,2 @@
+module Sneakers
+end

data/examples/rails/patch/sucker_punch/job.rbs

@@ -0,0 +1,2 @@
+module SuckerPunch::Job
+end

data/examples/rails/patch/sucker_punch.rbs

@@ -0,0 +1,2 @@
+module SuckerPunch
+end

data/examples/rails/patch/thor/actions/create_file.rbs

@@ -0,0 +1,2 @@
+class Thor::Actions::CreateFile
+end

data/examples/rails/patch/thor/actions.rbs

@@ -0,0 +1,2 @@
+module Thor::Actions
+end

data/examples/rails/patch/thor/error.rbs

@@ -0,0 +1,2 @@
+class Thor::Error < ::StandardError
+end

data/examples/rails/patch/thor/group.rbs

@@ -0,0 +1,2 @@
+class Thor::Group
+end

data/examples/rails/patch/thor.rbs

@@ -0,0 +1,2 @@
+class Thor
+end

data/lib/orthoses/active_model/has_secure_password.rb

@@ -13,7 +13,14 @@ 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

data/lib/orthoses/active_model/known_sig/7.0/serialization.rbs

@@ -0,0 +1,4 @@
+module ActiveModel::Serialization
+  # https://github.com/ruby/rbs/issues/1008
+  def send: (Object::name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+end

data/lib/orthoses/active_model/known_sig/7.0/validations.rbs

@@ -0,0 +1,4 @@
+module ActiveModel::Validations
+  # https://github.com/ruby/rbs/issues/1008
+  def send: (Object::name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+end

data/lib/orthoses/active_model/known_sig.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveModel
+    class KnownSig
+      include Orthoses::Rails::KnownSigHelper
+
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          paths = best_version_paths(::ActiveModel::VERSION::STRING, __dir__)
+          env = Content::Environment.load_from_paths(paths)
+          env.write_to(store: store)
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_model.rb

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

data/lib/orthoses/active_record/known_sig/6.0/result.rbs

@@ -0,0 +1,5 @@
+class ActiveRecord::Result
+  include Enumerable[Hash[String, untyped]]
+  def each: () -> Enumerator[Hash[String, untyped], Array[Hash[String, untyped]]]
+          | () { (Hash[String, untyped]) -> void } -> Array[Hash[String, untyped]]
+end

data/lib/orthoses/active_record/known_sig/6.1/result.rbs

@@ -0,0 +1,5 @@
+class ActiveRecord::Result
+  include Enumerable[Hash[String, untyped]]
+  def each: () -> Enumerator[Hash[String, untyped], Array[Hash[String, untyped]]]
+          | () { (Hash[String, untyped]) -> void } -> Array[Hash[String, untyped]]
+end

data/lib/orthoses/active_record/known_sig/7.0/encryption/context.rbs

@@ -0,0 +1,9 @@
+# attr_accessor in #each
+class ActiveRecord::Encryption::Context
+  attr_accessor key_provider: untyped
+  attr_accessor key_generator: untyped
+  attr_accessor cipher: untyped
+  attr_accessor message_serializer: untyped
+  attr_accessor encryptor: untyped
+  attr_accessor frozen_encryption: untyped
+end

data/lib/orthoses/active_record/known_sig/7.0/result.rbs

@@ -0,0 +1,5 @@
+class ActiveRecord::Result
+  include Enumerable[Hash[String, untyped]]
+  def each: () -> Enumerator[Hash[String, untyped], Array[Hash[String, untyped]]]
+          | () { (Hash[String, untyped]) -> void } -> Array[Hash[String, untyped]]
+end

data/lib/orthoses/active_record/known_sig.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    class KnownSig
+      include Orthoses::Rails::KnownSigHelper
+
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          paths = best_version_paths(::ActiveRecord::VERSION::STRING, __dir__)
+          env = Content::Environment.load_from_paths(paths)
+          env.write_to(store: store)
+        end
+      end
+    end
+  end
+end

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,8 @@
+# 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/known_sig'
+require_relative 'active_record/query_methods'

data/lib/orthoses/active_support/class_attribute.rb

@@ -15,7 +15,13 @@ 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
@@ -34,6 +40,9 @@ module Orthoses
             argument[:instance_predicate] = options.fetch(:instance_predicate, true)
             argument[:default_value]      = options.fetch(:default, nil)
           end
+
+          content = store[receiver_name]
+
           argument[:attrs].each do |name|
             next unless @if.nil? || @if.call(method, name)
 
@@ -47,11 +56,13 @@ module Orthoses
             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 value) -> untyped" if 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/concern.rb

@@ -8,8 +8,16 @@ module Orthoses
       end
 
       def call
+        target_method = begin
+          ::ActiveSupport::Concern.method(:extended)
+        rescue NameError => err
+          Orthoses.logger.warn("Run `require 'active_support/concern'` and retry because #{err}")
+          require 'active_support/concern'
+          retry
+        end
+
         extended = CallTracer.new
-        store = extended.trace(::ActiveSupport::Concern.method(:extended)) do
+        store = extended.trace(target_method) do
           @loader.call
         end
         extended.result.each do |method, argument|

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.result.each do |method, argument|
+          receiver_name = Utils.module_name(method.receiver) or next
+          receiver_content = store[receiver_name]
+          case argument[:to]
+          when Module
+            to_module_name = Utils.module_name(argument[:to]) or next
+            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 #{arg.inspect}")
+              end
+            end
+          else
+            to_name = 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 #{argument.inspect}")
+              next
+            end
+            if to_return_type.instance_of?(RBS::Types::Bases::Any)
+              argument[:methods].each do |method|
+                receiver_content << "# defined by `delegate` to: :#{to_name}(#{to_return_type})"
+                receiver_content << "def #{method}: (*untyped, **untyped) -> untyped"
+              end
+            else
+              to_typename = to_return_type.name.relative!.to_s
+              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 << sig
+                else
+                  Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore #{method.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
+              binding.irb
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_support/known_sig/7.0/active_support/callbacks/callback_chain.rbs

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Callbacks
+    class CallbackChain
+      include Enumerable[::ActiveSupport::Callbacks::Callback]
+      def each: () -> Enumerator[::ActiveSupport::Callbacks::Callback, Array[::ActiveSupport::Callbacks::Callback]]
+              | () { (::ActiveSupport::Callbacks::Callback) -> void } -> Array[::ActiveSupport::Callbacks::Callback]
+    end
+  end
+end

data/lib/orthoses/active_support/known_sig/7.0/active_support/hash_with_indifferent_access.rbs

@@ -0,0 +1,6 @@
+module ActiveSupport
+  class HashWithIndifferentAccess[K, V] < ::Hash[K, V]
+    def []=: (K key, V value) -> untyped
+    def []: (K key) -> V
+  end
+end

data/lib/orthoses/active_support/known_sig/7.0/hash_with_indifferent_access.rbs

@@ -0,0 +1,2 @@
+class HashWithIndifferentAccess[K, V] < ActiveSupport::HashWithIndifferentAccess[K, V]
+end

data/lib/orthoses/active_support/known_sig/{time.rbs → 7.0/time.rbs}

@@ -1,6 +1,10 @@
 module DateAndTime
   module Calculations
   end
+  module Zones
+  end
+  module Compatibility
+  end
 end
 module ActiveSupport
   class TimeZone

data/lib/orthoses/active_support/known_sig.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveSupport
+    class KnownSig
+      include Orthoses::Rails::KnownSigHelper
+
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          paths = best_version_paths(::ActiveSupport::VERSION::STRING, __dir__)
+          env = Content::Environment.load_from_paths(paths)
+          env.write_to(store: store)
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_support/mattr_accessor.rb

@@ -16,8 +16,8 @@ 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
@@ -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

@@ -15,10 +15,10 @@ module Orthoses
       # 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
 
@@ -35,15 +35,18 @@ module Orthoses
         localtime
       ]
 
-      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
+        env = Utils.rbs_environment(collection: true).dup
+        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)

data/lib/orthoses/active_support.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'active_support/class_attribute'
+require_relative 'active_support/concern'
+require_relative 'active_support/delegation'
+require_relative 'active_support/mattr_accessor'
+require_relative 'active_support/time_with_zone'
+require_relative 'active_support/known_sig'
+
+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 Concern
+      yield Delegation
+      yield MattrAccessor
+      yield TimeWithZone
+      yield KnownSig
+    end
+  end
+end