yoda-language-server 0.4.0

data/lib/yoda/parsing/node_objects/send_node.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class SendNode
+        attr_reader :node
+
+        # @param node [::Parser::AST::Node]
+        def initialize(node)
+          fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
+          @node = node
+        end
+
+        # @return [true, false]
+        def on_selector?(location)
+          node.location.selector ? selector_range.include?(location) : false
+        end
+
+        # @param location [Location]
+        # @return [true, false]
+        def on_dot?(location)
+          node.location.dot ? dot_range.include?(location) : false
+        end
+
+        # @param location [Location]
+        # @return [true, false]
+        def on_parameter?(location)
+          parameter_range.include?(location)
+        end
+
+        # @return [Range]
+        def parameter_range
+          @parameter_range ||=
+            Range.new(
+              Location.of_ast_location(node.location.selector.end),
+              Location.of_ast_location(node.location.expression.end).move(row: 0, column: -1),
+            )
+        end
+
+        # @return [Range]
+        def selector_range
+          @selector_range ||= Range.of_ast_location(node.location.selector)
+        end
+
+        # @return [Range, nil]
+        def dot_range
+          @dot_range ||= node.location.dot && Range.of_ast_location(node.location.dot)
+        end
+
+        # @return [Location, nil]
+        def next_location_to_dot
+          node.location.dot && Range.of_ast_location(node.location.dot).end_location
+        end
+
+        # @return [Parser::AST::Node, nil]
+        def receiver_node
+          node && node.children[0]
+        end
+
+        # @return [String]
+        def selector_name
+          node.children[1].to_s
+        end
+
+        # @param location [Location]
+        # @return Integer
+        def offset_in_selector(location)
+          location.offset_from_begin(node.location.selector)[:column]
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/parser.rb

@@ -0,0 +1,27 @@
+require 'parser/current'
+
+module Yoda
+  module Parsing
+    class Parser
+      # @param string [String]
+      # @return [::Parser::AST::Node]
+      def parse(string)
+        ::Parser::CurrentRuby.parse(string)
+      end
+
+      # @param string [String]
+      # @return [(::Parser::AST::Node, Array<::Parser::Source::Comment>)]
+      def parse_with_comments(string)
+        ::Parser::CurrentRuby.parse_with_comments(string)
+      end
+
+      # @param string [String]
+      # @return [(::Parser::AST::Node, Array<::Parser::Source::Comment>), nil]
+      def parse_with_comments_if_valid(string)
+        parse_with_comments(source)
+      rescue ::Parser::SyntaxError
+        nil
+      end
+    end
+  end
+end

data/lib/yoda/parsing/query.rb

