module ActionView::Layouts::ClassMethods

def _implied_layout_name

* String - A template name
==== Returns

value of this method.
If no layout is supplied, look for a template named the return

def _implied_layout_name
  controller_path
end

def _write_layout_method # :nodoc:

:nodoc:
if nothing is found then try same procedure to find super class's layout.
If a layout is not explicitly mentioned then look for a layout with the controller's name.

Creates a _layout method to be called by _default_layout .

def _write_layout_method # :nodoc:
  silence_redefinition_of_method(:_layout)
  prefixes = /\blayouts/.match?(_implied_layout_name) ? [] : ["layouts"]
  default_behavior = "lookup_context.find_all('#{_implied_layout_name}', #{prefixes.inspect}, false, [], { formats: formats }).first || super"
  name_clause = if name
    default_behavior
  else
    <<-RUBY
      super
    RUBY
  end
  layout_definition = \
    case _layout
    when String
      _layout.inspect
    when Symbol
      <<-RUBY
        #{_layout}.tap do |layout|
          return #{default_behavior} if layout.nil?
          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
      RUBY
    when Proc
      define_method :_layout_from_proc, &_layout
      private :_layout_from_proc
      <<-RUBY
        result = _layout_from_proc(#{_layout.arity == 0 ? '' : 'self'})
        return #{default_behavior} if result.nil?
        result
      RUBY
    when false
      nil
    when true
      raise ArgumentError, "Layouts must be specified as a String, Symbol, Proc, false, or nil"
    when nil
      name_clause
    end
  class_eval <<-RUBY, __FILE__, __LINE__ + 1
    # frozen_string_literal: true
    def _layout(lookup_context, formats)
      if _conditional_layout?
        #{layout_definition}
      else
        #{name_clause}
      end
    end
    private :_layout
  RUBY
end

def inherited(klass) # :nodoc:

:nodoc:

def inherited(klass) # :nodoc:
  super
  klass._write_layout_method
end

def layout(layout, conditions = {})

* +:except+ - Apply this layout to all actions but this one.
* +:only+ - A list of actions to apply this layout to.

==== Options (conditions)

* layout - The layout to use.

==== Parameters

with the same meaning as described above.
Return value of +Proc+ and +Symbol+ arguments should be +String+, +false+, +true+, or +nil+

nil:: Force default layout behavior with inheritance
true:: raise an ArgumentError
false:: There is no layout
Proc:: call the passed Proc
Symbol:: call the method specified by the symbol
String:: the String is the template name
If the specified layout is a:

Specify the layout to use for this class.

def layout(layout, conditions = {})
  include LayoutConditions unless conditions.empty?
  conditions.each { |k, v| conditions[k] = Array(v).map(&:to_s) }
  self._layout_conditions = conditions
  self._layout = layout
  _write_layout_method
end

Modules

Classes