Rename to nesting_namespaces

lib/rdoc/code_object/class_module.rb

@@ -298,19 +298,19 @@ def full_name
   ##
   # Return array of full_name splitted by +::+.
 
-  def namespaces
+  def nesting_namespaces
     @namespaces ||= full_name.split("::").reject(&:empty?)
   end
 
   ##
-  # Return array of fully qualified namespaces.
+  # Return array of fully qualified nesting namespaces.
   #
   # For example, if full_name is +A::B::C+, this method returns <code>["A", "A::B", "A::B::C"]</code>
 
-  def fully_qualified_namespaces
-    return namespaces if namespaces.length < 2
-    @fqns ||= namespaces.map.with_index do |_, i|
-      namespaces[0..i].join("::")
+  def fully_qualified_nesting_namespaces
+    return nesting_namespaces if nesting_namespaces.length < 2
+    @fqns ||= nesting_namespaces.map.with_index do |_, i|
+      nesting_namespaces[0..i].join("::")
     end
   end
 

lib/rdoc/generator/darkfish.rb

@@ -350,7 +350,7 @@ def generate_class klass, template_file = nil
     asset_rel_prefix = rel_prefix + @asset_rel_path
     svninfo          = get_svninfo(current)
 
-    breadcrumb = generate_namespaces_breadcrumb(current, rel_prefix)
+    breadcrumb = generate_nesting_namespaces_breadcrumb(current, rel_prefix)
 
     @title = "#{klass.type} #{klass.full_name} - #{@options.title}"
 
@@ -830,18 +830,18 @@ def generate_ancestor_list(ancestors, klass)
 
   private
 
-  def namespaces_to_class_modules klass
+  def nesting_namespaces_to_class_modules klass
     tree = {}
 
-    klass.namespaces.zip(klass.fully_qualified_namespaces) do |ns, fqns|
+    klass.nesting_namespaces.zip(klass.fully_qualified_nesting_namespaces) do |ns, fqns|
       tree[ns] = @store.classes_hash[fqns] || @store.modules_hash[fqns]
     end
 
     tree
   end
 
-  def generate_namespaces_breadcrumb klass, rel_prefix
-    namespaces_to_class_modules(klass).map do |namespace, class_module|
+  def generate_nesting_namespaces_breadcrumb klass, rel_prefix
+    nesting_namespaces_to_class_modules(klass).map do |namespace, class_module|
       path = class_module ? (rel_prefix + class_module.path).to_s : ""
       { name: namespace, path: path, self: klass.full_name == class_module&.full_name }
     end

test/rdoc/test_rdoc_class_module.rb

@@ -1506,26 +1506,26 @@ def test_update_extends_with_colons
     assert_equal [a, c], @c1.extends
   end
 
-  def test_namespaces
+  def test_nesting_namespaces
     cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.namespaces
+    assert_equal ["A"], cm1.nesting_namespaces
 
     cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "B"], cm2.namespaces
+    assert_equal ["A", "B"], cm2.nesting_namespaces
 
     cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "B", "C"], cm3.namespaces
+    assert_equal ["A", "B", "C"], cm3.nesting_namespaces
   end
 
-  def test_fully_qualified_namespaces
+  def test_fully_qualified_nesting_namespaces
     cm1 = RDoc::ClassModule.new "A"
-    assert_equal ["A"], cm1.fully_qualified_namespaces
+    assert_equal ["A"], cm1.fully_qualified_nesting_namespaces
 
     cm2 = RDoc::ClassModule.new "A::B"
-    assert_equal ["A", "A::B"], cm2.fully_qualified_namespaces
+    assert_equal ["A", "A::B"], cm2.fully_qualified_nesting_namespaces
 
     cm3 = RDoc::ClassModule.new "::A::B::C"
-    assert_equal ["A", "A::B", "A::B::C"], cm3.fully_qualified_namespaces
+    assert_equal ["A", "A::B", "A::B::C"], cm3.fully_qualified_nesting_namespaces
   end
 
   class TestRDocClassModuleMixins < XrefTestCase