2009-10-18 18:20:14 -04:00
|
|
|
require 'active_support/dependencies'
|
|
|
|
|
2009-03-03 19:42:20 -05:00
|
|
|
module AbstractController
|
|
|
|
module Helpers
|
2009-05-28 12:35:36 -04:00
|
|
|
extend ActiveSupport::Concern
|
2009-05-07 11:29:22 -04:00
|
|
|
|
2009-05-07 11:38:57 -04:00
|
|
|
included do
|
2010-03-18 21:12:04 -04:00
|
|
|
class_attribute :_helpers
|
2010-01-31 21:32:28 -05:00
|
|
|
self._helpers = Module.new
|
2010-08-26 22:18:35 -04:00
|
|
|
|
|
|
|
class_attribute :_helper_methods
|
|
|
|
self._helper_methods = Array.new
|
2009-03-03 19:42:20 -05:00
|
|
|
end
|
2009-05-11 13:22:07 -04:00
|
|
|
|
2009-03-03 19:42:20 -05:00
|
|
|
module ClassMethods
|
2009-06-09 17:50:01 -04:00
|
|
|
# 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.
|
2009-03-03 19:42:20 -05:00
|
|
|
def inherited(klass)
|
2009-06-09 17:50:01 -04:00
|
|
|
helpers = _helpers
|
|
|
|
klass._helpers = Module.new { include helpers }
|
2010-02-14 16:05:02 -05:00
|
|
|
klass.class_eval { default_helper_module! unless anonymous? }
|
2009-03-03 19:42:20 -05:00
|
|
|
super
|
|
|
|
end
|
2009-05-22 18:17:05 -04:00
|
|
|
|
|
|
|
# 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 -%>
|
2009-06-09 17:50:01 -04:00
|
|
|
#
|
|
|
|
# ==== Parameters
|
2010-08-25 12:57:27 -04:00
|
|
|
# * <tt>method[, method]</tt> - A name or names of a method on the controller
|
2009-06-09 17:50:01 -04:00
|
|
|
# to be made available on the view.
|
2009-03-03 19:42:20 -05:00
|
|
|
def helper_method(*meths)
|
2010-08-26 22:18:35 -04:00
|
|
|
meths.flatten!
|
|
|
|
self._helper_methods += meths
|
|
|
|
|
|
|
|
meths.each do |meth|
|
2009-06-09 17:50:01 -04:00
|
|
|
_helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
|
2009-03-03 19:42:20 -05:00
|
|
|
def #{meth}(*args, &blk)
|
|
|
|
controller.send(%(#{meth}), *args, &blk)
|
|
|
|
end
|
|
|
|
ruby_eval
|
|
|
|
end
|
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-10-18 18:20:14 -04:00
|
|
|
# The +helper+ class method can take a series of helper module names, a block, or both.
|
2009-06-09 17:50:01 -04:00
|
|
|
#
|
|
|
|
# ==== Parameters
|
2010-08-25 12:57:27 -04:00
|
|
|
# * <tt>*args</tt> - Module, Symbol, String, :all
|
|
|
|
# * <tt>block</tt> - A block defining helper methods
|
2009-10-18 18:20:14 -04:00
|
|
|
#
|
|
|
|
# ==== 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
|
2011-05-23 19:22:33 -04:00
|
|
|
# and include the module in the template class. The second form illustrates how to include custom helpers
|
2009-10-18 18:20:14 -04:00
|
|
|
# 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 }
|
|
|
|
#
|
2009-05-22 18:17:05 -04:00
|
|
|
def helper(*args, &block)
|
2010-02-16 13:45:59 -05:00
|
|
|
modules_for_helpers(args).each do |mod|
|
2009-10-18 18:20:14 -04:00
|
|
|
add_template_helper(mod)
|
2009-03-03 19:42:20 -05:00
|
|
|
end
|
2009-10-18 18:20:14 -04:00
|
|
|
|
2009-06-09 17:50:01 -04:00
|
|
|
_helpers.module_eval(&block) if block_given?
|
|
|
|
end
|
|
|
|
|
2010-08-26 15:03:10 -04:00
|
|
|
# Clears up all existing helpers in this class, only keeping the helper
|
|
|
|
# with the same name as this class.
|
|
|
|
def clear_helpers
|
2010-08-26 22:18:35 -04:00
|
|
|
inherited_helper_methods = _helper_methods
|
2010-08-26 15:03:10 -04:00
|
|
|
self._helpers = Module.new
|
2010-08-26 22:18:35 -04:00
|
|
|
self._helper_methods = Array.new
|
|
|
|
|
|
|
|
inherited_helper_methods.each { |meth| helper_method meth }
|
2010-08-26 15:03:10 -04:00
|
|
|
default_helper_module! unless anonymous?
|
|
|
|
end
|
|
|
|
|
2009-10-18 18:20:14 -04:00
|
|
|
# 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
|
2010-08-25 12:57:27 -04:00
|
|
|
# * <tt>args</tt> - An array of helpers
|
2009-10-18 18:20:14 -04:00
|
|
|
#
|
|
|
|
# ==== Returns
|
2010-08-25 12:57:27 -04:00
|
|
|
# * <tt>Array</tt> - A normalized list of modules for the list of
|
2009-10-18 18:20:14 -04:00
|
|
|
# helpers provided.
|
2010-02-16 13:45:59 -05:00
|
|
|
def modules_for_helpers(args)
|
2009-10-18 18:20:14 -04:00
|
|
|
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
|
2010-01-30 10:35:22 -05:00
|
|
|
|
2011-04-25 09:02:41 -04:00
|
|
|
private
|
|
|
|
# Makes all the (instance) methods in the helper module available to templates
|
|
|
|
# rendered through this controller.
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# * <tt>module</tt> - The module to include into the current helper module
|
|
|
|
# for the class
|
|
|
|
def add_template_helper(mod)
|
|
|
|
_helpers.module_eval { include mod }
|
|
|
|
end
|
|
|
|
|
2010-01-30 10:35:22 -05:00
|
|
|
def default_helper_module!
|
|
|
|
module_name = name.sub(/Controller$/, '')
|
|
|
|
module_path = module_name.underscore
|
|
|
|
helper module_path
|
|
|
|
rescue MissingSourceFile => e
|
|
|
|
raise e unless e.is_missing? "helpers/#{module_path}_helper"
|
|
|
|
rescue NameError => e
|
|
|
|
raise e unless e.missing_name? "#{module_name}Helper"
|
|
|
|
end
|
2009-03-03 19:42:20 -05:00
|
|
|
end
|
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
end
|