yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/store/query/find_signature.rb

@@ -5,9 +5,17 @@ module Yoda
         # @param namespace [Objects::NamespaceObject]
         # @param method_name [String, Regexp]
         # @param visibility [Array<Symbol>, nil]
-        # @return [Array<Objects::MethodObject>]
+        # @return [Array<Model::FunctionSignatures::Base>]
         def select(namespace, method_name, visibility: nil)
-          FindMethod.new(registry).select(namespace, method_name, visibility: visibility).map { |el| build(namespace, el) }.flatten
+          FindMethod.new(registry).select(namespace, method_name, visibility: visibility).flat_map { |el| build(namespace, el) }
+        end
+
+        # @param namespaces [Array<Objects::NamespaceObject>]
+        # @param method_name [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Array<Objects::MethodObject>]
+        def select_on_multiple(namespaces, method_name, visibility: nil)
+          namespaces.flat_map { |namespace| select(namespace, method_name, visibility: visibility) }
         end
 
         private
@@ -30,7 +38,7 @@ module Yoda
         # @return [FunctionSignatures::Constructor, nil]
         def try_to_build_constructor(receiver, method_object)
           if method_object.path == 'Class#new' && receiver.is_a?(Store::Objects::MetaClassObject) && receiver.path != 'Class'
-            base_class = registry.find(receiver.base_class_address) || return
+            base_class = registry.get(receiver.base_class_address) || return
             initialize_object = FindMethod.new(registry).find(base_class, 'initialize') || return
             Model::FunctionSignatures::Constructor.new(base_class, initialize_object)
           else

data/lib/yoda/store/query/find_workspace_objects.rb

@@ -0,0 +1,36 @@
+module Yoda
+  module Store
+    module Query
+      class FindWorkspaceObjects < Base
+        # @param query [String]
+        # @return [Enumerator<Objects::Base>]
+        def select(query)
+          lazy_select(query)
+        end
+
+        private
+
+        # @param query [String]
+        # @return [Enumerator::Lazy<Objects::Base>]
+        def lazy_select(query)
+          registry.local_store.registry.items.lazy.select do |item|
+            item.primary_source && fuzzy_match?(item.name, query)
+          end
+        end
+
+        # @param name [String]
+        # @param query [String, Regexp]
+        # @return [true, false]
+        def fuzzy_match?(name, query)
+          left_chars = query.chars
+          name.each_char do |c|
+            break if left_chars.empty?
+            left_chars.shift if c == left_chars.first
+          end
+
+          left_chars.empty?
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/method_member_set.rb

