yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/store/actions/import_std_library.rb

@@ -2,32 +2,27 @@ module Yoda
   module Store
     module Actions
       class ImportStdLibrary
-        # @return [Registry]
-        attr_reader :registry
+        # @return [Project::Dependency::Std]
+        attr_reader :dep
 
         class << self
-          # @return [true, false]
-          def run(registry)
-            new(registry).run
+          # @param dep [Project::Dependency::Std]
+          # @return [Objects::Patch]
+          def run(dep)
+            new(dep).run
           end
         end
 
-        def initialize(registry)
-          @registry = registry
+        # @param dep [Project::Dependency::Std]
+        def initialize(dep)
+          @dep = dep
         end
 
-        # @return [true, false]
+        # @return [Objects::Patch]
         def run
-          return false unless File.exist?(doc_path)
-          patch = YardImporter.import(doc_path)
-          registry.add_patch(patch)
-          true
-        end
-
-        private
-
-        def doc_path
-          File.expand_path("~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib")
+          BuildCoreIndex.run unless BuildCoreIndex.exists?
+          return false unless File.exist?(dep.doc_path)
+          YardImporter.import(dep.doc_path)
         end
       end
     end

data/lib/yoda/store/actions/read_file.rb

@@ -8,27 +8,42 @@ module Yoda
         # @return [String]
         attr_reader :file
 
+        # @return [String, nil]
+        attr_reader :content
+
         # @param registry [Registry]
         # @param file [String]
         # @return [void]
-        def self.run(registry, file, root_path: nil)
-          self.new(registry, file, root_path: root_path).run
+        def self.run(registry, file, content: nil, root_path: nil)
+          self.new(registry, file, content: content, root_path: root_path).run
+        end
+
+        # @param file [String]
+        # @return [String]
+        def self.patch_id_for_file(file)
+          YardImporter.patch_id_for_file(file)
         end
 
         # @param registry [Registry]
         # @param file [String]
-        def initialize(registry, file, root_path: nil)
+        # @param content [String, nil]
+        def initialize(registry, file, content: nil, root_path: nil)
           @registry = registry
           @file = file
+          @content = content
           @root_path = root_path
         end
 
         # @return [void]
         def run
           YARD::Registry.clear
-          YARD.parse([file])
-          patch = YardImporter.new(file).import(YARD::Registry.all + [YARD::Registry.root]).patch
-          registry.add_patch(patch)
+          if content
+            YARD.parse_string(content) if Yoda::Parsing.parse_with_comments(content)
+          else
+            YARD.parse([file])
+          end
+          patch = YardImporter.new(file, source_path: file).import(YARD::Registry.all + [YARD::Registry.root]).patch
+          registry.local_store.add_file_patch(patch)
         end
       end
     end

data/lib/yoda/store/actions/read_project_files.rb

@@ -8,6 +8,12 @@ module Yoda
         # @return [String]
         attr_reader :root_path
 
+        # @param project [Project]
+        # @return [ReadProjectFiles]
+        def self.for_project(project)
+          new(project.registry, project.root_path)
+        end
+
         def initialize(registry, root_path)
           @registry = registry
           @root_path = root_path
@@ -29,7 +35,7 @@ module Yoda
 
         # @return [Array<String>]
         def project_files
-          Dir.chdir(root_path) { Dir.glob("{lib,app}/**/*.rb\0ext/**/*.c\0.yoda/*.rb").map { |name| File.expand_path(name, root_path) } }
+          Dir.chdir(root_path) { Dir.glob(["{lib,app}/**/*.rb", "ext/**/*.c", ".yoda/*.rb"]).map { |name| File.expand_path(name, root_path) } }
         end
       end
     end

data/lib/yoda/store/actions.rb

@@ -5,6 +5,7 @@ module Yoda
       require 'yoda/store/actions/import_core_library'
       require 'yoda/store/actions/import_std_library'
       require 'yoda/store/actions/import_gem'
+      require 'yoda/store/actions/import_project_dependencies'
       require 'yoda/store/actions/read_file'
       require 'yoda/store/actions/read_project_files'
     end

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

@@ -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