yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/store/adapters/base.rb

@@ -14,49 +14,88 @@ module Yoda
         end
 
         # @abstract
+        # @param address [String, Symbol]
+        # @return [Object, nil]
         def get(address)
           fail NotImplementedError
         end
 
         # @abstract
+        # @param address [String, Symbol]
+        # @param object [Object]
+        # @return [void]
         def put(address, object)
           fail NotImplementedError
         end
 
         # @abstract
+        # @param address [String, Symbol]
+        # @return [void]
         def delete(address)
           fail NotImplementedError
         end
 
         # @abstract
+        # @param address [String, Symbol]
+        # @return [Boolean]
         def exist?(address)
           fail NotImplementedError
         end
 
         # @abstract
+        # @return [Integer]
         def keys
           fail NotImplementedError
         end
 
         # @abstract
+        # @return [Object]
         def stats
           fail NotImplementedError
         end
 
         # @abstract
+        # @return [void]
         def sync
           fail NotImplementedError
         end
 
+        # Clear all contents in the database.
         # @abstract
+        # @return [void]
         def clear
           fail NotImplementedError
         end
 
+        # @abstract
+        # @return [Boolean]
+        def empty?
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @param name [String, Symbol]
+        # @return [Base]
+        def namespace(name)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Boolean]
+        def persistable?
+          fail NotImplementedError
+        end
+
         # @param data [Enumerator<(String, Object)>]
         # @param bar [#increment, nil]
         # @abstract
         def batch_write(data, bar)
+          fail NotImplementedError
+        end
+
+        # @return [String]
+        def inspect
+          "#<#{self.class.name}: #{self.class.type}>"
         end
       end
     end

data/lib/yoda/store/adapters/gdbm_adapter/namespace_accessor.rb

@@ -0,0 +1,152 @@
+module Yoda
+  module Store
+    module Adapters
+      class GdbmAdapter
+        class NamespaceAccessor
+          KEYS_ADDRESS = "%keys"
+
+          # @return [GDBM]
+          attr_reader :database
+
+          # @return [String, nil]
+          attr_reader :namespace
+
+          # @param database [GDBM]
+          # @param namespace [String, Symbol, nil]
+          def initialize(database:, namespace:)
+            @database = database
+            @namespace = namespace&.to_s
+          end
+
+          # @param address [String, Symbol]
+          # @return [Object, nil]
+          def get(address, **)
+            JSON.load(database[build_key(address)], symbolize_names: true)
+          end
+
+          # @param address [String, Symbol]
+          # @param object [#to_json]
+          # @return [void]
+          def put(address, object, modify_keys: true)
+            database[build_key(address)] = object.to_json
+            add_addresses([address]) if modify_keys
+          end
+
+          # @param address [String, Symbol]
+          # @return [void]
+          def delete(address)
+            database.delete(build_key(address))
+          end
+
+          # @abstract
+          # @param address [String, Symbol]
+          # @return [Boolean]
+          def exist?(address)
+            database.has_key?(build_key(address))
+          end
+
+          # @abstract
+          # @return [Integer]
+          def keys
+            if namespace
+              get(KEYS_ADDRESS) || []
+            else
+              database.keys
+            end
+          end
+
+          # @abstract
+          # @return [Object]
+          def stats
+            {}
+          end
+
+          # @abstract
+          # @return [void]
+          def sync
+            database.sync
+          end
+
+          # Clear all contents in the database.
+          # @abstract
+          # @return [void]
+          def clear
+            if namespace
+              keys.each do |key|
+                delete(key)
+              end
+              delete(KEYS_ADDRESS)
+            else
+              database.clear
+            end
+          end
+
+          # @abstract
+          # @return [Boolean]
+          def empty?
+            if namespace
+              keys.empty?
+            else
+              database.empty?
+            end
+          end
+
+          # @abstract
+          # @return [Boolean]
+          def persistable?
+            true
+          end
+
+          # @param data [Enumerator<(String, Object)>]
+          # @param bar [#increment, nil]
+          # @abstract
+          def batch_write(data, bar)
+            data.each do |(k, v)|
+              put(k, v, modify_keys: false)
+              bar&.increment
+            end
+            add_addresses(data.map(&:first).map(&:to_s).compact)
+          end
+
+          # @return [String]
+          def inspect
+            "#<#{self.class.name}: #{self.class.type}>"
+          end
+
+          private
+
+          def add_addresses(new_addresses)
+            return unless namespace
+            # not locked
+            database[build_key(KEYS_ADDRESS)] = (Set.new(keys) + new_addresses).to_a.to_json
+          end
+
+          # @param address [String, Symbol]
+          # @param [String]
+          def build_key(address)
+            if namespace
+              [namespace, address.to_s].join("/")
+            else
+              address.to_s
+            end
+          end
+
+          # @param key [String]
+          # @param [String, nil]
+          def remove_namespace_from_key(key)
+            if namespace
+              prefix = "#{namespace}/"
+              if key.start_with?(prefix)
+                key.delete_prefix(prefix)
+              else
+                nil
+              end
+            else
+              key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters/gdbm_adapter.rb

