yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/services/evaluator.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+
+module Yoda
+  module Services
+    class Evaluator
+      extend Forwardable
+
+      # @return [AST::Vnode]
+      attr_reader :ast
+
+      # @return [Model::Environment]
+      attr_reader :environment
+
+      # @return [Typing::Inferencer]
+      attr_reader :inferencer
+
+      delegate %i(type context_variable_types receiver_type method_candidates node_info) => :tracer
+
+      # @param ast [::Parser::AST::Node]
+      # @param registry [Model::Environment]
+      def initialize(ast:, environment:)
+        @ast = ast
+        @environment = environment
+        @inferencer = Typing::Inferencer.create_for_root(environment: environment)
+        @lock = Concurrent::ReadWriteLock.new
+      end
+
+      # @return [void]
+      def evaluate
+        tracer
+      end
+
+      # @return [Typing::Inferencer::Tracer]
+      def tracer
+        @lock.with_write_lock do
+          @tracer ||= begin
+            inferencer.infer(ast)
+            inferencer.tracer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/services/loadable_path_resolver.rb

@@ -0,0 +1,33 @@
+module Yoda
+  module Services
+    class LoadablePathResolver
+      def initialize
+      end
+
+      # @param base_paths [Array<String>]
+      # @param pattern [String]
+      # @return [String, nil]
+      def find_loadable_path(base_paths, pattern)
+        # TODO: Support absolute path
+        return nil if File.absolute_path?(pattern)
+        return nil if pattern.start_with?("~/")
+        return nil if pattern.start_with?("./")
+        return nil if pattern.start_with?("../")
+
+        base_paths.each do |base_path|
+          path = File.join(base_path, pattern)
+
+          if File.extname(path).empty?
+            paths_with_suffix = ::Gem.suffixes.map { |suffix| path + suffix }
+            matched_path = paths_with_suffix.find { |path| File.file?(path) }
+            return matched_path if matched_path
+          else
+            return path if File.file?(path)
+          end
+        end
+
+        return nil
+      end
+    end
+  end
+end

data/lib/yoda/services/signature_discovery.rb

@@ -0,0 +1,74 @@
+module Yoda
+  module Services
+    # SignatureDiscovery infers method candidates for the nearest send node and specify the number of index of these parameters.
+    # SignatureDiscovery shows help for the current parameter of method candidates.
+    class SignatureDiscovery
+      # @return [Evaluator]
+      attr_reader :evaluator
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param environment [Model::Environment]
+      # @param registry [Store::Registry]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      # @return [SignatureDiscovery]
+      def self.from_source(environment:, source:, location:)
+        new(
+          evaluator: Evaluator.new(environment: environment, ast: Parsing.parse(source)),
+          location: location
+        )
+      end
+
+      # @param evaluator [Evaluator]
+      # @param location [Parsing::Location]
+      def initialize(evaluator:, location:)
+        @evaluator = evaluator
+        @location = location
+      end
+
+      def valid?
+        !!nearest_send_node
+      end
+
+      # @return [Array<Model::FunctionSignatures::Warpper>]
+      def method_candidates
+        return [] unless valid?
+        nearest_send_node_info.method_candidates
+      end
+
+      # @return [Integer, nil]
+      def argument_number
+        nearest_send_node&.expanded_arguments&.find_index { |node| node == nearest_argument_node }
+      end
+
+      private
+
+      # @return [String, nil]
+      def index_word
+        nearest_send_node&.selector_name
+      end
+
+      # @return [AST::SendNode, nil]
+      def nearest_send_node
+        @nearest_send_node ||= current_node.query_ancestors(type: :send).reverse_each.find { |node| node.on_arguments?(location) }
+      end
+
+      # @return [Typing::NodeInfo]
+      def nearest_send_node_info
+        evaluator.node_info(nearest_send_node)
+      end
+
+      # @return [AST::ParameterNode, nil]
+      def nearest_argument_node
+        @nearest_argument_node ||= nearest_send_node&.expanded_arguments&.find { |node| node.positionally_include?(location) }
+      end
+
+      # @return [Parser::AST::Node]
+      def current_node
+        @current_node ||= evaluator.ast.positionally_nearest_child(location)
+      end
+    end
+  end
+end

data/lib/yoda/services.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module Services
+    require 'yoda/services/evaluator'
+    require 'yoda/services/current_node_explain'
+    require 'yoda/services/comment_completion'
+    require 'yoda/services/code_completion'
+    require 'yoda/services/loadable_path_resolver'
+    require 'yoda/services/signature_discovery'
+  end
+end

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

@@ -1,7 +1,10 @@
+require 'zip'
+require 'open-uri'
+require 'fileutils'
+
 module Yoda
   module Store
     module Actions
