pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/sorter.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module RBS
+  class Sorter
+    include RBS::AST
+
+    attr_reader :path, :stdout
+
+    def initialize(path, stdout: $stdout)
+      @path = path
+      @stdout = stdout
+    end
+
+    def run
+      stdout.puts "Opening #{path}..."
+
+      buffer = Buffer.new(name: path, content: path.read)
+      _, _, sigs = Parser.parse_signature(buffer)
+
+      sigs = sigs.map do |m|
+        sort_decl m
+      end
+
+      stdout.puts "Writing #{path}..."
+      path.open('w') do |out|
+        writer = RBS::Writer.new(out: out)
+        writer.write _ = sigs
+      end
+    end
+
+    def sort_decl(decl)
+      case decl
+      when Declarations::Class, Declarations::Module, Declarations::Interface
+        partitioned = {
+          type_alias_decls: [],
+          constant_decls: [],
+          class_decls: [],
+          mixin_includes: [],
+          mixin_prepends: [],
+          mixin_extends: [],
+          class_variables: [],
+          class_instance_variables: [],
+          instance_variables: [],
+          singleton_attributes: [],
+          instance_attributes: [],
+          module_functions: [],
+          singleton_new_methods: [],
+          public_singleton_methods: [],
+          private_singleton_methods: [],
+          instance_initialize_methods: [],
+          public_instance_methods: [],
+          private_instance_methods: [],
+        } #: partitioned
+
+        members = decl.members.map { |m| sort_decl m }
+        decl = decl.update(members: _ = members)
+
+        visibility_annotated_members = [] #: Array[member]
+
+        decl.members.inject(:public) do |current_visibility, member| #$ AST::Members::visibility
+          case member
+          when Members::Public
+            :public
+          when Members::Private
+            :private
+          when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
+            visibility_annotated_members << member.update(visibility: member.visibility || current_visibility)
+            current_visibility
+          else
+            visibility_annotated_members << member
+            current_visibility
+          end
+        end
+
+        visibility_annotated_members.each do |member|
+          case member
+          when Declarations::TypeAlias
+            partitioned[:type_alias_decls] << member
+          when Declarations::Constant
+            partitioned[:constant_decls] << member
+          when Declarations::Class, Declarations::Module, Declarations::Interface
+            partitioned[:class_decls] << member
+          when Members::Include
+            partitioned[:mixin_includes] << member
+          when Members::Prepend
+            partitioned[:mixin_prepends] << member
+          when Members::Extend
+            partitioned[:mixin_extends] << member
+          when Members::ClassVariable
+            partitioned[:class_variables] << member
+          when Members::ClassInstanceVariable
+            partitioned[:class_instance_variables] << member
+          when Members::InstanceVariable
+            partitioned[:instance_variables] << member
+          when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
+            if member.kind == :singleton
+              partitioned[:singleton_attributes] << member.update(visibility: nil)
+            else
+              partitioned[:instance_attributes] << member.update(visibility: nil)
+            end
+          when Members::MethodDefinition
+            case member.kind
+            when :singleton_instance
+              partitioned[:module_functions] << member.update(visibility: nil)
+            when :singleton
+              if member.name == :new
+                partitioned[:singleton_new_methods] << member.update(visibility: nil)
+              elsif member.visibility == :public
+                partitioned[:public_singleton_methods] << member.update(visibility: nil)
+              else
+                partitioned[:private_singleton_methods] << member.update(visibility: nil)
+              end
+            else
+              if member.name == :initialize
+                partitioned[:instance_initialize_methods] << member.update(visibility: nil)
+              elsif member.visibility == :public
+                partitioned[:public_instance_methods] << member.update(visibility: nil)
+              else
+                partitioned[:private_instance_methods] << member.update(visibility: nil)
+              end
+            end
+          when Members::Alias
+            if member.singleton?
+              partitioned[:public_singleton_methods] << member
+            else
+              partitioned[:public_instance_methods] << member
+            end
+          when Members::Public, Members::Private
+            raise
+          else
+            partitioned[:other_decls] << member
+          end
+        end
+
+        partitioned[:type_alias_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:constant_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_includes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_prepends].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_extends].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_instance_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:instance_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:singleton_attributes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:instance_attributes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:module_functions].sort_by! {|decl| decl.name.to_s }
+        partitioned[:public_singleton_methods].sort_by! {|decl| decl.is_a?(Members::MethodDefinition) ? decl.name.to_s : decl.new_name.to_s }
+        partitioned[:private_singleton_methods].sort_by! {|decl| decl.name.to_s }
+        partitioned[:public_instance_methods].sort_by! {|decl| decl.is_a?(Members::MethodDefinition) ? decl.name.to_s : decl.new_name.to_s }
+        partitioned[:private_instance_methods].sort_by! {|decl| decl.name.to_s }
+
+        members = [] #: Array[member]
+        members.push(*partitioned[:type_alias_decls])
+        members.push(*partitioned[:constant_decls])
+        members.push(*partitioned[:class_decls])
+        members.push(*partitioned[:mixin_includes])
+        members.push(*partitioned[:mixin_prepends])
+        members.push(*partitioned[:mixin_extends])
+        members.push(*partitioned[:class_variables])
+        members.push(*partitioned[:class_instance_variables])
+        members.push(*partitioned[:instance_variables])
+        members.push(*partitioned[:module_functions])
+        members.push(*partitioned[:singleton_attributes])
+
+        current_visibility = :public #: AST::Members::visibility
+
+        members.push(*partitioned[:singleton_new_methods])
+        members.push(*partitioned[:public_singleton_methods])
+
+        if !partitioned[:private_singleton_methods].empty?
+          current_visibility = :private
+          members.push Members::Private.new(location: nil)
+        end
+        members.push(*partitioned[:private_singleton_methods])
+
+        if current_visibility == :private && !partitioned[:public_instance_methods].empty?
+          current_visibility = :public
+          members.push Members::Public.new(location: nil)
+        end
+        members.push(*partitioned[:instance_attributes])
+        members.push(*partitioned[:instance_initialize_methods])
+        members.push(*partitioned[:public_instance_methods])
+
+        if current_visibility == :public && !partitioned[:private_instance_methods].empty?
+          current_visibility = :private
+          members.push Members::Private.new(location: nil)
+        end
+        members.push(*partitioned[:private_instance_methods])
+
+        members.push(*partitioned[:other_decls])
+
+        decl.update(members: _ = members)
+      else
+        decl
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/source.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RBS
+  module Source
+    class RBS
+      attr_reader :buffer, :directives, :declarations
+
+      def initialize(buffer, directives, decls)
+        @buffer = buffer
+        @directives = directives
+        @declarations = decls
+      end
+
+      def each_type_name(&block)
+        if block
+          set = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(set, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Declarations::Class
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Module
+          decl.each_decl { each_declaration_type_name(names, _1, &block) }
+          type_name = decl.name
+        when AST::Declarations::Interface
+          type_name = decl.name
+        when AST::Declarations::TypeAlias
+          type_name = decl.name
+        when AST::Declarations::ModuleAlias
+          type_name = decl.new_name
+        when AST::Declarations::ClassAlias
+          type_name = decl.new_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+
+    class Ruby
+      attr_reader :buffer
+      attr_reader :prism_result
+      attr_reader :declarations
+      attr_reader :diagnostics
+
+      def initialize(buffer, prism, declarations, diagnostics)
+        @buffer = buffer
+        @prism_result = prism
+        @declarations = declarations
+        @diagnostics = diagnostics
+      end
+
+      def each_type_name(&block)
+        if block
+          names = Set[] #: Set[TypeName]
+          declarations.each do |decl|
+            each_declaration_type_name(names, decl, &block)
+          end
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def each_declaration_type_name(names, decl, &block)
+        case decl
+        when AST::Ruby::Declarations::ClassDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.class_name
+        when AST::Ruby::Declarations::ModuleDecl
+          decl.each_decl do |d|
+            each_declaration_type_name(names, d, &block)
+          end
+          type_name = decl.module_name
+        end
+
+        if type_name
+          unless names.include?(type_name)
+            yield type_name
+            names << type_name
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/substitution.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RBS
+  class Substitution
+    attr_reader :mapping
+    attr_accessor :instance_type
+
+    def empty?
+      mapping.empty? && instance_type.nil?
+    end
+
+    def initialize()
+      @mapping = {}
+    end
+
+    def add(from:, to:)
+      mapping[from] = to
+    end
+
+    def self.build(variables, types, instance_type: nil, &block)
+      unless variables.size == types.size
+        raise "Broken substitution: variables=#{variables}, types=#{types}"
+      end
+
+      mapping = variables.zip(types).to_h
+
+      self.new.tap do |subst|
+        mapping.each do |v, t|
+          type = block_given? ? yield(t) : t
+          subst.add(from: v, to: type)
+        end
+
+        subst.instance_type = instance_type
+      end
+    end
+
+    def apply(ty)
+      case ty
+      when Types::Variable
+        # @type var ty: Types::Variable
+        mapping[ty.name] || ty
+      when Types::Bases::Instance
+        if t = instance_type
+          t
+        else
+          ty
+        end
+      else
+        ty
+      end
+    end
+
+    alias [] apply
+
+    def without(*vars)
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+        vars.each do |var|
+          subst.mapping.delete(var)
+        end
+
+        subst.instance_type = self.instance_type
+      end
+    end
+
+    def +(other)
+      return self if other.empty?
+      return other if self.empty?
+
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+
+        other.mapping.each do |var, type|
+          if mapping.key?(var)
+            subst.add(from: var, to: self[type])
+          else
+            subst.add(from: var, to: type)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/subtractor.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module RBS
+  class Subtractor
+    def initialize(minuend, subtrahend)
+      @minuend = minuend
+      @subtrahend = subtrahend
+    end
+
+    def call(minuend = @minuend, context: nil)
+      minuend.map do |decl|
+        case decl
+        when AST::Declarations::Constant
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.constant_name?(name)
+        when AST::Declarations::Interface
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.interface_name?(name)
+        when AST::Declarations::Class, AST::Declarations::Module
+          name = absolute_typename(decl.name, context: context)
+          case
+          when @subtrahend.class_decl?(name) && decl.is_a?(AST::Declarations::Class)
+            filter_members(decl, context: context)
+          when @subtrahend.module_decl?(name) && decl.is_a?(AST::Declarations::Module)
+            filter_members(decl, context: context)
+          when @subtrahend.constant_name?(name)
+            nil
+          else
+            decl
+          end
+        when AST::Declarations::Global
+          decl unless @subtrahend.global_decls[decl.name]
+        when AST::Declarations::TypeAlias
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.type_alias_decls[name]
+        when AST::Declarations::ClassAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.class_alias?(name) || @subtrahend.class_decl?(name)
+        when AST::Declarations::ModuleAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
+        else
+          raise "unknown decl: #{(_ = decl).class}"
+        end
+      end.compact
+    end
+
+    private def filter_members(decl, context:)
+      owner = absolute_typename(decl.name, context: context)
+
+      context = _ = [context, decl.name]
+      children = call(decl.each_decl.to_a, context: context) +
+        decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
+      children = filter_redundant_access_modifiers(children)
+      return nil if children.empty?
+
+      update_decl(decl, members: children)
+    end
+
+    private def member_exist?(owner, member, context:)
+      case member
+      when AST::Members::MethodDefinition
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::Alias
+        method_exist?(owner, member.new_name, member.kind)
+      when AST::Members::AttrReader
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::AttrWriter
+        method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::AttrAccessor
+        # TODO: It unexpectedly removes attr_accessor even if either reader or writer does not exist in the subtrahend.
+        method_exist?(owner, member.name, member.kind) || method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::InstanceVariable
+        ivar_exist?(owner, member.name, :instance)
+      when AST::Members::ClassInstanceVariable
+        ivar_exist?(owner, member.name, :singleton)
+      when AST::Members::ClassVariable
+        cvar_exist?(owner, member.name)
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        mixin_exist?(owner, member, context: context)
+      when AST::Members::Public, AST::Members::Private
+        # They should not be removed even if the subtrahend has them.
+        false
+      else
+        raise "unknown member: #{(_ = member).class}"
+      end
+    end
+
+    private def method_exist?(owner, method_name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::MethodDefinition
+          m.name == method_name && m.kind == kind
+        when AST::Members::Alias
+          m.new_name == method_name && m.kind == kind
+        when AST::Members::AttrReader
+          m.name == method_name && m.kind == kind
+        when AST::Members::AttrWriter
+          :"#{m.name}=" == method_name && m.kind == kind
+        when AST::Members::AttrAccessor
+          (m.name == method_name || :"#{m.name}=" == method_name) && m.kind == kind
+        end
+      end
+    end
+
+    private def ivar_exist?(owner, name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::InstanceVariable
+          m.name == name && kind == :instance
+        when AST::Members::ClassInstanceVariable
+          m.name == name && kind == :singleton
+        when AST::Members::Attribute
+          ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
+          ivar_name == name && m.kind == kind
+        end
+      end
+    end
+
+    private def cvar_exist?(owner, name)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::ClassVariable
+          m.name == name
+        end
+      end
+    end
+
+    private def each_member(owner, &block)
+      return enum_for((__method__ or raise), owner) unless block
+
+      entry = @subtrahend.class_decls[owner]
+      return unless entry
+      entry.each_decl do |d|
+        next unless d.is_a?(AST::Declarations::Base)
+        d.members.each { |m| block.call(m) }
+      end
+    end
+
+    private def mixin_exist?(owner, mixin, context:)
+      candidates = typename_candidates(mixin.name, context: context)
+      each_member(owner).any? do |m|
+        case m
+        when mixin.class
+          # @type var m: AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+          candidates.include?(m.name)
+        end
+      end
+    end
+
+    private def filter_redundant_access_modifiers(decls)
+      decls = decls.dup
+      decls.pop while access_modifier?(decls.last)
+      decls = decls.map.with_index do |decl, i|
+        if access_modifier?(decl) && access_modifier?(decls[i + 1])
+          nil
+        else
+          decl
+        end
+      end.compact
+    end
+
+    private def access_modifier?(decl)
+      decl.is_a?(AST::Members::Public) || decl.is_a?(AST::Members::Private)
+    end
+
+    private def update_decl(decl, members:)
+      case decl
+      when AST::Declarations::Class
+        decl.class.new(name: decl.name, type_params: decl.type_params, super_class: decl.super_class,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      when AST::Declarations::Module
+        decl.class.new(name: decl.name, type_params: decl.type_params, self_types: decl.self_types,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      end
+    end
+
+    private def absolute_typename(name, context:)
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        context = _ = context[0]
+      end
+      name.absolute!
+    end
+
+    private def typename_candidates(name, context:)
+      ret = [name.absolute!, name.relative!]
+      return ret if name.absolute?
+
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        ret.concat [name.absolute!, name.relative!]
+
+        context = _ = context[0]
+      end
+
+      ret
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/test/errors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module Errors
+      ArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      BlockArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      ArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      BlockArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      ReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+      BlockReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+
+      UnexpectedBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      MissingBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+
+      UnresolvedOverloadingError = Struct.new(:klass, :method_name, :method_types, keyword_init: true)
+
+      def self.format_param(param)
+        if param.name
+          "`#{param.type}` (#{param.name})"
+        else
+          "`#{param.type}`"
+        end
+      end
+
+      RESPOND_TO = ::Kernel.instance_method :respond_to?
+      private_constant :RESPOND_TO
+
+      def self.inspect_(obj)
+        if RESPOND_TO.bind_call(obj, :inspect)
+          obj.inspect
+        else
+          Test::INSPECT.bind(obj).call     # For the case inspect is not defined (like BasicObject)
+        end
+      end
+
+      def self.method_tag(error)
+        if error.klass.singleton_class?
+          name = inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
+          method_name = ".#{error.method_name}"
+        else
+          name = error.klass.name
+          method_name = "##{error.method_name}"
+        end
+        "[#{name}#{method_name}]"
+      end
+
+      def self.to_string(error)
+        case error
+        when ArgumentTypeError
+          "#{method_tag(error)} ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when BlockArgumentTypeError
+          "#{method_tag(error)} BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when ArgumentError
+          "#{method_tag(error)} ArgumentError: expected method type #{error.method_type}"
+        when BlockArgumentError
+          "#{method_tag(error)} BlockArgumentError: expected method type #{error.method_type}"
+        when ReturnTypeError
+          "#{method_tag(error)} ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when BlockReturnTypeError
+          "#{method_tag(error)} BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when UnexpectedBlockError
+          "#{method_tag(error)} UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
+        when MissingBlockError
+          "#{method_tag(error)} MissingBlockError: required block is missing for `#{error.method_type}`"
+        when UnresolvedOverloadingError
+          "#{method_tag(error)} UnresolvedOverloadingError: couldn't find a suitable overloading"
+        else
+          raise "Unexpected error: #{inspect_(error)}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/test/guaranteed.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module Guaranteed
+      module Inspect
+        EQUAL = ::BasicObject.instance_method(:equal?)
+        INSPECT = ::Kernel.instance_method(:inspect)
+        private_constant :EQUAL, :INSPECT
+
+        module_function def guaranteed_inspect(obj)
+          obj.inspect
+        rescue NoMethodError
+          INSPECT.bind_call(obj)
+        end
+
+        def inspect
+          string = "<#{self.class.name}:"
+
+          instance_variables.each_with_index do |variable, index|
+            string.concat ', ' unless index.zero?
+            string.concat "#{variable}: #{guaranteed_inspect(instance_variable_get(variable))}"
+          end
+
+          string.concat '>'
+        end
+      end
+    end
+  end
+end