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/vendor/builder-2.1.2/blankslate.rb,
lib/active_support/core_ext/module/attribute_accessors.rb,
lib/active_support/core_ext/module/attr_accessor_with_default.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:.
- #append_features(mod) ⇒ Object
- #as_load_path ⇒ Object
-
#attr_accessor_with_default(sym, default = nil, &block) ⇒ Object
Declare an attribute accessor with an initial default return value.
-
#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.
- #blankslate_original_append_features ⇒ Object
-
#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
-
#local_constant_names ⇒ Object
Returns the names of the constants defined locally rather than the constants themselves.
-
#local_constants ⇒ Object
Return the constants that have been defined locally by this object and not in an ancestor.
- #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 < Content
alias_attribute :subject, :title
end
e = Email.find(1)
e.title # => "Superstars"
e.subject # => "Superstars"
e.subject? # => true
e.subject = "Megastars"
e.title # => "Megastars"
63 64 65 66 67 68 69 |
# File 'lib/active_support/core_ext/module/aliasing.rb', line 63 def alias_attribute(new_name, old_name) module_eval <<-STR, __FILE__, __LINE__+1 def #{new_name}; self.#{old_name}; end def #{new_name}?; self.#{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 31 32 33 34 35 36 37 38 39 40 41 42 |
# 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? with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}" alias_method without_method, target alias_method target, with_method case when public_method_defined?(without_method) public target when protected_method_defined?(without_method) protected target when private_method_defined?(without_method) private target end end |
#append_features(mod) ⇒ Object
105 106 107 108 109 110 111 112 |
# File 'lib/active_support/vendor/builder-2.1.2/blankslate.rb', line 105 def append_features(mod) result = blankslate_original_append_features(mod) return result if mod != Object instance_methods.each do |name| BlankSlate.hide(name) end result 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_accessor_with_default(sym, default = nil, &block) ⇒ Object
Declare an attribute accessor with an initial default return value.
To give attribute :age
the initial value 25
:
class Person
attr_accessor_with_default :age, 25
end
some_person.age
=> 25
some_person.age = 26
some_person.age
=> 26
To give attribute :element_name
a dynamic default value, evaluated in scope of self:
attr_accessor_with_default(:element_name) { name.underscore }
21 22 23 24 25 26 27 28 29 30 |
# File 'lib/active_support/core_ext/module/attr_accessor_with_default.rb', line 21 def attr_accessor_with_default(sym, default = nil, &block) raise 'Default value or block required' unless !default.nil? || block define_method(sym, block_given? ? block : Proc.new { default }) module_eval(<<-EVAL, __FILE__, __LINE__) def #{sym}=(value) class << self; attr_reader :#{sym} end @#{sym} = value end EVAL 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 |
#blankslate_original_append_features ⇒ Object
104 |
# File 'lib/active_support/vendor/builder-2.1.2/blankslate.rb', line 104 alias blankslate_original_append_features append_features |
#const_missing(class_id) ⇒ Object
Use const_missing to autoload associations so we don’t have to require_association when using single-table inheritance.
452 453 454 |
# File 'lib/active_support/dependencies.rb', line 452 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
belongs_to :greeter
delegate :hello, :goodbye, :to => :greeter
end
Foo.new.goodbye # => "goodbye"
Methods can be delegated to instance variables, class variables, or constants by providing the variable as a symbol:
class Foo
CONSTANT_ARRAY = [0,1,2,3]
@@class_array = [4,5,6,7]
def initialize
@instance_array = [8,9,10,11]
end
delegate :sum, :to => :CONSTANT_ARRAY
delegate :min, :to => :@@class_array
delegate :max, :to => :@instance_array
end
Foo.new.sum # => 6
Foo.new.min # => 4
Foo.new.max # => 11
48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
# File 'lib/active_support/core_ext/module/delegation.rb', line 48 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 |
#local_constant_names ⇒ Object
Returns the names of the constants defined locally rather than the constants themselves. See local_constants
.
38 39 40 |
# File 'lib/active_support/core_ext/module/introspection.rb', line 38 def local_constant_names local_constants.map(&:to_s) end |
#local_constants ⇒ Object
Return the constants that have been defined locally by this object and not in an ancestor. This method may miss some constants if their definition in the ancestor is identical to their definition in the receiver.
25 26 27 28 29 30 31 32 33 34 |
# File 'lib/active_support/core_ext/module/introspection.rb', line 25 def local_constants inherited = {} ancestors.each do |anc| next if anc == self anc.constants.each { |const| inherited[const] = anc.const_get(const) } end constants.select do |const| ! inherited.key?(const) || inherited[const].object_id != const_get(const).object_id 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. 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
448 |
# File 'lib/active_support/dependencies.rb', line 448 alias :rails_original_const_missing :const_missing |
#unloadable(const_desc = self) ⇒ Object
456 457 458 |
# File 'lib/active_support/dependencies.rb', line 456 def unloadable(const_desc = self) super(const_desc) end |