# module AbstractController::Helpers::ClassMethods

### Public Instance Methods

clear_helpers() click to toggle source

Clears up all existing helpers in this class, only keeping the helper with the same name as this class.

    # File lib/abstract_controller/helpers.rb, line 104
    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

helper(*args, &block) click to toggle source

The `helper` class method can take a series of helper module names, a block, or both.

#### Parameters¶ ↑

- `*args` - Module, Symbol, String, :all

- `block` - A block defining helper methods

#### Examples¶ ↑

When the argument is a module it will be included directly in the template class.

    helper FooHelper # => includes FooHelper

When the argument is a string or symbol, the method will provide the “_helper” suffix, require the file and include the module in the template class. The second form illustrates how to include custom helpers when working with namespaced controllers, or other cases where the file containing the helper definition is not in one of Rails’ standard load paths:

    helper :foo             # => requires 'foo_helper' and includes FooHelper
    helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper

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

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

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

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

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

    # File lib/abstract_controller/helpers.rb, line 94
    def helper(*args, &block)
      modules_for_helpers(args).each do |mod|
        add_template_helper(mod)
      end

      _helpers.module_eval(&block) if block_given?
    end

helper_method(*meths) click to toggle source

Declare a controller method as a helper. For example, the following makes the `current_user` controller method available to the view:

    class ApplicationController < ActionController::Base
      helper_method :current_user, :logged_in?

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

       def logged_in?
         current_user != nil
       end
    end

In a view:

    <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>

#### Parameters¶ ↑

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

    # File lib/abstract_controller/helpers.rb, line 46
          def helper_method(*meths)
            meths.flatten!
            self._helper_methods += meths

            meths.each do |meth|
              _helpers.class_eval "            def #{meth}(*args, &blk)
                  controller.send(%(#{meth}), *args, &blk)
                end
    ", __FILE__, __LINE__ + 1
            end
          end

inherited(klass) click to toggle source

When a class is inherited, wrap its helper module in a new module. This ensures that the parent class’s module can be changed independently of the child class’s.

Calls superclass method

    # File lib/abstract_controller/helpers.rb, line 19
    def inherited(klass)
      helpers = _helpers
      klass._helpers = Module.new { include helpers }
      klass.class_eval { default_helper_module! unless anonymous? }
      super
    end

modules_for_helpers(args) click to toggle source

Returns a list of modules, normalized from the acceptable kinds of helpers with the following behavior:

String or Symbol

  :FooBar or “FooBar” becomes “foo_bar_helper”,

    and "foo_bar_helper.rb" is loaded using require_dependency.

Module

  No further processing

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

#### Parameters¶ ↑

- `args` - An array of helpers

#### Returns¶ ↑

- `Array` - A normalized list of modules for the list of helpers provided.

    # File lib/abstract_controller/helpers.rb, line 130
    def modules_for_helpers(args)
      args.flatten.map! do |arg|
        case arg
        when String, Symbol
          file_name = "#{arg.to_s.underscore}_helper"
          require_dependency(file_name, "Missing helper file helpers/%s.rb")
          file_name.camelize.constantize
        when Module
          arg
        else
          raise ArgumentError, "helper must be a String, Symbol, or Module"
        end
      end
    end