yoda-language-server 0.4.0

data/lib/yoda/parsing/query/current_node_comment_query.rb

@@ -0,0 +1,40 @@
+module Yoda
+  module Parsing
+    module Query
+      class CurrentNodeCommentQuery
+        attr_reader :ast, :comments, :location
+
+        # @param ast      [::Parser::AST::Node]
+        # @param comments [Array<::Parser::Source::Comment>]
+        # @param location [Location]
+        def initialize(comments, location)
+          @ast = ast
+          @comments = comments
+          @location = location
+        end
+
+        # @return [Array<::Parser::Source::Comment>]
+        def current_commenting_node
+          @current_commenting_node ||= inverse_association[current_comment_block]
+        end
+
+        private
+
+        # @return [{::Parser::AST::Node => Array<::Parser::Source::Comment>}]
+        def association
+          @association ||= ::Parser::Source::Comment.associate(ast, comments)
+        end
+
+        # @return [{Array<::Parser::Source::Comment> => ::Parser::AST::Node}]
+        def inverse_association
+          @inverse_association ||= association.invert
+        end
+
+        # @return [{::Parser::Source::Map => Array<::Parser::Source::Comment>]
+        def location_association
+          @location_association ||= ::Parser::Source::Comment.associate_with_location(ast, comments)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/range.rb

@@ -0,0 +1,41 @@
+module Yoda
+  module Parsing
+    class Range
+      attr_reader :begin_location, :end_location
+      # @param begin_location [Integer]
+      # @param end_location   [Integer]
+      def initialize(begin_location, end_location)
+        @begin_location = begin_location
+        @end_location = end_location
+      end
+
+      # @param ast_location [Parser::Source::Map, Parser::Source::Range]
+      # @return [Location, nil]
+      def self.of_ast_location(ast_location)
+        return nil unless Location.valid_location?(ast_location)
+        new(
+          Location.new(row: ast_location.line, column: ast_location.column),
+          Location.new(row: ast_location.last_line, column: ast_location.last_column),
+        )
+      end
+
+      # @return [{Symbol => { Symbol => Integer } }]
+      def to_language_server_protocol_range
+        { start: begin_location.to_language_server_protocol_range, end: end_location.to_language_server_protocol_range }
+      end
+
+      # @param row    [Integer]
+      # @param column [Integer]
+      # @return [Range]
+      def move(row:, column:)
+        self.class.new(begin_location.move(row: row, column: column), end_location.move(row: row, column: column))
+      end
+
+      # @param location [Location]
+      # @return [true, false]
+      def include?(location)
+        begin_location <= location && location <= end_location
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module Parsing
+    module Scopes
+      require 'yoda/parsing/scopes/base'
+      require 'yoda/parsing/scopes/root'
+      require 'yoda/parsing/scopes/method_definition'
+      require 'yoda/parsing/scopes/module_definition'
+      require 'yoda/parsing/scopes/class_definition'
+      require 'yoda/parsing/scopes/meta_method_definition'
+      require 'yoda/parsing/scopes/meta_class_definition'
+
+      require 'yoda/parsing/scopes/builder'
+    end
+  end
+end

data/lib/yoda/parsing/scopes/base.rb

@@ -0,0 +1,78 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Base class for wrapper classes of nodes which create lexical scopes.
+      # @abstract
+      class Base
+        # @return [::Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Namespace, nil]
+        attr_reader :parent
+
+        # @return [Array<Base>]
+        attr_reader :child_scopes
+
+        # @return [Array<MethodDefinition>]
+        attr_reader :method_definitions
+
+        # @param node [::Parser::AST::Node]
+        # @param parent [Base, nil]
+        def initialize(node, parent = nil)
+          fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
+          fail ArgumentError, parent if parent && !parent.is_a?(Base)
+          @node = node
+          @parent = parent
+          @method_definitions = []
+          @child_scopes = []
+        end
+
+        # @abstract
+        # @return [Array<::Parser::AST::Node>]
+        def body_nodes
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [::Parser::AST::Node]
+        def body_node
+          fail NotImplementedError
+        end
+
+        # @param location [Location]
+        # @return [true, false]
+        def inner_location?(location)
+          location.included?(node.location)
+        end
+
+        # @abstract
+        # @return [Symbol]
+        def kind
+          fail NotImplementedError
+        end
+
+        # @return [true, false]
+        def method?
+          false
+        end
+
+        # @param current_location [Location]
+        # @return [Namespace, nil]
+        def find_evaluation_root_scope(current_location)
+          return nil unless inner_location?(current_location)
+          [*child_scopes, *method_definitions].each do |s|
+            if scope = s.find_evaluation_root_scope(current_location)
+              return scope
+            end
+          end
+          return self
+        end
+
+        # @return [Array<String>]
+        def ancestor_scopes
+          [scope_name, *(parent ? parent.ancestor_scopes : [])]
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/builder.rb

