yoda-language-server 0.7.0 → 0.8.0

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

@@ -2,6 +2,10 @@ module Yoda
   module Store
     module Objects
       class ValueObject < Base
+        class Connected < Base::Connected
+          delegate_to_object :value
+        end
+
         # @return [String]
         attr_reader :value
 
@@ -13,7 +17,7 @@ module Yoda
         # @param path [String]
         # @param value [String]
         def initialize(value: nil, **kwargs)
-          super(kwargs)
+          super(**kwargs)
           @value = value
         end
 

data/lib/yoda/store/objects.rb

@@ -8,6 +8,7 @@ module Yoda
       require 'yoda/store/objects/addressable'
       require 'yoda/store/objects/patchable'
       require 'yoda/store/objects/base'
+      require 'yoda/store/objects/connected_delegation'
       require 'yoda/store/objects/namespace_object'
       require 'yoda/store/objects/class_object'
       require 'yoda/store/objects/value_object'
@@ -19,7 +20,10 @@ module Yoda
       require 'yoda/store/objects/patch'
       require 'yoda/store/objects/patch_set'
       require 'yoda/store/objects/tag'
-      require 'yoda/store/objects/project_status'
+      require 'yoda/store/objects/libraries_status'
+      require 'yoda/store/objects/library'
+      require 'yoda/store/objects/serializable_set'
+      require 'yoda/store/objects/map'
 
       class << self
         # @param hsh [Hash]

data/lib/yoda/store/project/dependency.rb

