Class: Class

Inherits:
Object show all
Defined in:
lib/active_support/core_ext/class/subclasses.rb,
lib/active_support/core_ext/class/attribute.rb,
lib/active_support/core_ext/object/duplicable.rb,
lib/active_support/core_ext/class/attribute_accessors.rb,
lib/active_support/core_ext/class/delegating_attributes.rb,
lib/active_support/core_ext/class/inheritable_attributes.rb,
lib/active_support/core_ext/class/inheritable_attributes.rb

Overview

Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of their parents’ attributes, instead of just a pointer to the same. This means that the child can add elements to, for example, an array without those additions being shared with either their parent, siblings, or children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.

The copies of inheritable parent attributes are added to subclasses when they are created, via the inherited hook.

Constant Summary collapse

EMPTY_INHERITABLE_ATTRIBUTES =

Prevent this constant from being created multiple times

{}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.subclasses_of(*superclasses) ⇒ Object

Exclude this class unless it’s a subclass of our supers and is defined. We check defined? in case we find a removed class that has yet to be garbage collected. This also fails for anonymous classes – please submit a patch if you have a workaround.



48
49
50
51
52
53
54
 
# File 'lib/active_support/core_ext/class/subclasses.rb', line 48

def self.subclasses_of(*superclasses) #:nodoc:
  subclasses = []
  superclasses.each do |klass|
    subclasses.concat klass.descendents.select {|k| k.anonymous? || k.reachable?}
  end
  subclasses
end

Instance Method Details

#cattr_accessor(*syms, &blk) ⇒ Object 



59
60
61
62
 
# File 'lib/active_support/core_ext/class/attribute_accessors.rb', line 59

def cattr_accessor(*syms, &blk)
  cattr_reader(*syms)
  cattr_writer(*syms, &blk)
end

#cattr_reader(*syms) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/active_support/core_ext/class/attribute_accessors.rb', line 12

def cattr_reader(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval("      unless defined? @@\#{sym}\n        @@\#{sym} = nil\n      end\n\n      def self.\#{sym}\n        @@\#{sym}\n      end\n    EOS\n\n    unless options[:instance_reader] == false\n      class_eval(<<-EOS, __FILE__, __LINE__ + 1)\n        def \#{sym}\n          @@\#{sym}\n        end\n      EOS\n    end\n  end\nend\n", __FILE__, __LINE__ + 1)

#cattr_writer(*syms) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/active_support/core_ext/class/attribute_accessors.rb', line 35

def cattr_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval("      unless defined? @@\#{sym}\n        @@\#{sym} = nil\n      end\n\n      def self.\#{sym}=(obj)\n        @@\#{sym} = obj\n      end\n    EOS\n\n    unless options[:instance_writer] == false\n      class_eval(<<-EOS, __FILE__, __LINE__ + 1)\n        def \#{sym}=(obj)\n          @@\#{sym} = obj\n        end\n      EOS\n    end\n    self.send(\"\#{sym}=\", yield) if block_given?\n  end\nend\n", __FILE__, __LINE__ + 1)

#class_attribute(*attrs) ⇒ Object

Declare a class-level attribute whose value is inheritable and overwritable by subclasses:

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

This matches normal Ruby method inheritance: think of writing an attribute on a subclass as overriding the reader method.

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 writer method, pass :instance_writer => false.

object.setting = false  # => NoMethodError



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/active_support/core_ext/class/attribute.rb', line 40

def class_attribute(*attrs)
  instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]

  attrs.each do |name|
    class_eval "      def self.\#{name}() nil end\n      def self.\#{name}?() !!\#{name} end\n\n      def self.\#{name}=(val)\n        singleton_class.class_eval do\n          remove_possible_method(:\#{name})\n          define_method(:\#{name}) { val }\n        end\n      end\n\n      def \#{name}\n        defined?(@\#{name}) ? @\#{name} : singleton_class.\#{name}\n      end\n\n      def \#{name}?\n        !!\#{name}\n      end\n    RUBY\n\n    attr_writer name if instance_writer\n  end\nend\n", __FILE__, __LINE__ + 1

#class_inheritable_accessor(*syms) ⇒ Object 



