yoda-language-server 0.7.2 → 0.8.0

data/lib/yoda/store/objects/meta_class_object.rb

@@ -1,20 +1,47 @@
 module Yoda
   module Store
     module Objects
+      # @todo Rename to SingletonClassObject
       class MetaClassObject < NamespaceObject
+        class Connected < NamespaceObject::Connected
+          delegate_to_object :base_class_address
+
+          # @return [NamespaceObject::Connected]
+          def superclass
+            ancestor_tree.superclass.with_connection(**connection_options)
+          end
+
+          # @return [Base::Connected, nil]
+          def instance
+            registry.get(path)&.with_connection(**connection_options)
+          end
+        end
+
         # @param path [String]
         # @return [String]
         def self.address_of(path)
           "#{path}%class"
         end
 
+        # @param address [String]
+        # @return [true, false]
+        def self.meta_class_address?(address)
+          address.end_with?('%class')
+        end
+
+        # @param address [String]
+        # @return [String]
+        def self.path_of(address)
+          address.sub(/%class$/, '')
+        end
+
         # @param path [String]
         # @param document [Document, nil]
         # @param tag_list [TagList, nil]
         # @param instance_method_paths [Array<String>]
         # @param instance_mixin_paths [Array<String>]
         def initialize(**kwargs)
-          super(kwargs)
+          super(**kwargs)
         end
 
         # @return [String]

data/lib/yoda/store/objects/method_object.rb

@@ -2,6 +2,10 @@ module Yoda
   module Store
     module Objects
       class MethodObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :parameters, :visibility, :overloads, :sep, :namespace_path, :parent_address, :namespace_path
+        end
+
         # @return [Array<(String, String)>]
         attr_reader :parameters
 
@@ -12,38 +16,53 @@ module Yoda
         attr_reader :overloads
 
         class << self
