### Home Classes Methods

### In Files

- lib/active_support/core_ext/object/duplicable.rb
- lib/active_support/core_ext/class/attribute_accessors.rb
- lib/active_support/core_ext/class/attribute.rb
- lib/active_support/core_ext/class/subclasses.rb
- lib/active_support/core_ext/class/delegating_attributes.rb

### Parent

Object

### Methods

- #cattr_accessor
- #cattr_reader
- #cattr_writer
- #class_attribute
- #duplicable?
- #superclass_delegating_accessor

### Class/Module Index

Quicksearch

- ActiveSupport
- ActiveSupport::Autoload
- ActiveSupport::BacktraceCleaner
- ActiveSupport::Base64
- ActiveSupport::BasicObject
- ActiveSupport::Benchmarkable
- ActiveSupport::BufferedLogger
- ActiveSupport::BufferedLogger::Severity
- ActiveSupport::Cache
- ActiveSupport::Cache::Entry
- ActiveSupport::Cache::FileStore
- ActiveSupport::Cache::MemCacheStore
- ActiveSupport::Cache::MemoryStore
- ActiveSupport::Cache::NullStore
- ActiveSupport::Cache::Store
- ActiveSupport::Cache::Strategy
- ActiveSupport::Cache::Strategy::LocalCache
- ActiveSupport::Cache::Strategy::LocalCache::LocalStore
- ActiveSupport::Callbacks
- ActiveSupport::Callbacks::ClassMethods
- ActiveSupport::Concern
- ActiveSupport::Configurable
- ActiveSupport::Configurable::ClassMethods
- ActiveSupport::Configurable::Configuration
- ActiveSupport::Dependencies
- ActiveSupport::Dependencies::ClassCache
- ActiveSupport::Dependencies::WatchStack
- ActiveSupport::Deprecation
- ActiveSupport::DescendantsTracker
- ActiveSupport::Duration
- ActiveSupport::FileUpdateChecker
- ActiveSupport::FileWatcher
- ActiveSupport::FileWatcher::Backend
- ActiveSupport::Gzip
- ActiveSupport::Gzip::Stream
- ActiveSupport::HashWithIndifferentAccess
- ActiveSupport::HashWithIndifferentAccess
- ActiveSupport::Inflector
- ActiveSupport::Inflector::Inflections
- ActiveSupport::InheritableOptions
- ActiveSupport::JSON
- ActiveSupport::JSON::Encoding
- ActiveSupport::JSON::Encoding::CircularReferenceError
- ActiveSupport::JSON::Encoding::Encoder
- ActiveSupport::JSON::Variable
- ActiveSupport::LogSubscriber
- ActiveSupport::LogSubscriber::TestHelper
- ActiveSupport::LogSubscriber::TestHelper::MockLogger
- ActiveSupport::Memoizable
- ActiveSupport::Memoizable::InstanceMethods
- ActiveSupport::MessageEncryptor
- ActiveSupport::MessageEncryptor::InvalidMessage
- ActiveSupport::MessageVerifier
- ActiveSupport::MessageVerifier::InvalidSignature
- ActiveSupport::Multibyte
- ActiveSupport::Multibyte::Chars
- ActiveSupport::Multibyte::EncodingError
- ActiveSupport::Multibyte::Unicode
- ActiveSupport::Multibyte::Unicode::Codepoint
- ActiveSupport::Multibyte::Unicode::UnicodeDatabase
- ActiveSupport::Notifications
- ActiveSupport::Notifications::Event
- ActiveSupport::Notifications::Fanout
- ActiveSupport::Notifications::Instrumenter
- ActiveSupport::OrderedHash
- ActiveSupport::OrderedOptions
- ActiveSupport::Railtie
- ActiveSupport::Rescuable
- ActiveSupport::Rescuable::ClassMethods
- ActiveSupport::SafeBuffer
- ActiveSupport::SafeBuffer::SafeConcatError
- ActiveSupport::StringInquirer
- ActiveSupport::TaggedLogging
- ActiveSupport::TestCase
- ActiveSupport::Testing
- ActiveSupport::Testing::Assertions
- ActiveSupport::Testing::Declarative
- ActiveSupport::Testing::Isolation
- ActiveSupport::Testing::Isolation::Forking
- ActiveSupport::Testing::Isolation::MiniTest
- ActiveSupport::Testing::Isolation::Subprocess
- ActiveSupport::Testing::Isolation::TestUnit
- ActiveSupport::Testing::Pending
- ActiveSupport::Testing::Performance
- ActiveSupport::Testing::Performance::Benchmarker
- ActiveSupport::Testing::Performance::ForClassicTestUnit
- ActiveSupport::Testing::Performance::ForMiniTest
- ActiveSupport::Testing::Performance::Metrics
- ActiveSupport::Testing::Performance::Metrics::Amount
- ActiveSupport::Testing::Performance::Metrics::Base
- ActiveSupport::Testing::Performance::Metrics::CpuTime
- ActiveSupport::Testing::Performance::Metrics::DigitalInformationUnit
- ActiveSupport::Testing::Performance::Metrics::GcRuns
- ActiveSupport::Testing::Performance::Metrics::GcTime
- ActiveSupport::Testing::Performance::Metrics::Memory
- ActiveSupport::Testing::Performance::Metrics::Objects
- ActiveSupport::Testing::Performance::Metrics::ProcessTime
- ActiveSupport::Testing::Performance::Metrics::Time
- ActiveSupport::Testing::Performance::Metrics::UserTime
- ActiveSupport::Testing::Performance::Metrics::WallTime
- ActiveSupport::Testing::Performance::Performer
- ActiveSupport::Testing::Performance::Profiler
- ActiveSupport::Testing::ProxyTestResult
- ActiveSupport::Testing::RemoteError
- ActiveSupport::Testing::SetupAndTeardown
- ActiveSupport::Testing::SetupAndTeardown::ClassMethods
- ActiveSupport::Testing::SetupAndTeardown::ForClassicTestUnit
- ActiveSupport::Testing::SetupAndTeardown::ForMiniTest
- ActiveSupport::TimeWithZone
- ActiveSupport::TimeZone
- ActiveSupport::XmlMini
- ActiveSupport::XmlMini_LibXMLSAX
- ActiveSupport::XmlMini_LibXMLSAX::HashBuilder
- ActiveSupport::XmlMini_NokogiriSAX
- ActiveSupport::XmlMini_NokogiriSAX::HashBuilder
- Test
- Test::Unit
- Test::Unit::Collector
- Test::Unit::Collector::ObjectSpace
- Object
- Object::HashWithIndifferentAccess
- Object::MissingSourceFile
- ERB
- ERB::Util
- I18n
- I18n::Railtie
- LoadError
- LoadError
- Logger
- Logger::SimpleFormatter
- Array
- Base64
- Benchmark
- BigDecimal
- Class
- Date
- DateTime
- Enumerable
- FalseClass
- File
- Float
- Hash
- Integer
- Kernel
- Module
- NameError
- NilClass
- Numeric
- Process
- QualifiedConstUtils
- Range
- Regexp
- String
- Symbol
- Time
- TrueClass
- URI

