Class: Class

Inherits:
Object show all
Defined in:
lib/cloudist/core_ext/class.rb

Overview

Extracted from ActiveSupport 3.0

Instance Method Summary collapse

Instance Method Details

#class_attribute(*attrs) ⇒ Object

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

object.setting = false  # => NoMethodError



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/cloudist/core_ext/class.rb', line 90

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\n        if singleton_class?\n          class_eval do\n            remove_possible_method(:\#{name})\n            def \#{name}\n              defined?(@\#{name}) ? @\#{name} : singleton_class.\#{name}\n            end\n          end\n        end\n        val\n      end\n\n      remove_method :\#{name} if method_defined?(:\#{name})\n      def \#{name}\n        defined?(@\#{name}) ? @\#{name} : self.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

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

Taken from coderrr.wordpress.com/2008/04/10/lets-stop-polluting-the-threadcurrent-hash/



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/cloudist/core_ext/class.rb', line 8

def thread_local_accessor name, options = {}
  m = Module.new
  m.module_eval do
    class_variable_set :"@@#{name}", Hash.new {|h,k| h[k] = options[:default] }
  end
  m.module_eval %{
    FINALIZER = lambda {|id| @@#{name}.delete id }

    def #{name}
      @@#{name}[Thread.current.object_id]
    end

    def #{name}=(val)
      ObjectSpace.define_finalizer Thread.current, FINALIZER  unless @@#{name}.has_key? Thread.current.object_id
      @@#{name}[Thread.current.object_id] = val
    end
  }

  class_eval do
    include m
    extend m
  end
end