yoda-language-server 0.4.0 → 0.5.0

data/lib/yoda/server/completion_provider.rb

@@ -1,18 +1,18 @@
 module Yoda
   class Server
     class CompletionProvider
-      # @type ClientInfo
-      attr_reader :client_info
+      # @type Session
+      attr_reader :session
 
-      # @param client_info [ClientInfo]
-      def initialize(client_info)
-        @client_info = client_info
+      # @param session [Session]
+      def initialize(session)
+        @session = session
       end
 
       # @param uri      [String]
       # @param position [{Symbol => Integer}]
       def complete(uri, position)
-        source = client_info.file_store.get(uri)
+        source = session.file_store.get(uri)
         location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
         if candidates = comment_complete(source, location)
@@ -29,7 +29,7 @@ module Yoda
       def comment_complete(source, location)
         ast, comments = Parsing::Parser.new.parse_with_comments(source)
         return nil unless Parsing::Query::CurrentCommentQuery.new(comments, location).current_comment
-        completion_worker = Evaluation::CommentCompletion.new(client_info.registry, ast, comments, location)
+        completion_worker = Evaluation::CommentCompletion.new(session.registry, ast, comments, location)
         return nil unless completion_worker.available?
 
         completion_items = completion_worker.candidates
@@ -47,7 +47,7 @@ module Yoda
       # @return [LanguageServerProtocol::Interface::CompletionList, nil]
       def complete_from_cut_source(source, location)
         cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
-        method_completion_worker = Evaluation::CodeCompletion.new(client_info.registry, cut_source, location)
+        method_completion_worker = Evaluation::CodeCompletion.new(session.registry, cut_source, location)
         completion_items = method_completion_worker.candidates
         return nil if completion_items.empty?
 

data/lib/yoda/server/definition_provider.rb

@@ -1,22 +1,22 @@
 module Yoda
   class Server
     class DefinitionProvider
-      # @type ClientInfo
-      attr_reader :client_info
+      # @type Session
+      attr_reader :session
 
-      # @param client_info [ClientInfo]
-      def initialize(client_info)
-        @client_info = client_info
+      # @param session [Session]
+      def initialize(session)
+        @session = session
       end
 
       # @param uri      [String]
       # @param position [{Symbol => Integer}]
       # @param include_declaration [Boolean]
       def provide(uri, position, include_declaration = false)
-        source = client_info.file_store.get(uri)
+        source = session.file_store.get(uri)
         location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
-        node_worker = Evaluation::CurrentNodeExplain.new(client_info.registry, source, location)
+        node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
         references = node_worker.defined_files
         references.map { |(path, line, column)| create_location(path, line, column) }
       end
@@ -27,7 +27,7 @@ module Yoda
       def create_location(path, line, column)
         location = Parsing::Location.new(row: line - 1, column: column)
         LSP::Interface::Location.new(
-          uri: client_info.uri_of_path(path),
+          uri: session.uri_of_path(path),
           range: LSP::Interface::Range.new(Parsing::Range.new(location, location).to_language_server_protocol_range),
         )
       end

data/lib/yoda/server/hover_provider.rb

@@ -1,20 +1,20 @@
 module Yoda
   class Server
     class HoverProvider
-      attr_reader :client_info
+      attr_reader :session
 
-      # @param client_info [ClientInfo]
-      def initialize(client_info)
-        @client_info = client_info
+      # @param session [Session]
+      def initialize(session)
+        @session = session
       end
 
       # @param uri      [String]
       # @param position [{Symbol => Integer}]
       def request_hover(uri, position)
-        source = client_info.file_store.get(uri)
+        source = session.file_store.get(uri)
         location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
-        node_worker = Evaluation::CurrentNodeExplain.new(client_info.registry, source, location)
+        node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
 
         current_node_signature = node_worker.current_node_signature
         create_hover(current_node_signature) if current_node_signature

data/lib/yoda/server/initialization_provider.rb

