yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/cli.rb

@@ -0,0 +1,117 @@
+require 'thor'
+
+module Yoda
+  # Cli module has handler for each cli command.
+  module Cli
+    require 'yoda/cli/analyze_deps'
+    require 'yoda/cli/base'
+    require 'yoda/cli/file_cursor_parsable'
+    require 'yoda/cli/infer'
+    require 'yoda/cli/complete'
+    require 'yoda/cli/console'
+
+    class << self
+      # @return [String]
+      def exe_dir
+        File.expand_path('../../exe', __dir__)
+      end
+
+      # @return [String]
+      def yoda_exe
+        File.expand_path('./yoda', exe_dir)
+      end
+    end
+
+    class Top < Thor
+      class_option :log_level, type: :string, desc: 'Set log level (debug info warn error fatal)'
+      class_option :profile, type: :boolean, desc: 'Set log level (debug info warn error fatal)'
+      class_option :help, type: :boolean, desc: 'Show help', aliases: :h,  hide: true
+
+      desc 'setup', 'Setup indexes for current Ruby version and project gems'
+      option :force_build, type: :boolean, desc: "If enabled, (re)build current project's index forcibly"
+      def setup
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Instrument.instance.hear(initialization_progress: method(:on_progress), registry_dump: method(:on_progress)) do
+          Store.setup(dir: Dir.pwd, force_build: options[:force_build])
+        end
+      end
+
+      desc 'infer POSITION', 'Infer the type of value at the specified position'
+      def infer(position)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Infer.run(position)
+      end
+
+      desc 'complete POSITION', 'Provide completion candidates for the specified position'
+      def complete(position)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Complete.run(position)
+      end
+
+      desc 'console', 'Launch debug console'
+      def console
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Console.run
+      end
+
+      desc 'server', 'Start Language Server'
+      def server
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Server.new.run
+      end
+
+      desc 'analyze-deps PATH', 'Analyze dependencies of the given path'
+      def analyze_deps(path)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::AnalyzeDeps.run(path)
+      end
+
+      desc 'version', 'show current version'
+      def version
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        say "#{Yoda::VERSION}"
+      end
+
+      private
+
+      def process_class_options
+        set_log_level
+        use_profiler_if_enabled
+      end
+
+      def set_log_level
+        Yoda::Logger.log_level = options[:log_level].to_sym if options[:log_level]
+      end
+
+      def use_profiler_if_enabled
+        if options[:profile]
+          require 'stackprof'
+          require 'securerandom'
+          Logger.info('Enabled profiler')
+          StackProf.start(mode: :wall, raw: true)
+
+          at_exit do
+            StackProf.stop
+            tmpfile_path = File.expand_path(SecureRandom.hex(12), Dir.tmpdir)
+            StackProf.results(tmpfile_path)
+            Logger.fatal("Dumped file to: #{tmpfile_path}")
+          end
+        end
+      end
+
+      def on_progress(phase: :save_keys, index: nil, length: nil, **params)
+        return unless index
+        @bars ||= {}
+        @bar = @bars[phase] ||= ProgressBar.create(format: "%t: %c/%C |%w>%i| %e ", title: phase.to_s.gsub('_', ' '), starting_at: index, total: length)
+        @bar.progress = index if index <= @bar.total
+      end
+    end
+  end
+end

data/lib/yoda/has_services.rb

@@ -0,0 +1,40 @@
+module Yoda
+  module HasServices
+    module ClassMethods
+      # Register a service with the specified name
+      # @params name [String]
+      def service(name, &block)
+        service_hub_class.register_service(name, &block)
+        define_method(:"#{name}_service") { services.public_send(name) }
+      end
+
+      # @return [Class<ServiceHub>]
+      def service_hub_class
+        @service_hub_class ||= Class.new(ServiceHub)
+      end
+    end
+
+    class ServiceHub
+      attr_reader :instance
+
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def self.register_service(name, &block)
+        define_method(name) do
+          instance.instance_exec(instance, &block)
+        end
+      end
+    end
+
+    # @return [ServiceHub]
+    def services
+      @services ||= self.class.service_hub_class.new(self)
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/yoda/id_mask.rb

