yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/ast/comment_block/range_calculation.rb

@@ -0,0 +1,58 @@
+module Yoda
+  module AST
+    class CommentBlock
+      # @abstract
+      module RangeCalculation
+        # @!method comment_block
+        #   @abstract
+        #   @return [CommentBlock]
+
+        # @abstract
+        # @return [Integer]
+        def begin_index
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Integer]
+        def end_index
+          fail NotImplementedError
+        end
+
+        # @return [Parsing::Location, nil]
+        def begin_location
+          @begin_location ||= comment_block.location_from_index(begin_index)
+        end
+
+        # @return [Parsing::Location, nil]
+        def end_location
+          @end_location ||= comment_block.location_from_index(end_index)
+        end
+
+        # @return [Parsing::Range, nil]
+        def range
+          if begin_location && end_location
+            Parsing::Range.new(begin_location, end_location)
+          else
+            nil
+          end
+        end
+
+        # @return [String, nil]
+        def text
+          if begin_location && end_location
+            comment_block.text.slice(Range.new(begin_index, end_index))
+          else
+            nil
+          end
+        end
+
+        # @param location [Parsing::Location]
+        # @return [Boolean]
+        def include?(location)
+          range&.include?(location)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/tag_part.rb

@@ -0,0 +1,88 @@
+module Yoda
+  module AST
+    class CommentBlock
+      class TagPart < BasePart
+        # @return [CommentBlock]
+        attr_reader :comment_block
+
+        # @return [Parsing::CommentTokenizer::Sequence]
+        attr_reader :token
+
+        # @param comment_block [CommentBlock]
+        # @param token [Parsing::CommentTokenizer::Sequence]
+        def initialize(comment_block:, token:)
+          @comment_block = comment_block
+          @token = token
+        end
+
+        # @return [Integer]
+        def begin_index
+          token.all_tokens.first.offset
+        end
+
+        # @return [Integer]
+        def end_index
+          last_token = token.all_tokens.last
+          last_token.offset + last_token.length
+        end
+
+        # @return [TagTextTypePart, nil]
+        def type_part
+          return nil if tokens_in_bracket.empty?
+          @type_part ||= begin
+            TagTextTypePart.new(parent: self, tokens: tokens_in_bracket)
+          end
+        end
+
+        # @return [TagTextNamePart, nil]
+        def name_part
+          @name_part ||= begin
+            if tokens_before_bracket.empty?
+              if tokens_after_bracket.empty?
+                nil
+              else
+                TagTextNamePart.new(parent: self, tokens: [tokens_after_bracket.first])
+              end
+            else
+              TagTextNamePart.new(parent: self, tokens: tokens_before_bracket)
+            end
+          end
+        end
+
+        # @param location [Parsing::Location]
+        # @return [BasePart]
+        def nearest_part(location)
+          [type_part, name_part, self].compact.find { |part| part.range.include?(location) }
+        end
+
+        private
+
+        # @return [Array<Parslet::Slice>]
+        def tokens_in_bracket
+          @tokens_in_bracket ||= begin
+            tokens_from_bracket = token.all_tokens.drop_while { |token| token.to_s != "[" }
+            tokens = tokens_from_bracket.slice_after { |token| token.to_s == "]" }.first
+
+            tokens&.last&.to_s == "]" ? tokens : []
+          end
+        end
+
+        # @return [Array<Parslet::Slice>]
+        def tokens_before_bracket
+          @tokens_before_bracket ||= begin
+            tokens = token.all_tokens.take_while { |token| token.to_s != "[" }
+            tokens.length != token.all_tokens ? tokens : []
+          end
+        end
+
+        # @return [Array<Parslet::Slice>]
+        def tokens_after_bracket
+          @tokens_after_bracket ||= begin
+            tokens_after_left_bracket = token.all_tokens.drop_while { |token| token.to_s != "[" }.slice(1..)
+            tokens_after_left_bracket.drop_while { |token| token.to_s != "]" }.slice(1..)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/tag_text_name_part.rb