85
86
87
88
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 85

def class_inheritable_accessor(*syms)
  class_inheritable_reader(*syms)
  class_inheritable_writer(*syms)
end

#class_inheritable_array(*syms) ⇒ Object 



90
91
92
93
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 90

def class_inheritable_array(*syms)
  class_inheritable_reader(*syms)
  class_inheritable_array_writer(*syms)
end

#class_inheritable_array_writer(*syms) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 51

def class_inheritable_array_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval("      def self.\#{sym}=(obj)                          # def self.levels=(obj)\n        write_inheritable_array(:\#{sym}, obj)        #   write_inheritable_array(:levels, obj)\n      end                                            # end\n                                                     #\n      \#{\"                                            #\n      def \#{sym}=(obj)                               # def levels=(obj)\n        self.class.\#{sym} = obj                      #   self.class.levels = obj\n      end                                            # end\n      \" unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false\n    EOS\n  end\nend\n", __FILE__, __LINE__ + 1)

#class_inheritable_hash(*syms) ⇒ Object 



95
96
97
98
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 95

def class_inheritable_hash(*syms)
  class_inheritable_reader(*syms)
  class_inheritable_hash_writer(*syms)
end

#class_inheritable_hash_writer(*syms) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 68

def class_inheritable_hash_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval("      def self.\#{sym}=(obj)                          # def self.nicknames=(obj)\n        write_inheritable_hash(:\#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)\n      end                                            # end\n                                                     #\n      \#{\"                                            #\n      def \#{sym}=(obj)                               # def nicknames=(obj)\n        self.class.\#{sym} = obj                      #   self.class.nicknames = obj\n      end                                            # end\n      \" unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false\n    EOS\n  end\nend\n", __FILE__, __LINE__ + 1)

#class_inheritable_reader(*syms) ⇒ Object

:nodoc:



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 16

