require 'active_support/core_ext/kernel/singleton_class' require 'active_support/core_ext/module/remove_method' require 'active_support/core_ext/array/extract_options' class Class # 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 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 <<-RUBY, __FILE__, __LINE__ + 1 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 RUBY attr_writer name if instance_writer end end private def singleton_class? ancestors.first != self end end