Introduce Concern#class_methods and Kernel#concern

1 files changed, 44 insertions, 14 deletions

diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index c6863b24a4..07d860b71c 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -1,35 +1,65 @@
 require 'abstract_unit'
 require 'active_support/core_ext/module/concerning'
 
-class ConcerningTest < ActiveSupport::TestCase
-  def test_concern_shortcut_creates_a_module_but_doesnt_include_it
-    mod = Module.new { concern(:Foo) { } }
-    assert_kind_of Module, mod::Foo
-    assert mod::Foo.respond_to?(:included)
-    assert !mod.ancestors.include?(mod::Foo), mod.ancestors.inspect
+class ModuleConcerningTest < ActiveSupport::TestCase
+  def test_concerning_declares_a_concern_and_includes_it_immediately
+    klass = Class.new { concerning(:Foo) { } }
+    assert klass.ancestors.include?(klass::Foo), klass.ancestors.inspect
   end
+end
 
+class ModuleConcernTest < ActiveSupport::TestCase
   def test_concern_creates_a_module_extended_with_active_support_concern
     klass = Class.new do
-      concern :Foo do
+      concern :Baz do
         included { @foo = 1 }
         def should_be_public; end
       end
     end
 
     # Declares a concern but doesn't include it
-    assert_kind_of Module, klass::Foo
-    assert !klass.ancestors.include?(klass::Foo), klass.ancestors.inspect
+    assert klass.const_defined?(:Baz, false)
+    assert !ModuleConcernTest.const_defined?(:Baz)
+    assert_kind_of ActiveSupport::Concern, klass::Baz
+    assert !klass.ancestors.include?(klass::Baz), klass.ancestors.inspect
 
     # Public method visibility by default
-    assert klass::Foo.public_instance_methods.map(&:to_s).include?('should_be_public')
+    assert klass::Baz.public_instance_methods.map(&:to_s).include?('should_be_public')
 
     # Calls included hook
-    assert_equal 1, Class.new { include klass::Foo }.instance_variable_get('@foo')
+    assert_equal 1, Class.new { include klass::Baz }.instance_variable_get('@foo')
   end
 
-  def test_concerning_declares_a_concern_and_includes_it_immediately
-    klass = Class.new { concerning(:Foo) { } }
-    assert klass.ancestors.include?(klass::Foo), klass.ancestors.inspect
+  class Foo
+    concerning :Bar do
+      module ClassMethods
+        def will_be_orphaned; end
+      end
+
+      const_set :ClassMethods, Module.new {
+        def hacked_on; end
+      }
+
+      # Doesn't overwrite existing ClassMethods module.
+      class_methods do
+        def nicer_dsl; end
+      end
+
+      # Doesn't overwrite previous class_methods definitions.
+      class_methods do
+        def doesnt_clobber; end
+      end
+    end
+  end
+
+  def test_using_class_methods_blocks_instead_of_ClassMethods_module
+    assert !Foo.respond_to?(:will_be_orphaned)
+    assert Foo.respond_to?(:hacked_on)
+    assert Foo.respond_to?(:nicer_dsl)
+    assert Foo.respond_to?(:doesnt_clobber)
+
+    # Orphan in Foo::ClassMethods, not Bar::ClassMethods.
+    assert Foo.const_defined?(:ClassMethods)
+    assert Foo::ClassMethods.method_defined?(:will_be_orphaned)
   end
 end