def class_inheritable_reader(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    next if sym.is_a?(Hash)
    class_eval("      def self.\#{sym}                                # def self.after_add\n        read_inheritable_attribute(:\#{sym})          #   read_inheritable_attribute(:after_add)\n      end                                            # end\n                                                     #\n      \#{\"                                            #\n      def \#{sym}                                     # def after_add\n        self.class.\#{sym}                            #   self.class.after_add\n      end                                            # end\n      \" unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false\n    EOS\n  end\nend\n", __FILE__, __LINE__ + 1)

#class_inheritable_writer(*syms) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 34

def class_inheritable_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval("      def self.\#{sym}=(obj)                          # def self.color=(obj)\n        write_inheritable_attribute(:\#{sym}, obj)    #   write_inheritable_attribute(:color, obj)\n      end                                            # end\n                                                     #\n      \#{\"                                            #\n      def \#{sym}=(obj)                               # def color=(obj)\n        self.class.\#{sym} = obj                      #   self.class.color = obj\n      end                                            # end\n      \" unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false\n    EOS\n  end\nend\n", __FILE__, __LINE__ + 1)

#descendents ⇒ Object 



14
15
16
17
18
 
# File 'lib/active_support/core_ext/class/subclasses.rb', line 14

def descendents
  subclasses = []
  __subclasses__.each {|k| subclasses << k; subclasses.concat k.descendents }
  subclasses
end

#duplicable? ⇒ Boolean

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/active_support/core_ext/object/duplicable.rb', line 56

def duplicable?
  false
end

#extlib_inheritable_accessor(*syms, &block) ⇒ Array[#to_s]

Defines class-level inheritable attribute accessor. Attributes are available to subclasses, each subclass has a copy of parent’s attribute.

Parameters:

  • *syms (Array[*#to_s, Hash{:instance_writer => Boolean}]) —

    Array of attributes to define inheritable accessor for.

  • syms (Hash) —

    a customizable set of options

Options Hash (*syms):

  • :instance_writer (Boolean) —

    if true, instance-level inheritable attribute writer is defined.

Returns:

  • (Array[#to_s]) —

    An Array of attributes turned into inheritable accessors.



228
229
230
231
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 228

def extlib_inheritable_accessor(*syms, &block)
  extlib_inheritable_reader(*syms)
  extlib_inheritable_writer(*syms, &block)
end

#extlib_inheritable_reader(*ivars, &block) ⇒ Array[#to_s]

TODO:

Do we want to block instance_reader via :instance_reader => false

TODO:

It would be preferable that we do something with a Hash passed in (error out or do the same as other methods above) instead of silently moving on). In particular, this makes the return value of this function less useful.

Defines class-level inheritable attribute reader. Attributes are available to subclasses, each subclass has a copy of parent’s attribute.

Parameters:

  • *syms (Array[#to_s]) —

    Array of attributes to define inheritable reader for.

Returns:

  • (Array[#to_s]) —

    Array of attributes converted into inheritable_readers.



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 165

def extlib_inheritable_reader(*ivars, &block)
  options = ivars.extract_options!

  ivars.each do |ivar|
    self.class_eval "      def self.\#{ivar}\n        return @\#{ivar} if self.object_id == \#{self.object_id} || defined?(@\#{ivar})\n        ivar = superclass.\#{ivar}\n        return nil if ivar.nil? && !\#{self}.instance_variable_defined?(\"@\#{ivar}\")\n        @\#{ivar} = ivar.duplicable? ? ivar.dup : ivar\n      end\n    RUBY\n    unless options[:instance_reader] == false\n      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1\n        def \#{ivar}\n          self.class.\#{ivar}\n        end\n      RUBY\n    end\n    instance_variable_set(:\"@\#{ivar}\", yield) if block_given?\n  end\nend\n", __FILE__, __LINE__ + 1

#extlib_inheritable_writer(*ivars) ⇒ Array[#to_s]

TODO:

We need a style for class_eval <<-HEREDOC. I’d like to make it class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.

Defines class-level inheritable attribute writer. Attributes are available to subclasses, each subclass has a copy of parent’s attribute.

Parameters:

  • *syms (Array[*#to_s, Hash{:instance_writer => Boolean}]) —

    Array of attributes to define inheritable writer for.

  • syms (Hash) —

    a customizable set of options

Returns:

  • (Array[#to_s]) —

    An Array of the attributes that were made into inheritable writers.



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 200

def extlib_inheritable_writer(*ivars)
  options = ivars.extract_options!

  ivars.each do |ivar|
    self.class_eval "      def self.\#{ivar}=(obj)\n        @\#{ivar} = obj\n      end\n    RUBY\n    unless options[:instance_writer] == false\n      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1\n        def \#{ivar}=(obj) self.class.\#{ivar} = obj end\n      RUBY\n    end\n\n    self.send(\"\#{ivar}=\", yield) if block_given?\n  end\nend\n", __FILE__, __LINE__ + 1

#inheritable_attributes ⇒ Object 



100
101
102
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 100

def inheritable_attributes
  @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
end

#read_inheritable_attribute(key) ⇒ Object 



121
122
123
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 121

def read_inheritable_attribute(key)
  inheritable_attributes[key]
end

#reset_inheritable_attributes ⇒ Object 



125
126
127
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 125

def reset_inheritable_attributes
  @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
end

#subclasses ⇒ Object

Returns an array with the names of the subclasses of self as strings.

Integer.subclasses # => ["Bignum", "Fixnum"]



8
9
10
 
# File 'lib/active_support/core_ext/class/subclasses.rb', line 8

def subclasses
  Class.subclasses_of(self).map { |o| o.to_s }
end

#superclass_delegating_accessor(name, options = {}) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# 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

#write_inheritable_array(key, elements) ⇒ Object 



111
112
113
114
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 111

def write_inheritable_array(key, elements)
  write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
  write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
end

#write_inheritable_attribute(key, value) ⇒ Object 



104
105
106
107
108
109
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 104

def write_inheritable_attribute(key, value)
  if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
    @inheritable_attributes = {}
  end
  inheritable_attributes[key] = value
end

#write_inheritable_hash(key, hash) ⇒ Object 



116
117
118
119
 
# File 'lib/active_support/core_ext/class/inheritable_attributes.rb', line 116

def write_inheritable_hash(key, hash)
  write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
  write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
end