Merge pull request #93 from r7kamura/feature/family

Use more consistent name on Node family API

Author: r7kamura

lib/rucoa/handlers/text_document_document_highlight_handler.rb

@@ -300,7 +300,7 @@ def global_variable_scopable_node
           def nodes
             return [] unless global_variable_scopable_node
 
-            global_variable_scopable_node.each_descendant(:gvar, :gvasgn).select do |node|
+            global_variable_scopable_node.each_descendant_node(:gvar, :gvasgn).select do |node|
               node.name == @node.name
             end
           end
@@ -331,7 +331,7 @@ def instance_variable_scopable_node
           def nodes
             return [] unless instance_variable_scopable_node
 
-            instance_variable_scopable_node.each_descendant(:ivar, :ivasgn).select do |node|
+            instance_variable_scopable_node.each_descendant_node(:ivar, :ivasgn).select do |node|
               node.name == @node.name
             end
           end
@@ -361,7 +361,7 @@ def instance_variable_scopable_node
           def nodes
             return [] unless instance_variable_scopable_node
 
-            instance_variable_scopable_node.each_descendant(:cvar, :cvasgn).select do |node|
+            instance_variable_scopable_node.each_descendant_node(:cvar, :cvasgn).select do |node|
               node.name == @node.name
             end
           end
@@ -410,10 +410,10 @@ def assignment_node
                     end
                     break target if target
                   else
-                    target = node.previous_siblings.reverse.find do |sibling|
+                    target = node.previous_sibling_nodes.reverse.find do |sibling_node|
                       lvasgn_node = [
-                        sibling,
-                        *sibling.descendants
+                        sibling_node,
+                        *sibling_node.descendant_nodes
                       ].reverse.find do |sibling_or_sibling_descendant|
                         case sibling_or_sibling_descendant
                         when Nodes::LvasgnNode
@@ -452,11 +452,11 @@ def reference_nodes
                 [assignment_node] + assignment_node.ancestors.take_while do |node|
                   !SCOPE_BOUNDARY_NODE_TYPES.include?(node.type)
                 end
-              ).flat_map(&:next_siblings)
+              ).flat_map(&:next_sibling_nodes)
             end.flat_map do |node|
               [
                 node,
-                *node.descendants
+                *node.descendant_nodes
               ]
             end.take_while do |node| # FIXME: flat_map and take_while are not correct solution for shadowing.
               case node

lib/rucoa/nodes/base.rb

@@ -25,8 +25,8 @@ def child_nodes
       end
 
       # @return [Array<Rucoa::Nodes::Base>]
-      def descendants
-        each_descendant.to_a
+      def descendant_nodes
+        each_descendant_node.to_a
       end
 
       # @param types [Array<Symbol>]
@@ -58,13 +58,13 @@ def each_child_node(
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_descendant(
+      def each_descendant_node(
         *types,
         &block
       )
         return to_enum(__method__, *types) unless block
 
-        visit_descendants(types, &block)
+        visit_descendant_nodes(types, &block)
         self
       end
 
@@ -150,11 +150,11 @@ def namespace
       #       line: 4
       #     )
       #   )
-      #   expect(node.next_siblings.map(&:name)).to eq(%w[d e])
-      def next_siblings
+      #   expect(node.next_sibling_nodes.map(&:name)).to eq(%w[d e])
+      def next_sibling_nodes
         return [] unless parent
 
-        parent.child_nodes[(sibling_index + 1)..]
+        parent.child_nodes[(sibling_node_index + 1)..]
       end
 
       # @return [Rucoa::Nodes::Base, nil]
@@ -186,11 +186,11 @@ def parent=(node)
       #       line: 4
       #     )
       #   )
-      #   expect(node.previous_siblings.map(&:name)).to eq(%w[a b])
-      def previous_siblings
+      #   expect(node.previous_sibling_nodes.map(&:name)).to eq(%w[a b])
+      def previous_sibling_nodes
         return [] unless parent
 
-        parent.child_nodes[0...sibling_index]
+        parent.child_nodes[0...sibling_node_index]
       end
 
       # @note Override.
@@ -212,23 +212,23 @@ def updated(
 
       protected
 
-      # Visit all descendants.
+      # Visit all descendant_nodes.
       # @param types [Array<Symbol>]
       # @return [void]
-      def visit_descendants(
+      def visit_descendant_nodes(
         types,
         &block
       )
         each_child_node do |child|
           yield(child) if types.empty? || types.include?(child.type)
-          child.visit_descendants(types, &block)
+          child.visit_descendant_nodes(types, &block)
         end
       end
 
       private
 
       # @return [Integer, nil]
-      def sibling_index
+      def sibling_node_index
         parent&.child_nodes&.index do |child|
           child.equal?(self)
         end

lib/rucoa/source.rb

@@ -122,7 +122,7 @@ def parse_result
     def root_and_descendant_nodes
       return [] unless root_node
 
-      [root_node, *root_node.descendants]
+      [root_node, *root_node.descendant_nodes]
     end
 
     # @return [URI]

lib/rucoa/yard/definitions_loader.rb

@@ -35,7 +35,7 @@ def initialize(
       def call
         [
           @root_node,
-          *@root_node.descendants
+          *@root_node.descendant_nodes
         ].flat_map do |node|
           [
             DefinitionGenerators::ClassDefinitionGenerator,