module AbstractController::Helpers::ClassMethods

def add_template_helper(mod)

for the class
* module - The module to include into the current helper module
==== Parameters

rendered through this controller.
Makes all the (instance) methods in the helper module available to templates 
def add_template_helper(mod)
  _helpers.module_eval { include mod }
end

def clear_helpers

with the same name as this class.
Clears up all existing helpers in this class, only keeping the helper 
def clear_helpers
  inherited_helper_methods = _helper_methods
  self._helpers = Module.new
  self._helper_methods = Array.new
  inherited_helper_methods.each { |meth| helper_method meth }
  default_helper_module! unless anonymous?
end

def default_helper_module! 

def default_helper_module!
  module_name = name.sub(/Controller$/, ''.freeze)
  module_path = module_name.underscore
  helper module_path
rescue LoadError => e
  raise e unless e.is_missing? "helpers/#{module_path}_helper"
rescue NameError => e
  raise e unless e.missing_name? "#{module_name}Helper"
end

def helper(*args, &block)


helper(:three, BlindHelper) { def mice() 'mice' end }

+symbols+, +strings+, +modules+ and blocks.
Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of

end
end
"#{bar} is the very best"
def foo(bar)
helper do
# Multi-line

helper { def hello() "Hello, world!" end }
# One line

to the template.
Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available

helper 'resources/foo' # => requires 'resources/foo_helper' and includes Resources::FooHelper
helper :foo # => requires 'foo_helper' and includes FooHelper
in one of Rails' standard load paths:
when working with namespaced controllers, or other cases where the file containing the helper definition is not
and include the module in the template class. The second form illustrates how to include custom helpers
When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file

helper FooHelper # => includes FooHelper
When the argument is a module it will be included directly in the template class.

* block - A block defining helper methods
* *args - Module, Symbol, String
==== Options

The +helper+ class method can take a series of helper module names, a block, or both. 
def helper(*args, &block)
  modules_for_helpers(args).each do |mod|
    add_template_helper(mod)
  end
  _helpers.module_eval(&block) if block_given?
end

def helper_method(*meths)

to be made available on the view.
* method[, method] - A name or names of a method on the controller
==== Parameters

<% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
In a view:

end
end
current_user != nil
def logged_in?

end
@current_user ||= User.find_by(id: session[:user])
def current_user

helper_method :current_user, :logged_in?
class ApplicationController < ActionController::Base
to the view:
makes the +current_user+ and +logged_in?+ controller methods available
Declare a controller method as a helper. For example, the following 
def helper_method(*meths)
  meths.flatten!
  self._helper_methods += meths
  meths.each do |meth|
    _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
      def #{meth}(*args, &blk)                               # def current_user(*args, &blk)
        controller.send(%(#{meth}), *args, &blk)             #   controller.send(:current_user, *args, &blk)
      end                                                    # end
    ruby_eval
  end
end

def inherited(klass)

independently of the child class's.
This ensures that the parent class's module can be changed
When a class is inherited, wrap its helper module in a new module. 
def inherited(klass)
  helpers = _helpers
  klass._helpers = Module.new { include helpers }
  klass.class_eval { default_helper_module! } unless klass.anonymous?
  super
end

def modules_for_helpers(args)

helpers provided.
* Array - A normalized list of modules for the list of
==== Returns

* args - An array of helpers
==== Parameters

are returned.
After loading the appropriate files, the corresponding modules

Module:: No further processing

and "foo_bar_helper.rb" is loaded using require_dependency.
String or Symbol:: :FooBar or "FooBar" becomes "foo_bar_helper",

helpers with the following behavior:
Returns a list of modules, normalized from the acceptable kinds of 
def modules_for_helpers(args)
  args.flatten.map! do |arg|
    case arg
    when String, Symbol
      file_name = "#{arg.to_s.underscore}_helper"
      begin
        require_dependency(file_name)
      rescue LoadError => e
        raise AbstractController::Helpers::MissingHelperError.new(e, file_name)
      end
      mod_name = file_name.camelize
      begin
        mod_name.constantize
      rescue LoadError
        # dependencies.rb gives a similar error message but its wording is
        # not as clear because it mentions autoloading. To the user all it
        # matters is that a helper module couldn't be loaded, autoloading
        # is an internal mechanism that should not leak.
        raise NameError, "Couldn't find #{mod_name}, expected it to be defined in helpers/#{file_name}.rb"
      end
    when Module
      arg
    else
      raise ArgumentError, "helper must be a String, Symbol, or Module"
    end
  end
end