1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
# A typical module looks like this:
#
# module M
# def self.included(base)
# base.send(:extend, ClassMethods)
# base.send(:include, InstanceMethods)
# scope :foo, :conditions => { :created_at => nil }
# end
#
# module ClassMethods
# def cm; puts 'I am a class method'; end
# end
#
# module InstanceMethods
# def im; puts 'I am an instance method'; end
# end
# end
#
# By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
#
# require 'active_support/concern'
#
# module M
# extend ActiveSupport::Concern
#
# included do
# scope :foo, :conditions => { :created_at => nil }
# end
#
# module ClassMethods
# def cm; puts 'I am a class method'; end
# end
#
# module InstanceMethods
# def im; puts 'I am an instance method'; end
# end
# end
#
# Moreover, it gracefully handles module dependencies. Given a Foo module and a Bar module which depends on the former, we would typically write the following:
#
# module Foo
# def self.included(base)
# # Define some :enhanced_method for Host class
# base.class_eval do
# def self.enhanced_method
# # Do enhanced stuff
# end
# end
# end
# end
#
# module Bar
# def self.included(base)
# base.send(:enhanced_method)
# end
# end
#
# class Host
# include Foo # We need to include this dependency for Bar
# include Bar # Bar is the module that Host really needs
# end
#
# But why should Host care about Bar's dependencies, namely Foo? We could try to hide these from Host directly including Foo in Bar:
#
# module Foo
# def self.included(base)
# # Define some :enhanced_method for Host class
# base.class_eval do
# def self.enhanced_method
# # Do enhanced stuff
# end
# end
# end
# end
#
# module Bar
# include Foo
# def self.included(base)
# base.send(:enhanced_method)
# end
# end
#
# class Host
# include Bar
# end
#
# Unfortunately this won't work, since when Foo is included, its <tt>base</tt> is Bar module, not Host class.
# With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
#
# require 'active_support/concern'
#
# module Foo
# extend ActiveSupport::Concern
# included do
# class_eval do
# def self.enhanced_method
# # Do enhanced stuff
# end
# end
# end
# end
#
# module Bar
# extend ActiveSupport::Concern
# include Foo
#
# included do
# self.send(:enhanced_method)
# end
# end
#
# class Host
# include Bar # Host only needs to care about Bar without needing to know about its dependencies
# end
#
module ActiveSupport
module Concern
def self.extended(base)
base.instance_variable_set("@_dependencies", [])
end
def append_features(base)
if base.instance_variable_defined?("@_dependencies")
base.instance_variable_get("@_dependencies") << self
return false
else
return false if base < self
@_dependencies.each { |dep| base.send(:include, dep) }
super
base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
end
end
def included(base = nil, &block)
if base.nil?
@_included_block = block
else
super
end
end
end
end
|
