yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/store/registry.rb

@@ -1,109 +1,37 @@
-require 'concurrent'
-require 'yard'
+require "digest"
 
 module Yoda
   module Store
-    class Registry
-      # @note This number must be updated when breaking change is added.
-      REGISTRY_VERSION = 1
-
-      PROJECT_STATUS_KEY = '%project_status'
-
-      def initialize(adapter = nil)
-        @patch_set = Objects::PatchSet.new
-        @adapter = adapter
-        @registry_cache = RegistryCache.new
-        @lock = Concurrent::ReentrantReadWriteLock.new
-      end
-
-      # @return [Objects::ProjectStatus, nil]
-      def project_status
-        lock.with_read_lock do
-          adapter&.exist?(PROJECT_STATUS_KEY) && adapter.get(PROJECT_STATUS_KEY)
-        end
-      end
-
-      # @param new_project_status [Objects::ProjectStatus]
-      def save_project_status(new_project_status)
-        lock.with_write_lock do
-          adapter.put(PROJECT_STATUS_KEY, new_project_status)
-        end
-      end
+    module Registry
+      require 'yoda/store/registry/cache'
+      require 'yoda/store/registry/composer'
+      require 'yoda/store/registry/index'
+      require 'yoda/store/registry/library_registry_set'
+      require 'yoda/store/registry/library_registry'
+      require 'yoda/store/registry/local_store'
+      require 'yoda/store/registry/project_registry'
 
-      # @param path [String]
-      # @return [Objects::Base, nil]
-      def find(path)
-        lock.with_read_lock do
-          registry_cache.fetch_or_calc(path) do
-            if adapter&.exist?(path)
-              patch_set.patch(adapter.get(path))
-            else
-              patch_set.find(path)
-            end
+      # @note This number must be updated when breaking change is added.
+      REGISTRY_VERSION = 6
+
+      class << self
+        def registry_name
+          @registry_name ||= begin
+            digest = Digest::SHA256.new
+            digest.update(RUBY_VERSION)
+            digest.update(REGISTRY_VERSION.to_s)
+            digest.update(Adapters.default_adapter_class.type.to_s)
+            digest.hexdigest
           end
         end
-      end
-
-      # @param patch [Patch]
-      def add_patch(patch)
-        lock.with_write_lock do
-          registry_cache.clear_from_patch(patch)
-          patch_set.register(patch)
-        end
-      end
 
-      # @param path [String]
-      # @return [true, false]
-      def has_key?(path)
-        lock.with_read_lock do
-          adapter&.exists?(path) || patch_set.has_key?(path)
+        # @param project [Project]
+        # @param memory [Boolean]
+        # @return [Registry]
+        def for_project(project)
+          ProjectRegistry.for_project(project)
         end
       end
-
-      def clear
-        lock.with_write_lock do
-          registry_cache.delete_all
-          adapter.clear
-        end
-      end
-
-      # Store patch set data to the database.
-      # old data in the database are discarded.
-      def compress_and_save
-        return unless adapter
-        lock.with_write_lock do
-          el_keys = patch_set.keys
-          progress = Instrument::Progress.new(el_keys.length) { |length:, index:| Instrument.instance.registry_dump(index: index, length: length) }
-
-          data = Enumerator.new do |yielder|
-            el_keys.each { |key| yielder << [key, patch_set.find(key)] }
-          end
-
-          adapter.batch_write(data, progress)
-          adapter.sync
-          Logger.info "saved #{el_keys.length} keys."
-          @patch_set = Objects::PatchSet.new
-          registry_cache.delete_all
-        end
-      end
-
-      private
-
-      # @return [Adapters::LmdbAdapter, nil]
-      attr_reader :adapter
-
-      # @return [Objects::PatchSet]
-      attr_reader :patch_set
-
-      # @return [RegistryCache]
-      attr_reader :registry_cache
-
-      # @return [Concurrent::ReentrantReadWriteLock]
-      attr_reader :lock
-
-      def keys
-        Set.new(adapter&.keys.map(&:to_s) || []).union(patch_set.keys)
-      end
     end
   end
 end