No matching classes.

# Class

Extends the class object with class and instance accessors for class attributes, just like the native attr* accessors for instance attributes.

### Public Instance Methods

cattr_accessor(*syms, &blk) click to toggle source

Defines both class and instance accessors for class attributes.

    class Person
      cattr_accessor :hair_colors
    end

    Person.hair_colors = [:brown, :black, :blonde, :red]
    Person.hair_colors     # => [:brown, :black, :blonde, :red]
    Person.new.hair_colors # => [:brown, :black, :blonde, :red]

If a subclass changes the value then that would also change the value for parent class. Similarly if parent class changes the value then that would change the value of subclasses too.

    class Male < Person
    end

    Male.hair_colors << :blue
    Person.hair_colors # => [:brown, :black, :blonde, :red, :blue]

To opt out of the instance writer method, pass `:instance_writer => false`. To opt out of the instance reader method, pass `:instance_reader => false`.

    class Person
      cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
    end

    Person.new.hair_colors = [:brown]  # => NoMethodError
    Person.new.hair_colors             # => NoMethodError

Or pass `:instance_accessor => false`, to opt out both instance methods.

    class Person
      cattr_accessor :hair_colors, :instance_accessor => false
    end

    Person.new.hair_colors = [:brown]  # => NoMethodError
    Person.new.hair_colors             # => NoMethodError

Also you can pass a block to set up the attribute with a default value.

    class Person
      cattr_accessor :hair_colors do
        [:brown, :black, :blonde, :red]
      end
    end

    Person.class_variable_get("@@hair_colors") #=> [:brown, :black, :blonde, :red]

    # File lib/active_support/core_ext/class/attribute_accessors.rb, line 164
    def cattr_accessor(*syms, &blk)
      cattr_reader(*syms)
      cattr_writer(*syms, &blk)
    end

