repl_type_completor 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22c32aa7e27069f8002c1fe8080bb31c8470760c6c780ba8b566252389dc326d
-  data.tar.gz: 296c548b10082570baadd90d3c94323f91373a6f0edbde307d01228aac7d83e0
+  metadata.gz: 45c80e0c90081af7992d51765854f270adbaec795050775ae778560737db52b2
+  data.tar.gz: 9b4745ab99625ebfd3b6c1ecb526ff6e5186ef9320873b55cc4f6d88103f25ec
 SHA512:
-  metadata.gz: 3494ca3dfd41ac33f784e35384299a502703e503fc94732a7572cf2c4418d7754b53dfb2be49588aca33eab595dc3ed181686b4cfc32da0a36c6523aa82183c9
-  data.tar.gz: 4beada48ab3e6d67c7543cf9a3e7797792fef8548cf4a8637024d72b865dcbb50ace5fe460ff8e504dae73e308116aefa523fdcbf4f161ed534060fa9c700e59
+  metadata.gz: c1a11765f19a07a3cf1a387448e2a57f8d0a087991a9cdae946eebdb6000552e4b7ed7a172a1d7dc65ba273def75e345b76e7adc290cb99af153017cc84df8e8
+  data.tar.gz: 682c8671b614077226d873dba34543dfae6598fb555cefa69bdce155e09de2bb4cc5cfb107d7a5b4887e50d6381eb923b2fda1d4babb5d458b506484b118b2d5

data/lib/repl_type_completor/methods.rb

@@ -2,7 +2,8 @@
 
 module ReplTypeCompletor
   module Methods
-    OBJECT_SINGLETON_CLASS_METHOD = Object.instance_method(:singleton_class)
+    OBJECT_SINGLETON_METHODS_METHOD = Object.instance_method(:singleton_methods)
+    OBJECT_PRIVATE_METHODS_METHOD = Object.instance_method(:private_methods)
     OBJECT_INSTANCE_VARIABLES_METHOD = Object.instance_method(:instance_variables)
     OBJECT_INSTANCE_VARIABLE_GET_METHOD = Object.instance_method(:instance_variable_get)
     OBJECT_CLASS_METHOD = Object.instance_method(:class)

data/lib/repl_type_completor/scope.rb

@@ -284,36 +284,19 @@ module ReplTypeCompletor
     end
 
     def instance_variables
-      self_singleton_types = self_type.types.grep(Types::SingletonType)
-      singleton_classes = self_type.types.grep(Types::InstanceType).map(&:klass).select(&:singleton_class?)
-      base_self = base_scope.self_object
-      self_instance_variables = singleton_classes.flat_map do |singleton_class|
-        if singleton_class.respond_to? :attached_object
-          Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(singleton_class.attached_object).map(&:to_s)
-        elsif singleton_class == Methods::OBJECT_SINGLETON_CLASS_METHOD.bind_call(base_self)
-          Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(base_self).map(&:to_s)
-        else
-          []
-        end
-      end
+      modules = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
+      instances = self_type.types.grep(Types::InstanceType).filter_map(&:instances).flatten(1)
+      self_objects = modules + instances
       [
-        self_singleton_types.flat_map { _1.module_or_class.instance_variables.map(&:to_s) },
-        self_instance_variables || [],
+        self_objects.flat_map { Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(_1).map(&:to_s) },
         table_instance_variables
-      ].inject(:|)
+      ].inject([], :|)
     end
 
     def self_instance_variable_get(name)
-      self_objects = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
-      singleton_classes = self_type.types.grep(Types::InstanceType).map(&:klass).select(&:singleton_class?)
-      base_self = base_scope.self_object
-      singleton_classes.each do |singleton_class|
-        if singleton_class.respond_to? :attached_object
-          self_objects << singleton_class.attached_object
-        elsif singleton_class == base_self.singleton_class
-          self_objects << base_self
-        end
-      end
+      modules = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
+      instances = self_type.types.grep(Types::InstanceType).filter_map(&:instances).flatten(1)
+      self_objects = modules + instances
       types = self_objects.map do |object|
         value = begin
           Methods::OBJECT_INSTANCE_VARIABLE_GET_METHOD.bind_call(object, name)

data/lib/repl_type_completor/types.rb

@@ -177,21 +177,20 @@ module ReplTypeCompletor
     def self.type_from_object(object)
       case object
       when Array
-        InstanceType.new Array, { Elem: union_type_from_objects(object) }
+        InstanceType.new Array, nil, [object]
       when Hash
-        InstanceType.new Hash, { K: union_type_from_objects(object.keys), V: union_type_from_objects(object.values) }
+        InstanceType.new Hash, nil, [object]
       when Module
         SingletonType.new object
       else
-        klass = Methods::OBJECT_SINGLETON_CLASS_METHOD.bind_call(object) rescue Methods::OBJECT_CLASS_METHOD.bind_call(object)
-        InstanceType.new klass
+        InstanceType.new Methods::OBJECT_CLASS_METHOD.bind_call(object), nil, [object]
       end
     end
 
     def self.union_type_from_objects(objects)