+          METHOD_SEPARATOR_PATTERN = /[#.]|(::)/
+
           # @param path [String]
           # @return [String]
           def namespace_of_path(path)
-            path.slice(0, (path.rindex(/[#.]/) || 0))
+            divide_by_separator(path)&.at(0)
           end
 
           # @param path [String]
           # @return [String]
           def name_of_path(path)
-            path.slice((path.rindex(/[#.]/) || -1) + 1, path.length)
+            divide_by_separator(path)&.at(2)
           end
 
           # @param path [String]
-          # @return [String]
+          # @return [String, nil]
           def sep_of_path(path)
-            path.slice(path.rindex(/[#.]/))
+            divide_by_separator(path)&.at(1)
           end
 
           # @return [Array<Symbol>]
           def attr_names
             super + %i(parameters visibility overloads)
           end
+
+          private
+
+          # @param path [String]
+          # @return [(String, String, String), nil]
+          def divide_by_separator(path)
+            rev_path = path.reverse
+            if match_data = rev_path.match(METHOD_SEPARATOR_PATTERN)
+              [match_data.post_match.reverse, match_data.to_s, match_data.pre_match.reverse]
+            else
+              nil
+            end
+          end
         end
 
         # @param path [String]
         # @param document [Document, nil]
-        # @param tag_list [TagList, nil]
+        # @param tag_list [Array<Tag>, nil]
         # @param visibility [Symbol]
         # @param overloads [Array<Overload>]
         # @param parameters [Array<(String, String)>, nil]
         def initialize(parameters: [], visibility: :public, overloads: [], **kwargs)
-          super(kwargs)
+          super(**kwargs)
           fail ArgumentError, visibility unless %i(public private protected)
           @visibility = visibility.to_sym
           @parameters = parameters
@@ -65,6 +84,20 @@ module Yoda
           @namespace_path ||= MethodObject.namespace_of_path(path)
         end
 
+        # @return [String]
+        def parent_address
+          @parent_address ||= begin
+            case MethodObject.sep_of_path(path)
+            when '#'
+              namespace_path
+            when '.', '::'
+              MetaClassObject.address_of(namespace_path)
+            else
+              fail TypeError
+            end
+          end
+        end
+
         def kind
           :method
         end

data/lib/yoda/store/objects/module_object.rb

@@ -2,6 +2,9 @@ module Yoda
   module Store
     module Objects
       class ModuleObject < NamespaceObject
+        class Connected < NamespaceObject::Connected
+        end
+
         def kind
           :module
         end

data/lib/yoda/store/objects/namespace_object.rb

@@ -3,6 +3,36 @@ module Yoda
     module Objects
       # @abstract
       class NamespaceObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :instance_method_addresses, :mixin_addresses, :constant_addresses, :ancestors, :methods
+
+          # @return [Enumerator<NamespaceObject::Connected>]
+          def ancestors
+            ancestor_tree.ancestors.map { |object| object.with_connection(**connection_options) }
+          end
+
+          # @return [Enumerator<NamespaceObject::Connected>]
+          def mixins
+            ancestor_tree.mixins.map { |object| object.with_connection(**connection_options) }
+          end
+
+          # @return [Query::MethodMemberSet]
+          def method_members
+            @method_members ||= Query::MethodMemberSet.new(registry: registry, object: object)
+          end
+
+          # @return [Query::ConstantMemberSet]
+          def constant_members
+            @constant_members ||= Query::ConstantMemberSet.new(registry: registry, object: object)
+          end
+
+          private
+
+          def ancestor_tree
+            @ancestor_tree ||= Query::AncestorTree.new(registry: registry, object: object)
+          end
+        end
+
         # @return [Array<String>]
         attr_reader :instance_method_addresses
 
@@ -30,18 +60,20 @@ module Yoda
         # @param constant_addresses [Array<String>]
         # @param mixin_addresses [Array<String>]
         def initialize(instance_method_addresses: [], mixin_addresses: [], constant_addresses: [], **kwargs)
-          super(kwargs)
+          super(**kwargs)
           @instance_method_addresses = instance_method_addresses
           @mixin_addresses = mixin_addresses
           @constant_addresses = constant_addresses
           @ancestors ||= []
         end
 
+        # @note Override of {Base#name}
         # @return [String]
         def name
           @name ||= path.match(MODULE_TAIL_PATTERN) { |md| md[1] || md[2] }
         end
 
+        # @note Override of {Base#to_h}
         def to_h
           super.merge(
             instance_method_addresses: instance_method_addresses,
@@ -50,6 +82,11 @@ module Yoda
           )
         end
 
+        # @note Override of {Base#namespace?}
+        def namespace?
+          true
+        end
+
         private
 
         # @param another [self]

data/lib/yoda/store/objects/overload.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(name tag_list document parameters).include?(k) }.to_h)
+            new(**params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(name tag_list document parameters).include?(k) }.to_h)
           end
         end
 

data/lib/yoda/store/objects/patch.rb

@@ -15,21 +15,12 @@ module Yoda
           @registry = (contents || []).map { |content| [content.address.to_sym, content] }.to_h
         end
 
-        # @param addressable [Addressable]
-        # @return [void]
-        def register(addressable)
-          if el = @registry[addressable.address.to_sym]
-            @registry[addressable.address.to_sym] = el.merge(addressable)
-          else
-            @registry[addressable.address.to_sym] = addressable
-          end
-        end
-
         # @param address [String, Symbol]
         # @return [Addressable, nil]
         def find(address)
           @registry[address.to_sym]
         end
+        alias get find
 
         # @param address [String, Symbol]
         # @return [true, false]
@@ -41,6 +32,58 @@ module Yoda
         def keys
           @registry.keys
         end
+
+        # @param addressable [Addressable]
+        # @return [void]
+        def register(addressable)
+          parent_modifier.add_address_to_parent(addressable)
+
+          if el = @registry[addressable.address.to_sym]
+            @registry[addressable.address.to_sym] = el.merge(addressable)
+          else
+            @registry[addressable.address.to_sym] = addressable
+          end
+        end
+
+        private
+
+        def parent_modifier
+          @parent_modifier ||= ParentModifier.new(self)
+        end
+
+        class ParentModifier
+          attr_reader :patch
+
+          # @param patch [Patch]
+          def initialize(patch)
+            @patch = patch
+          end
+
+          # @param code_object [Base]
+          # @return [void]
+          def add_address_to_parent(code_object)
+            parent_module = patch.find(code_object.parent_address) || create_parent_module(code_object)
+            return unless parent_module.namespace?
+            patch.register(parent_module) if !patch.has_key?(parent_module.address) && parent_module.address != code_object.address
+
+            case code_object.kind
+            when :method
+              parent_module.instance_method_addresses.push(code_object.address) unless parent_module.instance_method_addresses.include?(code_object.address)
+            when :class, :module, :value
+              parent_module.constant_addresses.push(code_object.address) unless parent_module.constant_addresses.include?(code_object.address)
+            end
+          end
+
+          def create_parent_module(code_object)
+            if code_object.address == code_object.parent_address
+              code_object
+            elsif MetaClassObject.meta_class_address?(code_object.parent_address)
+              MetaClassObject.new(path: MetaClassObject.path_of(code_object.parent_address))
+            else
+              ModuleObject.new(path: code_object.parent_address)
+            end
+          end
+        end
       end
     end
   end

data/lib/yoda/store/objects/serializable.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.reject { |k, _v| k.to_sym == :json_class }.map { |k, v| [k.to_sym, v] }.to_h)
+            new(**params.reject { |k, _v| k.to_sym == :json_class }.map { |k, v| [k.to_sym, v] }.to_h)
           end
         end
 
@@ -31,7 +31,22 @@ module Yoda
         # Create a new instance which has the original parameters and overrided parameters.
         # @param params [Hash{Symbol => Object}] parameters to override
         def derive(params = {})
-          self.class.new(to_h.merge(params))
+          self.class.new(**to_h.merge(params))
+        end
+
+        def eql?(another)
+          return object.eql?(another) if respond_to?(:object) && !object.respond_to?(:object)
+          return eql?(another.object) if another.respond_to?(:object) && !another.object.respond_to?(:object)
+          return false unless self.class.name == another.class.name
+          to_h.eql?(another.to_h)
+        end
+
+        def ==(another)
+          eql?(another)
+        end
+
+        def hash
+          to_h.hash
         end
       end
     end

data/lib/yoda/store/objects/serializable_set.rb

@@ -0,0 +1,23 @@
+module Yoda
+  module Store
+    module Objects
+      class SerializableSet
+        include MissingDelegatable
+        include Serializable
+
+        delegate_missing :set
+
+        # @return [Set]
+        attr_reader :set
+
+        def initialize(els = nil, elements: nil)
+          @set = Set.new(els || elements)
+        end
+
+        def to_h
+          { elements: set.to_a }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/tag.rb

@@ -9,7 +9,7 @@ module Yoda
 
           # @param params [Hash]
           def json_create(params)
-            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(tag_name name yard_types text lexical_scope).include?(k) }.to_h)
+            new(**params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(tag_name name yard_types text lexical_scope).include?(k) }.to_h)
           end
         end
 

data/lib/yoda/store/objects/value_object.rb

@@ -2,6 +2,10 @@ module Yoda
   module Store
     module Objects
       class ValueObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :value
+        end
+
         # @return [String]
         attr_reader :value
 
@@ -13,7 +17,7 @@ module Yoda
         # @param path [String]
         # @param value [String]
         def initialize(value: nil, **kwargs)
-          super(kwargs)
+          super(**kwargs)
           @value = value
         end
 

data/lib/yoda/store/objects.rb

@@ -8,6 +8,7 @@ module Yoda
       require 'yoda/store/objects/addressable'
       require 'yoda/store/objects/patchable'
       require 'yoda/store/objects/base'
+      require 'yoda/store/objects/connected_delegation'
       require 'yoda/store/objects/namespace_object'
       require 'yoda/store/objects/class_object'
       require 'yoda/store/objects/value_object'
@@ -19,7 +20,10 @@ module Yoda
       require 'yoda/store/objects/patch'
       require 'yoda/store/objects/patch_set'
       require 'yoda/store/objects/tag'
-      require 'yoda/store/objects/project_status'
+      require 'yoda/store/objects/libraries_status'
+      require 'yoda/store/objects/library'
+      require 'yoda/store/objects/serializable_set'
+      require 'yoda/store/objects/map'
 
       class << self
         # @param hsh [Hash]

data/lib/yoda/store/project/dependency.rb

@@ -0,0 +1,83 @@
+require 'open3'
+
+module Yoda
+  module Store
+    class Project
+      class Dependency
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [Array<Objects::Library::Gem>]
+        def gems
+          builder.gems
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [Library, nil]
+        def gem_dependency(name:, version:)
+          libraries.find { |library| library.name == name && library.version == version }
+        end
+
+        # @return [Objects::Library::Core]
+        def core
+          @core ||= Objects::Library.core
+        end
+
+        # @return [Objects::Library::Std]
+        def std
+          @std ||= Objects::Library.std
+        end
+
+        def builder
+          @builder ||= Builder.new(project)
+        end
+
+        class Builder
+          # @return [Project]
+          attr_reader :project
+
+          # @param project [Project]
+          def initialize(project)
+            @project = project
+          end
+
+          # @return [Array<Objects::Library::Gem>]
+          def gems
+            @gems ||= begin
+              dependencies
+                .map { |attrs| Objects::Library::Gem.new(**attrs) }
+                .reject { |spec| project.config.ignored_gems.include?(spec.name) }
+            end
+          end
+
+          private
+
+          # @return [Array<Hash>]
+          def dependencies
+            analyzed_deps[:dependencies] || []
+          end
+
+          # @return [Hash]
+          def analyzed_deps
+            @analyzed_deps ||= begin
+              return {} unless project.root_path
+
+              # Bundler pollutes environment variables in the current process, so analyze in another process.
+              stdout, stderr, status = Open3.capture3(Yoda::Cli.yoda_exe, "analyze-deps", project.root_path)
+
+              fail stderr unless status.success?
+
+              Logger.trace("Analysis Result: #{stdout}")
+              JSON.parse(stdout, symbolize_names: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project/file_finder.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Yoda
+  module Store
+    class Project
+      # Find registry file for the current project settings.
+      class FileFinder
+        # @return [Project]
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [true, false]
+        def present?
+          File.exist?(cache_path)
+        end
+
+        # @return [String, nil]
+        def yoda_dir_path
+          expand_path('.yoda')
+        end
+
+        # @return [String, nil]
+        def cache_dir_path
+          expand_path('.yoda/cache')
+        end
+
+        # @return [String, nil]
+        def library_registry_dir_path
+          expand_path(File.join('.yoda', 'library_registry'))
+        end
+
+        # @return [String, nil]
+        def library_local_yardoc_dir_path
+          expand_path(File.join('.yoda', 'yardoc', RUBY_VERSION))
+        end
+
+        # @return [String, nil]
+        def gemfile_lock_path
+          expand_path('Gemfile.lock')
+        end
+
+        # @return [String, nil]
+        def config_file_path
+          expand_path('.yoda.yml')
+        end
+
+        # @return [String, nil]
+        def readable_config_file_path
+          path = config_file_path
+          path && File.readable?(config_file_path) ? path : nil
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [String, nil]
+        def library_local_yardoc_path(name:, version:)
+          expand_path("#{name}-#{version}.yardoc", library_local_yardoc_dir_path)
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [String, nil]
+        def library_registry_path(name:, version:)
+          expand_path(Registry.registry_name, library_registry_dir_path)
+        end
+
+        # @return [String, nil]
+        def project_registry_path
+          expand_path(Registry.registry_name, cache_dir_path)
+        end
+
+        def make_dir
+          make_dir_at(cache_dir_path)
+          make_dir_at(library_local_yardoc_dir_path)
+          make_dir_at(library_registry_dir_path)
+        end
+
+        def clear_dir
+          yoda_dir_path && File.exist?(yoda_dir_path) && FileUtils.rm_rf(yoda_dir_path)
+        end
+
+        private
+
+        def expand_path(relative_path, base_path = project.root_path)
+          return nil unless base_path
+          File.expand_path(relative_path, base_path)
+        end
+
+        # @param dir_path [String]
+        def make_dir_at(dir_path)
+          dir_path && (File.exist?(dir_path) || FileUtils.mkdir_p(dir_path))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project/rbs_loader.rb

@@ -0,0 +1,41 @@
+require 'rbs'
+
+module Yoda
+  module Store
+    class Project
+      # Find registry file for the current project settings.
+      class RbsLoader
+        # @return [Project]
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [RBS::Environment]
+        def rbs_environment
+          @rbs_environment ||= begin
+            repository = RBS::Repository.new
+            project.config.rbs_repository_paths.each do |repo_path|
+              pathname = Pathname(repo_path).expand_path(project.root_path)
+              repository.add(pathname)
+            end
+
+            loader = RBS::EnvironmentLoader.new(repository: repository)
+            project.config.rbs_signature_paths.each do |sig_path|
+              pathname = Pathname(sig_path).expand_path(project.root_path)
+              loader.add(path: pathname)
+            end
+
+            project.config.rbs_libraries.each do |library|
+              loader.add(library: library)
+            end
+
+            RBS::Environment.from_loader(loader).resolve_type_names
+          end
+        end
+      end
+    end
+  end
+end