Modified the helper Ramaze::Helper::Layout so that it allows you to call set_layout multiple times as well as setting layouts for multiple methods. A good example is the following:

    set_layout 'my_layout' => [:index, :edit]
    set_layout 'default'   => [:add]

Please note that Ramaze::Helper::Layout#set_layout_except is deprecated and will issue a warning, you should use set_layout instead.

Author: YorickPeterse

lib/ramaze/helper/layout.rb

@@ -1,97 +1,124 @@
 module Ramaze
   module Helper
-
+    ##
     # Provides wrapper methods for a higher-level approach than the core layout
-    # method.  These are useful for simpler layout needs, particularly:
+    # method. The layout() method that comes with Innate/Ramaze is fairly basic as it only
+    # allows you to specify a single layout to always use or a block giving you some extra
+    # flexibility. The latter however is still a bit of a pain when dealing with many
+    # custom layouts in a single controller. Meet the Layout helper. This helper provides
+    # a single method (since April 2011, it used to provide more) called "set_layout".
+    # This method allows you to specify a number of layouts and the methods for which 
+    # these layouts should be used.
+    #
+    # == Examples
+    #
+    # The most basic example is simply setting a layout as you would do with the layout()
+    # method:
     #
-    # * layout all actions
-    # * layout a whitelist of actions
-    # * layout all but a blacklist of actions
+    #  set_layout 'default'
     #
-    # As with the core layout method, the layout rules apply only to the
-    # controller on which they are applied.  Furthermore, multiple layout
-    # definitions are not combined; only the last definition will be used.
+    # This of course is very boring, time to add some more spices to our code:
     #
-    # This helper is one of the default helpers, so no explicit helper call
-    # is necessary before using it in your controllers.
+    #  set_layout 'default' => [:index]
     #
-    # Usage:
+    # Woah! What just happened? It's quite easy actually, we merely defined that the 
+    # layout called "default" should be used for the index method *only*. Pretty sweet
+    # huh? It gets even better:
     #
-    #    class MainController < Controller
-    #      # Apply the default layout (e.g. ./layout/default.xhtml) to all
-    #      # three actions.
-    #      set_layout 'default'
-    #      def action1; end
-    #      def action2; end
-    #      def action3; end
-    #    end
+    #  set_layout 'default' => [:index, :edit], 'alternative' => [:add, :process]
     #
-    #    class MainController < Controller
-    #      # These two layout definitions accomplish the same thing.  The
-    #      # first uses a whitelist, the second uses a blacklist.
-    #      set_layout 'default' => [:laid_out1, :laid_out2]
-    #      set_layout_except 'default' => [:not_laid_out1, :not_laid_out2]
+    # A few things changed. First of all there are now two key/value groups. Each group
+    # defines a layout (the key) and a set of methods (the value) for which each layout
+    # should be used. In this case the layout "default" will be used for index() and edit()
+    # but the layout "alternative" will be used for add() and process().
     #
-    #      def laid_out1; end
-    #      def laid_out2; end
+    # Last but not least, multiple calls to set_layout will no longer override any 
+    # existing settings *unless* you actually specify the same method with a different
+    # layout. This is possible because the set_layout method stores all these details in
+    # an instance variable called "_ramaze_layouts".
+    #
+    # @author Yorick Peterse
+    # @author Michael Fellinger
+    # @author Pistos
     #
-    #      def not_laid_out1; end
-    #      def not_laid_out2; end
-    #    end
     module Layout
+
+      ##
+      # Extends the class that included this module so that the methods that this helper
+      # provides can be called outside of instance of class methods.
+      #
+      # @param [Object] into The class that included this module.
+      # @author Michael Fellinger
+      # @author Pistos
+      #
       def self.included(into)
         into.extend SingletonMethods
       end
 
       module SingletonMethods
-        # @param [String Hash] Either a layout name, or a single-element Hash
-        #   which maps a layout name to an Array containing a whitelist of
-        #   action names
-        # @see set_layout_except Innate::Node::layout
-        # @author Pistos, manveru
-        # @example Use a layout named 'default' on all actions of the controller:
-        #   set_layout 'default'
-        # @example Use a layout named 'default' on just the index and admin actions:
-        #   set_layout 'default' => [ :index, :admin ]
-        def set_layout(hash_or_the_layout)
-          if hash_or_the_layout.respond_to?(:to_hash)
-            f = hash_or_the_layout.to_hash.find{|k,v| k && v }
-            the_layout = f[0]
-            whitelist = f[1].map{|action| action.to_s }
-          else
-            the_layout = hash_or_the_layout
-          end
+        ##
+        # The set_layout method allows you to specify a number of methods and their 
+        # layout. This allows you to use layout A for methods 1, 2 and 3 but layout B for
+        # method 4.
+        #
+        # @example
+        #  # The key is the layout, the value an array of methods
+        #  set_layout 'default' => [:method_1], 'alternative' => [:method_2]
+        #
+        #  # We can combine this method with layout()
+        #  layout 'default'
+        #  set_layout 'alternative' => [:method_1]
+        #
+        #  # This is also perfectly fine
+        #  set_layout 'default'
+        #
+        # @author Yorick Peterse
+        # @author Michael Fellinger
+        # @author Pistos
+        # @param  [Hash/String] hash_or_layout Can either be a string or a hash. In case 
+        #  it's a string it will directly be used as the layout. When setting a hash this
+        #  hash should have it's keys set to the layouts and it's values to an array of
+        #  methods that use the specific layout. For more information see the examples.
+        #
+        def set_layout(hash_or_layout)
+          @_ramaze_layouts ||= {}
 
