Extends the API for constants to be able to deal with qualified names. Arguments are assumed to be relative to the receiver.
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"
# File lib/active_support/core_ext/module/aliasing.rb, line 63 63: def alias_attribute(new_name, old_name) 64: module_eval def #{new_name}; self.#{old_name}; end # def subject; self.title; end def #{new_name}?; self.#{old_name}?; end # def subject?; self.title?; end def #{new_name}=(v); self.#{old_name} = v; end # def subject=(v); self.title = v; end, __FILE__, __LINE__ + 1 65: end
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.
# File lib/active_support/core_ext/module/aliasing.rb, line 23 23: def alias_method_chain(target, feature) 24: # Strip out punctuation on predicates or bang methods since 25: # e.g. target?_without_feature is not a valid method name. 26: aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1 27: yield(aliased_target, punctuation) if block_given? 28: 29: with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}" 30: 31: alias_method without_method, target 32: alias_method target, with_method 33: 34: case 35: when public_method_defined?(without_method) 36: public target 37: when protected_method_defined?(without_method) 38: protected target 39: when private_method_defined?(without_method) 40: private target 41: end 42: end
A module may or may not have a name.
module M; end M.name # => "M" m = Module.new m.name # => ""
A module gets a name when it is first assigned to a constant. Either via the module or class keyword or by an explicit assignment:
m = Module.new # creates an anonymous module M = m # => m gets a name here as a side-effect m.name # => "M"
# File lib/active_support/core_ext/module/anonymous.rb, line 19 19: def anonymous? 20: # Uses blank? because the name of an anonymous class is an empty 21: # string in 1.8, and nil in 1.9. 22: name.blank? 23: end
Declares an attribute reader and writer backed by an internally-named instance variable.
# File lib/active_support/core_ext/module/attr_internal.rb, line 14 14: def attr_internal_accessor(*attrs) 15: attr_internal_reader(*attrs) 16: attr_internal_writer(*attrs) 17: end
Declares an attribute reader backed by an internally-named instance variable.
# File lib/active_support/core_ext/module/attr_internal.rb, line 3 3: def attr_internal_reader(*attrs) 4: attrs.each {|attr_name| attr_internal_define(attr_name, :reader)} 5: end
Declares an attribute writer backed by an internally-named instance variable.
# File lib/active_support/core_ext/module/attr_internal.rb, line 8 8: def attr_internal_writer(*attrs) 9: attrs.each {|attr_name| attr_internal_define(attr_name, :writer)} 10: end
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 via the :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 them as a symbols:
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
Delegates can optionally be prefixed using the :prefix option. If the value is true, the delegate methods are prefixed with the name of the object being delegated to.
Person = Struct.new(:name, :address) class Invoice < Struct.new(:client) delegate :name, :address, :to => :client, :prefix => true end john_doe = Person.new("John Doe", "Vimmersvej 13") invoice = Invoice.new(john_doe) invoice.client_name # => "John Doe" invoice.client_address # => "Vimmersvej 13"
It is also possible to supply a custom prefix.
class Invoice < Struct.new(:client) delegate :name, :address, :to => :client, :prefix => :customer end invoice = Invoice.new(john_doe) invoice.customer_name # => "John Doe" invoice.customer_address # => "Vimmersvej 13"
If the delegate object is nil an exception is raised, and that happens no matter whether nil responds to the delegated method. You can get a nil instead with the :allow_nil option.
class Foo attr_accessor :bar def initialize(bar = nil) @bar = bar end delegate :zoo, :to => :bar end Foo.new.zoo # raises NoMethodError exception (you called nil.zoo) class Foo attr_accessor :bar def initialize(bar = nil) @bar = bar end delegate :zoo, :to => :bar, :allow_nil => true end Foo.new.zoo # returns nil
# File lib/active_support/core_ext/module/delegation.rb, line 104 104: def delegate(*methods) 105: options = methods.pop 106: unless options.is_a?(Hash) && to = options[:to] 107: raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)." 108: end 109: prefix, to, allow_nil = options[:prefix], options[:to], options[:allow_nil] 110: 111: if prefix == true && to.to_s =~ /^[^a-z_]/ 112: raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method." 113: end 114: 115: method_prefix = 116: if prefix 117: "#{prefix == true ? to : prefix}_" 118: else 119: '' 120: end 121: 122: file, line = caller.first.split(':', 2) 123: line = line.to_i 124: 125: methods.each do |method| 126: method = method.to_s 127: 128: if allow_nil 129: module_eval( def #{method_prefix}#{method}(*args, &block) # def customer_name(*args, &block) if #{to} || #{to}.respond_to?(:#{method}) # if client || client.respond_to?(:name) #{to}.__send__(:#{method}, *args, &block) # client.__send__(:name, *args, &block) end # end end # end, file, line - 2) 130: else 131: exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") 132: 133: module_eval( def #{method_prefix}#{method}(*args, &block) # def customer_name(*args, &block) #{to}.__send__(:#{method}, *args, &block) # client.__send__(:name, *args, &block) rescue NoMethodError # rescue NoMethodError if #{to}.nil? # if client.nil? #{exception} # # add helpful message to the exception else # else raise # raise end # end end # end, file, line - 1) 134: end 135: end 136: end
Declare that a method has been deprecated.
deprecate :foo deprecate :bar => 'message' deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
# File lib/active_support/core_ext/module/deprecation.rb, line 6 6: def deprecate(*method_names) 7: ActiveSupport::Deprecation.deprecate_methods(self, *method_names) 8: end
Modules are not duplicable:
m = Module.new # => #<Module:0x10328b6e0> m.dup # => #<Module:0x10328b6e0>
Note dup returned the same module object.
# File lib/active_support/core_ext/object/duplicable.rb, line 103 103: def duplicable? 104: false 105: end
# File lib/active_support/core_ext/module/method_names.rb, line 3 3: def instance_method_names(*args) 4: instance_methods(*args).map(&:to_s) 5: end
Returns the names of the constants defined locally rather than the constants themselves. See local_constants.
# File lib/active_support/core_ext/module/introspection.rb, line 85 85: def local_constant_names 86: local_constants.map { |c| c.to_s } 87: end
Returns the constants that have been defined locally by this object and not in an ancestor. This method is exact if running under Ruby 1.9. In previous versions it may miss some constants if their definition in some ancestor is identical to their definition in the receiver.
# File lib/active_support/core_ext/module/introspection.rb, line 65 65: def local_constants 66: inherited = {} 67: 68: ancestors.each do |anc| 69: next if anc == self 70: anc.constants.each { |const| inherited[const] = anc.const_get(const) } 71: end 72: 73: constants.select do |const| 74: !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id 75: end 76: end
Extends the module object with module and instance accessors for class attributes, just like the native attr* accessors for instance attributes.
module AppConfiguration mattr_accessor :google_api_key self.google_api_key = "123456789" mattr_accessor :paypal_url self.paypal_url = "www.sandbox.paypal.com" end AppConfiguration.google_api_key = "overriding the api key!"
To opt out of the instance writer method, pass :instance_writer => false. To opt out of the instance reader method, pass :instance_reader => false. To opt out of both instance methods, pass :instance_accessor => false.
# File lib/active_support/core_ext/module/attribute_accessors.rb, line 60 60: def mattr_accessor(*syms) 61: mattr_reader(*syms) 62: mattr_writer(*syms) 63: end
# File lib/active_support/core_ext/module/attribute_accessors.rb, line 4 4: def mattr_reader(*syms) 5: options = syms.extract_options! 6: syms.each do |sym| 7: class_eval( @@#{sym} = nil unless defined? @@#{sym} def self.#{sym} @@#{sym} end, __FILE__, __LINE__ + 1) 8: 9: unless options[:instance_reader] == false || options[:instance_accessor] == false 10: class_eval( def #{sym} @@#{sym} end, __FILE__, __LINE__ + 1) 11: end 12: end 13: end
# File lib/active_support/core_ext/module/attribute_accessors.rb, line 25 25: def mattr_writer(*syms) 26: options = syms.extract_options! 27: syms.each do |sym| 28: class_eval( def self.#{sym}=(obj) @@#{sym} = obj end, __FILE__, __LINE__ + 1) 29: 30: unless options[:instance_writer] == false || options[:instance_accessor] == false 31: class_eval( def #{sym}=(obj) @@#{sym} = obj end, __FILE__, __LINE__ + 1) 32: end 33: end 34: end
# File lib/active_support/core_ext/module/method_names.rb, line 7 7: def method_names(*args) 8: methods(*args).map(&:to_s) 9: end
Returns the module which contains this one according to its name.
module M module N end end X = M::N M::N.parent # => M X.parent # => M
The parent of top-level and anonymous modules is Object.
M.parent # => Object Module.new.parent # => Object
# File lib/active_support/core_ext/module/introspection.rb, line 30 30: def parent 31: parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object 32: end
Returns the name of the module containing this one.
M::N.parent_name # => "M"
# File lib/active_support/core_ext/module/introspection.rb, line 7 7: def parent_name 8: unless defined? @parent_name 9: @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil 10: end 11: @parent_name 12: end
Returns all the parents of this module according to its name, ordered from nested outwards. The receiver is not contained within the result.
module M module N end end X = M::N M.parents # => [Object] M::N.parents # => [M, Object] X.parents # => [M, Object]
# File lib/active_support/core_ext/module/introspection.rb, line 47 47: def parents 48: parents = [] 49: if parent_name 50: parts = parent_name.split('::') 51: until parts.empty? 52: parents << ActiveSupport::Inflector.constantize(parts * '::') 53: parts.pop 54: end 55: end 56: parents << Object unless parents.include? Object 57: parents 58: end
# File lib/active_support/core_ext/module/qualified_const.rb, line 37 37: def qualified_const_defined?(path, search_parents=true) 38: QualifiedConstUtils.raise_if_absolute(path) 39: 40: QualifiedConstUtils.names(path).inject(self) do |mod, name| 41: return unless mod.const_defined?(name, search_parents) 42: mod.const_get(name) 43: end 44: return true 45: end
# File lib/active_support/core_ext/module/qualified_const.rb, line 27 27: def qualified_const_defined?(path) 28: QualifiedConstUtils.raise_if_absolute(path) 29: 30: QualifiedConstUtils.names(path).inject(self) do |mod, name| 31: return unless mod.const_defined?(name) 32: mod.const_get(name) 33: end 34: return true 35: end
# File lib/active_support/core_ext/module/qualified_const.rb, line 48 48: def qualified_const_get(path) 49: QualifiedConstUtils.raise_if_absolute(path) 50: 51: QualifiedConstUtils.names(path).inject(self) do |mod, name| 52: mod.const_get(name) 53: end 54: end
# File lib/active_support/core_ext/module/qualified_const.rb, line 56 56: def qualified_const_set(path, value) 57: QualifiedConstUtils.raise_if_absolute(path) 58: 59: const_name = path.demodulize 60: mod_name = path.deconstantize 61: mod = mod_name.empty? ? self : qualified_const_get(mod_name) 62: mod.const_set(const_name, value) 63: end
# File lib/active_support/core_ext/module/remove_method.rb, line 12 12: def redefine_method(method, &block) 13: remove_possible_method(method) 14: define_method(method, &block) 15: end
# File lib/active_support/core_ext/module/remove_method.rb, line 2 2: def remove_possible_method(method) 3: if method_defined?(method) || private_method_defined?(method) 4: remove_method(method) 5: end 6: rescue NameError 7: # If the requested method is defined on a superclass or included module, 8: # method_defined? returns true but remove_method throws a NameError. 9: # Ignore this. 10: end
Synchronize access around a method, delegating synchronization to a particular mutex. A mutex (either a Mutex, or any object that responds to # and yields to a block) must be provided as a final :with option. The :with option should be a symbol or string, and can represent a method, constant, or instance or class variable. Example:
class SharedCache @@lock = Mutex.new def expire ... end synchronize :expire, :with => :@@lock end
# File lib/active_support/core_ext/module/synchronization.rb, line 20 20: def synchronize(*methods) 21: options = methods.extract_options! 22: unless options.is_a?(Hash) && with = options[:with] 23: raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)." 24: end 25: 26: methods.each do |method| 27: aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1 28: 29: if method_defined?("#{aliased_method}_without_synchronization#{punctuation}") 30: raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported." 31: end 32: 33: module_eval( def #{aliased_method}_with_synchronization#{punctuation}(*args, &block) # def expire_with_synchronization(*args, &block) #{with}.synchronize do # @@lock.synchronize do #{aliased_method}_without_synchronization#{punctuation}(*args, &block) # expire_without_synchronization(*args, &block) end # end end # end, __FILE__, __LINE__ + 1) 34: 35: alias_method_chain method, :synchronization 36: end 37: end
# File lib/active_support/core_ext/module/attr_internal.rb, line 29 29: def attr_internal_define(attr_name, type) 30: internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '') 31: class_eval do # class_eval is necessary on 1.9 or else the methods a made private 32: # use native attr_* methods as they are faster on some Ruby implementations 33: send("attr_#{type}", internal_name) 34: end 35: attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer 36: alias_method attr_name, internal_name 37: remove_method internal_name 38: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.