@@ -0,0 +1,56 @@
+require 'gdbm'
+require 'fileutils'
+require 'yoda/store/adapters/base'
+
+module Yoda
+  module Store
+    module Adapters
+      class GdbmAdapter < Base
+        require 'yoda/store/adapters/gdbm_adapter/namespace_accessor'
+
+        class << self
+          def for(path)
+            @pool ||= {}
+            @pool[path] || (@pool[path] = new(path))
+          end
+
+          def type
+            :gdbm
+          end
+        end
+
+        # @return [DBM]
+        attr_reader :database
+        private :database
+
+        extend Forwardable
+        delegate [:get, :batch_write, :put, :delete, :exists, :keys, :clear, :empty?, :persistable?] => :root
+
+        # @param path [String]
+        def initialize(path)
+          dirname = File.dirname(path)
+          FileUtils.mkdir_p(dirname) unless Dir.exist?(dirname)
+          @path = path
+          @database = GDBM.open(path, 0666, GDBM::NOLOCK)
+        end
+
+        def root
+          @root ||= NamespaceAccessor.new(database: database, namespace: nil)
+        end
+
+        # @param namespace [String, Symbol]
+        # @return [NamespaceAccessor]
+        def namespace_for(name)
+          @namespaces ||= {}
+          @namespaces[name.to_sym] ||= NamespaceAccessor.new(database: database, namespace: name)
+        end
+        alias :namespace :namespace_for
+
+        # @return [String]
+        def inspect
+          "#<#{self.class.name}: #{self.class.type}>"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters/lazy_adapter.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+
+module Yoda
+  module Store
+    module Adapters
+      class LazyAdapter < Base
+        class << self
+          def for(path, type)
+            @pool ||= {}
+            @pool[path] || (@pool[path] = new(path))
+          end
+
+          def type
+            :lazy
+          end
+        end
+
+        extend Forwardable
+
+        delegate %i(get put delete exist keys stats sync clear batch_write) => :adapter
+
+        # @param path [String] represents the path to store db.
+        def initialize(path)
+          @path = path
+        end
+
+        # @return [Adapters::Base]
+        def adapter
+          @adapter ||= Adapters.for(path)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters/memory_adapter.rb

@@ -28,7 +28,7 @@ module Yoda
 
         # @param address [String]
         # @return [any]
-        def get(address)
+        def get(address, **)
           JSON.load(db[address.to_s], symbolize_names: true)
         end
 
@@ -60,11 +60,21 @@ module Yoda
           db.member?(address.to_s)
         end
 
+        # @param name [String]
+        # @return [MemoryAdapter]
+        def namespace(name)
+          namespaces[name.to_s] ||= MemoryAdapter.new
+        end
+
         # @return [Array<String>]
         def keys
           db.keys
         end
 
+        def empty?
+          db.empty?
+        end
+
         def stats
           "No stats"
         end
@@ -75,6 +85,17 @@ module Yoda
 
         def sync
         end
+
+        def persistable?
+          false
+        end
+
+        private
+
+        # @return [Hash{String => MemoryAdapter}]
+        def namespaces
+          @namespaces ||= {}
+        end
       end
     end
   end

data/lib/yoda/store/adapters.rb

