yoda-language-server 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c06ab67892292a50ff422a252b794cf49f38dad60a8b32e7faf14936a2b648e
-  data.tar.gz: 20546678432670fae9b613a6d55e23f6ee3b2c544d6a6b62ff3ff80d6bd3e376
+  metadata.gz: a1135858460f719a79d288fd6210011d1380f39ecedf817b06277aa400277e79
+  data.tar.gz: 5fa3c98c453be13419c9e3225d5cbeea81ee1103e77812a1097f251f29c4a39d
 SHA512:
-  metadata.gz: 0eac21b1b1b73f3d3864c2cdb37c2f8df39c9be6841518b59282d5b89c8b64d54972c9c8b9318d35273250c9c740465d7c2156098e0629ee0df831a05ad41e2a
-  data.tar.gz: 9b9991e147783643687d6c259c45c9ab45cfa009df5a60a23f1dce36571c5dc9a61d8a12bb70d57a79f30bf2288ed24933ea84e4a54c0df583b820ed54357cc6
+  metadata.gz: 6dffa44d4bb6dbe751fdb34c0f47ea2b371deae46e22b85da27dc0c2c57938d8203f593b0990cea379dc708d34c060173dff6c512e2603edc98808d9131b9026
+  data.tar.gz: 2df74769182891b2ef9926a89abf8e8487e4a734a87719ead05374c3bc6b52db53ec4b3f01186de03af60bbf5f54bb1a323a3803a908d78f106fbd3a3d874b90

data/lib/yoda/store.rb

@@ -5,6 +5,7 @@ module Yoda
     require 'yoda/store/actions'
     require 'yoda/store/adapters'
     require 'yoda/store/project'
+    require 'yoda/store/registry_cache'
     require 'yoda/store/registry'
     require 'yoda/store/objects'
     require 'yoda/store/query'

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

@@ -1,3 +1,6 @@
+require 'set'
+require 'forwardable'
+
 module Yoda
   module Store
     module Objects
@@ -36,7 +39,7 @@ module Yoda
 
         # @return [Hash{ Symbol => Object }]
         def attributes
-          @attributes ||= instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) }
+          @attributes ||= normalize_attributes(instances.map { |i| default_attributes.merge(i.to_h) }.reduce { |a, b| merge_attributes(a, b) })
         end
 
         # @param one [Hash{ Symbol => Object }]
@@ -45,15 +48,15 @@ module Yoda
           {
             path: one[:path] || another[:path],
             document: one[:document] + (one[:document].empty? || another[:document].empty? ? '' : "\n") + another[:document],
-            tag_list: one[:tag_list] + another[:tag_list],
-            sources: one[:sources] + another[:sources],
+            tag_list: PendingArray.append(one[:tag_list], another[:tag_list]),
+            sources: PendingSet.merge(one[:sources], another[:sources]),
             primary_source: one[:primary_source] || another[:primary_source],
-            instance_method_addresses: (one[:instance_method_addresses] + another[:instance_method_addresses]).uniq,
-            mixin_addresses: (one[:mixin_addresses] + another[:mixin_addresses]).uniq,
-            constant_addresses: (one[:constant_addresses] + another[:constant_addresses]).uniq,
+            instance_method_addresses: PendingSet.merge(one[:instance_method_addresses], another[:instance_method_addresses]),
+            mixin_addresses: PendingSet.merge(one[:mixin_addresses], another[:mixin_addresses]),
+            constant_addresses: PendingSet.merge(one[:constant_addresses], another[:constant_addresses]),
             visibility: one[:visibility] || another[:visibility],
             parameters: one[:parameters].empty? ? another[:parameters] : one[:parameters],
-            overloads: one[:overloads] + another[:overloads],
+            overloads: PendingArray.append(one[:overloads], another[:overloads]),
             superclass_path: select_superclass(one, another),
             value: one[:value] || another[:value],
           }
@@ -78,6 +81,26 @@ module Yoda
           }
         end
 
+        # @param attrs [Hash{ Symbol => Object }]
+        # @return [Hash{ Symbol => Object }]
+        def normalize_attributes(attrs)
+          {
+            path: attrs[:path],
+            document: attrs[:document],
+            tag_list: attrs[:tag_list].to_a,
+            sources: attrs[:sources].to_a,
+            primary_source: attrs[:primary_source],
+            instance_method_addresses: attrs[:instance_method_addresses].to_a,
+            mixin_addresses: attrs[:mixin_addresses].to_a,
+            constant_addresses: attrs[:constant_addresses].to_a,
+            visibility: attrs[:visibility],
+            parameters: attrs[:parameters].to_a,
+            overloads: attrs[:overloads].to_a,
+            superclass_path: attrs[:superclass_path],
+            value: attrs[:value],
+          }
+        end
+
         # @param one [Hash{ Symbol => Object }]
         # @param another [Hash{ Symbol => Object }]
         # @return [ScopedPath]
