Class: Class

Inherits:
Object show all
Defined in:
lib/core_ext/duplicable.rb,
lib/core_ext/inheritable_attributes.rb,
lib/core_ext/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.

Constant Summary collapse

EMPTY_INHERITABLE_ATTRIBUTES =

Prevent this constant from being created multiple times

{}.freeze

Instance Method Summary collapse

Instance Method Details

#class_inheritable_accessor(*syms) ⇒ Object 



77
78
79
80
 
# File 'lib/core_ext/inheritable_attributes.rb', line 77

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

#class_inheritable_array(*syms) ⇒ Object 



82
83
84
85
 
# File 'lib/core_ext/inheritable_attributes.rb', line 82

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

#class_inheritable_array_writer(*syms) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/core_ext/inheritable_attributes.rb', line 43

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 



87
88
89
90
 
# File 'lib/core_ext/inheritable_attributes.rb', line 87

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

#class_inheritable_hash_writer(*syms) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/core_ext/inheritable_attributes.rb', line 60

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:



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/core_ext/inheritable_attributes.rb', line 11

def class_inheritable_reader(*syms)
  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      def \#{sym}                              # def after_add\n        self.class.\#{sym}                     #   self.class.after_add\n      end                                     # end\n    EOS\n  end\nend\n", __FILE__, __LINE__ + 1)

#class_inheritable_writer(*syms) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/core_ext/inheritable_attributes.rb', line 26

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)

#duplicable? ⇒ Boolean

Returns:

  • (Boolean) 


40
41
42
 
# File 'lib/core_ext/duplicable.rb', line 40

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.



218
219
220
221
 
# File 'lib/core_ext/inheritable_attributes.rb', line 218

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

#extlib_inheritable_reader(*ivars) ⇒ 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.



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/core_ext/inheritable_attributes.rb', line 157

def extlib_inheritable_reader(*ivars)
  instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)

  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 && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar\n      end\n    RUBY\n    unless 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  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.



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/core_ext/inheritable_attributes.rb', line 191

def extlib_inheritable_writer(*ivars)
  instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
  ivars.each do |ivar|
    self.class_eval "      def self.\#{ivar}=(obj)\n        @\#{ivar} = obj\n      end\n    RUBY\n    unless 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 



92
93
94
 
# File 'lib/core_ext/inheritable_attributes.rb', line 92

def inheritable_attributes
  @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
end

#read_inheritable_attribute(key) ⇒ Object 



113
114
115
 
# File 'lib/core_ext/inheritable_attributes.rb', line 113

def read_inheritable_attribute(key)
  inheritable_attributes[key]
end

#reset_inheritable_attributes ⇒ Object 



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

def reset_inheritable_attributes
  @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
end

#write_inheritable_array(key, elements) ⇒ Object 



103
104
105
106
 
# File 'lib/core_ext/inheritable_attributes.rb', line 103

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 



96
97
98
99
100
101
 
# File 'lib/core_ext/inheritable_attributes.rb', line 96

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 



108
109
110
111
 
# File 'lib/core_ext/inheritable_attributes.rb', line 108

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