@@ -2,13 +2,21 @@ module Yoda
   module Store
     module Adapters
       require 'yoda/store/adapters/base'
-      require 'yoda/store/adapters/leveldb_adapter'
-      require 'yoda/store/adapters/lmdb_adapter'
+      require 'yoda/store/adapters/gdbm_adapter'
       require 'yoda/store/adapters/memory_adapter'
 
-      # @return [Base.class]
+      # @return [Class<Base>]
       def self.default_adapter_class
-        LmdbAdapter
+        GdbmAdapter
+      end
+
+      # @param path [String, nil]
+      def self.for(path)
+        if path
+          default_adapter_class.for(path + ".#{default_adapter_class.type}")
+        else
+          MemoryAdapter.new
+        end
       end
     end
   end

data/lib/yoda/store/config.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+
+module Yoda
+  module Store
+    class Config
+      # @param yaml_str [String]
+      def self.from_yaml_data(yaml_str)
+        new(YAML.load(yaml_str, symbolize_names: true) || {})
+      end
+
+      # @param path [String]
+      def self.at(path)
+        new(YAML.load(File.read(path), symbolize_names: true) || {})
+      end
+
+      # @param contents [Hash]
+      def initialize(contents)
+        @contents = contents
+        Logger.trace("Config: #{contents}")
+      end
+
+      # @return [Array<String>]
+      def ignored_gems
+        @ignored_gems ||= (@contents[:gems] || []).select { |gem_data| gem_data[:ignore] }.map { |gem_data| gem_data[:name] }
+      end
+
+      # @return [Array<String>]
+      def rbs_signature_paths
+        @contents.dig(:rbs, :signature) || []
+      end
+
+      # @return [Array<String>]
+      def rbs_repository_paths
+        @contents.dig(:rbs, :repository) || []
+      end
+
+      # @return [Array<String>]
+      def rbs_libraries
+        @contents.dig(:rbs, :library) || []
+      end
+    end
+  end
+end

data/lib/yoda/store/file_tree.rb

