yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/{evaluation → services}/comment_completion.rb

@@ -1,13 +1,13 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
-      require 'yoda/evaluation/comment_completion/base_provider'
-      require 'yoda/evaluation/comment_completion/param_provider'
-      require 'yoda/evaluation/comment_completion/tag_provider'
-      require 'yoda/evaluation/comment_completion/type_provider'
+      require 'yoda/services/comment_completion/base_provider'
+      require 'yoda/services/comment_completion/param_provider'
+      require 'yoda/services/comment_completion/tag_provider'
+      require 'yoda/services/comment_completion/type_provider'
 
-      # @type Store::Registry
-      attr_reader :registry
+      # @return [Model::Environment]
+      attr_reader :environment
 
       # @type ::Parser::AST::Node
       attr_reader :ast
@@ -18,12 +18,12 @@ module Yoda
       # @type Location
       attr_reader :location
 
-      # @param registry [Store::Registry]
+      # @param environment [Model::Environment]
       # @param ast      [::Parser::AST::Node]
       # @param comments [Array<::Parser::Source::Comment>]
       # @param location [Location]
-      def initialize(registry, ast, comments, location)
-        @registry = registry
+      def initialize(environment, ast, comments, location)
+        @environment = environment
         @ast = ast
         @comments = comments
         @location = location
@@ -48,17 +48,17 @@ module Yoda
 
       # @return [ParamProvider]
       def param_provider
-        @param_provider ||= ParamProvider.new(registry, ast, comments, location)
+        @param_provider ||= ParamProvider.new(environment, ast, comments, location)
       end
 
       # @return [TagProvider]
       def tag_provider
-        @tag_provider ||= TagProvider.new(registry, ast, comments, location)
+        @tag_provider ||= TagProvider.new(environment, ast, comments, location)
       end
 
       # @return [TypeProvider]
       def type_provider
-        @type_provider ||= TypeProvider.new(registry, ast, comments, location)
+        @type_provider ||= TypeProvider.new(environment, ast, comments, location)
       end
 
       def comment?

data/lib/yoda/services/current_node_explain/comment_signature.rb

@@ -0,0 +1,77 @@
+module Yoda
+  module Services
+    class CurrentNodeExplain
+      class CommentSignature
+        # @return [AST::CommentBlock]
+        attr_reader :comment
+
+        # @return [Parsing::Location]
+        attr_reader :location
+
+        # @return [Typing::NodeInfo]
+        attr_reader :node_info
+
+        # @param comment [AST::CommentBlock]
+        # @param location [Parsing::Location]
+        # @param node_info [Typing::NodeInfo]
+        def initialize(comment:, location:, node_info:)
+          @comment = comment
+          @location = location
+          @node_info = node_info
+        end
+
+        # @return [Boolean]
+        def providable?
+          node_range
+        end
+
+        # @return [Range, nil]
+        def node_range
+          current_comment_token&.range
+        end
+
+        # @return [Array<Model::Descriptions::Base>]
+        def descriptions
+          [node_type_description, *type_descriptions].compact
+        end
+
+        # @return [Array<String>]
+        def defined_files
+          objects.map { |value| Model::PrimarySourceInferencer.new.infer_for_object(value) }.compact
+        end
+
+        # @return [Model::Descriptions::Base, nil]
+        def node_type_description
+          if constants_type
+            Model::Descriptions::CommentTokenDescription.new(current_comment_token, constants_type)
+          end
+        end
+
+        # @return [Array<Descriptions::Base>]
+        def type_descriptions
+          objects.map { |object| Model::Descriptions::ValueDescription.new(object) }
+        end
+
+        private
+
+        # @return [Array<Store::Objects::Base>]
+        def objects
+          constants_type&.value&.referred_objects || []
+        end
+
+        # @return [AST::CommentBlock::Token, nil]
+        def current_comment_token
+          part = comment.nearest_tag_part(location)
+          part&.type_part&.nearest_token(location)
+        end
+
+        # @return [Typing::Types::Type, nil]
+        def constants_type
+          @constants_type ||= begin
+            current_comment_token && node_info.resolve_constant(current_comment_token.content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/services/current_node_explain.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Services
+    # CurrentNodeExplain shows help for the current node.
+    class CurrentNodeExplain
+      require 'yoda/services/current_node_explain/comment_signature'
+
+      # @return [Evaluator]
+      attr_reader :evaluator
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param environment [Model::Environment]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      # @return [CurrentNodeExplain]
+      def self.from_source(environment:, source:, location:)
+        ast, _ = Parsing.parse_with_comments(source)
+        new(
+          evaluator: Evaluator.new(environment: environment, ast: ast),
+          location: location
+        )
+      end
+
+      # @param evaluator [Evaluator]
+      # @param location [Parsing::Location]
+      def initialize(evaluator:, location:)
+        @evaluator = evaluator
+        @location = location
+      end
+
+      # @return [Model::NodeSignature, nil]
+      def current_node_signature
+        return nil if !valid? || !current_node
+        @current_node_signature ||= Model::NodeSignatures.for_node_info(current_node_info)
+      end
+
+      # @return [CommentSignature, nil]
+      def current_comment_signature
+        return nil if !valid? || !current_comment || !commenting_node_info
+        @current_comment_signature ||= CommentSignature.new(comment: current_comment, node_info: commenting_node_info, location: location)
+      end
+
+      # @return [true, false]
+      def valid?
+        !!(current_comment || current_node)
+      end
+
+      private
+
+      # @return [Typing::NodeInfo]
+      def current_node_info
+        @current_node_info ||= evaluator.node_info(current_node)
+      end
+
+      # @return [Typing::NodeInfo]
+      def commenting_node_info
+        @commenting_node_info ||= current_comment&.node ? evaluator.node_info(current_comment&.node) : nil
+      end
+
+      # @return [Parser::AST::Node]
+      def current_node
+        @current_node ||= evaluator.ast.positionally_nearest_child(location)
+      end
+
+      # @return [AST::CommentBlock, nil]
+      def current_comment
+        @current_comment || evaluator.ast.positionally_nearest_comment(location)
+      end
+    end
+  end
+end

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/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,9 @@
+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/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