@@ -0,0 +1,50 @@
+module Yoda
+  module Store
+    module Query
+      class MethodMemberSet
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Objects::NamespaceObject]
+        attr_reader :object
+
+        # @param object [Objects::NamespaceObject]
+        # @param registry [Registry]
+        # @param origin [AncestorTree]
+        def initialize(registry:, object:)
+          @registry = registry
+          @object = object
+        end
+
+        # @return [Enumerator<Objects::MethodObject>]
+        def to_enum(**kwargs)
+          FindMethod.new(registry).all(object, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Objects::MethodObject, nil]
+        def find(method_name, **kwargs)
+          FindMethod.new(registry).find(object, method_name, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Enumerator<Objects::MethodObject>]
+        def select(method_name, **kwargs)
+          FindMethod.new(registry).select(object, method_name, **kwargs)
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Model::FunctionSignatures::Base]
+        def find_signature(method_name, **kwargs)
+          FindSignature.new(registry).select(object, method_name, **kwargs).first
+        end
+
+        # @param method_name [String, Regexp]
+        # @return [Array<Model::FunctionSignatures::Base>]
+        def select_signature(method_name, **kwargs)
+          FindSignature.new(registry).select(object, method_name, **kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query.rb

@@ -6,7 +6,11 @@ module Yoda
       require 'yoda/store/query/find_meta_class'
       require 'yoda/store/query/find_method'
       require 'yoda/store/query/find_signature'
+      require 'yoda/store/query/find_workspace_objects'
       require 'yoda/store/query/associators'
+      require 'yoda/store/query/ancestor_tree'
+      require 'yoda/store/query/constant_member_set'
+      require 'yoda/store/query/method_member_set'
     end
   end
 end

data/lib/yoda/store/{registry_cache.rb → registry/cache.rb}

@@ -1,10 +1,35 @@
 require 'concurrent'
+require 'forwardable'
 
 module Yoda
   module Store
     # Registry Cache is a cache layer for {Registry}.
     # This class intended to reduce patch calculations of {PatchSet#patch}.
-    class RegistryCache
+    class Registry::Cache
+      class RegistryWrapper
+        extend Forwardable
+        include MissingDelegatable
+
+        delegate_missing :registry
+
+        attr_reader :registry
+
+        def initialize(registry, cache = Registry::Cache.new)
+          @registry = registry
+          @cache = cache
+        end
+
+        def get(key)
+          @cache.fetch_or_calc(key) do
+            @registry.get(key)
+          end
+        end
+
+        def clear_cache
+          @cache.delete_all
+        end
+      end
+
       def initialize
         @data = Concurrent::Map.new
       end

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

@@ -0,0 +1,47 @@
+module Yoda
+  module Store
+    class Registry::Composer 
+      # @return [Symbol]
+      attr_reader :id
+
+      # @return [Hash{Symbol => Registry}]
+      attr_reader :registries
+
+      def initialize(id:, registries: [])
+        @id = id
+        @registries = registries.map { |registry| [registry.id, registry] }.to_h
+      end
+
+      def add_registry(registry)
+        registries[registry.id] = registry
+      end
+
+      def remove_registry(registry)
+        registries.delete(registry.id)
+      end
+
+      def get(address, registry_ids: nil)
+        target_registries = registry_ids ? registry_ids.map { |id| get_registry(id) }.compact : all_registries
+        objects_in_registry = target_registries.map { |registry| registry.get(address) }.compact
+        objects_in_registry.empty? ? nil : Objects::Merger.new(objects_in_registry).merged_instance
+      end
+
+      # @return [Set]
+      def keys
+        registries.values.map(&:keys).reduce(Set.new) { |memo, keys| memo + keys }
+      end
+
+      def get_registry(key)
+        registries[key]
+      end
+
+      def has_registry(key)
+        registries.has_key?(key)
+      end
+
+      def all_registries
+        registries.values.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'set'
+require 'forwardable'
+
+module Yoda
+  module Store
+    class Registry::Index
+      class ComposerWrapper
+        extend Forwardable
+        include MissingDelegatable
+
+        delegate_missing :composer
+
+        # @return [Registry::Index]
+        attr_reader :index
+
+        # @return [Registry::Composer]
+        attr_reader :composer
+
+        # @param index [Registry::Index]
+        # @param composer [Registry::Composer]
+        def initialize(index:, composer:)
+          fail TypeError, "index must be an instance of Registry::Index but #{index}" unless index.is_a?(Registry::Index)
+          fail TypeError, "composer must be an instance of Registry::Composer but #{composer}" unless composer.is_a?(Registry::Composer)
+          @index = index
+          @composer = composer
+        end
+
+        # @param [String, Symbol]
+        # @return [Objects::Addressable]
+        def get(address)
+          composer.get(address, registry_ids: index.get(address))
+        end
+
+        def add_registry(registry)
+          if old_registry = composer.get_registry(registry.id)
+            index.remove_registry(old_registry)
+          end
+          composer.add_registry(registry)
+          index.add_registry(registry)
+        end
+
+        def remove_registry(registry)
+          composer.remove_registry(registry)
+          index.remove_registry(registry)
+        end
+
+        def keys
+          index.keys
+        end
+
+        # @return [Enumerator<Object>]
+        def items
+          Enumerator.new do |y|
+            keys.each do |key|
+              value = get(key)
+              if value
+                y << value
+              else
+                Logger.warn("Not found value in registry for the key: #{key}")
+              end
+            end
+          end
+        end
+      end
+
+      # @return [Hash]
+      attr_reader :content
+
+      # @return [Set]
+      attr_reader :registry_ids
+
+      def initialize(content: {}, registry_ids: Set.new)
+        @content = content
+        @registry_ids = Set.new(registry_ids)
+      end
+
+      # @param address [String, Symbol]
+      # @return [Set<Symbol>]
+      def get(address)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+      end
+
+      # @param address [String, Symbol]
+      # @param registry_id [String, Symbol]
+      def add(address, registry_id)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+        content[address.to_sym].add(registry_id)
+        content[address.to_sym].select! { |id| registry_ids.member?(id) }
+      end
+
+      # @param address [String, Symbol]
+      # @param registry_id [String, Symbol]
+      def remove(address, registry_id)
+        content[address.to_sym] ||= Objects::SerializableSet.new
+        content[address.to_sym].delete(registry_id)
+      end
+
+      def keys
+        Set.new(content.keys)
+      end
+
+      def add_registry(registry)
+        registry_ids.add(registry.id)
+        registry.keys.each { |key| add(key, registry.id) }
+      end
+
+      def remove_registry(registry)
+        registry_ids.delete(registry.id)
+      end
+
+      def wrap(composer)
+        ComposerWrapper.new(composer: composer, index: self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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?
+            Instrument.instance.build_library_registry(name: library.name, version: library.version, message: "Building registry for #{library.name} (#{library.version})")
+            patch = library.create_patch
+            patch && compress_and_save(patch: patch, adapter: namespace)
+            Instrument.instance.build_library_registry(name: library.name, version: library.version, message: "Finished to build registry for #{library.name} (#{library.version})")
+          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