Add depends_on, use, and setup to abstract up ideas about module inheritance.

actionpack/lib/action_controller/abstract/callbacks.rb

 module AbstractController
   module Callbacks
-    def self.included(klass)
-      klass.class_eval do
-        include ActiveSupport::NewCallbacks
-        define_callbacks :process_action
-        extend ClassMethods
-      end
+    setup do
+      include ActiveSupport::NewCallbacks
+      define_callbacks :process_action      
     end
     
     def process_action

actionpack/lib/action_controller/abstract/helpers.rb

 module AbstractController
   module Helpers
-  
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-        unless self < ::AbstractController::Renderer
-          raise "You need to include AbstractController::Renderer before including " \
-                "AbstractController::Helpers"
-        end
-        extlib_inheritable_accessor :master_helper_module
-        self.master_helper_module = Module.new
-      end
+    depends_on Renderer
+    
+    setup do
+      extlib_inheritable_accessor :master_helper_module
+      self.master_helper_module = Module.new
     end
+  
+    # def self.included(klass)
+    #   klass.class_eval do
+    #     extlib_inheritable_accessor :master_helper_module
+    #     self.master_helper_module = Module.new
+    #   end
+    # end
     
     def _action_view
       @_action_view ||= begin

actionpack/lib/action_controller/abstract/layouts.rb

 module AbstractController
   module Layouts
     
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
+    depends_on Renderer
+        
     module ClassMethods
       def layout(layout)
         unless [String, Symbol, FalseClass, NilClass].include?(layout.class)
           raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
         end
         
-        @layout = layout || false # Converts nil to false
+        @_layout = layout || false # Converts nil to false
+        _write_layout_method
       end
       
       def _write_layout_method
-        case @layout
+        case @_layout
         when String