-      # @todo Build index without using shell script
       class BuildCoreIndex
         class << self
           # @return [true, false]
@@ -11,31 +14,57 @@ module Yoda
 
           def exists?
             [
-              "~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc",
-              "~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib",
-            ].all? { |path| File.exists?(File.expand_path(path)) }
+              VersionStore.for_current_version.core_yardoc_path,
+              VersionStore.for_current_version.stdlib_yardoc_path,
+            ].all? { |path| File.exists?(path) }
           end
         end
 
         # @return [true, false]
         def run
+          Logger.info "Downloading ruby source"
+          download_core_index_file
+          Logger.info "Building ruby core and stdlib index"
           build_core_index
         end
 
         private
 
-        # @return [String]
-        def script_path
-          File.expand_path('../../../../scripts/build_core_index.sh', __dir__)
+        def ruby_version_major_minor
+          RUBY_VERSION.sub(/^(\d+)\.(\d+)\.\d+$/, '\\1.\\2')
+        end
+
+        def download_core_index_file
+          Zip.warn_invalid_date = false
+
+          URI.open("https://cache.ruby-lang.org/pub/ruby/#{ruby_version_major_minor}/ruby-#{RUBY_VERSION}.zip") do |file|
+            Zip::File.open_buffer(file) do |zip_file|
+              zip_file.each do |entry|
+                # entry path already include `ruby-#{RUBY_VERSION}/``
+                extracted_entry_path = File.join(VersionStore.for_current_version.ruby_source_path, "../", entry.to_s)
+                FileUtils.mkdir_p(File.dirname(extracted_entry_path))
+                zip_file.extract(entry, extracted_entry_path) { true }
+              end
+            end
+          end
         end
 
         def build_core_index
-          o, e = Open3.capture2e(script_path)
+          Dir.chdir(VersionStore.for_current_version.ruby_source_path) do
+            exec_yardoc("yard doc -n *.c") || return
+            exec_yardoc("yard doc -b .yardoc-stdlib -o doc-stdlib -n") || return
+          end
+          Logger.info "Success to build yard index"
+        end
+
+        def exec_yardoc(cmdline)
+          o, e = Open3.capture2e(cmdline)
           Logger.debug o unless o.empty?
           if e.success?
-            Logger.info "Success to build yard index"
+            true
           else
             Logger.warn "Failed to build core index"
+            false
           end
         end
       end

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

@@ -2,33 +2,28 @@ module Yoda
   module Store
     module Actions
       class ImportCoreLibrary
-        # @return [Registry]
-        attr_reader :registry
+        # @return [Project::Dependency::Core]
+        attr_reader :dep
 
         class << self
-          # @return [true, false]
-          def run(registry)
-            new(registry).run
+          # @param dep [Project::Dependency::Core]
+          # @return [Objects::Patch]
+          def run(dep)
+            new(dep).run
           end
         end
 
-        # @param registry [Registry]
-        def initialize(registry)
-          @registry = registry
+        # @param dep [Project::Dependency::Core]
+        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")
+          BuildCoreIndex.run unless BuildCoreIndex.exists?
+          return unless File.exist?(dep.doc_path)
+          patch = YardImporter.import(dep.doc_path)
+          Transformers::CoreVisibility.transform(patch)
         end
       end
     end

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

@@ -4,11 +4,8 @@ module Yoda
   module Store
     module Actions
       class ImportGem
-        # @return [Registry]
-        attr_reader :registry
-
-        # @return [String]
-        attr_reader :gem_name, :gem_version
+        # @return [Objects::Library::Gem::Connected]
+        attr_reader :dep
 
         class << self
           # @return [true, false]
@@ -17,37 +14,40 @@ module Yoda
           end
         end
 
-        # @param registry [Registry]
-        # @param gem_name [String]
-        # @param gem_version [String]
-        def initialize(registry:, gem_name:, gem_version:)
-          @registry = registry
-          @gem_name = gem_name
-          @gem_version = gem_version
+        # @param dep [Objects::Library::Gem::Connected]
+        def initialize(dep)
+          @dep = dep
         end
 
-        # @return [true, false]
+        # @return [Objects::Patch]
         def run
           create_dependency_doc
           if yardoc_file = yardoc_path
-            if patch = load_yardoc(yardoc_file, gem_path)
-              registry.add_patch(patch)
-              return true
-            end
+            load_yardoc(yardoc_file, gem_path)
           end
-          false
         end
 
         private
 
         def create_dependency_doc
-          if yardoc_path
+          if dep.managed_by_rubygems? && readable?(yardoc_path)
             Logger.info "Gem docs for #{gem_name} #{gem_version} already exist"