@@ -0,0 +1,35 @@
+module Yoda
+  module AST
+    class CommentBlock
+      class TagTextNamePart < BasePart
+        # @return [BasePart]
+        attr_reader :parent
+
+        # @return [Array<Parslet::Slice>]
+        attr_reader :tokens
+
+        # @param parent [BasePart]
+        # @param tokens [Array<Parslet::Slice>]
+        def initialize(parent:, tokens:)
+          @parent = parent
+          @tokens = tokens
+        end
+
+        # @return [CommentBlock]
+        def comment_block
+          parent.comment_block
+        end
+
+        # @return [Integer]
+        def begin_index
+          tokens.first.offset
+        end
+
+        # @return [Integer]
+        def end_index
+          tokens.last.offset + tokens.last.length
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/tag_text_type_part.rb

@@ -0,0 +1,52 @@
+module Yoda
+  module AST
+    class CommentBlock
+      class TagTextTypePart < BasePart
+        # @return [BasePart]
+        attr_reader :parent
+
+        # @return [Array<Parslet::Slice>]
+        attr_reader :tokens
+
+        # @param parent [BasePart]
+        # @param tokens [Array<Parslet::Slice>]
+        def initialize(parent:, tokens:)
+          @parent = parent
+          @tokens = tokens
+        end
+
+        # @return [CommentBlock]
+        def comment_block
+          parent.comment_block
+        end
+
+        # @return [Integer]
+        def begin_index
+          tokens.first.offset
+        end
+
+        # @return [Integer]
+        def end_index
+          tokens.last.offset + tokens.last.length
+        end
+
+        # @return [Array<Token>]
+        def type_tokens
+          @type_tokens ||= tokens.slice(1..-2).map { |token| Token.from_parslet(token, comment_block: comment_block) }
+        end
+
+        # @param location [Parsing::Location]
+        # @return [Token, nil]
+        def nearest_token(location)
+          type_tokens.find { |token| token.include?(location) }
+        end
+
+        private
+
+        def type_text
+          text.slice(1..-2)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/text_part.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module AST
+    class CommentBlock
+      class TextPart < BasePart
+        # @return [CommentBlock]
+        attr_reader :comment_block
+
+        # @return [Parsing::CommentTokenizer::Text]
+        attr_reader :token
+
+        # @param comment_block [CommentBlock]
+        # @param token [Parsing::CommentTokenizer::Text]
+        def initialize(comment_block:, token:)
+          @comment_block = comment_block
+          @token = token
+        end
+
+        def begin_index
+          token.content.offset
+        end
+
+        def end_index
+          token.content.offset + token.content.length
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/token.rb

@@ -0,0 +1,44 @@
+require 'yoda/ast/comment_block/range_calculation'
+
+module Yoda
+  module AST
+    class CommentBlock
+      class Token
+        # @param slice [Parslet::Slice]
+        # @param comment_block [CommentBlock]
+        # @return [CommentBlock::Slice]
+        def self.from_parslet(slice, comment_block:)
+          begin_location = comment_block.location_from_index(slice.offset)
+          end_location = comment_block.location_from_index(slice.offset + slice.length)
+
+          range = if begin_location && end_location
+            Parsing::Range.new(begin_location, end_location)
+          else
+            nil
+          end
+
+          new(slice.to_s, range: range)
+        end
+
+        # @return [String]
+        attr_reader :content
+
+        # @return [Parsing::Range, nil]
+        attr_reader :range
+
+        # @param content [String]
+        # @param range [Parsing::Range, nil]
+        def initialize(content, range:)
+          @content = content
+          @range = range
+        end
+
+        # @param location [Parsing::Location]
+        # @return [Boolean]
+        def include?(location)
+          range&.include?(location)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block.rb