data/lib/yoda/store/transformers/core_visibility.rb

@@ -0,0 +1,61 @@
+module Yoda
+  module Store
+    module Transformers
+      # YARD parses some kernel methods as public.
+      # This class fixes these visibilities.
+      class CoreVisibility
+        # @param patch [Objects::Patch]
+        # @return [Objects::Patch]
+        def self.transform(patch)
+          new(patch).transformed_patch
+        end
+
+        # @return [Objects::Patch]
+        attr_reader :patch
+
+        # @param patch [Objects::Patch]
+        def initialize(patch)
+          @patch = patch
+        end
+
+        # @return [Objects::Patch]
+        def transformed_patch
+          @transformed_patch = begin
+            if patch.has_key?(:Kernel)
+              create_patch
+            else
+              patch
+            end
+          end
+        end
+
+        private
+
+        # @return [Objects::Patch]
+        def create_patch
+          new_patch = Objects::Patch.new(patch.id)
+
+          patch.keys.each do |key|
+            new_patch.register(transform_object(patch.get(key)))
+          end
+
+          new_patch
+        end
+
+        # @param object [Objects::Base]
+        # @return [Objects::Base]
+        def transform_object(object)
+          if object.kind == :method && object.namespace_path == "Kernel"
+            if Kernel.private_instance_methods.include?(object.name.to_sym)
+              Objects::MethodObject.new(**object.to_h, visibility: :private)
+            else
+              object
+            end
+          else
+            object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/transformers.rb

@@ -0,0 +1,7 @@
+module Yoda
+  module Store
+    module Transformers
+      require 'yoda/store/transformers/core_visibility'
+    end
+  end
+end

data/lib/yoda/store/version_store.rb

@@ -0,0 +1,71 @@
+module Yoda
+  module Store
+    # Return paths for each Ruby version.
+    class VersionStore
+      SOURCE_PATH_BASE = File.expand_path("~/.yoda/sources")
+      REGISTRY_PATH_BASE = File.expand_path('~/.yoda/registry')
+
+      # @return [VersionStore]
+      def self.for_current_version
+        new(RUBY_VERSION)
+      end
+
+      attr_reader :ruby_version
+
+      # @param version [String]
+      def initialize(ruby_version)
+        @ruby_version = ruby_version
+      end
+
+      # Return the path to store the version's Ruby.
+      # @return [String]
+      def ruby_source_path
+        File.join(SOURCE_PATH_BASE, "ruby-#{ruby_version}")
+      end
+
+      # Return the path to store yard document index of the core library.
+      # @return [String]
+      def core_yardoc_path
+        File.join(ruby_source_path, '.yardoc')
+      end
+
+      # Return the path to store yard document index of the standard library.
+      # @return [String]
+      def stdlib_yardoc_path
+        File.join(ruby_source_path, '.yardoc-stdlib')
+      end
+
+      # Return the path to store registries.
+      # @return [String]
+      def registries_path
+        File.join(REGISTRY_PATH_BASE, ruby_version)
+      end
+
+      # Return the path to store registry of the gem.
+      # @param name [String]
+      # @param version [String]
+      # @return [String]
+      def registry_path_for_gem(name:, version:)
+        library_registry_path
+      end
+
+      # Return the path to store registry of the core library.
+      # @return [String]
+      def registry_path_for_core
+        library_registry_path
+      end
+
+      # Return the path to store registry of the standard library.
+      # @return [String]
+      def registry_path_for_stdlib
+        library_registry_path
+      end
+
+      # Return the path to store registry of whole library
+      # @return [String]
+      def library_registry_path
+        File.join(registries_path, Registry.registry_name, "library")
+      end
+    end
+  end
+end