@@ -0,0 +1,84 @@
+require 'set'
+
+module Yoda
+  class IdMask
+    # @return [Hash<Symbol>, nil]
+    attr_reader :pattern
+
+    # @param pattern [IdMask, Set<Symbol>, Array<Symbol>, Hash<Symbol>, nil]
+    # @return [IdMask]
+    def self.build(pattern)
+      if pattern.is_a?(IdMask)
+        pattern
+      elsif pattern.nil?
+        new(pattern)
+      elsif pattern.is_a?(Hash)
+        new(pattern.map { |k, v| [k.to_sym, v] }.to_h)
+      else
+        new(pattern.to_a.to_h { |id| [id.to_sym, nil] })
+      end
+    end
+
+    # @param pattern [Hash<Symbol>, nil]
+    def initialize(pattern)
+      fail TypeError, "pattern must be a Hash or nil" unless pattern.is_a?(Hash) || pattern.nil?
+      @pattern = pattern
+    end
+
+    # @param id [Symbol, String]
+    # @return [Boolean]
+    def cover?(id)
+      return true if any?
+      pattern.has_key?(id.to_sym)
+    end
+
+    # @param another [IdMasklia, Set<Symbol>, Array<Symbol>, Hash<Symbol>, nil]
+    # @return [IdMask]
+    def intersection(another)
+      another_mask = IdMask.build(another)
+      return another_mask if any?
+      return self if another_mask.any?
+
+      ids_intersection = covering_ids & another_mask.covering_ids
+
+      intersection_pattern = ids_intersection.map do |id|
+        [id, nesting_mask(id) & another_mask.nesting_mask(id)]
+      end.to_h
+
+      IdMask.build(intersection_pattern)
+    end
+
+    alias_method :&, :intersection
+
+    # @return [Boolean]
+    def any?
+      pattern.nil?
+    end
+
+    # @return [Set<Symbol>, nil]
+    def covering_ids
+      @covering_ids ||= begin
+        if any?
+          nil
+        else 
+          Set.new(pattern.keys)
+        end
+      end
+    end
+
+    # @param id [String, Symbol]
+    # @return [IdMask]
+    def nesting_mask(id)
+      if pattern.is_a?(Hash)
+        IdMask.build(pattern[id.to_sym])
+      else
+        IdMask.build(nil)
+      end
+    end
+
+    # @return [Hash, nil]
+    def to_pattern
+      pattern&.map { |k, v| [k, v&.to_pattern] }&.to_h
+    end
+  end
+end

data/lib/yoda/instrument.rb

@@ -1,4 +1,5 @@
 require 'concurrent'
+require 'forwardable'
 
 module Yoda
   class Instrument
@@ -25,8 +26,8 @@ module Yoda
         instrument.unsubscribe(self)
       end
 
-      def call(params)
-        callback.call(params)
+      def call(*params, **kwargs)
+        callback.call(*params, **kwargs)
       end
     end
 
@@ -60,12 +61,20 @@ module Yoda
     attr_reader :subscriptions
 
     class << self
+      extend Forwardable
+
+      delegate %i(hear subscribe emit unsubscribe) => :instance
+
       # Returns Instrument instance (thread local).
       # @return [Instrument]
       def instance
         local.value
       end
 
+      def clean
+        local.value = Instrument.new
+      end
+
       private
 
       # @return [Concurrent::ThreadLocalVar<Instrument>]
@@ -95,10 +104,10 @@ module Yoda
     end
 
     # @param name [String]
-    # @param [String]
-    def emit(name, params)
+    # @param params [Hash]
+    def emit(name, **params)
       Logger.trace("#{name}: #{params}")
-      subscriptions.select { |subscription| subscription.name === name }.each { |subscription| subscription.call(params) }
+      subscriptions.select { |subscription| subscription.name === name }.each { |subscription| subscription.call(**params) }
     end
 
     # @param subscription [Subscription]
@@ -121,5 +130,12 @@ module Yoda
     def registry_dump(index: nil, length: nil)
       emit(:registry_dump, index: index, length: length)
     end
+
+    # @param name [String]
+    # @param version [String]
+    # @param message [String]
+    def build_library_registry(message:, name:, version:)
+      emit(:build_library_registry, name: name, version: version, message: message)
+    end
   end
 end

data/lib/yoda/logger.rb

@@ -20,10 +20,12 @@ module Yoda
       #   @!method allow_$1?
       #     @return [true, false]
       def define_logging_method(level)
-        define_method(level) do |content, tag: nil|
+        define_method(level) do |content = nil, tag: nil|
           return unless public_send("allow_#{level}?")
+          content = yield if block_given?
+          content ||= ""
           prefix = "[#{level}]#{tag ? ' (' + tag + ')' : '' } "
