Convert Module aliasing and introspection extension modules to class reopen

3 files changed, 142 insertions, 149 deletions

diff --git a/activesupport/lib/active_support/core_ext/module.rb b/activesupport/lib/active_support/core_ext/module.rb
index da8d28ec13..f35a554364 100644
--- a/activesupport/lib/active_support/core_ext/module.rb
+++ b/activesupport/lib/active_support/core_ext/module.rb
@@ -1,11 +1,12 @@
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/introspection'
+
 require 'active_support/core_ext/module/inclusion'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/attr_internal'
 require 'active_support/core_ext/module/attr_accessor_with_default'
 require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/loading'
-require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/model_naming'
 require 'active_support/core_ext/module/synchronization'
 
diff --git a/activesupport/lib/active_support/core_ext/module/aliasing.rb b/activesupport/lib/active_support/core_ext/module/aliasing.rb
index 10fa520ba1..3cad164148 100644
--- a/activesupport/lib/active_support/core_ext/module/aliasing.rb
+++ b/activesupport/lib/active_support/core_ext/module/aliasing.rb
@@ -1,74 +1,70 @@
-module ActiveSupport
-  module CoreExtensions
-    module Module
-      # Encapsulates the common pattern of:
-      #
-      #   alias_method :foo_without_feature, :foo
-      #   alias_method :foo, :foo_with_feature
-      #
-      # With this, you simply do:
-      #
-      #   alias_method_chain :foo, :feature
-      #
-      # And both aliases are set up for you.
-      #
-      # Query and bang methods (foo?, foo!) keep the same punctuation:
-      #
-      #   alias_method_chain :foo?, :feature
-      #
-      # is equivalent to
-      #
-      #   alias_method :foo_without_feature?, :foo?
-      #   alias_method :foo?, :foo_with_feature?
-      #
-      # so you can safely chain foo, foo?, and foo! with the same feature.
-      def alias_method_chain(target, feature)
-        # Strip out punctuation on predicates or bang methods since
-        # e.g. target?_without_feature is not a valid method name.
-        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-        yield(aliased_target, punctuation) if block_given?
+class Module
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  #
+  # Query and bang methods (foo?, foo!) keep the same punctuation:
+  #
+  #   alias_method_chain :foo?, :feature
+  #
+  # is equivalent to
+  #
+  #   alias_method :foo_without_feature?, :foo?
+  #   alias_method :foo?, :foo_with_feature?
+  #
+  # so you can safely chain foo, foo?, and foo! with the same feature.
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
 
-        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
 
-        alias_method without_method, target
-        alias_method target, with_method
+    alias_method without_method, target
+    alias_method target, with_method
 
-        case
-          when public_method_defined?(without_method)
-            public target
-          when protected_method_defined?(without_method)
-            protected target
-          when private_method_defined?(without_method)
-            private target
-        end
-      end
-
-      # Allows you to make aliases for attributes, which includes
-      # getter, setter, and query methods.
-      #
-      # Example:
-      #
-      #   class Content < ActiveRecord::Base
-      #     # has a title attribute
-      #   end
-      #
-      #   class Email < Content
-      #     alias_attribute :subject, :title
-      #   end
-      #
-      #   e = Email.find(1)
-      #   e.title    # => "Superstars"
-      #   e.subject  # => "Superstars"
-      #   e.subject? # => true
-      #   e.subject = "Megastars"
-      #   e.title    # => "Megastars"
-      def alias_attribute(new_name, old_name)
-        module_eval <<-STR, __FILE__, __LINE__+1
-          def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
-          def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
-          def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
-        STR
-      end
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
     end
   end
+
+  # Allows you to make aliases for attributes, which includes
+  # getter, setter, and query methods.
+  #
+  # Example:
+  #
+  #   class Content < ActiveRecord::Base
+  #     # has a title attribute
+  #   end
+  #
+  #   class Email < Content
+  #     alias_attribute :subject, :title
+  #   end
+  #
+  #   e = Email.find(1)
+  #   e.title    # => "Superstars"
+  #   e.subject  # => "Superstars"
+  #   e.subject? # => true
+  #   e.subject = "Megastars"
+  #   e.title    # => "Megastars"
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__+1
+      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
+      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
+      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
+    STR
+  end
 end
