yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/store/registry/library_registry.rb

@@ -0,0 +1,69 @@
+module Yoda
+  module Store
+    class Registry::LibraryRegistry
+      class << self
+        # @param library [Objects::Library]
+        def for_library(library)
+          adapter = Adapters.for(library.registry_path)
+          namespace = adapter.namespace(library.name)
+
+          if namespace.empty?
+            patch = library.create_patch
+            patch && compress_and_save(patch: patch, adapter: namespace)
+          end
+
+          new(id: library.id, adapter: namespace)
+        end
+
+        private
+
+        # Store patch set data to the database.
+        # old data in the database are discarded.
+        # @param patch [Objects::Patch]
+        # @param adapter [Adapters::Base]
+        def compress_and_save(patch:, adapter:)
+          el_keys = patch.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.get(key)] }
+          end
+
+          adapter.batch_write(data, progress)
+          Logger.info "saved #{el_keys.length} keys."
+        end
+      end
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [Adapters::Base]
+      attr_reader :adapter
+
+      # @param id [String]
+      # @param adapter [Adapters::Base]
+      def initialize(id:, adapter:)
+        @id = id
+        @adapter = adapter
+      end
+
+      def get(path)
+        adapter.get(path)
+      end
+
+      # @param path [String]
+      # @return [true, false]
+      def has_key?(path)
+        adapter.exists?(path)
+      end
+
+      def persistable?
+        adapter.persistable?
+      end
+
+      def keys
+        @keys ||= Set.new(adapter.keys.map(&:to_s) || [])
+      end
+    end
+  end
+end

data/lib/yoda/store/registry/library_registry_set.rb

@@ -0,0 +1,133 @@
+module Yoda
+  module Store
+    module Registry
+      class LibraryRegistrySet
+        STATUS_KEY = '%library_status'
+        PERSISTABLE_LIBRARY_STORE_INDEX_KEY = '%persistable_library_store_index'
+
+        # @return [Project]
+        attr_reader :project
+
+        # @return [Adapters::Base]
+        attr_reader :adapter
+        private :adapter
+
+        # @return [Proc, nil]
+        attr_reader :on_change
+
+        # @param project [Project]
+        # @param adapter [Adapters::Base]
+        # @param on_change [Proc, nil]
+        def initialize(project:, adapter:, on_change: nil)
+          fail TypeError, adapter unless adapter.is_a?(Adapters::Base)
+          @project = project
+          @adapter = adapter
+          @on_change = on_change
+        end
+
+        # @return [Registry::Composer]
+        def registry
+          Registry::Composer.new(id: :libraries, registries: [persistable_library_store, volatile_library_store])
+        end
+
+        # @param add [Array<Objects::Library::Core, Objects::Library::Gem, Objects::Library::Std>]
+        # @param remove [Array<Objects::Library::Core, Objects::Library::Gem, Objects::Library::Std>]
+        def modify(add:, remove:)
+          add = add.map { |library| library.with_project_connection(project: project) }
+          remove = remove.map { |library| library.with_project_connection(project: project) }
+
+          remove.each do |library|
+            if registry = library.registry
+              persistable_library_store.remove_registry(registry)
+              volatile_library_store.remove_registry(registry)
+              status.remove_library(library)
+            end
+          end
+          add.each do |library|
+            if registry = library.registry
+              if registry.persistable?
+                persistable_library_store.add_registry(registry)
+              else
+                volatile_library_store.add_registry(registry)
+              end
+              status.add_library(library)
+            end
+          end
+          on_change&.call
+          save
+        end
+
+        # @param library [Library::Core, Library::Std, Library::Gem]
+        def add(library)
+          library = library.with_project_connection(project: project)
+          add_library_registry(library.registry)
+          status.add_library(library)
+          save
+        end
+
+        # @param library [Library::Core, Library::Std, Library::Gem]
+        def remove(library)
+          library = library.with_project_connection(project: project)
+          remove_library_registry(library.registry)
+          status.remove_library(library)
+          save
+        end
+
+        # @return [Objects::LibrariesStatus::Connected]
+        def status
+          @status ||= (adapter.get(STATUS_KEY) || Objects::LibrariesStatus.new).with_project_connection(project: project)
+        end
+
+        def save
+          persistable_library_store_index_content.save
+          adapter.put(STATUS_KEY, status)
+        end
+
+        private
+
+        def add_library_registry(registry)
+          if registry.persistable?
+            persistable_library_store.add_registry(registry)
+          else
+            volatile_library_store.add_registry(registry)
+          end
+
+          on_change&.call
+          save
+        end
+
+        def remove_library_registry(registry)
+          persistable_library_store.remove_registry(registry)
+          volatile_library_store.remove_registry(registry)
+          on_change&.call
+          save
+        end
+
+        def persistable_library_store
+          @persistable_library_store ||= begin
+            library_composer = Registry::Composer.new(id: :persistable_library, registries: status.registries.select(&:persistable?))
+            persistable_library_store_index.wrap(library_composer)
+          end
+        end
+
+        def persistable_library_store_index
+          @persistable_library_store_index ||= Registry::Index.new(content: persistable_library_store_index_content, registry_ids: status.libraries.map(&:id))
+        end
+
+        def persistable_library_store_index_content
+          @persistable_library_store_index_content ||= Objects::Map.new(path: PERSISTABLE_LIBRARY_STORE_INDEX_KEY, adapter: adapter)
+        end
+
+        def volatile_library_store
+          @volatile_library_store ||= begin
+            Registry::Composer.new(id: :volatile_library, registries: status.registries.reject(&:persistable?))
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name}: @adapter=#{adapter.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/registry/local_store.rb

