Refactor CasgnNode and ConstNode to extract common functionality …

…to `ConstantNode` mixin.

lib/rubocop/ast.rb

@@ -27,6 +27,7 @@
 require_relative 'ast/node/mixin/binary_operator_node'
 require_relative 'ast/node/mixin/collection_node'
 require_relative 'ast/node/mixin/conditional_node'
+require_relative 'ast/node/mixin/constant_node'
 require_relative 'ast/node/mixin/hash_element_node'
 require_relative 'ast/node/mixin/method_dispatch_node'
 require_relative 'ast/node/mixin/modifier_node'

lib/rubocop/ast/node/casgn_node.rb

@@ -6,19 +6,9 @@ module AST
     # This will be used in place of a plain node when the builder constructs
     # the AST, making its methods available to all assignment nodes within RuboCop.
     class CasgnNode < Node
-      # The namespace of the constant being assigned.
-      #
-      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
-      def namespace
-        node_parts[0]
-      end
+      include ConstantNode
 
-      # The name of the variable being assigned as a symbol.
-      #
-      # @return [Symbol] the name of the variable being assigned
-      def name
-        node_parts[1]
-      end
+      alias name short_name
 
       # The expression being assigned to the variable.
       #

lib/rubocop/ast/node/const_node.rb

@@ -4,58 +4,7 @@ module RuboCop
   module AST
     # A node extension for `const` nodes.
     class ConstNode < Node
-      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
-      def namespace
-        children[0]
-      end
-
-      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
-      def short_name
-        children[1]
-      end
-
-      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
-      #                   Note: some classes might have uppercase in which case this method
-      #                         returns false
-      def module_name?
-        short_name.match?(/[[:lower:]]/)
-      end
-      alias class_name? module_name?
-
-      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
-      def absolute?
-        return false unless namespace
-
-        each_path.first.cbase_type?
-      end
-
-      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
-      def relative?
-        !absolute?
-      end
-
-      # Yield nodes for the namespace
-      #
-      #   For `::Foo::Bar::BAZ` => yields:
-      #      s(:cbase), then
-      #      s(:const, :Foo), then
-      #      s(:const, s(:const, :Foo), :Bar)
-      def each_path(&block)
-        return to_enum(__method__) unless block
-
-        descendants = []
-        last = self
-        loop do
-          last = last.children.first
-          break if last.nil?
-
-          descendants << last
-          break unless last.const_type?
-        end
-        descendants.reverse_each(&block)
-
-        self
-      end
+      include ConstantNode
     end
   end
 end

lib/rubocop/ast/node/mixin/constant_node.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that deal with constants:
+    # `const`, `casgn`.
+    module ConstantNode
+      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+      def namespace
+        children[0]
+      end
+
+      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+      def short_name
+        children[1]
+      end
+
+      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+      #                   Note: some classes might have uppercase in which case this method
+      #                         returns false
+      def module_name?
+        short_name.match?(/[[:lower:]]/)
+      end
+      alias class_name? module_name?
+
+      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+      def absolute?
+        return false unless namespace
+
+        each_path.first.cbase_type?
+      end
+
+      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+      def relative?
+        !absolute?
+      end
+
+      # Yield nodes for the namespace
+      #
+      #   For `::Foo::Bar::BAZ` => yields:
+      #      s(:cbase), then
+      #      s(:const, :Foo), then
+      #      s(:const, s(:const, :Foo), :Bar)
+      def each_path(&block)
+        return to_enum(__method__) unless block
+
+        descendants = []
+        last = self
+        loop do
+          last = last.children.first
+          break if last.nil?
+
+          descendants << last
+          break unless last.const_type?
+        end
+        descendants.reverse_each(&block)
+
+        self
+      end
+    end
+  end
+end

spec/rubocop/ast/casgn_node_spec.rb

@@ -43,6 +43,14 @@
     it { is_expected.to eq(:VAR) }
   end
 
+  describe '#short_name' do
+    subject { casgn_node.short_name }
+
+    let(:source) { 'VAR = value' }
+
+    it { is_expected.to eq(:VAR) }
+  end
+
   describe '#expression' do
     include AST::Sexp
 
@@ -52,4 +60,67 @@
 
     it { is_expected.to eq(s(:send, nil, :value)) }
   end
+
+  describe '#module_name?' do
+    context 'with a constant with only uppercase letters' do
+      let(:source) { 'VAR = value' }
+
+      it { expect(casgn_node).not_to be_module_name }
+    end
+
+    context 'with a constant with a lowercase letter' do
+      let(:source) { '::Foo::Bar = value' }
+
+      it { expect(casgn_node).to be_module_name }
+    end
+  end
+
+  describe '#absolute?' do
+    context 'with a constant starting with ::' do
+      let(:source) { '::VAR' }
+
+      it { expect(casgn_node).to be_absolute }
+    end
+
+    context 'with a constant not starting with ::' do
+      let(:source) { 'Foo::Bar::BAZ' }
+
+      it { expect(casgn_node).not_to be_absolute }
+    end
+
+    context 'with a non-namespaced constant' do
+      let(:source) { 'Foo' }
+
+      it { expect(casgn_node).not_to be_absolute }
+    end
+  end
+
+  describe '#relative?' do
+    context 'with a constant starting with ::' do
+      let(:source) { '::VAR' }
+
+      it { expect(casgn_node).not_to be_relative }
+    end
+
+    context 'with a constant not starting with ::' do
+      let(:source) { 'Foo::Bar::BAZ' }
+
+      it { expect(casgn_node).to be_relative }
+    end
+
+    context 'with a non-namespaced constant' do
+      let(:source) { 'Foo' }
+
+      it { expect(casgn_node).to be_relative }
+    end
+  end
+
+  describe '#each_path' do
+    let(:source) { '::Foo::Bar::BAZ = value' }
+
+    it 'yields all parts of the namespace' do
+      expect(casgn_node.each_path.map(&:type)).to eq %i[cbase const const]
+      expect(casgn_node.each_path.to_a.last(2).map(&:short_name)).to eq %i[Foo Bar]
+    end
+  end
 end