@@ -0,0 +1,83 @@
+require 'open3'
+
+module Yoda
+  module Store
+    class Project
+      class Dependency
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [Array<Objects::Library::Gem>]
+        def gems
+          builder.gems
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [Library, nil]
+        def gem_dependency(name:, version:)
+          libraries.find { |library| library.name == name && library.version == version }
+        end
+
+        # @return [Objects::Library::Core]
+        def core
+          @core ||= Objects::Library.core
+        end
+
+        # @return [Objects::Library::Std]
+        def std
+          @std ||= Objects::Library.std
+        end
+
+        def builder
+          @builder ||= Builder.new(project)
+        end
+
+        class Builder
+          # @return [Project]
+          attr_reader :project
+
+          # @param project [Project]
+          def initialize(project)
+            @project = project
+          end
+
+          # @return [Array<Objects::Library::Gem>]
+          def gems
+            @gems ||= begin
+              dependencies
+                .map { |attrs| Objects::Library::Gem.new(**attrs) }
+                .reject { |spec| project.config.ignored_gems.include?(spec.name) }
+            end
+          end
+
+          private
+
+          # @return [Array<Hash>]
+          def dependencies
+            analyzed_deps[:dependencies] || []
+          end
+
+          # @return [Hash]
+          def analyzed_deps
+            @analyzed_deps ||= begin
+              return {} unless project.root_path
+
+              # Bundler pollutes environment variables in the current process, so analyze in another process.
+              stdout, stderr, status = Open3.capture3(Yoda::Cli.yoda_exe, "analyze-deps", project.root_path)
+
+              fail stderr unless status.success?
+
+              Logger.trace("Analysis Result: #{stdout}")
+              JSON.parse(stdout, symbolize_names: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project/file_finder.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Yoda
+  module Store
+    class Project
+      # Find registry file for the current project settings.
+      class FileFinder
+        # @return [Project]
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [true, false]
+        def present?
+          File.exist?(cache_path)
+        end
+
+        # @return [String, nil]
+        def yoda_dir_path
+          expand_path('.yoda')
+        end
+
+        # @return [String, nil]
+        def cache_dir_path
+          expand_path('.yoda/cache')
+        end
+
+        # @return [String, nil]
+        def library_registry_dir_path
+          expand_path(File.join('.yoda', 'library_registry'))
+        end
+
+        # @return [String, nil]
+        def library_local_yardoc_dir_path
+          expand_path(File.join('.yoda', 'yardoc', RUBY_VERSION))
+        end
+
+        # @return [String, nil]
+        def gemfile_lock_path
+          expand_path('Gemfile.lock')
+        end
+
+        # @return [String, nil]
+        def config_file_path
+          expand_path('.yoda.yml')
+        end
+
+        # @return [String, nil]
+        def readable_config_file_path
+          path = config_file_path
+          path && File.readable?(config_file_path) ? path : nil
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [String, nil]
+        def library_local_yardoc_path(name:, version:)
+          expand_path("#{name}-#{version}.yardoc", library_local_yardoc_dir_path)
+        end
+
+        # @param name [String]
+        # @param version [String]
+        # @return [String, nil]
+        def library_registry_path(name:, version:)
+          expand_path(Registry.registry_name, library_registry_dir_path)
+        end
+
+        # @return [String, nil]
+        def project_registry_path
+          expand_path(Registry.registry_name, cache_dir_path)
+        end
+
+        def make_dir
+          make_dir_at(cache_dir_path)
+          make_dir_at(library_local_yardoc_dir_path)
+          make_dir_at(library_registry_dir_path)
+        end
+
+        def clear_dir
+          yoda_dir_path && File.exist?(yoda_dir_path) && FileUtils.rm_rf(yoda_dir_path)
+        end
+
+        private
+
+        def expand_path(relative_path, base_path = project.root_path)
+          return nil unless base_path
+          File.expand_path(relative_path, base_path)
+        end
+
+        # @param dir_path [String]
+        def make_dir_at(dir_path)
+          dir_path && (File.exist?(dir_path) || FileUtils.mkdir_p(dir_path))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project/rbs_loader.rb

@@ -0,0 +1,41 @@
+require 'rbs'
+
+module Yoda
+  module Store
+    class Project
+      # Find registry file for the current project settings.
+      class RbsLoader
+        # @return [Project]
+        attr_reader :project
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @return [RBS::Environment]
+        def rbs_environment
+          @rbs_environment ||= begin
+            repository = RBS::Repository.new
+            project.config.rbs_repository_paths.each do |repo_path|
+              pathname = Pathname(repo_path).expand_path(project.root_path)
+              repository.add(pathname)
+            end
+
+            loader = RBS::EnvironmentLoader.new(repository: repository)
+            project.config.rbs_signature_paths.each do |sig_path|
+              pathname = Pathname(sig_path).expand_path(project.root_path)
+              loader.add(path: pathname)
+            end
+
+            project.config.rbs_libraries.each do |library|
+              loader.add(library: library)
+            end
+
+            RBS::Environment.from_loader(loader).resolve_type_names
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project/setuper.rb

@@ -0,0 +1,68 @@
+require "yoda/instrument"
+require "ruby-progressbar"
+
+module Yoda
+  module Store
+    class Project
+      class Setuper
+        # @return [Project]
+        attr_reader :project
+
+        # @return [Hash{ Symbol => ProgressBar }]
+        attr_reader :bars
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+          @bars = {}
+        end
+
+        # @param rebuild [Boolean]
+        # @return [Array<BaseError>]
+        def run(rebuild: false)
+          build_core_index
+
+          if rebuild
+            clear
+          end
+          project.file_finder.make_dir
+
+          Logger.info 'Building index for the current project...'
+          dependency_importer.run
+          project.rbs_environment
+          load_project_files
+
+          dependency_importer.errors
+        end
+
+        def clear
+          project.file_finder.clear_dir
+        end
+
+        def reset
+          run(rebuild: true)
+        end
+
+        private
+
+        def build_core_index
+          unless Store::Actions::BuildCoreIndex.exists?
+            Instrument.instance.initialization_progress(phase: :core, message: 'Downloading and building core index')
+            Store::Actions::BuildCoreIndex.run
+          end
+        end
+
+        def load_project_files
+          Logger.debug('Loading current project files...')
+          Instrument.instance.initialization_progress(phase: :load_project_files, message: 'Loading current project files')
+          project.root_path && Actions::ReadProjectFiles.for_project(project).run
+        end
+
+        # @return [Actions::ImportProjectDependencies]
+        def dependency_importer
+          Actions::ImportProjectDependencies.new(project)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project.rb

@@ -1,74 +1,132 @@
 require 'fileutils'
+require 'forwardable'
+require 'pathname'
 
 module Yoda
   module Store
     class Project
-      require 'yoda/store/project/cache'
-      require 'yoda/store/project/library_doc_loader'
+      require 'yoda/store/project/file_finder'
+      require 'yoda/store/project/dependency'
+      require 'yoda/store/project/setuper'
+      require 'yoda/store/project/rbs_loader'
+
+      extend Forwardable
+
+      class << self
+        # @param name [String]
+        # @param root_path [String, nil]
+        def for_path(root_path, name: nil)
+          file_tree = FileTree.new(base_path: root_path)
+          name ||= root_path ? File.basename(root_path) : "root"
+          new(name: name, file_tree: file_tree)
+        end
+
+        def temporal(name: "temporal")
+          new(name: name, file_tree: FileTree.new(base_path: nil))
+        end
+      end
+
+      delegate(
+        [
+          :yoda_dir_path,
+          :cache_dir_path,
+          :library_registry_dir_path,
+          :gemfile_lock_path,
+          :config_file_path,
+          :readable_config_file_path,
+          :library_local_yardoc_path,
+          :library_registry_path,
+          :project_registry_path,
+        ] => :file_finder,
+      )
+
+      delegate [:rbs_environment] => :rbs_loader
+      delegate [:clear, :reset] => :setuper
+
+      # @return [FileTree]
+      attr_reader :file_tree
 
       # @return [String]
-      attr_reader :root_path
+      attr_reader :name
 
-      # @return [Registry, nil]
-      attr_reader :registry
+      # @param name [String]
+      # @param file_tree [FileTree]
+      def initialize(name:, file_tree:)
+        @name = name
+        @file_tree = file_tree
+        register_file_tree_events
+      end
 
-      # @param root_path [String]
-      def initialize(root_path)
-        fail ArgumentError, root_path unless root_path.is_a?(String)
+      # @return [String, nil]
+      def root_path
+        file_tree.base_path
+      end
 
-        @root_path = File.absolute_path(root_path)
+      # @return [Registry::ProjectRegistry]
+      def registry
+        @registry ||= Registry.for_project(self)
       end
 
-      def setup
-        return if registry
-        make_dir
-        @registry = cache.prepare_registry
+      # @return [Dependency]
+      def dependency
+        @dependency ||= Dependency.new(self)
       end
 
-      # Delete all data from registry
-      def clear
-        setup
-        registry.clear
+      # @return [RBS::Environment]
+      def rbs_loader
+        @rbs_loader ||= RbsLoader.new(self)
       end
 
-      # @return [Array<BaseError>]
-      def build_cache
-        setup
-        loader = LibraryDocLoader.build_for(self)
-        loader.run
-        load_project_files
-        loader.errors
+      # @return [Model::Environment]
+      def environment
+        @environment ||= Model::Environment.from_project(self)
       end
 
-      def rebuild_cache
-        clear
-        build_cache
+      # @return [Array<BaseError>]
+      def setup(rebuild: false)
+        setuper.run(rebuild: rebuild)
       end
 
-      def yoda_dir
-        File.expand_path('.yoda', root_path)
+      # @return [Config]
+      def config
+        @config ||= begin
+          if readable_config_file_path
+            Config.at(readable_config_file_path)
+          else
+            Config.from_yaml_data('')
+          end
+        end
       end
 
-      # @param source_path [String]
-      def read_source(source_path)
-        Actions::ReadFile.run(registry, source_path)
+      # @return [FileFinder]
+      def file_finder
+        @file_finder ||= FileFinder.new(self)
       end
 
       private
 
-      def load_project_files
-        Logger.debug('Loading current project files...')
-        Instrument.instance.initialization_progress(phase: :load_project_files, message: 'Loading current project files')
-        Actions::ReadProjectFiles.new(registry, root_path).run
+      def setuper
+        Setuper.new(self)
       end
 
-      def make_dir
-        File.exist?(yoda_dir) || FileUtils.mkdir(yoda_dir)
+      def register_file_tree_events
+        file_tree.on_change do |path:, content:|
+          if content
+            Actions::ReadFile.run(registry, path, content: content)
+          else
+            unread_source(path)
+          end
+        end
+      end
+
+      # @param source_path [String]
+      def unread_source(source_path)
+        patch = registry.local_store.find_file_patch(Actions::ReadFile.patch_id_for_file(source_path))
+        registry.local_store.remove_file_patch(patch) if patch
       end
 
-      # @return [Cache]
-      def cache
-        @cache ||= Cache.build_for(self)
+      def on_memory?
+        !root_path
       end
     end
   end

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

@@ -0,0 +1,126 @@
+require 'set'
+
+module Yoda
+  module Store
+    module Query
+      class AncestorTree
+        class CircularReferenceError < StandardError
+          # @param circular_scope [Objects::NamespaceObject, nil]
+          def initialize(circular_scope)
+            super("#{circular_scope&.path} appears twice")
+          end
+        end
+
+        # An wrapper of {Enumerator::Yielder} to detect circular references.
+        # @private
+        class Visitor
+          # @param yielder [Enumerator::Yielder]
+          def initialize(yielder)
+            @yielder = yielder
+          end
+
+          def <<(object)
+            @yielder << object
+          end
+
+          def meet(object)
+            add_met(object)
+            self << object
+          end
+          
+          private
+
+          def add_met(object)
+            @met ||= Set.new
+            fail CircularReferenceError, object if @met.include?(object)
+            @met.add(object)
+          end
+        end
+
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Objects::NamespaceObject]
+        attr_reader :object
+
+        # @param object [Objects::NamespaceObject]
+        # @param registry [Registry]
+        def initialize(registry:, object:)
+          @registry = registry
+          @object = object
+        end
+
+        def ancestors(**kwargs)
+          Enumerator.new do |yielder|
+            walk_ancestors(Visitor.new(yielder), **kwargs)
+          end
+        end
+
+        # @return [Enumerator<Objects::NamespaceObject>]
+        def mixins
+          Enumerator.new do |yielder|
+            object.mixin_addresses.each do |address|
+              if el = registry.get(address.to_s)
+                yielder << el
+              end
+            end
+          end
+        end
+
+        # @return [AncestorTree, nil]
+        def parent
+          @parent ||= superclass && AncestorTree.new(registry: registry, object: superclass)
+        end
+
+        # @return [Objects::NamespaceObject, nil]
+        def superclass
+          return @superclass if instance_variable_defined?(:@superclass)
+          @superclass = begin
+            found_object = begin
+              if object.respond_to?(:base_class_address)
+                base_class_superclass
+              elsif object.respond_to?(:superclass_path)
+                if object.superclass_path
+                  FindConstant.new(registry).find(object.superclass_path)
+                else
+                  nil
+                end
+              else
+                nil
+              end
+            end
+
+            found_object&.namespace? ? found_object : nil
+          end
+        end
+
+        protected
+
+        # @param visitor [Visitor]
+        # @param include_self [Boolean]
+        def walk_ancestors(visitor, include_self: true)
+          visitor.meet(object) if include_self
+          mixins.each { |mixin| visitor << mixin }
+
+          if parent
+            parent.walk_ancestors(visitor, include_self: true)
+          end
+        end
+
+        private
+
+        # @return [Objects::NamespaceObject, nil]
+        def base_class_superclass
+          base_class = registry.get(object.base_class_address)
+          if base_class && base_class.respond_to?(:superclass_path) && base_class.superclass_path
+            FindMetaClass.new(registry).find(base_class.superclass_path)
+          elsif base_class
+            registry.get('Class')
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end