@@ -0,0 +1,85 @@
+module Yoda
+  class Server
+    class InitializationProvider
+      # @return [Session]
+      attr_reader :session
+
+      # @param session [Session]
+      def initialize(session)
+        @session = session
+      end
+
+      # @return [LanguageServer::Protocol::Interface::ShowMessageParams, nil]
+      def provide
+        errors = session.setup
+        build_complete_message(errors)
+      end
+
+      private
+
+      # @param errors [Array<BaseError>]
+      # @return [Array<Object>]
+      def build_complete_message(errors)
+        return [] if errors.empty?
+        gem_import_errors = errors.select { |error| error.is_a?(GemImportError) }
+        core_import_errors = errors.select { |error| error.is_a?(CoreImportError) }
+
+        notifications = [
+          {
+            method: 'window/showMessage',
+            params: LanguageServer::Protocol::Interface::ShowMessageParams.new(
+              type: LanguageServer::Protocol::Constant::MessageType::WARNING,
+              message: "Failed to load some libraries (Please check console for details)",
+            )
+          }
+        ]
+
+        if gem_message = gem_import_warnings(gem_import_errors)
+          notifications.push(
+            method: 'window/logMessage',
+            params: LanguageServer::Protocol::Interface::LogMessageParams.new(
+              type: LanguageServer::Protocol::Constant::MessageType::WARNING,
+              message: gem_message,
+            ),
+          )
+        end
+
+        if core_message = core_import_warnings(core_import_errors)
+          notifications.push(
+            method: 'window/logMessage',
+            params: LanguageServer::Protocol::Interface::LogMessageParams.new(
+              type: LanguageServer::Protocol::Constant::MessageType::WARNING,
+              message: core_message,
+            ),
+          )
+        end
+
+        notifications
+      end
+
+      # @param gem_import_errors [Array<GemImportError>]
+      # @return [String, nil]
+      def gem_import_warnings(gem_import_errors)
+        return if gem_import_errors.empty?
+        warnings = gem_import_errors.map { |error| "- #{error.name} (#{error.version})" }
+
+        <<~EOS
+        Failed to import some gems.
+        Please check these gems are installed for Ruby version #{RUBY_VERSION}.
+        #{warnings.join("\n")}
+        EOS
+      end
+
+      # @param gem_import_errors [Array<GemImportError>]
+      # @return [String, nil]
+      def core_import_warnings(core_import_errors)
+        return if core_import_errors.empty?
+
+        <<~EOS
+        Failed to import some core libraries (Ruby version: #{RUBY_VERSION}).
+        Please execute `yoda setup` with Ruby version #{RUBY_VERSION}.
+        EOS
+      end
+    end
+  end
+end

data/lib/yoda/server/{client_info.rb → session.rb}

@@ -2,7 +2,7 @@ require 'uri'
 
 module Yoda
   class Server
-    class ClientInfo
+    class Session
       # @return [String]
       attr_reader :root_uri
 
@@ -12,11 +12,14 @@ module Yoda
       # @return [Store::Project]
       attr_reader :project
 
+      attr_accessor :client_initialized
+
       # @param root_uri [String] an uri expression of project root path
       def initialize(root_uri)
         @root_uri = root_uri
         @file_store = FileStore.new
         @project = Store::Project.new(root_path)
+        @client_initialized = false
       end
 
       def root_path
@@ -29,7 +32,8 @@ module Yoda
       end
 
       def setup
-        project.setup
+        Store::Actions::BuildCoreIndex.run unless Store::Actions::BuildCoreIndex.exists?
+        project.build_cache
       end
 
       # @param path [String]

data/lib/yoda/server/signature_provider.rb

@@ -1,21 +1,21 @@
 module Yoda
   class Server
     class SignatureProvider
-      attr_reader :client_info
+      attr_reader :session
 
-      # @param client_info [ClientInfo]
-      def initialize(client_info)
-        @client_info = client_info
+      # @param session [Session]
+      def initialize(session)
+        @session = session
       end
 
       # @param uri      [String]
       # @param position [{Symbol => Integer}]
       def provide(uri, position)
-        source = client_info.file_store.get(uri)
+        source = session.file_store.get(uri)
         location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
         cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
 
-        signature_worker = Evaluation::SignatureDiscovery.new(client_info.registry, cut_source, location)
+        signature_worker = Evaluation::SignatureDiscovery.new(session.registry, cut_source, location)
 
         functions = signature_worker.method_candidates
         create_signature_help(functions)

data/lib/yoda/store/actions.rb

@@ -1,8 +1,10 @@
 module Yoda
   module Store
     module Actions
+      require 'yoda/store/actions/build_core_index'
       require 'yoda/store/actions/import_core_library'
-      require 'yoda/store/actions/import_gems'
+      require 'yoda/store/actions/import_std_library'
+      require 'yoda/store/actions/import_gem'
       require 'yoda/store/actions/read_file'
       require 'yoda/store/actions/read_project_files'
     end

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

@@ -0,0 +1,44 @@
+module Yoda
+  module Store
+    module Actions
+      # @todo Build index without using shell script
+      class BuildCoreIndex
+        class << self
+          # @return [true, false]
+          def run
+            new.run
+          end
+
+          def exists?
+            [
+              "~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc",
+              "~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib",
+            ].all? { |path| File.exists?(File.expand_path(path)) }
+          end
+        end
+
+        # @return [true, false]
+        def run
+          build_core_index
+        end
+
+        private
+
+        # @return [String]
+        def script_path
+          File.expand_path('../../../../scripts/build_core_index.sh', __dir__)
+        end
+
+        def build_core_index
+          o, e = Open3.capture2e(script_path)
+          STDERR.puts o unless o.empty?
+          if e.success?
+            STDERR.puts "Success to build yard index"
+          else
+            STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,24 +5,29 @@ module Yoda
         # @return [Registry]
         attr_reader :registry
 
+        class << self
+          # @return [true, false]
+          def run(registry)
+            new(registry).run
+          end
+        end
+
         def initialize(registry)
           @registry = registry
         end
 
+        # @return [true, false]
         def run
-          load_core_patches.each do |patch|
-            registry.add_patch(patch)
-          end
+          return false unless File.exist?(doc_path)
+          patch = YardImporter.import(doc_path)
+          registry.add_patch(patch)
+          true
         end
 
         private
 
-        def load_core_patches
-          core_doc_files.map { |yardoc_file| YardImporter.import(yardoc_file) }
-        end
-
-        def core_doc_files
-          %W(.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc .yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib).map { |path| File.expand_path(path, '~') }.select { |path| File.exist?(path) }
+        def doc_path
+          File.expand_path("~/.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc")
         end
       end
     end

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

@@ -0,0 +1,98 @@
+require 'open3'
+
+module Yoda
+  module Store
+    module Actions
+      class ImportGem
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [String]
+        attr_reader :gem_name, :gem_version
+
+        class << self
+          # @return [true, false]
+          def run(args = {})
+            new(args).run
+          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
+        end
+
+        # @return [true, false]
+        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
+          end
+          false
+        end
+
+        private
+
+        def create_dependency_doc
+          if yardoc_path
+            STDERR.puts "Gem docs for #{gem_name} #{gem_version} already exist"
+            return true
+          end
+          STDERR.puts "Building gem docs for #{gem_name} #{gem_version}"
+          begin
+            o, e = Open3.capture2e("yard gems #{gem_name} #{gem_version}")
+            STDERR.puts o unless o.empty?
+            if e.success?
+              STDERR.puts "Done building gem docs for #{gem_name} #{gem_version}"
+            else
+              STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+            end
+          rescue => ex
+            STDERR.puts ex
+            STDERR.puts ex.backtrace
+            STDERR.puts "Failed to build #{gem_name} #{gem_version}"
+          end
+        end
+
+        # @param yardoc_file [String]
+        # @param gem_source_path [String]
+        # @return [Objects::Patch, nil]
+        def load_yardoc(yardoc_file, gem_source_path)
+          begin
+            YardImporter.import(yardoc_file, root_path: gem_source_path)
+          rescue => ex
+            STDERR.puts ex
+            STDERR.puts ex.backtrace
+            STDERR.puts "Failed to load #{yardoc_file}"
+            nil
+          end
+        end
+
+        # @return [String, nil]
+        def yardoc_path
+          YARD::Registry.yardoc_file_for_gem(gem_name, gem_version)
+        rescue Bundler::BundlerError => ex
+          STDERR.puts ex
+          STDERR.puts ex.backtrace
+          nil
+        end
+
+        # @return [String, nil]
+        def gem_path
+          @gem_path ||= begin
+            if spec = Gem.source_index.find_name(gem_name).first
+              spec.full_gem_path
+            end
+          end
+        end
+      end
+    end
+  end
+end