@@ -0,0 +1,131 @@
+module Yoda
+  module Store
+    class FileTree
+      # @return [String, nil]
+      attr_reader :base_path
+
+      # @param base_path [String, nil]
+      def initialize(base_path:)
+        @base_path = base_path ? File.absolute_path(base_path) : nil
+      end
+
+      def open_at(path)
+        normalized_path = normalize_path(path)
+        content = read_at(normalized_path)
+        notify_changed(path: normalized_path, content: content)
+        content
+      end
+
+      # @param path [String]
+      # @return [String, nil]
+      def read_at(path)
+        editing_content[normalize_path(path)] || read_real_at(path)
+      end
+
+      # @param path [String]
+      # @return [String, nil]
+      def read_real_at(path)
+        if File.file?(path)
+          File.read(path)
+        else
+          nil
+        end
+      end
+
+      # @param path [String]
+      # @param content [String]
+      def set_editing_at(path, content)
+        normalized_path = normalize_path(path)
+        editing_content[normalized_path] = content
+        notify_changed(path: normalized_path, content: content)
+      end
+
+      # @param path [String]
+      # @return [Boolean]
+      def editing_at?(path)
+        editing_content.has_key?(normalize_path(path))
+      end
+
+      # @param path [String]
+      # @return [void]
+      def clear_editing_at(path)
+        normalized_path = normalize_path(path)
+        editing_content.delete(normalized_path)
+        notify_changed(path: normalized_path, content: read_real_at(normalized_path))
+      end
+
+      # @param path [String]
+      # @return [void]
+      def mark_deleted(path)
+        normalized_path = normalize_path(path)
+        editing_content.delete(normalized_path)
+        notify_changed(path: normalized_path, content: nil)
+      end
+
+      # @param path [String]
+      # @return [String]
+      def normalize_path(path)
+        if base_path
+          File.expand_path(path, base_path)
+        else
+          File.absolute_path(path)
+        end
+      end
+
+      # @param path [String]
+      # @return [Boolean]
+      def subpath?(path)
+        if base_path
+          File.fnmatch(File.join(base_path, "**/*"), path)
+        else
+          false
+        end
+      end
+
+      # @yield [path:, content:]
+      # @yieldparam path [String]
+      # @yieldparam content [String, nil]
+      def on_change(&handler)
+        changed_events.listen(&handler)
+      end
+
+      private
+
+      # @param path [String]
+      # @param content [String, nil]
+      def notify_changed(path:, content:)
+        changed_events.notify(path: path, content: content)
+      end
+
+      # @return [Hash{String => String}]
+      def editing_content
+        @editing_content ||= Concurrent::Map.new
+      end
+
+      # @return [EventSet]
+      def changed_events
+        @changed_events ||= EventSet.new
+      end
+
+      class EventSet
+        # @return [Array<#call>]
+        attr_reader :listeners
+
+        def initialize
+          @listeners = []
+        end
+
+        # @param listener [#call]
+        def listen(&listener)
+          listeners << listener
+        end
+
+        def notify(**kwargs)
+          listeners.each do |listener|
+            listener.call(**kwargs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'yoda/store/objects/connected_delegation'
+
 module Yoda
   module Store
     module Objects
@@ -14,6 +16,51 @@ module Yoda
           end
         end
 
+        # A wrapper class of {Objects::Base} to allow access to registry.
+        class Connected
+          extend ConnectedDelegation
+
+          # @return [Base]
+          attr_reader :object
+          
+          # @return [Registry]
+          attr_reader :registry
+
+          delegate_to_object :address, :path, :document, :tag_list, :sources, :primary_source, :json_class, :to_json, :derive
+          delegate_to_object :name, :kind, :address, :parent_adderss, :to_h, :hash, :eql?, :==, :namespace?, :meta_class_address
+          
+          # @param object [Base]
+          # @param registry [Registry]
+          def initialize(object, registry:)
+            @object = object
+            @registry = registry
+          end
+
+          def with_connection(**kwargs)
+            if kwargs == connection_options
+              self
+            else
+              object.with_connection(**kwargs)
+            end
+          end
+
+          def merge(another)
+            object.merge(another).with_connection(**connection_options)
+          end
+          
+          # @return [Objects::MetaClassObject::Connected, nil]
+          def meta_class
+            registry.get(meta_class_address)&.with_connection(**connection_options)
+          end
+
+          private
+
+          # @return [Hash]
+          def connection_options
+            { registry: registry }
+          end
+        end
+
         # @return [String]
         attr_reader :path
 
@@ -31,7 +78,7 @@ module Yoda
 
         # @param path [String]
         # @param document [String]
-        # @param tag_list [TagList, nil]
+        # @param tag_list [Array<Tag>, nil]
         # @param sources [Array<(String, Integer, Integer)>]
         # @param primary_source [(String, Integer, Integer), nil]
         def initialize(path:, document: '', tag_list: [], sources: [], primary_source: nil, json_class: nil, kind: nil)
@@ -57,6 +104,19 @@ module Yoda
           path
         end
 
+        # @return [String]
+        def meta_class_address
+          MetaClassObject.address_of(address)
+        end
+
+        # @return [String]
+        def parent_address
+          @parent_address ||= begin
+            sliced_address = address.slice(0, (path.rindex('::') || 0))
+            sliced_address.empty? ? 'Object' : sliced_address
+          end
+        end
+
         # @return [Hash]
         def to_h
           {
@@ -65,14 +125,14 @@ module Yoda
             document: document,
             tag_list: tag_list,
             sources: sources,
-            primary_source: primary_source
+            primary_source: primary_source,
           }
         end
 
         # @param another [self]
         # @return [self]
         def merge(another)
-          self.class.new(merge_attributes(another))
+          Merger.new([self, another]).merged_instance
         end
 
         def hash
@@ -80,13 +140,22 @@ module Yoda
         end
 
         def eql?(another)
-          self.class == another.class && to_h == another.to_h
+          another.respond_to?(:kind) && self.kind == another.kind && to_h == another.to_h
         end
 
         def ==(another)
           eql?(another)
         end
 
+        def namespace?
+          false
+        end
+
+        # @return [Connected]
+        def with_connection(**kwargs)
+          self.class.const_get(:Connected).new(self, **kwargs)
+        end
+
         private
 
         # @param another [self]