-          self.class_eval %{def _layout() #{@layout.inspect} end}
+          self.class_eval %{def _layout() #{@_layout.inspect} end}
         when Symbol
-          self.class_eval %{def _layout() #{@layout} end}
+          self.class_eval %{def _layout() #{@_layout} end}
         when false
           self.class_eval %{def _layout() end}
         else
@@ -43,7 +42,7 @@ def _render_template(template, options)
   private
   
     def _layout() end # This will be overwritten
-    
+
     def _layout_for_option(name)
       case name
       when String then _layout_for_name(name)

actionpack/lib/action_controller/abstract/logger.rb

 module AbstractController
   module Logger
-    def self.included(klass)
-      klass.cattr_accessor :logger
+    setup do
+      cattr_accessor :logger
     end
   end
 end
\ No newline at end of file

actionpack/lib/action_controller/abstract/renderer.rb

@@ -2,20 +2,16 @@
 
 module AbstractController
   module Renderer
+    depends_on AbstractController::Logger
     
-    def self.included(klass)
-      klass.class_eval do        
-        extend ClassMethods
-        
-        attr_internal :formats
-        
-        extlib_inheritable_accessor :_view_paths
-        
-        self._view_paths ||= ActionView::PathSet.new
-        include AbstractController::Logger
-      end
+    setup do
+      attr_internal :formats
+      
+      extlib_inheritable_accessor :_view_paths
+      
+      self._view_paths ||= ActionView::PathSet.new
     end
-    
+        
     def _action_view
       @_action_view ||= ActionView::Base.new(self.class.view_paths, {}, self)      
     end

actionpack/lib/action_controller/new_base/hide_actions.rb

 module ActionController
   module HideActions
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-        extlib_inheritable_accessor :hidden_actions
-        self.hidden_actions ||= Set.new
-      end
+    setup do
+      extlib_inheritable_accessor :hidden_actions
+      self.hidden_actions ||= Set.new      
     end
     
     def action_methods() self.class.action_names end

actionpack/lib/action_controller/new_base/layouts.rb

 module ActionController
   module Layouts
+    depends_on ActionController::Renderer
+    depends_on AbstractController::Layouts
+    
     def render_to_string(options)
       if !options.key?(:text) || options.key?(:layout)
         options[:_layout] = options.key?(:layout) ? _layout_for_option(options[:layout]) : _default_layout

actionpack/lib/action_controller/new_base/renderer.rb

 module ActionController
   module Renderer
-    
-    # def self.included(klass)
-    #   klass.extend ClassMethods
-    # end
-    # 
-    # module ClassMethods
-    #   def prefix
-    #     @prefix ||= name.underscore
-    #   end      
-    # end
+    depends_on AbstractController::Renderer
     
     def initialize(*)
       self.formats = [:html]

actionpack/test/abstract_controller/abstract_controller_test.rb

@@ -27,7 +27,7 @@ class TestBasic < ActiveSupport::TestCase
     # Test Render mixin
     # ====
     class RenderingController < AbstractController::Base
-      include Renderer
+      use Renderer
 
       def _prefix() end
 
@@ -116,7 +116,7 @@ class TestPrefixedViews < ActiveSupport::TestCase
     # ====
     # self._layout is used when defined
     class WithLayouts < PrefixedViews
-      include Layouts
+      use Layouts
       
       private
       def self.layout(formats)

actionpack/test/abstract_controller/callbacks_test.rb

@@ -4,7 +4,7 @@ module AbstractController
   module Testing
   
     class ControllerWithCallbacks < AbstractController::Base
-      include AbstractController::Callbacks
+      use AbstractController::Callbacks
     end
     
     class Callback1 < ControllerWithCallbacks

actionpack/test/abstract_controller/helper_test.rb

@@ -4,8 +4,8 @@ module AbstractController
   module Testing
   
     class ControllerWithHelpers < AbstractController::Base
-      include Renderer
-      include Helpers
+      use Renderer
+      use Helpers
       
       def render(string)
         super(:_template_name => string)

actionpack/test/abstract_controller/layouts_test.rb

@@ -5,8 +5,8 @@ module Layouts
 
     # Base controller for these tests
     class Base < AbstractController::Base
-      include AbstractController::Renderer
-      include AbstractController::Layouts
+      use AbstractController::Renderer
+      use AbstractController::Layouts
       
       self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
         "layouts/hello.erb"              => "With String <%= yield %>",

actionpack/test/new_base/test_helper.rb

@@ -26,16 +26,14 @@
 
 module ActionController
   class Base2 < AbstractBase
-    include AbstractController::Callbacks
-    include AbstractController::Renderer
-    include AbstractController::Helpers
-    include AbstractController::Layouts
-    include AbstractController::Logger
-    
-    include ActionController::HideActions
-    include ActionController::UrlFor
-    include ActionController::Layouts
-    include ActionController::Renderer
+    use AbstractController::Callbacks
+    use AbstractController::Helpers
+    use AbstractController::Logger
+
+    use ActionController::HideActions
+    use ActionController::UrlFor
+    use ActionController::Renderer
+    use ActionController::Layouts
     
     def self.inherited(klass)
       ::ActionController::Base2.subclasses << klass.to_s

activesupport/lib/active_support/core_ext/module.rb

@@ -8,6 +8,7 @@
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/model_naming'
 require 'active_support/core_ext/module/synchronization'
+require 'active_support/core_ext/module/setup'
 
 module ActiveSupport
   module CoreExtensions

activesupport/lib/active_support/core_ext/module/setup.rb

+class Module
+  attr_accessor :_setup_block
+  attr_accessor :_dependencies
+  
+  def setup(&blk)
+    @_setup_block = blk
+  end
+  
+  def use(mod)
+    return if self < mod
+    
+    (mod._dependencies || []).each do |dep|
+      use dep
+    end
+    # raise "Circular dependencies" if self < mod
+    include mod
+    extend mod.const_get("ClassMethods") if mod.const_defined?("ClassMethods")
+    class_eval(&mod._setup_block) if mod._setup_block
+  end
+  
+  def depends_on(mod)
+    return if self < mod
+    @_dependencies ||= []
+    @_dependencies << mod
+  end
+end
\ No newline at end of file