@@ -0,0 +1,119 @@
+module Yoda
+  module AST
+    class CommentBlock
+      require 'yoda/ast/comment_block/base_part'
+      require 'yoda/ast/comment_block/range_calculation'
+      require 'yoda/ast/comment_block/tag_part'
+      require 'yoda/ast/comment_block/tag_text_name_part'
+      require 'yoda/ast/comment_block/tag_text_type_part'
+      require 'yoda/ast/comment_block/text_part'
+      require 'yoda/ast/comment_block/token'
+
+      # @param comment_block [CommentBlock]
+      # @param token [Parsing::CommentTokenizer::Sequence, Parsing::CommentTokenizer::Text]
+      # @return [BasePart]
+      def self.build_part(comment_block:, token:)
+        case token
+        when Parsing::CommentTokenizer::Sequence
+          TagPart.new(comment_block: comment_block, token: token)
+        when Parsing::CommentTokenizer::Text
+          TextPart.new(comment_block: comment_block, token: token)
+        else
+          fail "unexpected"
+        end
+      end
+
+      # @return [Array<::Parser::Source::Comment>]
+      attr_reader :comments
+
+      # @return [Vnode]
+      attr_reader :node
+
+      # @param comments [Array<::Parser::Source::Comment>]
+      # @param node [Vnode]
+      def initialize(comments, node: nil)
+        @comments = Array(comments)
+        @node = node
+      end
+
+      # @return [String]
+      def text
+        comments.map(&:text).join
+      end
+
+      # @return [Array<BasePart>]
+      def parts
+        @parts ||= parsed_tokens.map do |token|
+          build_part(token)
+        end
+      end
+
+      # @param location [Parsing::Location]
+      # @return [BasePart, nil]
+      def nearest_part(location)
+        parts.find { |part| part.include?(location) }
+      end
+
+      # @param location [Parsing::Location]
+      # @return [TagPart, nil]
+      def nearest_tag_part(location)
+        part = nearest_part(location)
+        part&.is_a?(TagPart) ? part : nil
+      end
+
+      # @param index [Integer]
+      # @return [Parsing::Location, nil]
+      def location_from_index(index)
+        partial_text = text.slice(::Range.new(0, index))
+        *lines_before, curent_line = partial_text.split("\n", -1)
+        begin_location&.move(row: lines_before.length, column: curent_line&.length || 0)
+      end
+
+      # @param location [Parsing::Location]
+      # @return [Integer, nil]
+      def offset_from_location(location)
+        if begin_location
+          row_diff = location.row - begin_location.row
+          column_diff = location.column - begin_location.column
+
+          lines = text.split("\n", -1)
+          lines.slice(0, row_diff).join("\n").length + column_diff
+        end
+      end
+
+      # @param token [Parsing::CommentTokenizer::Sequence, String]
+      # @return [BasePart]
+      def build_part(token)
+        self.class.build_part(comment_block: self, token: token)
+      end
+
+      # @return [Parsing::Location, nil]
+      def begin_location
+        return nil unless Parsing::Location.valid_location?(comments.first.location)
+        Parsing::Location.new(row: comments.first.location.line, column: comments.first.location.column)
+      end
+
+      # @return [Parsing::Location, nil]
+      def end_location
+        return nil unless Parsing::Location.valid_location?(comments.last.location)
+        Parsing::Location.new(row: comments.last.location.last_line, column: comments.last.location.last_column)
+      end
+
+      # @return [Parsing::Range, nil]
+      def range
+        if begin_location && end_location
+          Parsing::Range.new(begin_location, end_location)
+        else
+          nil
+        end
+      end
+
+      private
+
+      # @return [Array<String, Parsing::CommentTokenizer::Sequence>]
+      def parsed_tokens
+        @parsed_tokens ||= Parsing::CommentTokenizer.new.parse(text)
+      end
+    end
+  end
+end

data/lib/yoda/ast/conditional_loop_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class ConditionalLoopNode < Node
+      # @return [Node]
+      def condition
+        children[0]
+      end
+
+      # @return [Node]
+      def body
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/constant_assignment_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class ConstantAssignmentNode < Node
+      # @return [Node]
+      def assignee_base
+        children[0]
+      end
+
+      # @return [Node]
+      def assignee_name
+        children[1]
+      end
+
+      # @return [Node]
+      def content
+        children[2]
+      end
+    end
+  end
+end

data/lib/yoda/ast/constant_base_node.rb

