yoda-language-server 0.7.2 → 0.8.0

data/lib/yoda/ast/literal_node.rb

@@ -0,0 +1,18 @@
+module Yoda
+  module AST
+    class LiteralNode < Node
+      def children
+        []
+      end
+
+      # @return [Object]
+      def value
+        node.children[0]
+      end
+
+      def inspect_content
+        value
+      end
+    end
+  end
+end

data/lib/yoda/ast/method_traversable.rb

@@ -0,0 +1,22 @@
+
+module Yoda
+  module AST
+    module MethodTraversable
+      # @return [true, false]
+      def method?
+        false
+      end
+
+      # @return [Namespace]
+      def including_method
+        @including_method ||= method? ? self : parent.including_method
+      end
+
+      # @param location [Location]
+      # @return [DefNode, DefSingletonNode, nil]
+      def calc_current_location_method(location)
+        positionally_nearest_child(location)&.including_method
+      end
+    end
+  end
+end

data/lib/yoda/ast/module_node.rb

@@ -0,0 +1,17 @@
+module Yoda
+  module AST
+    class ModuleNode < Node
+      include Namespace
+
+      # @return [ConstantNode]
+      def receiver
+        children[0]
+      end
+
+      # @return [Vnode]
+      def body
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/multiple_left_hand_side_node.rb

