aboutsummaryrefslogtreecommitdiffstats
path: root/actionpack/lib/action_controller/abstract/layouts.rb
blob: f021dd8b627fdc839b3d181e00296430772b9e6a (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
module AbstractController
  module Layouts
    extend ActiveSupport::Concern

    include Renderer

    included do
      extlib_inheritable_accessor(:_layout_conditions) { Hash.new }
      _write_layout_method
    end

    module ClassMethods
      def inherited(klass)
        super
        klass._write_layout_method
      end

      # Specify the layout to use for this class.
      #
      # If the specified layout is a:
      # String:: the String is the template name
      # Symbol:: call the method specified by the symbol, which will return
      #   the template name
      # false::  There is no layout
      # true::   raise an ArgumentError
      #
      # ==== Parameters
      # layout<String, Symbol, false)>:: The layout to use.
      #
      # ==== Options (conditions)
      # :only<#to_s, Array[#to_s]>:: A list of actions to apply this layout to.
      # :except<#to_s, Array[#to_s]>:: Apply this layout to all actions but this one
      def layout(layout, conditions = {})
        conditions.each {|k, v| conditions[k] = Array(v).map {|a| a.to_s} }
        self._layout_conditions = conditions

        @_layout = layout || false # Converts nil to false
        _write_layout_method
      end

      # If no layout is supplied, look for a template named the return
      # value of this method.
      #
      # ==== Returns
      # String:: A template name
      def _implied_layout_name
        name.underscore
      end

      # Takes the specified layout and creates a _layout method to be called
      # by _default_layout
      #
      # If there is no explicit layout specified:
      # If a layout is found in the view paths with the controller's
      # name, return that string. Otherwise, use the superclass'
      # layout (which might also be implied)
      def _write_layout_method
        case @_layout
        when String
          self.class_eval %{def _layout(details) #{@_layout.inspect} end}
        when Symbol
          self.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
            def _layout(details)
              #{@_layout}.tap do |layout|
                unless layout.is_a?(String) || !layout
                  raise ArgumentError, "Your layout method :#{@_layout} returned \#{layout}. It " \
                    "should have returned a String, false, or nil"
                end
              end
            end
          ruby_eval
        when false
          self.class_eval %{def _layout(details) end}
        when true
          raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
        when nil
          self.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
            def _layout(details)
              if view_paths.find_by_parts?("#{_implied_layout_name}", details, "layouts")
                "#{_implied_layout_name}"
              else
                super
              end
            end
          ruby_eval
        end
        self.class_eval { private :_layout }
      end
    end

  private
    # This will be overwritten by _write_layout_method
    def _layout(details) end

    # Determine the layout for a given name and details.
    #
    # ==== Parameters
    # name<String>:: The name of the template
    # details<Hash{Symbol => Object}>:: A list of details to restrict
    #   the lookup to. By default, layout lookup is limited to the
    #   formats specified for the current request.
    def _layout_for_name(name, details = {:formats => formats})
      name && _find_layout(name, details)
    end

    # Take in the name and details and find a Template.
    #
    # ==== Parameters
    # name<String>:: The name of the template to retrieve
    # details<Hash>:: A list of details to restrict the search by. This
    #   might include details like the format or locale of the template.
    #
    # ==== Returns
    # Template:: A template object matching the name and details
    def _find_layout(name, details)
      # TODO: Make prefix actually part of details in ViewPath#find_by_parts
      prefix = details.key?(:prefix) ? details.delete(:prefix) : "layouts"
      view_paths.find_by_parts(name, details, prefix)
    end

    # Returns the default layout for this controller and a given set of details. 
    # Optionally raises an exception if the layout could not be found.
    #
    # ==== Parameters
    # details<Hash>:: A list of details to restrict the search by. This
    #   might include details like the format or locale of the template.
    # require_layout<Boolean>:: If this is true, raise an ArgumentError
    #   with details about the fact that the exception could not be
    #   found (defaults to false)
    #
    # ==== Returns
    # Template:: The template object for the default layout (or nil)
    def _default_layout(details, require_layout = false)
      if require_layout && _action_has_layout? && !_layout(details)
        raise ArgumentError,
          "There was no default layout for #{self.class} in #{view_paths.inspect}"
      end

      begin
        _layout_for_name(_layout(details), details) if _action_has_layout?
      rescue NameError => e
        raise NoMethodError,
          "You specified #{@_layout.inspect} as the layout, but no such method was found"
      end
    end

    # Determines whether the current action has a layout by checking the
    # action name against the :only and :except conditions set on the
    # layout.
    #
    # ==== Returns
    # Boolean:: True if the action has a layout, false otherwise.
    def _action_has_layout?
      conditions = _layout_conditions
      if only = conditions[:only]
        only.include?(action_name)
      elsif except = conditions[:except]
        !except.include?(action_name)
      else
        true
      end
    end
  end
end