@@ -0,0 +1,60 @@
+module Yoda
+  module Parsing
+    module Scopes
+      class Builder
+        # @return [AST::Node]
+        attr_reader :node
+
+        # @param node [AST::Node]
+        def initialize(node)
+          @node = node
+          @root_scope = Root.new(node)
+        end
+
+        # @return [Scope]
+        def root_scope
+          unless @did_build
+            @did_build = true
+            build(node, @root_scope)
+          end
+          @root_scope
+        end
+
+        # @param node [AST::Node]
+        # @param scope [Base]
+        # @return [void]
+        def build(node, scope)
+          return if !node || !node.is_a?(AST::Node)
+          case node.type
+          when :def
+            mscope = MethodDefinition.new(node, scope)
+            scope.method_definitions << mscope
+            mscope.body_nodes.each { |node| build(node, mscope)}
+          when :defs
+            mscope = SingletonMethodDefinition.new(node, scope)
+            scope.method_definitions << mscope
+            mscope.body_nodes.each { |node| build(node, mscope)}
+          when :class
+            cscope = ClassDefinition.new(node, scope)
+            scope.child_scopes << cscope
+            cscope.body_nodes.each { |node| build(node, cscope)}
+          when :sclass
+            cscope = SingletonClassDefinition.new(node, scope)
+            scope.child_scopes << cscope
+            cscope.body_nodes.each { |node| build(node, cscope)}
+          when :module
+            mscope = ModuleDefinition.new(node, scope)
+            scope.child_scopes << mscope
+            mscope.body_nodes.each { |node| build(node, mscope)}
+          when :begin, :kwbegin, :block
+            node.children.each { |node| build(node, scope) }
+          else
+            if node.respond_to?(:children)
+              node.children.map { |node| build(node, scope) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/class_definition.rb

@@ -0,0 +1,47 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Wrapper class for class node.
+      # @see https://github.com/whitequark/parser/blob/2.2/doc/AST_FORMAT.md#class
+      # ```
+      # (class (const nil :Foo) (const nil :Bar) (nil))
+      # "class Foo < Bar; end"
+      #  ~~~~~ keyword    ~~~ end
+      #            ~ operator
+      #  ~~~~~~~~~~~~~~~~~~~~ expression
+      #
+      # (class (const nil :Foo) nil (nil))
+      # "class Foo; end"
+      #  ~~~~~ keyword
+      #             ~~~ end
+      #  ~~~~~~~~~~~~~~ expression
+      # ```
+      class ClassDefinition < Base
+        def const_node
+          @const_node ||= NodeObjects::ConstNode.new(node.children[0])
+        end
+
+        def superclass_const_node
+          @superclass_const_node ||= node.children && NodeObjects::ConstNode.new(node.children[1])
+        end
+
+        def body_nodes
+          [body_node]
+        end
+
+        def body_node
+          node.children.last
+        end
+
+        def kind
+          :class
+        end
+
+        # @return [String]
+        def scope_name
+          const_node.to_s(parent.scope_name)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/meta_class_definition.rb

@@ -0,0 +1,44 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Wrapper class for singleton class node.
+      # @see https://github.com/whitequark/parser/blob/2.2/doc/AST_FORMAT.md#singleton-class
+      # ```
+      # (sclass (lvar :a) (nil))
+      # "class << a; end"
+      #  ~~~~~ keyword
+      #        ~~ operator
+      #              ~~~ end
+      #  ~~~~~~~~~~~~~~~ expression
+      # ```
+      class SingletonClassDefinition < Base
+        def instance_node
+          node.children[0]
+        end
+
+        def body_nodes
+          [body_node]
+        end
+
+        def body_node
+          node.children.last
+        end
+
+        def kind
+          :meta_class
+        end
+
+        # @return [String]
+        def scope_name
+          const_node.to_s(parent.scope_name)
+        end
+
+        # @param current_location [Location]
+        # @return [Namespace, nil]
+        def find_evaluation_root_scope(current_location)
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/meta_method_definition.rb

@@ -0,0 +1,70 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Wrapper class for singleton method node.
+      # @see https://github.com/whitequark/parser/blob/2.2/doc/AST_FORMAT.md#singleton-methods
+      # ```
+      # (defs (self) :foo (args) nil)
+      # "def self.foo; end"
+      #  ~~~ keyword
+      #           ~~~ name
+      #                ~~~ end
+      #  ~~~~~~~~~~~~~~~~~ expression
+      # ```
+      class SingletonMethodDefinition < Base
+        # @return [Symbol]
+        def name
+          node.children[1]
+        end
+
+        # @return [Parser::AST::Node]
+        def arg_node
+          node.children[2]
+        end
+
+        # @return [Parser::AST::Node]
+        def body_node
+          node.children[3]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def body_nodes
+          [body_node]
+        end
+
+        def body_node
+          node.children[3]
+        end
+
+        # @return [String]
+        def full_name
+          "#{namespace.full_name}##{name}"
+        end
+
+        # @return [String]
+        def namespace_name
+          namespace.full_name
+        end
+
+        def kind
+          :meta_method
+        end
+
+        def method?
+          true
+        end
+
+        # @return [String]
+        def scope_name
+          parent.scope_name
+        end
+
+        # @param current_location [Location]
+        # @return [Namespace, nil]
+        def find_evaluation_root_scope(current_location)
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/method_definition.rb

@@ -0,0 +1,69 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Wrapper class for instance method node.
+      # @see https://github.com/whitequark/parser/blob/2.2/doc/AST_FORMAT.md#instance-methods
+      # ```
+      # (def :foo (args) nil)
+      # "def foo; end"
+      #  ~~~ keyword
+      #      ~~~ name
+      #           ~~~ end
+      #  ~~~~~~~~~~~~ expression
+      # ```
+      class MethodDefinition < Base
+        # @return [Symbol]
+        def name
+          node.children[0]
+        end
+
+        # @return [Parser::AST::Node]
+        def arg_node
+          node.children[1]
+        end
+
+        # @return [Parser::AST::Node]
+        def body_node
+          node.children[2]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def body_nodes
+          [body_node]
+        end
+
+        # @return [String]
+        def full_name
+          "#{namespace.full_name}##{name}"
+        end
+
+        # @return [String]
+        def namespace_name
+          namespace.full_name
+        end
+
+        def singleton?
+          false
+        end
+
+        def kind
+          :method
+        end
+
+        def method?
+          true
+        end
+
+        # @return [String]
+        def scope_name
+          parent.scope_name
+        end
+
+        # @return [Array<String>]
+        def ancestor_scopes
+          parent.ancestor_scopes
+        end
+      end
+    end
+  end
+end