data/lib/yoda/store/yard_importer.rb

@@ -9,6 +9,9 @@ module Yoda
       # @return [String, nil]
       attr_reader :root_path
 
+      # @return [String, nil]
+      attr_reader :source_path
+
       # @param file [String]
       # @param root_path [String, nil]
       # @return [Objects::Patch]
@@ -16,13 +19,20 @@ module Yoda
         store = YARD::RegistryStore.new
         store.load(file)
         root_path ||= File.expand_path('..', file)
-        new(file, root_path: root_path).import(store.values).patch
+        new(patch_id_for_file(file), root_path: root_path).import(store.values).patch
+      end
+
+      # @param file [String]
+      # @return [String]
+      def self.patch_id_for_file(file)
+        file
       end
 
       # @param id [String]
-      def initialize(id, root_path: nil)
+      def initialize(id, root_path: nil, source_path: nil)
         @patch = Objects::Patch.new(id)
         @root_path = root_path
+        @source_path = source_path
         @registered = Set.new
       end
 
@@ -39,7 +49,7 @@ module Yoda
       def register(code_object)
         return if @registered.member?(code_object.path)
         @registered.add(code_object.path)
-        register(code_object.parent) if code_object.parent && !code_object.parent.root?
+        register(code_object.parent) if code_object.parent
 
         new_objects = begin
           case code_object.type
@@ -64,7 +74,6 @@ module Yoda
           end
         end
 
-        register_to_parent_proxy(code_object) if code_object.parent && code_object.parent.type == :proxy
         [new_objects].flatten.compact.each { |new_object| patch.register(new_object) }
       end
 
@@ -79,7 +88,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, '') },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: (code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path } + ['Object']).uniq,
         )
@@ -87,7 +96,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
         )
         [object_class, object_meta_class]
@@ -149,7 +158,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
         )
@@ -158,7 +167,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
         )
 
@@ -174,7 +183,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| path_to_store(constant) },
           superclass_path: !code_object.superclass || code_object.superclass&.path == 'Qnil' ? nil : path_to_store(code_object.superclass),
@@ -184,7 +193,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.class_mixins.map { |mixin| path_to_store(mixin) },
         )
 
@@ -248,18 +257,11 @@ module Yoda
         [module_object, meta_class_object]
       end
 
-      # @param code_object [::YARD::CodeObjects::Base]
-      # @return [vaid]
-      def register_to_parent_proxy(code_object)
-        proxy_module = patch.find(path_to_store(code_object.parent))
-        proxy_module.instance_method_addresses.push(path_to_store(code_object)) if code_object.type == :method
-        proxy_module.constant_addresses.push(path_to_store(code_object)) if [:class, :module, :proxy].include?(code_object.type)
-      end
-
       # @param source [(String, Integer)]
       # @return [(String, Integer, Integer)]
       def convert_source(source)
         file, line = source
+        file = source_path if source_path && file == "(stdin)"
         [root_path ? File.expand_path(file, root_path) : file, line, 0]
       end
 
@@ -271,13 +273,13 @@ module Yoda
       end
 
       # @param code_object [::YARD::CodeObjects::Base]
-      # @return [String]
+      # @return [String] absolute object path to store.
       def calc_path_to_store(object)
         return 'Object' if object.root?
         parent_path = path_to_store(object.parent)
 
         if object.type == :proxy || object.is_a?(YARD::CodeObjects::Proxy)
-          # For now, we suppose the proxy object exists directly under its lexical namespace.
+          # For now, we suppose the proxy object exists directly under its namespace.
           [path_to_store(object.parent), object.name].join('::')
         elsif object.parent.path == path_to_store(object.parent)
           object.path

data/lib/yoda/store.rb

@@ -1,14 +1,27 @@
 require 'yard'
 
 module Yoda
+  # {Store} treats persistence and caching of code objects and querying of these objects in {Store::Registry}.
   module Store
     require 'yoda/store/actions'
     require 'yoda/store/adapters'