cattr_reader(*syms) click to toggle source

Defines a class attribute if it’s not defined and creates a reader method that returns the attribute value.

    class Person
      cattr_reader :hair_colors
    end

    Person.class_variable_set("@@hair_colors", [:brown, :black])
    Person.hair_colors     # => [:brown, :black]
    Person.new.hair_colors # => [:brown, :black]

The attribute name must be a valid method name in Ruby.

    class Person
      cattr_reader :"1_Badname "
    end
    # => NameError: invalid attribute name

If you want to opt out the instance reader method, you can pass `:instance_reader => false` or `:instance_accessor => false`.

    class Person
      cattr_reader :hair_colors, :instance_reader => false
    end

    Person.new.hair_colors # => NoMethodError

    # File lib/active_support/core_ext/class/attribute_accessors.rb, line 32
    def cattr_reader(*syms)
      options = syms.extract_options!
      syms.each do |sym|
        class_eval(        unless defined? @@#{sym}          @@#{sym} = nil        end        def self.#{sym}          @@#{sym}        end, __FILE__, __LINE__ + 1)

        unless options[:instance_reader] == false || options[:instance_accessor] == false
          class_eval(          def #{sym}            @@#{sym}          end, __FILE__, __LINE__ + 1)
        end
      end
    end

cattr_writer(*syms) click to toggle source

Defines a class attribute if it’s not defined and creates a writer method to allow assignment to the attribute.

    class Person
      cattr_writer :hair_colors
    end

    Person.hair_colors = [:brown, :black]
    Person.class_variable_get("@@hair_colors") # => [:brown, :black]
    Person.new.hair_colors = [:blonde, :red]
    Person.class_variable_get("@@hair_colors") # => [:blonde, :red]

The attribute name must be a valid method name in Ruby.

    class Person
      cattr_writer :"1_Badname "
    end
    # => NameError: invalid attribute name

If you want to opt out the instance writer method, pass `:instance_writer => false` or `:instance_accessor => false`.

    class Person
      cattr_writer :hair_colors, :instance_writer => false
    end

    Person.new.hair_colors = [:blonde, :red] # => NoMethodError

Also, you can pass a block to set up the attribute with a default value.

    class Person
      cattr_writer :hair_colors do
        [:brown, :black, :blonde, :red]
      end
    end

    Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]

    # File lib/active_support/core_ext/class/attribute_accessors.rb, line 92
    def cattr_writer(*syms)
      options = syms.extract_options!
      syms.each do |sym|
        class_eval(        unless defined? @@#{sym}          @@#{sym} = nil        end        def self.#{sym}=(obj)          @@#{sym} = obj        end, __FILE__, __LINE__ + 1)

        unless options[:instance_writer] == false || options[:instance_accessor] == false
          class_eval(          def #{sym}=(obj)            @@#{sym} = obj          end, __FILE__, __LINE__ + 1)
        end
        self.send("#{sym}=", yield) if block_given?
      end
    end

class_attribute(*attrs) click to toggle source

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/active_support/core_ext/class/attribute.rb, line 68
    def class_attribute(*attrs)
      options = attrs.extract_options!
      instance_reader = 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

duplicable?() click to toggle source

Classes are not duplicable:

    c = Class.new # => #<Class:0x10328fd80>
    c.dup         # => #<Class:0x10328fd80>

Note `dup` returned the same class object.

    # File lib/active_support/core_ext/object/duplicable.rb, line 91
    def duplicable?
      false
    end

superclass_delegating_accessor(name, options = {}) click to toggle source

    # File lib/active_support/core_ext/class/delegating_attributes.rb, line 7
    def superclass_delegating_accessor(name, options = {})
      # Create private _name and _name= methods that can still be used if the public
      # methods are overridden. This allows
      _superclass_delegating_accessor("_#{name}")

      # Generate the public methods name, name=, and name?
      # These methods dispatch to the private _name, and _name= methods, making them
      # overridable
      singleton_class.send(:define_method, name) { send("_#{name}") }
      singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
      singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }

      # If an instance_reader is needed, generate methods for name and name= on the
      # class itself, so instances will be able to see them
      define_method(name) { send("_#{name}") } if options[:instance_reader] != false
      define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.