-      values = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
-      klasses = values.map { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
-      UnionType[*klasses.uniq.map { InstanceType.new _1 }]
+      instanes = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
+      class_instanes = instanes.group_by { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
+      UnionType[*class_instanes.map { InstanceType.new _1, nil, _2 }]
     end
 
     class SingletonType
@@ -212,18 +211,59 @@ module ReplTypeCompletor
     end
 
     class InstanceType
-      attr_reader :klass, :params
-      def initialize(klass, params = {})
+      attr_reader :klass, :raw_params, :instances
+      def initialize(klass, params = nil, instances = nil)
         @klass = klass
-        @params = params
+        @raw_params = params if params && !params.empty?
+        @instances = instances if instances && !instances.empty?
       end
+
       def transform() = yield(self)
-      def methods() = rbs_methods.select { _2.public? }.keys | @klass.instance_methods
-      def all_methods() = rbs_methods.keys | @klass.instance_methods | @klass.private_instance_methods
+      def methods() = rbs_methods.select { _2.public? }.keys | @klass.instance_methods | singleton_methods
+      def all_methods() = rbs_methods.keys | @klass.instance_methods | @klass.private_instance_methods | singleton_methods | instances_private_methods
+
+      def singleton_methods
+        return [] unless @instances
+        @singleton_methods ||= @instances.map do |instance|
+          Methods::OBJECT_SINGLETON_METHODS_METHOD.bind_call(instance)
+        end.inject(:|)
+      end
+
+      def instances_private_methods
+        return [] unless @instances
+        @private_instances_methods ||= @instances.map do |instance|
+          Methods::OBJECT_PRIVATE_METHODS_METHOD.bind_call(instance, false)
+        end.inject(:|)
+      end
+
+      def params
+        @params ||= expand_params
+      end
+
+      def expand_params
+        params = @raw_params || {}
+        return params unless @instances
+
+        if @klass == Array
+          type = Types.union_type_from_objects(@instances.flatten(1))
+          { Elem: UnionType[*params[:Elem], *type] }
+        elsif @klass == Hash
+          key = Types.union_type_from_objects(@instances.map(&:keys).flatten(1))
+          value = Types.union_type_from_objects(@instances.map(&:values).flatten(1))
+          {
+            K: UnionType[*params[:K], key],
+            V: UnionType[*params[:V], value]
+          }
+        else
+          params
+        end
+      end
+
       def constants() = []
       def types() = [self]
       def nillable?() = (@klass == NilClass)
       def nonnillable() = self
+
       def rbs_methods
         return {} unless Types.rbs_builder
 
@@ -231,6 +271,7 @@ module ReplTypeCompletor
         type_name = Types.rbs_absolute_type_name(name)
         Types.rbs_builder.build_instance(type_name).methods rescue {}
       end
+
       def inspect
         if params.empty?
           inspect_without_params
@@ -239,6 +280,7 @@ module ReplTypeCompletor
           "#{inspect_without_params}#{params_string}"
         end
       end
+
       def inspect_without_params
         if klass == NilClass
           'nil'
@@ -247,7 +289,7 @@ module ReplTypeCompletor
         elsif klass == FalseClass
           'false'
         else
-          klass.singleton_class? ? klass.superclass.to_s : klass.to_s
+          klass.to_s
         end
       end
     end
@@ -275,24 +317,26 @@ module ReplTypeCompletor
 
       def initialize(*types)
         @types = []
-        singletons = []
-        instances = {}
+        singleton_types = []
+        instance_types = {}
         collect = -> type do
           case type
           in UnionType
             type.types.each(&collect)
           in InstanceType
-            params = (instances[type.klass] ||= {})
-            type.params.each do |k, v|
+            params, instances = (instance_types[type.klass] ||= [{}, []])
+            type.instances&.each { instances << _1 }
+            type.raw_params&.each do |k, v|
               (params[k] ||= []) << v
             end
           in SingletonType
-            singletons << type
+            singleton_types << type
           end
         end
         types.each(&collect)
-        @types = singletons.uniq + instances.map do |klass, params|
-          InstanceType.new(klass, params.transform_values { |v| UnionType[*v] })
+        @types = singleton_types.uniq + instance_types.map do |klass, (params, instances)|
+          params = params.transform_values { |v| UnionType[*v] }
+          InstanceType.new(klass, params, instances)
         end
       end
 
@@ -322,7 +366,7 @@ module ReplTypeCompletor
       def methods() = @types.flat_map(&:methods).uniq
       def all_methods() = @types.flat_map(&:all_methods).uniq
       def constants() = @types.flat_map(&:constants).uniq
-      def inspect() = @types.map(&:inspect).join(' | ')
+      def inspect() = @types.map(&:inspect).sort.join(' | ')
     end
 
     BOOLEAN = UnionType[TRUE, FALSE]
@@ -362,7 +406,8 @@ module ReplTypeCompletor
             OBJECT
           end
         end
-      when RBS::Types::Union
+      when RBS::Types::Union, RBS::Types::Intersection
+        # Intersection is unsupported. fallback to union type
         UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
       when RBS::Types::Proc
         PROC
@@ -411,6 +456,8 @@ module ReplTypeCompletor
           params = names.map.with_index { [_1, args[_2] || OBJECT] }.to_h
         end
         InstanceType.new klass, params || {}
+      else
+        OBJECT
       end
     end
 

data/lib/repl_type_completor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReplTypeCompletor
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: repl_type_completor
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - tompng
 bindir: exe
 cert_chain: []
-date: 2025-01-21 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -84,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Type based completion for REPL.
 test_files: []