Declare a class-level attribute whose value is inheritable by subclasses. Subclasses can change their own value and it will not impact parent class.
class Base class_attribute :setting end class Subclass < Base end Base.setting = true Subclass.setting # => true Subclass.setting = false Subclass.setting # => false Base.setting # => true
In the above case as long as Subclass does not assign a value to setting by performing Subclass.setting = something , Subclass.setting would read value assigned to parent class. Once Subclass assigns a value then the value assigned by Subclass would be returned.
This matches normal Ruby method inheritance: think of writing an attribute on a subclass as overriding the reader method. However, you need to be aware when using class_attribute with mutable structures as Array or Hash. In such cases, you don't want to do changes in places but use setters:
Base.setting = [] Base.setting # => [] Subclass.setting # => [] # Appending in child changes both parent and child because it is the same object: Subclass.setting << :foo Base.setting # => [:foo] Subclass.setting # => [:foo] # Use setters to not propagate changes: Base.setting = [] Subclass.setting += [:foo] Base.setting # => [] Subclass.setting # => [:foo]
For convenience, a query method is defined as well:
Subclass.setting? # => false
Instances may overwrite the class value in the same way:
Base.setting = true object = Base.new object.setting # => true object.setting = false object.setting # => false Base.setting # => true
To opt out of the instance reader method, pass :instance_reader => false.
object.setting # => NoMethodError object.setting? # => NoMethodError
To opt out of the instance writer method, pass :instance_writer => false.
object.setting = false # => NoMethodError
# File lib/whois/core_ext/class/attribute.rb, line 68 def class_attribute(*attrs) options = attrs.extract_options! instance_reader = options.fetch(:instance_reader, true) instance_writer = options.fetch(:instance_writer, true) attrs.each do |name| class_eval def self.#{name}() nil end def self.#{name}?() !!#{name} end def self.#{name}=(val) singleton_class.class_eval do remove_possible_method(:#{name}) define_method(:#{name}) { val } end if singleton_class? class_eval do remove_possible_method(:#{name}) def #{name} defined?(@#{name}) ? @#{name} : singleton_class.#{name} end end end val end if instance_reader remove_possible_method :#{name} def #{name} defined?(@#{name}) ? @#{name} : self.class.#{name} end def #{name}? !!#{name} end end, __FILE__, __LINE__ + 1 attr_writer name if instance_writer end end
Generated with the Darkfish Rdoc Generator 2.