Class: Module
- Includes:
- ActiveSupport::Deprecation::ClassMethods
- Defined in:
- lib/active_support/dependencies.rb,
lib/active_support/deprecation.rb,
lib/active_support/core_ext/module/loading.rb,
lib/active_support/core_ext/module/aliasing.rb,
lib/active_support/core_ext/module/inclusion.rb,
lib/active_support/core_ext/module/delegation.rb,
lib/active_support/core_ext/module/attr_internal.rb,
lib/active_support/core_ext/module/introspection.rb,
lib/active_support/core_ext/module/attribute_accessors.rb
Overview
Extends the module object with module and instance accessors for class attributes, just like the native attr* accessors for instance attributes.
Instance Method Summary collapse
-
#alias_attribute(new_name, old_name) ⇒ Object
Allows you to make aliases for attributes, which includes getter, setter, and query methods.
-
#alias_method_chain(target, feature) {|aliased_target, punctuation| ... } ⇒ Object
Encapsulates the common pattern of:.
- #as_load_path ⇒ Object
-
#attr_internal_accessor(*attrs) ⇒ Object
(also: #attr_internal)
Declare attributes backed by ‘internal’ instance variables names.
-
#attr_internal_reader(*attrs) ⇒ Object
Declare an attribute reader backed by an internally-named instance variable.
-
#attr_internal_writer(*attrs) ⇒ Object
Declare an attribute writer backed by an internally-named instance variable.
-
#const_missing(class_id) ⇒ Object
Use const_missing to autoload associations so we don’t have to require_association when using single-table inheritance.
-
#delegate(*methods) ⇒ Object
Provides a delegate class method to easily expose contained objects’ methods as your own.
- #included_in_classes ⇒ Object
- #mattr_accessor(*syms) ⇒ Object
-
#mattr_reader(*syms) ⇒ Object
:nodoc:.
- #mattr_writer(*syms) ⇒ Object
-
#parent ⇒ Object
Return the module which contains this one; if this is a root module, such as
::MyModule
, then Object is returned. -
#parents ⇒ Object
Return all the parents of this module, ordered from nested outwards.
-
#rails_original_const_missing ⇒ Object
Rename the original handler so we can chain it to the new one.
- #unloadable(const_desc = self) ⇒ Object
Methods included from ActiveSupport::Deprecation::ClassMethods
#deprecate, #deprecated_method_warning, #deprecation_horizon
Instance Method Details
#alias_attribute(new_name, old_name) ⇒ Object
Allows you to make aliases for attributes, which includes getter, setter, and query methods.
Example:
class Content < ActiveRecord::Base
# has a title attribute
end
class Email < ActiveRecord::Base
alias_attribute :subject, :title
end
e = Email.find(1)
e.title # => "Superstars"
e.subject # => "Superstars"
e.subject? # => true
e.subject = "Megastars"
e.title # => "Megastars"
51 52 53 54 55 56 57 |
# File 'lib/active_support/core_ext/module/aliasing.rb', line 51 def alias_attribute(new_name, old_name) module_eval <<-STR, __FILE__, __LINE__+1 def #{new_name}; #{old_name}; end def #{new_name}?; #{old_name}?; end def #{new_name}=(v); self.#{old_name} = v; end STR end |
#alias_method_chain(target, feature) {|aliased_target, punctuation| ... } ⇒ Object
Encapsulates the common pattern of:
alias_method :foo_without_feature, :foo
alias_method :foo, :foo_with_feature
With this, you simply do:
alias_method_chain :foo, :feature
And both aliases are set up for you.
Query and bang methods (foo?, foo!) keep the same punctuation:
alias_method_chain :foo?, :feature
is equivalent to
alias_method :foo_without_feature?, :foo?
alias_method :foo?, :foo_with_feature?
so you can safely chain foo, foo?, and foo! with the same feature.
23 24 25 26 27 28 29 30 |
# File 'lib/active_support/core_ext/module/aliasing.rb', line 23 def alias_method_chain(target, feature) # Strip out punctuation on predicates or bang methods since # e.g. target?_without_feature is not a valid method name. aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1 yield(aliased_target, punctuation) if block_given? alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}" end |
#as_load_path ⇒ Object
2 3 4 5 6 7 8 9 10 11 12 |
# File 'lib/active_support/core_ext/module/loading.rb', line 2 def as_load_path if self == Object || self == Kernel '' elsif is_a? Class parent == self ? '' : parent.as_load_path else name.split('::').collect do |word| word.underscore end * '/' end end |
#attr_internal_accessor(*attrs) ⇒ Object Also known as: attr_internal
Declare attributes backed by ‘internal’ instance variables names.
17 18 19 20 |
# File 'lib/active_support/core_ext/module/attr_internal.rb', line 17 def attr_internal_accessor(*attrs) attr_internal_reader(*attrs) attr_internal_writer(*attrs) end |
#attr_internal_reader(*attrs) ⇒ Object
Declare an attribute reader backed by an internally-named instance variable.
3 4 5 6 7 |
# File 'lib/active_support/core_ext/module/attr_internal.rb', line 3 def attr_internal_reader(*attrs) attrs.each do |attr| module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end" end end |
#attr_internal_writer(*attrs) ⇒ Object
Declare an attribute writer backed by an internally-named instance variable.
10 11 12 13 14 |
# File 'lib/active_support/core_ext/module/attr_internal.rb', line 10 def attr_internal_writer(*attrs) attrs.each do |attr| module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end" end end |
#const_missing(class_id) ⇒ Object
Use const_missing to autoload associations so we don’t have to require_association when using single-table inheritance.
451 452 453 |
# File 'lib/active_support/dependencies.rb', line 451 def const_missing(class_id) Dependencies.load_missing_constant self, class_id end |
#delegate(*methods) ⇒ Object
Provides a delegate class method to easily expose contained objects’ methods as your own. Pass one or more methods (specified as symbols or strings) and the name of the target object as the final :to option (also a symbol or string). At least one method and the :to option are required.
Delegation is particularly useful with Active Record associations:
class Greeter < ActiveRecord::Base
def hello() "hello" end
def goodbye() "goodbye" end
end
class Foo < ActiveRecord::Base
belongs_to :greeter
delegate :hello, :to => :greeter
end
Foo.new.hello # => "hello"
Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
Multiple delegates to the same target are allowed:
class Foo < ActiveRecord::Base
delegate :hello, :goodbye, :to => :greeter
end
Foo.new.goodbye # => "goodbye"
27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
# File 'lib/active_support/core_ext/module/delegation.rb', line 27 def delegate(*methods) = methods.pop unless .is_a?(Hash) && to = [:to] raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)." end methods.each do |method| module_eval(<<-EOS, "(__DELEGATION__)", 1) def #{method}(*args, &block) #{to}.__send__(#{method.inspect}, *args, &block) end EOS end end |
#included_in_classes ⇒ Object
2 3 4 5 6 7 8 9 10 |
# File 'lib/active_support/core_ext/module/inclusion.rb', line 2 def included_in_classes classes = [] ObjectSpace.each_object(Class) { |k| classes << k if k.included_modules.include?(self) } classes.reverse.inject([]) do |unique_classes, klass| unique_classes << klass unless unique_classes.collect { |k| k.to_s }.include?(klass.to_s) unique_classes end end |
#mattr_accessor(*syms) ⇒ Object
44 45 46 47 |
# File 'lib/active_support/core_ext/module/attribute_accessors.rb', line 44 def mattr_accessor(*syms) mattr_reader(*syms) mattr_writer(*syms) end |
#mattr_reader(*syms) ⇒ Object
:nodoc:
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# File 'lib/active_support/core_ext/module/attribute_accessors.rb', line 4 def mattr_reader(*syms) syms.each do |sym| next if sym.is_a?(Hash) class_eval(<<-EOS, __FILE__, __LINE__) unless defined? @@#{sym} @@#{sym} = nil end def self.#{sym} @@#{sym} end def #{sym} @@#{sym} end EOS end end |
#mattr_writer(*syms) ⇒ Object
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
# File 'lib/active_support/core_ext/module/attribute_accessors.rb', line 23 def mattr_writer(*syms) = syms.last.is_a?(Hash) ? syms.pop : {} syms.each do |sym| class_eval(<<-EOS, __FILE__, __LINE__) unless defined? @@#{sym} @@#{sym} = nil end def self.#{sym}=(obj) @@#{sym} = obj end #{" def #{sym}=(obj) @@#{sym} = obj end " unless [:instance_writer] == false } EOS end end |
#parent ⇒ Object
Return the module which contains this one; if this is a root module, such as ::MyModule
, then Object is returned.
4 5 6 7 |
# File 'lib/active_support/core_ext/module/introspection.rb', line 4 def parent parent_name = name.split('::')[0..-2] * '::' parent_name.empty? ? Object : parent_name.constantize end |
#parents ⇒ Object
Return all the parents of this module, ordered from nested outwards. The receiver is not contained within the result.
11 12 13 14 15 16 17 18 19 20 |
# File 'lib/active_support/core_ext/module/introspection.rb', line 11 def parents parents = [] parts = name.split('::')[0..-2] until parts.empty? parents << (parts * '::').constantize parts.pop end parents << Object unless parents.include? Object parents end |
#rails_original_const_missing ⇒ Object
Rename the original handler so we can chain it to the new one
447 |
# File 'lib/active_support/dependencies.rb', line 447 alias :rails_original_const_missing :const_missing |
#unloadable(const_desc = self) ⇒ Object
455 456 457 |
# File 'lib/active_support/dependencies.rb', line 455 def unloadable(const_desc = self) super(const_desc) end |