diff --git a/activesupport/lib/active_support/core_ext/module/introspection.rb b/activesupport/lib/active_support/core_ext/module/introspection.rb
index 8beaff4b82..7708d573fa 100644
--- a/activesupport/lib/active_support/core_ext/module/introspection.rb
+++ b/activesupport/lib/active_support/core_ext/module/introspection.rb
@@ -1,90 +1,86 @@
-module ActiveSupport
-  module CoreExtensions
-    module Module
-      # Returns the name of the module containing this one.
-      #
-      #   p M::N.parent_name # => "M"
-      def parent_name
-        unless defined? @parent_name
-          @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
-        end
-        @parent_name
-      end
+class Module
+  # Returns the name of the module containing this one.
+  #
+  #   p M::N.parent_name # => "M"
+  def parent_name
+    unless defined? @parent_name
+      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+    end
+    @parent_name
+  end
 
-      # Returns the module which contains this one according to its name.
-      #
-      #   module M
-      #     module N
-      #     end
-      #   end
-      #   X = M::N
-      #
-      #   p M::N.parent # => M
-      #   p X.parent    # => M
-      #
-      # The parent of top-level and anonymous modules is Object.
-      #
-      #   p M.parent          # => Object
-      #   p Module.new.parent # => Object
-      #
-      def parent
-        parent_name ? parent_name.constantize : Object
-      end
+  # Returns the module which contains this one according to its name.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   p M::N.parent # => M
+  #   p X.parent    # => M
+  #
+  # The parent of top-level and anonymous modules is Object.
+  #
+  #   p M.parent          # => Object
+  #   p Module.new.parent # => Object
+  #
+  def parent
+    parent_name ? parent_name.constantize : Object
+  end
 
-      # Returns all the parents of this module according to its name, ordered from
-      # nested outwards. The receiver is not contained within the result.
-      #
-      #   module M
-      #     module N
-      #     end
-      #   end
-      #   X = M::N
-      #
-      #   p M.parents    # => [Object]
-      #   p M::N.parents # => [M, Object]
-      #   p X.parents    # => [M, Object]
-      #
-      def parents
-        parents = []
-        if parent_name
-          parts = parent_name.split('::')
-          until parts.empty?
-            parents << (parts * '::').constantize
-            parts.pop
-          end
-        end
-        parents << Object unless parents.include? Object
-        parents
+  # Returns all the parents of this module according to its name, ordered from
+  # nested outwards. The receiver is not contained within the result.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   p M.parents    # => [Object]
+  #   p M::N.parents # => [M, Object]
+  #   p X.parents    # => [M, Object]
+  #
+  def parents
+    parents = []
+    if parent_name
+      parts = parent_name.split('::')
+      until parts.empty?
+        parents << (parts * '::').constantize
+        parts.pop
       end
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
 
-      if RUBY_VERSION < '1.9'
-        # Returns the constants that have been defined locally by this object and
-        # not in an ancestor. This method is exact if running under Ruby 1.9. In
-        # previous versions it may miss some constants if their definition in some
-        # ancestor is identical to their definition in the receiver.
-        def local_constants
-          inherited = {}
-
-          ancestors.each do |anc|
-            next if anc == self
-            anc.constants.each { |const| inherited[const] = anc.const_get(const) }
-          end
+  if RUBY_VERSION < '1.9'
+    # Returns the constants that have been defined locally by this object and
+    # not in an ancestor. This method is exact if running under Ruby 1.9. In
+    # previous versions it may miss some constants if their definition in some
+    # ancestor is identical to their definition in the receiver.
+    def local_constants
+      inherited = {}
 
-          constants.select do |const|
-            !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
-          end
-        end
-      else
-        def local_constants #:nodoc:
-          constants(false)
-        end
+      ancestors.each do |anc|
+        next if anc == self
+        anc.constants.each { |const| inherited[const] = anc.const_get(const) }
       end
 
-      # Returns the names of the constants defined locally rather than the
-      # constants themselves. See <tt>local_constants</tt>.
-      def local_constant_names
-        local_constants.map { |c| c.to_s }
+      constants.select do |const|
+        !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
       end
     end
+  else
+    def local_constants #:nodoc:
+      constants(false)
+    end
+  end
+
+  # Returns the names of the constants defined locally rather than the
+  # constants themselves. See <tt>local_constants</tt>.
+  def local_constant_names
+    local_constants.map { |c| c.to_s }
   end
 end