+    require 'yoda/store/config'
+    require 'yoda/store/file_tree'
     require 'yoda/store/project'
-    require 'yoda/store/registry_cache'
-    require 'yoda/store/registry'
     require 'yoda/store/objects'
+    require 'yoda/store/registry'
     require 'yoda/store/query'
+    require 'yoda/store/transformers'
+    require 'yoda/store/version_store'
     require 'yoda/store/yard_importer'
+
+    class << self
+      # @return [Project]
+      def setup(dir: Dir.pwd, force_build: false)
+        project = Project.for_path(dir)
+        project.setup(rebuild: force_build)
+        project
+      end
+    end
   end
 end

data/lib/yoda/typing/constant_resolver/cbase_query.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class CbaseQuery < Query
+        # @return [nil]
+        def parent
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver/member_query.rb

@@ -0,0 +1,27 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class MemberQuery < Query
+        # @return [Query]
+        attr_reader :parent
+
+        # @return [Symbol]
+        attr_reader :name
+
+        # @return [NodeTracer, nil]
+        attr_reader :tracer
+
+        # @param parent [Query]
+        # @param name [Symbol]
+        # @param tracer [NodeTracer, nil]
+        def initialize(parent:, name:, tracer: nil)
+          @parent = parent
+          @name = name
+          @tracer = tracer
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver/node_tracer.rb

@@ -0,0 +1,36 @@
+module Yoda
+  module Typing
+    class ConstantResolver
+      class NodeTracer
+        # @return [AST::Node]
+        attr_reader :node
+
+        # @return [Inferencer::Tracer]
+        attr_reader :tracer
+
+        # @param node [AST::Node]
+        # @param tracer [Inferencer::Tracer]
+        def initialize(node:, tracer:)
+          @node = node
+          @tracer = tracer
+        end
+
+        # @param type [Types::Base]
+        # @param context [Contexts::BaseContext]
+        def bind_type(type:, context:)
+          tracer.bind_type(node: node, type: type, context: context)
+        end
+
+        # @param context [Contexts::BaseContext]
+        def bind_context(context:)
+          tracer.bind_context(node: node, context: context)
+        end
+
+        # @param constants [Array<Store::Objects::Base>]
+        def bind_constants(constants:)
+          tracer.bind_constants(node: node, constants: constants)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver/query.rb

@@ -0,0 +1,59 @@
+module Yoda
+  module Typing
+    class ConstantResolver
+      # @abstract
+      class Query
+        class << self
+          # @param node [AST::ConstantNode]
+          # @param tracer [Inferencer::Tracer]
+          def from_node(node, tracer: nil)
+            case node.type
+            when :cbase
+              CbaseQuery.new
+            when :empty
+              RelativeBaseQuery.new
+            else
+              MemberQuery.new(parent: from_node(node.base, tracer: tracer), name: node.name.name.to_s, tracer: tracer && NodeTracer.new(node: node, tracer: tracer))
+            end
+          end
+
+          def from_string(string, parent: RelativeBaseQuery.new)
+            base, child = string.split("::", 2)
+
+            case base
+            when nil
+              parent
+            when ""
+              base_query = CbaseQuery.new
+
+              if child.nil?
+                base_query
+              else
+                from_string(child, parent: base_query)
+              end
+            else
+              base_query = MemberQuery.new(parent: parent, name: base)
+
+              if child.nil?
+                base_query
+              else
+                from_string(child, parent: base_query)
+              end
+            end
+          end
+        end
+
+        # @abstract
+        # @return [Query, nil]
+        def parent
+          fail NotImplementedError
+        end
+
+        # @return [NodeTracer, nil]
+        def tracer
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver/relative_base_query.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class RelativeBaseQuery < Query
+        # @return [nil]
+        def parent
+          nil
+        end
+      end
+    end
+  end
+end