-            return true
+            return
+          end
+
+          if yardoc_path
+            Logger.info "Building gem docs for #{gem_name} #{gem_version}"
+            yard_doc_command
+          else
+            Logger.info "Cannot build gem docs for #{gem_name} #{gem_version}"
           end
-          Logger.info "Building gem docs for #{gem_name} #{gem_version}"
+        end
+
+        def yard_doc_command
           begin
-            o, e = Open3.capture2e("yard gems #{gem_name} #{gem_version}")
+            o, e = Dir.chdir(gem_path) do
+              Open3.capture2e("yard --no-stats --no-output -b #{yardoc_path} -c")
+            end
             Logger.debug o unless o.empty?
             if e.success?
               Logger.info "Done building gem docs for #{gem_name} #{gem_version}"
@@ -77,21 +77,53 @@ module Yoda
 
         # @return [String, nil]
         def yardoc_path
-          YARD::Registry.yardoc_file_for_gem(gem_name, gem_version)
-        rescue Bundler::BundlerError => ex
-          Logger.debug ex
-          Logger.debug ex.backtrace
-          nil
-        end
+          return nil unless readable?(gem_path)
 
-        # @return [String, nil]
-        def gem_path
-          @gem_path ||= begin
-            if spec = Gem.source_index.find_name(gem_name).first
-              spec.full_gem_path
+          if dep.managed_by_rubygems?
+            candidate = File.expand_path('.yardoc', dep.doc_dir)
+            if writable?(candidate)
+              candidate
+            else
+              dep.project.library_local_yardoc_path(name: gem_name, version: gem_version)
+            end
+          else
+            candidate = File.expand_path('.yardoc', gem_path)
+            if writable?(candidate)
+              candidate
+            else
+              dep.project.library_local_yardoc_path(name: gem_name, version: gem_version)
             end
           end
         end
+
+        def gem_name
+          dep.name
+        end
+
+        def gem_version
+          dep.version
+        end
+
+        # @return [String]
+        def gem_path
+          dep.full_gem_path
+        end
+
+        # @param path [String]
+        # @return [Boolean]
+        def writable?(path)
+          return true if File.writable?(path)
+          return true if !File.directory?(path) && File.writable?(File.dirname(path))
+          false
+        end
+
+        # @param path [String]
+        # @return [Boolean]
+        def readable?(path)
+          return false unless path
+          return false unless File.readable?(path)
+          true
+        end
       end
     end
   end

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

@@ -0,0 +1,47 @@
+module Yoda
+  module Store
+    module Actions
+      class ImportProjectDependencies
+        # @return [Project]
+        attr_reader :project
+
+        # @param errors [Array<BaseError>]
+        attr_reader :errors
+
+        # @param project [Project]
+        def initialize(project)
+          @project = project
+          @errors = []
+        end
+
+        def run
+          libraries_status = project.registry.libraries.status
+          library_to_add, library_to_remove = calculate_dependency(libraries_status)
+
+          if !library_to_add.empty? || !library_to_remove.empty?
+            Logger.info 'Constructing database for the current project.'
+            Logger.trace 'Adding libraries: ' + library_to_add.map(&:name).join(', ')
+            Logger.trace 'Removing libraries: ' + library_to_remove.map(&:name).join(', ')
+            project.registry.libraries.modify(add: library_to_add, remove: library_to_remove)
+          else
+            Logger.info 'No library changes to the current project.'
+          end
+
+          self
+        end
+
+        private
+
+        # @param libraries_status [Object::LibrariesStatus]
+        # @return [Array(Array<Object::Library::Core, Objects::Library::Std, Objects::Library::Gem>, Array<Object::Library::Core, Objects::Library::Std, Objects::Library::Gem>)]
+        def calculate_dependency(libraries_status)
+          libraries = Objects::LibrariesStatus.libraies_from_dependency(project.dependency)
+          Logger.trace 'Requested libraries: ' + libraries.map(&:name).join(', ')
+          library_to_add = libraries - libraries_status.libraries
+          library_to_remove = libraries_status.libraries - libraries
+          [library_to_add, library_to_remove]
+        end
+      end
+    end
+  end
+end

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

@@ -2,15 +2,23 @@ module Yoda
   module Store
     module Actions
       class ReadProjectFiles
+        # @return [Project]
+        attr_reader :project
+
         # @return [Registry]
         attr_reader :registry
 
-        # @return [String]
-        attr_reader :root_path
+        # @param project [Project]
+        # @return [ReadProjectFiles]
+        def self.for_project(project)
+          new(project, project.registry)
+        end
 
-        def initialize(registry, root_path)
+        # @param project [Project]
+        # @param registry [Project]
+        def initialize(project, registry)
+          @project = project
           @registry = registry
-          @root_path = root_path
         end
 
         def run
@@ -29,7 +37,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) } }
+          project.project_source_paths
         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