@@ -0,0 +1,11 @@
+module Yoda
+  module Parsing
+    module Query
+      require 'yoda/parsing/query/current_comment_query'
+      require 'yoda/parsing/query/current_comment_token_query'
+      require 'yoda/parsing/query/current_commenting_node_query'
+      require 'yoda/parsing/query/current_location_node_query'
+      require 'yoda/parsing/query/current_node_comment_query'
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Yoda
+  module Parsing
+    module Query
+      # Provides helper methods to find the current comment which means the comment on the current position.
+      class CurrentCommentQuery
+        attr_reader :comments, :location
+
+        # @param comments [Array<::Parser::Source::Comment>]
+        # @param location [Location] represents the current position.
+        def initialize(comments, location)
+          fail ArgumentError, comments unless comments.all? { |comment| comment.is_a?(::Parser::Source::Comment) }
+          fail ArgumentError, location unless location.is_a?(Location)
+          @comments = comments
+          @location = location
+        end
+
+        # The single line comment which the current position is on.
+        # @return [::Parser::Source::Comment, nil]
+        def current_comment
+          @current_comment ||= comments.find { |comment| location.included?(comment.location) }
+        end
+
+        # The multiple line comments which the current position is on.
+        # @return [Array<::Parser::Source::Comment>]
+        def current_comment_block
+          @current_comment_block ||= current_comment ? comment_blocks.find { |block| block.include?(current_comment) } : []
+        end
+
+        # The relative coordinates of the current position from the beginning position of the current comment.
+        # @return [Location]
+        def location_in_current_comment_block
+          relative_position(location)
+        end
+
+        # @return [Location]
+        def begin_point_of_current_comment_block
+          Location.new(row: current_comment_block.first.location.line, column: current_comment_block.first.location.column)
+        end
+
+        # @group Coordinate conversion
+
+        # Calculate relative position (the coordinates from the beginning point) from the relative position.
+        # @param position [Location]
+        def relative_position(position)
+          position.move(row: 1 - current_comment_block.first.location.line, column: - current_comment_block.first.location.column)
+        end
+
+        # Calculate absolute position from the relative position.
+        # @param position [Location]
+        def absolute_position(position)
+          position.move(row: current_comment_block.first.location.line - 1, column: current_comment_block.first.location.column)
+        end
+
+        # Calculate relative range from the relative range.
+        # @param range [Range]
+        def relative_range(range)
+          range.move(row: 1 - current_comment_block.first.location.line, column: - current_comment_block.first.location.column)
+        end
+
+        # Calculate absolute range from the relative range.
+        # @param range [Range]
+        def absolute_range(range)
+          range.move(row: current_comment_block.first.location.line - 1, column: current_comment_block.first.location.column)
+        end
+
+        # @return [String]
+        def current_comment_block_text
+          current_comment_block.map(&:text).join("\n")
+        end
+
+        private
+
+        # @return [Array<Array<::Parser::Source::Comment>>]
+        def comment_blocks
+          @comment_blocks ||= comments.chunk_while { |i, j| i.location.line + 1 == j.location.line }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+module Yoda
+  module Parsing
+    module Query
+      # Provides helper methods to find the current comment token (token on current position) and its kind.
+      class CurrentCommentTokenQuery
+        attr_reader :comment, :location_in_comment
+
+        # @param comment [String]
+        # @param location_in_comment [Location] represents relative coordinates of the current position from the beginning position of the current comment.
+        def initialize(comment, location_in_comment)
+          fail ArgumentError, comment unless comment.is_a?(String)
+          fail ArgumentError, location_in_comment unless location_in_comment.is_a?(Location)
+          @comment = comment
+          @location_in_comment = location_in_comment
+        end
+
+        # @return [String]
+        def current_line_comment
+          comment.split("\n")[location_in_comment.row - 1] || ''
+        end
+
+        # @return [Symbol]
+        def current_state
+          return :none unless inputting_line
+          inputting_line.current_state
+        end
+
+        # @return [String, nil]
+        def current_word
+          return nil unless inputting_line
+          inputting_line.current_token.to_s
+        end
+
+        # @return [Range, nil]
+        def current_range
+          return nil if !inputting_line || !inputting_line.current_range
+          start, last = inputting_line.current_range
+          Range.new(Location.new(row: location_in_comment.row, column: start), Location.new(row: location_in_comment.row, column: last))
+        end
+
+        # @return [true, false]
+        def at_sign?
+          inputting_line.at_sign?
+        end
+
+        private
+
+        # @return [CommentTokenizer::Sequence, nil]
+        def tokenize
+          return @tokenize if instance_variable_defined?(:@tokenized)
+          @tokenize = CommentTokenizer.new.parse(line_to_current_position)
+        rescue Parslet::ParseFailed
+          @tokenize = nil
+        end
+
+        # @return [String]
+        def line_to_current_position
+          current_line_comment.slice(0...location_in_comment.column)
+        end
+
+        # @return [InputtingLine, nil]
+        def inputting_line
+          return nil unless tokenize
+          @inputting_line ||= InputtingLine.new(tokenize, location_in_comment.column)
+        end
+
+        class InputtingLine
+          # @type CommentTokenizer::Sequence
+          attr_reader :token_sequence
+
+          # @type Integer
+          attr_reader :column
+
+          # @param token_sequence [CommentTokenizer::Sequence]
+          # @param column   [Integer]
+          def initialize(token_sequence, column)
+            @token_sequence = token_sequence
+            @column = column
+          end
+
+          # @return [Parslet::Slice, nil]
+          def tag
+            token_sequence.tag
+          end
+
+          # @return [(Integer, Integer), nil]
+          def current_range
+            return nil unless current_token
+            [current_token.offset, current_token.offset + current_token.size]
+          end
+
+          # @return [Parslet::Slice, nil]
+          def current_token
+            @current_token ||= token_sequence.all_tokens.find { |token| token.offset <= column && column <= token.offset + token.size }
+          end
+
+          # @return [Symbol]
+          def current_state
+            @current_state ||= begin
+              if tag && %w(@type @!sig).include?(tag.to_s) && !on_tag?
+                :type_tag_type
+              elsif tag && token_sequence.parameter_tokens.empty?
+                :tag
+              elsif in_bracket?
+                :type
+              elsif at_parameter_name?
+                :param
+              else
+                :none
+              end
+            end
+          end
+
+          # @return [true, false]
+          def at_sign?
+            current_token &&
+            current_token.to_s.match?(/\A[{}.&\]\[\(\)<>]/) &&
+            column == current_token.offset + current_token.size
+          end
+
+          private
+
+          # @return [Boolean]
+          def on_tag?
+            tag && tag.offset <= column && column <= tag.offset + tag.size
+          end
+
+          # @return [Boolean]
+          def at_parameter_name?
+            case token_sequence.parameter_tokens.length
+            when 0
+              # TODO
+              false
+            when 1
+              tag && %w(@param).include?(tag.to_s)
+            else
+              false
+            end
+          end
+
+          # @return [Boolean]
+          def in_bracket?
+            token_sequence.parameter_tokens.reverse_each do |token|
+              return false if token.to_s == ']'
+              return true if token.to_s == '['
+            end
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Yoda
+  module Parsing
+    module Query
+      # Provides helper methods to find the node whose comment include the current position (is the current comment).
+      class CurrentCommentingNodeQuery
+        attr_reader :ast, :comments, :location
+
+        # @param ast      [::Parser::AST::Node]
+        # @param comments [Array<::Parser::Source::Comment>]
+        # @param location [Location] represents the current position.
+        def initialize(ast, comments, location)
+          fail ArgumentError, ast unless ast.is_a?(::Parser::AST::Node)
+          fail ArgumentError, comments unless comments.all? { |comment| comment.is_a?(::Parser::Source::Comment) }
+          fail ArgumentError, location unless location.is_a?(Location)
+          @ast = ast
+          @comments = comments
+          @location = location
+        end
+
+        # @return [Array<::Parser::Source::Comment>]
+        def current_commenting_node
+          @current_commenting_node ||= inverse_association[current_comment_query.current_comment_block]
+        end
+
+        # @return [NodeObjects::Namespace, nil]
+        def current_namespace
+          @current_namespace ||= namespace.calc_current_location_namespace(current_commenting_node_location)
+        end
+
+        # @return [NodeObjects::MethodDefition, nil]
+        def current_method_definition
+          @current_method_definition ||= namespace.calc_current_location_method(current_commenting_node_location)
+        end
+
+        private
+
+        def current_commenting_node_location
+          @current_commenting_node_location ||= Location.of_ast_location(current_commenting_node.location)
+        end
+
+        # @return [Namespace]
+        def namespace
+          @namespace ||= NodeObjects::Namespace.new(ast)
+        end
+
+        # @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
+
+        # @return [CurrentCommentQuery]
+        def current_comment_query
+          @current_comment_query ||= CurrentCommentQuery.new(comments, location)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Yoda
+  module Parsing
+    module Query
+      class CurrentLocationQuery
+        attr_reader :ast, :location
+
+        # @param ast      [::Parser::AST::Node]
+        # @param location [Location]
+        def initialize(ast, location)
+          @ast = ast
+          @location = location
+        end
+
+        # @return [NodeObjects::Namespace, nil]
+        def current_namespace
+          @current_namespace ||= namespace.calc_current_location_namespace(location)
+        end
+
+        # @return [NodeObjects::MethodDefition, nil]
+        def current_method_definition
+          @current_method_definition ||= namespace.calc_current_location_method(location)
+        end
+
+        private
+
+        # @return [Namespace]
+        def namespace
+          @namespace ||= NodeObjects::Namespace.new(self.ast)
+        end
+
+        # @return [Array<::Parser::AST::Node>]
+        def nodes_to_current_location_from_root
+          @nodes_to_current_location ||= calc_nodes_to_current_location(ast, location)
+        end
+
+        # @param root_node [Array<::Parser::AST::Node>]
+        # @param current_location [Parser::Source::Map]
+        # @return [Array<::Parser::AST::Node>]
+        def calc_nodes_to_current_location(root_node, current_location)
+          nodes = []
+          node = root_node
+          while node && !node.children.empty?
+            nodes << node
+            node = node.children.find { |n| n.respond_to?(:location) && current_location.included?(n.location) }
+          end
+          nodes
+        end
+      end
+    end
+  end
+end