@@ -88,6 +111,66 @@ module Yoda
             another[:superclass_path] || one[:superclass_path]
           end
         end
+
+        class PendingArray
+          extend Forwardable
+
+          # @param els1 [Array<Object>, PendingArray]
+          # @param others [Array<Array<Object>, PendingArray>]
+          def self.append(els, *others)
+            if els.is_a?(PendingArray)
+              others.reduce(els) { |array, item| array.append(item) }
+            else
+              append(PendingArray.new(els), *others)
+            end
+          end
+
+          # @return [Array<Object>]
+          attr_reader :array
+
+          delegate %i(to_a each) => :array
+
+          # @param els [Array<Object>]
+          def initialize(els)
+            @array = els.dup
+          end
+
+          # @param els [Array<Object>]
+          def append(els)
+            array.push(*els)
+            self
+          end
+        end
+
+        class PendingSet
+          extend Forwardable
+
+          # @param els1 [Array<Object>, PendingSet]
+          # @param els2 [Array<Object>, PendingSet]
+          def self.merge(els1, els2)
+            if els1.is_a?(PendingSet)
+              els1.merge(els2)
+            else
+              PendingSet.new(els1).merge(els2)
+            end
+          end
+
+          # @return [Set<Object>]
+          attr_reader :set
+
+          delegate %i(to_a each) => :set
+
+          # @param els [Array<Object>]
+          def initialize(els)
+            @set = Set.new(els)
+          end
+
+          # @param els [Array<Object>]
+          def merge(els)
+            set.merge(els)
+            self
+          end
+        end
       end
     end
   end

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

@@ -9,9 +9,10 @@ module Yoda
         attr_reader :registry
 
         # @param id [String]
-        def initialize(id)
+        # @param  [Array[Addressable], nil]
+        def initialize(id, contents = nil)
           @id = id
-          @registry = Hash.new
+          @registry = (contents || []).map { |content| [content.address.to_sym, content] }.to_h
         end
 
         # @param addressable [Addressable]

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

@@ -1,78 +1,110 @@
+require 'set'
+
 module Yoda
   module Store
     module Objects
       # PatchSet manages patch updates and patch outdates.
       # Besides, this class provides api to modify objects by using owning patches.
       class PatchSet
-        # @return [{ Symbol => Array<Symbol> }]
-        attr_reader :address_index
+        class AddressIndex
+          def initialize
+            @index = Hash.new
+          end
 
-        # @return [{ Symbol => Patch }]
-        attr_reader :patches
+          # @param address [Symbol]
+          # @return [Set<Symbol>]
+          def get(address)
+            index[address] ||= Set.new
+          end
+
+          # @return [Set<Symbol>]
+          def keys
+            index.keys
+          end
+
+          # @param patch [Patch]
+          # @return [void]
+          def register(patch)
+            patch.keys.each do |key|
+              index[key.to_sym] ||= Set.new
+              index[key.to_sym].add(patch.id.to_sym)
+            end
+          end
+
+          # @param patch [Patch]
+          # @return [void]
+          def delete(patch)
+            patch.keys.each do |key|
+              (index[key.to_sym] || []).delete(patch.id.to_sym)
+            end
+          end
+
+          private
+          # @return [{ Symbol => Array<Symbol> }]
+          attr_reader :index
+        end
 
         def initialize
           @patches = Hash.new
-          @address_index = Hash.new
+          @address_index = AddressIndex.new
         end
 
         # @param patch [Patch]
         # @return [void]
         def register(patch)
-          register_to_index(patch)
+          address_index.register(patch)
           patches[patch.id.to_sym] = patch
         end
 
         # @param id [String, Symbol]
         def delete(id)
+          if patch = patches[id.to_sym]
+            address_index.delete(patch)
+          end
           patches.delete(id.to_sym)
         end
 
         # @param object [Addressable]
         # @return [Addressable]
         def patch(object)
-          check_outdated_index(object.address.to_sym)
-          objects_in_patch = (address_index[object.address.to_sym] || []).map { |patch_id| patches[patch_id].find(object.address.to_sym) }
+          objects_in_patch = get_patches(object.address)
           Merger.new([object, *objects_in_patch]).merged_instance
         end
 
         # @param address [String, Symbol]
         # @return [Addressable, nil]
         def find(address)
-          check_outdated_index(address.to_sym)
-          if (patch_ids = address_index[address.to_sym] || []).empty?
+          if (patches = get_patches(address)).empty?
             nil
           else
