yoda-language-server 0.4.0

data/lib/yoda/evaluation/signature_discovery.rb

@@ -0,0 +1,83 @@
+module Yoda
+  module Evaluation
+    class SignatureDiscovery
+      # @return [Store::Registry]
+      attr_reader :registry
+
+      # @return [String]
+      attr_reader :source
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param registry [Store::Registry]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      def initialize(registry, source, location)
+        @registry = registry
+        @source = source
+        @location = location
+      end
+
+      def valid?
+        !!nearest_send_node
+      end
+
+      # @return [Parsing::NodeObjects::SendNode, nil]
+      def nearest_send_node
+        @nearest_send_node ||= send_nodes_to_current_location.reverse.find { |node| node.on_parameter?(location) }
+      end
+
+      # @return [Array<Parsing::NodeObjects::SendNode>]
+      def send_nodes_to_current_location
+        @send_nodes_to_current_location ||= begin
+          analyzer.nodes_to_current_location_from_root.map do |node|
+            node.type == :send ? Parsing::NodeObjects::SendNode.new(node) : nil
+          end.compact
+        end
+      end
+
+      # @return [String, nil]
+      def index_word
+        nearest_send_node&.selector_name
+      end
+
+      # @return [Model::Types::Base]
+      def receiver_type
+        @receiver_type ||= begin
+          if nearest_send_node
+            evaluator.calculate_type(nearest_send_node.receiver_node)
+          else
+            Model::Types::InstanceType.new(analyzer.namespace_object.path)
+          end
+        end
+      end
+
+      # @return [Array<Store::Objects::MethodObject>]
+      def method_candidates
+        return [] unless valid?
+        receiver_values
+          .map { |value| Store::Query::FindSignature.new(registry).select(value, /\A#{Regexp.escape(index_word)}/) }
+          .flatten
+      end
+
+      private
+
+      # @return [Array<Store::Values::Base>]
+      def receiver_values
+        return [] unless valid?
+        @receiver_values ||= evaluator.calculate_values(nearest_send_node.receiver_node)
+      end
+
+      # @return [SourceAnalyzer]
+      def analyzer
+        @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
+      end
+
+      # @return [Evaluator]
+      def evaluator
+        @evaluator ||= Evaluator.from_ast(registry, analyzer.ast, location)
+      end
+    end
+  end
+end

data/lib/yoda/model.rb

@@ -0,0 +1,12 @@
+module Yoda
+  module Model
+    require 'yoda/model/function_signatures'
+    require 'yoda/model/descriptions'
+    require 'yoda/model/node_signature'
+    require 'yoda/model/path'
+    require 'yoda/model/scoped_path'
+    require 'yoda/model/types'
+    require 'yoda/model/values'
+    require 'yoda/model/completion_item'
+  end
+end

data/lib/yoda/model/completion_item.rb

@@ -0,0 +1,56 @@
+module Yoda
+  module Model
+    class CompletionItem
+      # @return [Descriptions::Base]
+      attr_reader :description
+
+      # @return [Parsing::Range]
+      attr_reader :range
+
+      # @return [Symbol]
+      attr_reader :kind
+
+      # @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)
+        fail ArgumentError, range unless range.is_a?(Parsing::Range)
+        fail ArgumentError, kind if !kind.nil? && !available_kinds.include?(kind)
+        @description = description
+        @range = range
+        @kind = kind
+        @prefix = prefix || ''
+      end
+
+      # @return [String]
+      def edit_text
+        prefix + description.sort_text
+      end
+
+      # @return [Symbol]
+      def available_kinds
+        %i(method class module constant)
+      end
+
+      def language_server_kind
+        case kind
+        when :constant
+          LanguageServer::Protocol::Constant::CompletionItemKind::VALUE
+        when :method
+          LanguageServer::Protocol::Constant::CompletionItemKind::METHOD
+        when :class
+          LanguageServer::Protocol::Constant::CompletionItemKind::CLASS
+        when :module
+          LanguageServer::Protocol::Constant::CompletionItemKind::MODULE
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/descriptions.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module Model
+    module Descriptions
+      require 'yoda/model/descriptions/base'
+      require 'yoda/model/descriptions/function_description'
+      require 'yoda/model/descriptions/value_description'
+      require 'yoda/model/descriptions/word_description'
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Yoda
+  module Model
+    module Descriptions
+      # @abstract
+      class Base
+        # @abstract
+        # @return [String]
+        def title
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def sort_text
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def to_markdown
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Yoda
+  module Model
+    module Descriptions
+      class FunctionDescription < Base
+        # @type Store::Objects::MethodObject
+        attr_reader :function
+
+        # @param function [FunctionSignatures::Base]
+        def initialize(function)
+          fail ArgumentError, function unless function.is_a?(FunctionSignatures::Base)
+          @function = function
+        end
+
+        def title
+          "#{function.namespace_path}#{function.sep}#{function.to_s}"
+        end
+
+        def signature
+          "#{function.to_s}"
+        end
+
+        def sort_text
+          function.name.to_s
+        end
+
+        def parameter_names
+          function.parameters.parameter_names
+        end
+
+        def to_markdown
+          <<~EOS
+          **#{title}**
+
+          #{function.document}
+          EOS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Yoda
+  module Model
+    module Descriptions
+      class ValueDescription < Base
+        # @return [Store::Objects::Base]
+        attr_reader :value
+
+        # @param value [Store::Objects::Base]
+        def initialize(value)
+          @value = value
+        end
+
+        # @return [String]
+        def title
+          "#{value.path}#{value.is_a?(Store::Objects::MetaClassObject) ? '.class' : ''}"
+        end
+
+        # @return [String]
+        def sort_text
+          value.name.to_s
+        end
+
+        def to_markdown
+          <<~EOS
+          **#{title}**
+
+          #{value.document}
+          EOS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Yoda
+  module Model
+    module Descriptions
+      class WordDescription < Base
+        # @return [String]
+        attr_reader :word
+
+        # @param function [String]
+        def initialize(word)
+          @word = word
+        end
+
+        # @return [String]
+        def title
+          word
+        end
+
+        # @return [String]
+        def sort_text
+          word
+        end
+
+        # @return [String]
+        def to_markdown
+          <<~EOS
+          word
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/function_signatures.rb

@@ -0,0 +1,13 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      require 'yoda/model/function_signatures/base'
+      require 'yoda/model/function_signatures/constructor'
+      require 'yoda/model/function_signatures/overload'
+      require 'yoda/model/function_signatures/method'
+      require 'yoda/model/function_signatures/parameter_list'
+      require 'yoda/model/function_signatures/type_builder'
+      require 'yoda/model/function_signatures/formatter'
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      # @abstract
+      class Base
+        # @abstract
+        # @return [Types::FunctionType]
+        def type
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Symbol]
+        def visibility
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def name
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def namespace_path
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def document
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [ParameterList]
+        def parameters
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<(String, Integer, Integer)>]
+        def sources
+          fail NotImplementedError
+        end
+
+        # @return [String]
+        def to_s
+          formatter.to_s
+        end
+
+        # @abstract
+        # @return [Types::Base, nil]
+        def parameter_type_of(param)
+          fail NotImplementedError
+        end
+
+        private
+
+        # @return [Formatter]
+        def formatter
+          @formatter ||= Formatter.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/function_signatures/constructor.rb