-          io.puts(prefix + content.to_s.split("\n").join(prefix))
+          io.puts(prefix + content.to_s.lines.join(prefix))
         end
 
         define_method("allow_#{level}?") do

data/lib/yoda/missing_delegatable.rb

@@ -0,0 +1,34 @@
+module Yoda
+  module MissingDelegatable
+    module ClassMethods
+      # @return [Symbol, nil]
+      attr_reader :delegate_missing_target
+
+      # @param target [Symbol] the delegation target if an missing method is passed.
+      def delegate_missing(target)
+        @delegate_missing_target = target
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private)
+      delegate_missing_target&.respond_to?(method_name, include_private) || super
+    end
+
+    def method_missing(method_name, *args, &blk)
+      if delegate_missing_target&.respond_to?(method_name)
+        delegate_missing_target.public_send(method_name, *args, &blk)
+      else
+        super
+      end
+    end
+
+    # @return [Object, nil]
+    def delegate_missing_target
+      self.class.delegate_missing_target && send(self.class.delegate_missing_target)
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  end
+end

data/lib/yoda/model/completion_item.rb

@@ -1,8 +1,10 @@
 module Yoda
   module Model
     class CompletionItem
-      # @return [Descriptions::Base]
-      attr_reader :description
+      extend Forwardable
+
+      # @return [Array<Descriptions::Base>]
+      attr_reader :descriptions
 
       # @return [Parsing::Range]
       attr_reader :range
@@ -13,30 +15,38 @@ module Yoda
       # @return [String]
       attr_reader :prefix
 
-      # @param description [Descriptions::Base]
-      # @param range       [Parsing::Range]
-      # @param kind        [Symbol, nil]
-      # @param prefix      [String, nil]
-      def initialize(description:, range:, kind: nil, prefix: nil)
-        fail ArgumentError, desctiption unless description.is_a?(Descriptions::Base)
+      delegate %i(label title to_markdown sort_text) => :primary_description
+
+      # @param descriptions [Array<Descriptions::Base>]
+      # @param range        [Parsing::Range]
+      # @param kind         [Symbol, nil]
+      # @param prefix       [String, nil]
+      def initialize(description: nil, descriptions: [], range:, kind: nil, prefix: nil)
+        fail ArgumentError, description if description && !description.is_a?(Descriptions::Base)
+        fail ArgumentError, descriptions unless descriptions.all? { |description| description.is_a?(Descriptions::Base) }
         fail ArgumentError, range unless range.is_a?(Parsing::Range)
         fail ArgumentError, kind if !kind.nil? && !available_kinds.include?(kind)
-        @description = description
+        @descriptions = ([description] + descriptions).compact
         @range = range
         @kind = kind
         @prefix = prefix || ''
       end
 
+      def primary_description
+        descriptions.first
+      end
+
       # @return [String]
       def edit_text
-        prefix + description.sort_text
+        prefix + primary_description.sort_text
       end
 
       # @return [Symbol]
       def available_kinds
-        %i(method class module constant)
+        %i(method class module constant variable)
       end
 
+      # @return [Symbol]
       def language_server_kind
         case kind
         when :constant
@@ -47,10 +57,32 @@ module Yoda
           LanguageServer::Protocol::Constant::CompletionItemKind::CLASS
         when :module
           LanguageServer::Protocol::Constant::CompletionItemKind::MODULE
+        when :variable
+          LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE
         else
           nil
         end
       end
+
+      def to_s
+        title
+      end
+
+      # @return [{Symbol => { Symbol => Integer } }]
+      def language_server_range
+        range.to_language_server_protocol_range
+      end
+
+      # @param function_description [FunctionDescription]
+      # @return [FunctionDescription, MultipleFunctionDescription]
+      def merge(completion_item)
+        self.class.new(
+          descriptions: descriptions + completion_item.descriptions,
+          range: range,
+          kind: kind,
+          prefix: prefix,
+        )
+      end
     end
   end
 end

data/lib/yoda/model/descriptions/base.rb

@@ -15,11 +15,22 @@ module Yoda
           fail NotImplementedError
         end
 
+        # @return [String]
+        def label
+          sort_text
+        end
+
         # @abstract
         # @return [String]
         def to_markdown
           fail NotImplementedError
         end
+
+        # Return an LSP MarkedString content for description
+        # @return [String, Hash]
+        def markup_content
+          to_markdown
+        end
       end
     end
   end

data/lib/yoda/model/descriptions/comment_token_description.rb