@@ -0,0 +1,38 @@
+module Yoda
+  module Store
+    module Registry
+      class LocalStore
+        # @return [Proc, nil]
+        attr_reader :on_change
+
+        # @param on_change [Proc, nil]
+        def initialize(on_change: nil)
+          @on_change = on_change
+        end
+
+        # @return [Registry::Index::ComposerWrapper]
+        def registry
+          @registry ||= Registry::Index.new.wrap(Registry::Composer.new(id: :local))
+        end
+
+        # @param patch [Objects::Patch]
+        def add_file_patch(patch)
+          registry.add_registry(patch)
+          on_change&.call
+        end
+
+        # @param patch [Objects::Patch, String, Symbol]
+        def remove_file_patch(patch)
+          registry.remove_registry(patch)
+          on_change&.call
+        end
+
+        # @param patch [String, Symbol]
+        # @return [Objects::Patch, nil]
+        def find_file_patch(id)
+          registry.get_registry(id)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/registry/project_registry.rb

@@ -0,0 +1,72 @@
+require 'forwardable'
+
+module Yoda
+  module Store
+    class Registry::ProjectRegistry
+      extend Forwardable
+      include HasServices
+
+      service(:constant_finder) { Query::FindConstant.new(self) }
+      service(:meta_class_finder) { Query::FindMetaClass.new(self) }
+      service(:method_finder) { Query::FindMethod.new(self) }
+      service(:signature_finder) { Query::FindSignature.new(self) }
+
+      delegate %i(get has_key? keys) => :root_store
+
+      attr_reader :project
+
+      class << self
+        # @param project [Project]
+        def for_project(project)
+          new(project)
+        end
+      end
+
+      # @param project [Project]
+      def initialize(project)
+        fail TypeError, project unless project.is_a?(Project)
+        @project = project
+      end
+
+      def root_store
+        @root_store ||= begin
+          Registry::Cache::RegistryWrapper.new(
+            Registry::Composer.new(id: :root, registries: [local_store.registry, libraries.registry]),
+          )
+        end
+      end
+
+      # @return [LibraryRegistrySet]
+      def libraries
+        @libraries ||= Registry::LibraryRegistrySet.new(project: project, adapter: adapter, on_change: -> { clear_cache })
+      end
+
+      # @return [LocalStore]
+      def local_store
+        @local_store ||= Registry::LocalStore.new(on_change: -> { clear_cache })
+      end
+
+      # @return [Adapters::Base]
+      def adapter
+        @adapter ||= begin
+          Adapters.for(project.project_registry_path)
+        end
+      end
+
+      # @param pp [PP]
+      def pretty_print(pp)
+        pp.object_group(self) do
+          pp.breakable
+          pp.text "@adapter="
+          pp.pp adapter
+        end
+      end
+
+      private
+
+      def clear_cache
+        root_store.clear_cache
+      end
+    end
+  end
+end

data/lib/yoda/store/registry.rb

@@ -1,101 +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
-      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
-          if adapter&.exist?(path)
-            patch_set.patch(adapter.get(path))
-          else
-            patch_set.find(path)
+      # @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
-          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
-          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
-        end
-      end
-
-      private
-
-      # @return [Adapters::LmdbAdapter, nil]
-      attr_reader :adapter
-
-      # @return [Objects::PatchSet]
-      attr_reader :patch_set
-
-      # @return [Concurrent::ReentrantReadWriteLock]
-      def lock
-        @lock ||= Concurrent::ReentrantReadWriteLock.new
-      end
-
-      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