@@ -0,0 +1,70 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      # Constructor provides a signature of `YourClass.new` from `initialize` method of the class.
+      class Constructor < Base
+        # @type Store::Objects::MethodObject
+        attr_reader :initialize_method
+
+        # @param namespace [Store::Objects::NamespaceObject]
+        # @param initialize_method [Store::Objects::MethodObject]
+        def initialize(namespace, initialize_method)
+          @namespace = namespace
+          @initialize_method = initialize_method
+        end
+
+        def type
+          type_builder.type
+        end
+
+        def name
+          'new'
+        end
+
+        def visibility
+          :public
+        end
+
+        def sep
+          '.'
+        end
+
+        def namespace_path
+          initialize_method.namespace_path
+        end
+
+        # @return [String]
+        def document
+          initialize_method.document
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def sources
+          initialize_method.sources
+        end
+
+        # @return [ParameterList]
+        def parameters
+          @parameters ||= ParameterList.new(initialize_method.parameters)
+        end
+
+        # @return [(String, Integer, Integer), nil]
+        def primary_source
+          initialize_method.primary_source
+        end
+
+        # @return [Types::Base, nil]
+        def parameter_type_of(param)
+          type_builder.type_of(param)
+        end
+
+        private
+
+        # @return [TypeBuilder]
+        def type_builder
+          @type_builder ||= TypeBuilder.new(parameters, initialize_method.tag_list)
+        end
+      end
+    end
+  end
+end