-          layout do |path, wish|
-            if whitelist.nil? || whitelist.include?(path.to_s)
-              the_layout
+          # Extract the layout to use
+          if hash_or_layout.respond_to?(:to_hash)
+            # Invert the method/layout hash and save them so they don't get lost
+            hash_or_layout.to_hash.each do |layout, methods|
+              # Dirty but it works
+              methods.each do |m|
+                @_ramaze_layouts[m.to_s] = layout.to_s
+              end
             end
-          end
-        end
 
-        # @param [String Hash] Either a layout name, or a single-element Hash
-        #   which maps a layout name to an Array containing a blacklist of
-        #   action names
-        # @see set_layout Innate::Node::layout
-        # @author Pistos, manveru
-        # @example Use a layout named 'default' on all actions except the user_data action:
-        #   set_layout_except 'default' => [ :user_data ]
-        def set_layout_except(hash_or_the_layout)
-          if hash_or_the_layout.respond_to?(:to_hash)
-            f = hash_or_the_layout.to_hash.find{|k,v| k && v }
-            the_layout = f[0]
-            blacklist = f[1].map{|action| action.to_s }
-          else
-            the_layout = hash_or_the_layout
-          end
+            # Only use the layout for the current method
+            layout do |path|
+              path = path.to_s
 
-          layout do |path, wish|
-            if blacklist.nil? || !blacklist.include?(path.to_s)
-              the_layout
+              if @_ramaze_layouts.key?(path)
+                @_ramaze_layouts[path]
+              end
+            end
+
+          else
+            # This is pretty easy isn't it?
+            layout do |path|
+              hash_or_layout
             end
           end
         end
+
+        # People might get confused when all of a sudden set_layout_except is gone. This
+        # warning should clear things up for them. This method can be removed a release
+        # after (or later) this modified helper has been introduced.
+        def set_layout_except(hash_or_layout)
+          Ramaze.deprecated('set_layout_except', 'set_layout')
+        end
+
       end
     end
+
   end
 end

spec/ramaze/helper/layout.rb

@@ -22,18 +22,16 @@ def laid_out2; end
   def not_laid_out; end
 end
 
-class LayoutHelper < Ramaze::Controller
+class LayoutHelperThree < Ramaze::Controller
   map '/three'
-  set_layout_except 'default' => [:not_laid_out1, :not_laid_out2]
+  set_layout 'default' => [:laid_out1], 'alternative' => [:laid_out2]
+  set_layout 'default' => [:laid_out3]
 
   def laid_out1; end
   def laid_out2; end
-
-  def not_laid_out1; end
-  def not_laid_out2; end
+  def laid_out3; end
 end
 
-
 describe Ramaze::Helper::Layout do
   behaves_like :rack_test
 
@@ -61,19 +59,18 @@ def not_laid_out2; end
     last_response.body.should.not.match /laid out/
   end
 
-  it 'lays out all actions except a blacklist' do
+  it 'Define a set of method specific layouts' do
     get '/three/laid_out1'
-    last_response.status.should == 200
+    last_response.status.should === 200
     last_response.body.should.match /laid out/
+
     get '/three/laid_out2'
-    last_response.status.should == 200
+    last_response.status.should === 200
+    last_response.body.should.match /alternative/
+
+    get '/three/laid_out3'
+    last_response.status.should === 200
     last_response.body.should.match /laid out/
-    get '/three/not_laid_out1'
-    last_response.status.should == 200
-    last_response.body.should.not.match /laid out/
-    get '/three/not_laid_out2'
-    last_response.status.should == 200
-    last_response.body.should.not.match /laid out/
   end
 
 end

spec/ramaze/helper/layout/alternative.xhtml

@@ -0,0 +1,5 @@
+<em>alternative</em>
+
+<div id="content">
+#@content
+</div>