-            objects = patch_ids.map { |id| patches[id].find(address.to_sym) }
-            Merger.new(objects).merged_instance
+            Merger.new(patches).merged_instance
           end
         end
 
         # @return [Array<Symbol>]
         def keys
-          address_index.keys
+          address_index.keys.to_a
         end
 
         # @param address [String, Symbol]
         # @return [true, false]
         def has_key?(address)
-          check_outdated_index(address.to_sym)
-          address_index[address.to_sym] && !address_index[address.to_sym].empty?
+          !address_index.get(address.to_sym).empty?
         end
 
         private
 
-        # @param patch [Patch]
-        # @return [void]
-        def register_to_index(patch)
-          patch.keys.each do |key|
-            address_index[key.to_sym] ||= []
-            address_index[key.to_sym].push(patch.id.to_sym)
-          end
-        end
+        # @return [AddressIndex]
+        attr_reader :address_index
+
+        # @return [{ Symbol => Patch }]
+        attr_reader :patches
 
-        # @param address [Symbol]
-        def check_outdated_index(address)
-          (address_index[address] || []).select! { |patch_id| patches[patch_id].has_key?(address) }
+        # @param address [String, Symbol]
+        # @return [Array<Patch>]
+        def get_patches(address)
+          patch_ids = address_index.get(address.to_sym)
+          patch_ids.map { |id| patches[id].find(address.to_sym) }
         end
       end
     end

data/lib/yoda/store/registry.rb

@@ -12,6 +12,8 @@ module Yoda
       def initialize(adapter = nil)
         @patch_set = Objects::PatchSet.new
         @adapter = adapter
+        @registry_cache = RegistryCache.new
+        @lock = Concurrent::ReentrantReadWriteLock.new
       end
 
       # @return [Objects::ProjectStatus, nil]
@@ -32,10 +34,12 @@ module Yoda
       # @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)
+          registry_cache.fetch_or_calc(path) do
+            if adapter&.exist?(path)
+              patch_set.patch(adapter.get(path))
+            else
+              patch_set.find(path)
+            end
           end
         end
       end
@@ -43,6 +47,7 @@ module Yoda
       # @param patch [Patch]
       def add_patch(patch)
         lock.with_write_lock do
+          registry_cache.clear_from_patch(patch)
           patch_set.register(patch)
         end
       end
@@ -57,6 +62,7 @@ module Yoda
 
       def clear
         lock.with_write_lock do
+          registry_cache.delete_all
           adapter.clear
         end
       end
@@ -77,6 +83,7 @@ module Yoda
           adapter.sync
           Logger.info "saved #{el_keys.length} keys."
           @patch_set = Objects::PatchSet.new
+          registry_cache.delete_all
         end
       end
 
@@ -88,10 +95,11 @@ module Yoda
       # @return [Objects::PatchSet]
       attr_reader :patch_set
 
+      # @return [RegistryCache]
+      attr_reader :registry_cache
+
       # @return [Concurrent::ReentrantReadWriteLock]
-      def lock
-        @lock ||= Concurrent::ReentrantReadWriteLock.new
-      end
+      attr_reader :lock
 
       def keys
         Set.new(adapter&.keys.map(&:to_s) || []).union(patch_set.keys)

data/lib/yoda/store/registry_cache.rb

@@ -0,0 +1,40 @@
+require 'concurrent'
+
+module Yoda
+  module Store
+    # Registry Cache is a cache layer for {Registry}.
+    # This class intended to reduce patch calculations of {PatchSet#patch}.
+    class RegistryCache
+      def initialize
+        @data = Concurrent::Map.new
+      end
+
+      # @param key [String, Symbol]
+      def fetch_or_calc(key)
+        if cache = data.get(key.to_sym)
+          return cache
+        end
+        yield.tap { |value| data.put_if_absent(key.to_sym, value) }
+      end
+
+      # @param key [String, Symbol]
+      def delete(key)
+        data.delete(key.to_sym)
+      end
+
+      def delete_all
+        data.clear
+      end
+
+      # @param patch [Objects::Patch]
+      def clear_from_patch(patch)
+        patch.keys.each { |key| delete(key) }
+      end
+
+      private
+
+      # @return [Concurrent::Map]
+      attr_reader :data
+    end
+  end
+end

data/lib/yoda/version.rb

@@ -1,3 +1,3 @@
 module Yoda
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yoda-language-server
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Tomoya Chiba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-28 00:00:00.000000000 Z
+date: 2018-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -446,6 +446,7 @@ files:
 - lib/yoda/store/query/find_method.rb
 - lib/yoda/store/query/find_signature.rb
 - lib/yoda/store/registry.rb
+- lib/yoda/store/registry_cache.rb
 - lib/yoda/store/yard_importer.rb
 - lib/yoda/typing.rb
 - lib/yoda/typing/context.rb