@@ -0,0 +1,31 @@
+module Yoda
+  module AST
+    class MultipleLeftHandSideNode < Node
+      # @return [Array<Vnode>]
+      def pre_nodes
+        @pre_nodes ||= children.take_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+      end
+
+      # @return [Vnode, nil]
+      def rest_node
+        @rest_node ||= node.children.find { |arg_node| arg_node.type == :restarg }
+      end
+
+      # @return [Array<Vnode>]
+      def post_nodes
+        @post_nodes ||= children.drop_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }.select { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+      end
+
+      # @return [Model::Parameters::Base]
+      def parameter
+        rest_parameter = rest_node&.respond_to?(:parameter) && rest_node.parameter
+
+        Model::Parameters::Multiple.new(
+          parameters: pre_nodes.map(&:parameter),
+          rest_parameter: rest_parameter,
+          post_parameters: post_nodes.map(&:paramter),
+        )
+      end
+    end
+  end
+end

data/lib/yoda/ast/name_vnode.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module AST
+    class NameVnode < Vnode
+      # @return [Symbol]
+      def type
+        :name
+      end
+
+      # @return [Symbol]
+      attr_reader :name
+
+      # @param name [Symbol]
+      def initialize(name, **kwargs)
+        @name = name
+        super(**kwargs)
+      end
+
+      # @return [Array<Node>, nil]
+      def children
+        []
+      end
+
+      def inspect_content
+        name
+      end
+    end
+  end
+end

data/lib/yoda/ast/namespace.rb

@@ -0,0 +1,36 @@
+
+module Yoda
+  module AST
+    module Namespace
+      # @return [true]
+      def root?
+        true
+      end
+
+      # @return [Namespace, nil]
+      def parent_namespace
+        parent&.namespace
+      end
+
+      # @return [Array<Namespace>]
+      def namespace_nestings
+        @namespace_nestings ||= (parent_namespace&.namespace_nestings || []) + [self]
+      end
+
+      # @return [Namespace]
+      def namespace
+        self
+      end
+
+      # @return [true, false]
+      def namespace?
+        true
+      end
+
+      # @return [String]
+      def path
+        fail NotImplementedError
+      end
+    end
+  end
+end

data/lib/yoda/ast/namespace_traversable.rb

@@ -0,0 +1,39 @@
+
+module Yoda
+  module AST
+    module NamespaceTraversable
+      # @return [true, false]
+      def root?
+        false
+      end
+
+      # @return [true, false]
+      def namespace?
+        false
+      end
+
+      # @return [Namespace]
+      def namespace
+        @namespace ||= namespace? ? self : parent.namespace
+      end
+
+      # @return [String]
+      def namespace_path
+        namespace.path
+      end
+
+      # @return [String, Symbol]
+      def full_name
+        return :root if type == :root
+        parent_name = parent && !parent.root? ? parent.full_name : ''
+        const_node ? ConstNode.new(const_node).to_s(parent_name) : parent_name
+      end
+
+      # @param location [Location]
+      # @return [Namespace, nil]
+      def calc_current_location_namespace(location)
+        positionally_nearest_child(location)&.namespace
+      end
+    end
+  end
+end

data/lib/yoda/ast/node.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+
+module Yoda
+  module AST
+    class Node < Vnode
+      extend Forwardable
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @return [Symbol]
+      delegate type: :node
+
+      # @return [String]
+      delegate to_s: :node
+      
+      # @param node [Parser::AST::Node]
+      # @param parent [Vnode]
+      # @param comment_by_node [Hash{Parser::AST::Node => Array<Parser::Source::Comment>}]
+      def initialize(node, parent: nil, comments_by_node: {})
+        @node = node
+        super(parent: parent, comments_by_node: comments_by_node)
+      end
+
+      # @return [Array<Vnode>]
+      def children
+        @children ||= node.children.map(&method(:wrap_child))
+      end
+
+      # @return [String]
+      def identifier
+        "#{type}:#{source_map&.expression ? source_map_expression : object_id}"
+      end
+      
+      # @return [Parser::Source::Map, nil]
+      def source_map
+        node.location
+      end
+
+      # @return [Symbol]
+      def kind
+        node.type
+      end
+
+      private
+
+      def source_map_expression
+        "#{source_map.expression.source_buffer.name}:(#{source_map.line},#{source_map.column})..(#{source_map.last_line},#{source_map.last_column})"
+      end
+    end
+  end
+end

data/lib/yoda/ast/optional_parameter_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class OptionalParameterNode < Node
+      # @return [Node]
+      def content
+        children[0]
+      end
+
+      # @return [Node]
+      def optional_value
+        children[1]
+      end
+
+      # @return [Model::Parameters::Base]
+      def parameter
+        content.present? ? Model::Parameters::Named.new(content.name) : Model::Parameters::Unnamed.new
+      end
+    end
+  end
+end

data/lib/yoda/ast/pair_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class PairNode < Node
+      # @return [Vnode]
+      def key
+        children[0]
+      end
+
+      # @return [Vnode]
+      def value
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/parameter_node.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module AST
+    class ParameterNode < Node
+      # @return [NameVnode, EmptyNode, nil]
+      def content
+        children[0]
+      end
+
+      # @return [Model::Parameters::Base]
+      def parameter
+        content&.present? ? Model::Parameters::Named.new(content.name) : Model::Parameters::Unnamed.new
+      end
+
+      # @return [Model::Parameters::Base]
+      def parameter_root
+        parameter_root_node.parameter
+      end
+
+      # @return [ParametersNode]
+      def parameter_root_node
+        parent.try(:parameter_root_node)
+      end
+    end
+  end
+end

data/lib/yoda/ast/parameters_node.rb

@@ -0,0 +1,62 @@
+module Yoda
+  module AST
+    class ParametersNode < Node
+      # @return [Array<ParameterNode>]
+      def parameter_clauses
+        children
+      end
+
+      # @return [Model::Parameters::Multiple]
+      def parameter
+        Model::Parameters::Multiple.new(
+          parameters: parameter_nodes.map(&:parameter),
+          rest_parameter: rest_parameter_node&.parameter,
+          post_parameters: post_parameter_nodes.map(&:parameter),
+          keyword_parameters: keyword_parameter_nodes.map(&:parameter),
+          keyword_rest_parameter: keyword_rest_parameter_node&.parameter,
+          block_parameter: block_parameter_node&.parameter,
+        )
+      end
+
+      # @return [Array<::AST::Node>]
+      def parameter_nodes
+        @parameter_nodes ||= children.take_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+      end
+
+      # @return [::AST::Node, nil]
+      def rest_parameter_node
+        @rest_parameter_node ||= children.find { |arg_node| arg_node.type == :restarg }
+      end
+
+      # @return [Array<::AST::Node>]
+      def post_parameter_nodes
+        @post_parameter_nodes ||= children.drop_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }.select { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+      end
+
+      # @return [Array<::AST::Node>]
+      def keyword_parameter_nodes
+        @keyword_parameter_nodes ||= children.select { |arg_node| %i(kwarg kwoptarg).include?(arg_node.type) }
+      end
+
+      # @return [::AST::Node, nil]
+      def keyword_rest_parameter_node
+        @keyword_rest_parameter_node ||= children.find { |arg_node| arg_node.type == :kwrestarg }
+      end
+
+      # @return [Node]
+      def block_parameter_node
+        @block_parameter_node ||= children.find { |arg_node| arg_node.type == :blockarg }
+      end
+
+      # @return [Model::Parameters::Base]
+      def parameter_root
+        parameter_root_node.parameter
+      end
+
+      # @return [ParametersNode]
+      def parameter_root_node
+        parent.try(:parameter_root_node) || self
+      end
+    end
+  end
+end

data/lib/yoda/ast/rescue_clause_node.rb

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

data/lib/yoda/ast/rescue_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class RescueNode < Node
+      # @return [Node]
+      def body
+        children[0]
+      end
+
+      # @return [Array<RescueClauseNode>]
+      def rescue_clauses
+        children[1..-2]
+      end
+
+      # @return [Node]
+      def else_clause
+        children[-1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/root_vnode.rb

@@ -0,0 +1,48 @@
+module Yoda
+  module AST
+    class RootVnode < Vnode
+      include Namespace
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param node [Parser::AST::Node]
+      # @param comment_by_node [Hash{Parser::AST::Node => Array<Parser::Source::Comment>}]
+      def initialize(node, comments_by_node: {})
+        @node = node
+        @comments_by_node = comments_by_node
+      end
+
+      # @return [nil]
+      def parent
+        nil
+      end
+
+      # @return [Symbol]
+      def type
+        :root
+      end
+
+      # @return [Vnode]
+      def content
+        @content ||= wrap_child(node)
+      end
+
+      # @return [Array<Vnode>]
+      def children
+        [content]
+      end
+
+      # @return [String]
+      def identifier
+        "#{type}:#{source_map.expression}"
+      end
+      
+      # @return [Parser::Source::Map, nil]
+      def source_map
+        node.location
+      end
+    end
+  end
+end
+

data/lib/yoda/ast/send_node.rb

@@ -0,0 +1,100 @@
+module Yoda
+  module AST
+    class SendNode < Node
+      # @return [Vnode]
+      def receiver
+        children[0]
+      end
+
+      # @return [NameVnode]
+      def selector
+        children[1]
+      end
+
+      # @return [Symbol]
+      def selector_name
+        selector.name
+      end
+
+      # @return [Array<Vnode>]
+      def arguments
+        children.slice(2..-1)
+      end
+
+      # @return [Array<Vnode>]
+      def expanded_arguments
+        block_pass_arguments, arguments_without_block_pass = arguments.partition { |node| node.type == :block_pass }
+        if last_argument = arguments_without_block_pass.last
+          arguments_without_block_pass.slice(0..-2) + (last_argument.type == :hash ? last_argument.children : [last_argument]) + block_pass_arguments
+        else
+          arguments_without_block_pass.slice(0..-2) + block_pass_arguments
+        end
+      end
+
+      def keyword_argument
+        non_bpass_arguments = arguments.reject { |node| node.type == :block_pass }
+        non_bpass_arguments.last&.type == :hash ? non_bpass_arguments.last : nil
+      end
+
+      def block_pass_argument
+        arguments.last.type == :block_pass ? arguments.last : nil
+      end
+
+      def implicit_receiver?
+        receiver.empty?
+      end
+
+      # @return [true, false]
+      def on_selector?(location)
+        source_map.selector ? selector_range.include?(location) : false
+      end
+
+      # @param location [Parsing::Location]
+      # @return [true, false]
+      def on_dot?(location)
+        source_map.dot ? dot_range.include?(location) : false
+      end
+
+      # @param location [Parsing::Location]
+      # @return [true, false]
+      def on_arguments?(location)
+        arguments_range.include?(location)
+      end
+
+      # @return [Parsing::Range]
+      def arguments_range
+        @arguments_range ||=
+          Parsing::Range.new(
+            Parsing::Location.of_ast_location(source_map.selector.end),
+            Parsing::Location.of_ast_location(source_map.expression.end).move(row: 0, column: -1),
+          )
+      end
+
+      # @return [Parsing::Range]
+      def selector_range
+        @selector_range ||= Parsing::Range.of_ast_location(source_map.selector)
+      end
+
+      # @return [Parsing::Range, nil]
+      def dot_range
+        @dot_range ||= source_map.dot && Parsing::Range.of_ast_location(source_map.dot)
+      end
+
+      # @return [Parsing::Location, nil]
+      def next_location_to_dot
+        source_map.dot && Parsing::Range.of_ast_location(source_map.dot).end_location
+      end
+
+      # @return [String]
+      def selector_name
+        selector.name.to_s
+      end
+
+      # @param location [Parsing::Location]
+      # @return [Integer]
+      def offset_in_selector(location)
+        location.offset_from_begin(source_map.selector)[:column]
+      end
+    end
+  end
+end

data/lib/yoda/ast/singleton_class_node.rb

@@ -0,0 +1,17 @@
+module Yoda
+  module AST
+    class SingletonClassNode < Node
+      include Namespace
+
+      # @return [ConstantNode]
+      def receiver
+        children[0]
+      end
+
+      # @return [Vnode]
+      def body
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/special_call_node.rb

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

data/lib/yoda/ast/traversable.rb

@@ -0,0 +1,34 @@
+module Yoda
+  module AST
+    # Add query methods to search expected nodes from AST.
+    # @see {Yoda::Parsing::Traverser::Matcher} for parameters of query methods.
+    # @example
+    #   ast.query(type: :if) # => returns a if node
+    #   ast.query(name: :hoge) # => returns a node about an object with the name
+    module Traversable
+      # @param query [Hash] (See {Yoda::Parsing::Traverser::Matcher.new} for detailed parameters)
+      # @return [Vnode, nil]
+      def query(**query)
+        Parsing::Traverser.new(self).query(**query)&.node
+      end
+
+      # @param query [Hash] (See {Yoda::Parsing::Traverser::Matcher.new} for detailed parameters)
+      # @return [Parsing::Traverser::ResultSet]
+      def query_all(**query)
+        Parsing::Traverser.new(self).query(**query)
+      end
+
+      # @param query [Hash] (See {Yoda::Parsing::Traverser::Matcher.new} for detailed parameters)
+      # @return [Vnode, nil]
+      def query_ancestor(**query)
+        Parsing::Traverser.new(self).query_ancestor(**query)&.node
+      end
+
+      # @param query [Hash] (See {Yoda::Parsing::Traverser::Matcher.new} for detailed parameters)
+      # @return [Parsing::Traverser::ResultSet]
+      def query_ancestors(**query)
+        Parsing::Traverser.new(self).query_ancestors(**query)
+      end
+    end
+  end
+end

data/lib/yoda/ast/value_vnode.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module AST
+    class ValueVnode < Vnode
+      # @return [Symbol]
+      def type
+        :value
+      end
+
+      # @return [Object]
+      attr_reader :value
+
+      # @param value [Object]
+      def initialize(name, **kwargs)
+        @value = value
+        super(**kwargs)
+      end
+
+      # @return [Array<Node>, nil]
+      def children
+        []
+      end
+
+      def inspect_content
+        value
+      end
+    end
+  end
+end

data/lib/yoda/ast/variable_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class VariableNode < Node
+      # @return [NameVnode]
+      def name_clause
+        children[0]
+      end
+
+      # @return [Symbol]
+      def name
+        name_clause.name
+      end
+    end
+  end
+end