@@ -0,0 +1,46 @@
+module Yoda
+  module Model
+    module Descriptions
+      class CommentTokenDescription < Base
+        # @return [AST::CommentBlock::Token]
+        attr_reader :comment_token
+
+        # @return [TypeExpressions::Base]
+        attr_reader :type
+
+        # @param comment_token [AST::CommentBlock::Token]
+        # @param type [TypeExpressions::Base]
+        def initialize(comment_token, type)
+          @comment_token = comment_token
+          @type = type
+        end
+
+        # @return [String]
+        def title
+          comment_token.content
+        end
+
+        # @return [String]
+        def sort_text
+          comment_token.content
+        end
+
+        # @return [String]
+        def to_markdown
+          <<~EOS
+          **#{title}**
+
+          #{value.document}
+          EOS
+        end
+
+        def markup_content
+          {
+            language: 'ruby',
+            value: "#{title.gsub("\n", ";")} # #{type}",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/descriptions/function_description.rb

@@ -2,12 +2,12 @@ module Yoda
   module Model
     module Descriptions
       class FunctionDescription < Base
-        # @type Store::Objects::MethodObject
+        # @return [FunctionSignatures::Base]
         attr_reader :function
 
         # @param function [FunctionSignatures::Base]
         def initialize(function)
-          fail ArgumentError, function unless function.is_a?(FunctionSignatures::Base)
+          fail ArgumentError, function unless function.is_a?(FunctionSignatures::Wrapper)
           @function = function
         end
 
@@ -15,6 +15,10 @@ module Yoda
           "#{function.namespace_path}#{function.sep}#{function.to_s}"
         end
 
+        def label
+          signature
+        end
+
         def signature
           "#{function.to_s}"
         end
@@ -32,8 +36,21 @@ module Yoda
           **#{title}**
 
           #{function.document}
+          #{tag_documents}
           EOS
         end
+
+        private
+
+        def tag_documents
+          function.tags.map do |tag|
+            str = "@#{tag.tag_name}"
+            str += " `#{tag.name}`" if tag.name
+            str += " [#{tag.yard_types.map { |name| "`#{name}`" }.join(', ')}]" if tag.yard_types && !(tag.yard_types.empty?)
+            str += " #{tag.text.chomp}" if tag.text
+            str
+          end.join("  \n") # Commonmark requires 2 spaces for line breaking
+        end
       end
     end
   end

data/lib/yoda/model/descriptions/node_description.rb

@@ -7,14 +7,14 @@ module Yoda
         # @return [::Parser::AST::Node]
         attr_reader :node
 
-        # @return [Typing::Traces::Base]
-        attr_reader :trace
+        # @return [TypeExpressions::Base]
+        attr_reader :type
 
-        # @param node  [::Parser::AST::Node]
-        # @param trace [Typing::Traces::Base]
-        def initialize(node, trace)
+        # @param node  [AST::Vnode]
+        # @param type [TypeExpressions::Base]
+        def initialize(node, type)
           @node = node
-          @trace = trace
+          @type = type
         end
 
         # @return [String]
@@ -30,15 +30,26 @@ module Yoda
         # @return [String]
         def to_markdown
           <<~EOS
-          #{node_body.gsub("\n", ";")}: #{trace.type}
+          #{node_body.gsub("\n", ";")}: #{type}
           EOS
         end
 
+        def markup_content
+          {
+            language: 'ruby',
+            value: "#{node_body.gsub("\n", ";")} # #{type}",
+          }
+        end
+
         private
 
         # @return [String]
         def node_body
-          @node_body ||= Unparser.unparse(node)
+          @node_body ||= begin
+            if node.respond_to?(:node)
+              Unparser.unparse(node.node)
+            end
+          end
         end
       end
     end

data/lib/yoda/model/descriptions/require_path_description.rb

@@ -0,0 +1,45 @@
+module Yoda
+  module Model
+    module Descriptions
+      # @abstract
+      class RequirePathDescription
+        # @return [String]
+        attr_reader :path
+
+        # @param path [String]
+        def initialize(path)
+          @path = path
+        end
+
+        # @abstract
+        # @return [String]
+        def title
+          path
+        end
+
+        # @abstract
+        # @return [String]
+        def sort_text
+          path
+        end
+
+        # @return [String]
+        def label
+          sort_text
+        end
+
+        # @abstract
+        # @return [String]
+        def to_markdown
+          path
+        end
+
+        # Return an LSP MarkedString content for description
+        # @return [String, Hash]
+        def markup_content
+          to_markdown
+        end
+      end
+    end
+  end
+end