@@ -0,0 +1,42 @@
+module Yoda
+  module AST
+    class ConstantBaseNode < Node
+      # @return [Vnode, nil]
+      def base
+        nil
+      end
+
+      # @return [true, false]
+      def absolute?
+        true
+      end
+
+      # @return [true, false]
+      def constant_base?
+        true
+      end
+
+      def constant?
+        true
+      end
+
+      # @param location [Location]
+      # @return [true, false]
+      def just_after_separator?(location)
+        return false unless node.location.double_colon
+        location == Location.of_ast_location(node.location.double_colon.end)
+      end
+
+      # @return [Model::Path]
+      def path
+        Model::Path.new(path_name)
+      end
+
+      # @param base [String, Symbol, nil]
+      # @return [String]
+      def path_name(base = nil)
+        '::'
+      end
+    end
+  end
+end

data/lib/yoda/ast/constant_node.rb

@@ -0,0 +1,53 @@
+module Yoda
+  module AST
+    class ConstantNode < Node
+      # @return [Vnode]
+      def base
+        children[0]
+      end
+
+      # @return [Vnode]
+      def name
+        children[1]
+      end
+
+      # @return [true, false]
+      def absolute?
+        base.absolute?
+      end
+
+      # @return [true, false]
+      def constant_base?
+        false
+      end
+
+      def constant?
+        true
+      end
+
+      # @param location [Parsing::Location]
+      # @return [true, false]
+      def just_after_separator?(location)
+        return false unless source_map.double_colon
+        location == Parsing::Location.of_ast_location(source_map.double_colon.end)
+      end
+
+      # @return [Model::Path]
+      def path
+        Model::Path.new(path_name)
+      end
+
+      # @param base [String, Symbol, nil]
+      # @return [String]
+      def path_name(base = nil)
+        if base.nil? || base.empty?
+          name.name.to_s
+        elsif base.constant_base?
+          "#{base.path_name}#{name.name}"
+        else
+          "#{base.path_name}::#{name.name}"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/ast/def_node.rb

@@ -0,0 +1,27 @@
+module Yoda
+  module AST
+    class DefNode < Node
+      # @return [Symbol]
+      delegate name: :name_clause
+
+      # @return [NameVnode]
+      def name_clause
+        children[0]
+      end
+
+      # @return [ParmetersNode]
+      def parameters
+        children[1]
+      end
+
+      # @return [Vnode]
+      def body
+        children[2]
+      end
+
+      def method?
+        true
+      end
+    end
+  end
+end

data/lib/yoda/ast/def_singleton_node.rb

@@ -0,0 +1,32 @@
+module Yoda
+  module AST
+    class DefSingletonNode < Node
+      # @return [Symbol]
+      delegate name: :name_clause
+
+      # @return [Vnode]
+      def receiver
+        children[0]
+      end
+
+      # @return [NameVnode]
+      def name_clause
+        children[1]
+      end
+
+      # @return [ParametersNode]
+      def parameters
+        children[2]
+      end
+
+      # @return [Vnode]
+      def body
+        children[3]
+      end
+
+      def method?
+        true
+      end
+    end
+  end
+end

data/lib/yoda/ast/empty_vnode.rb

@@ -0,0 +1,24 @@
+module Yoda
+  module AST
+    class EmptyVnode < Vnode
+      def initialize(_el = nil, **kwargs)
+        super(**kwargs)
+      end
+
+      # @return [Symbol]
+      def type
+        :empty
+      end
+
+      # @return [Array<Node>, nil]
+      def children
+        []
+      end
+
+      # @return [boolean]
+      def empty?
+        true
+      end
+    end
+  end
+end

data/lib/yoda/ast/ensure_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class EnsureNode < Node
+      # @return [Node]
+      def body
+        children[0]
+      end
+
+      # @return [Node]
+      def ensure_body
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/for_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class IfNode < Node
+      # @return [Node]
+      def assignee
+        children[0]
+      end
+
+      # @return [Node]
+      def collection
+        children[1]
+      end
+
+      # @return [Node]
+      def body
+        children[2]
+      end
+    end
+  end
+end

data/lib/yoda/ast/hash_node.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module AST
+    class HashNode < Node
+      # @return [Array<Vnode>]
+      def contents
+        children
+      end
+    end
+  end
+end